我在MainActivity类中提供了一个融合位置提供程序代码，提供纬度和经度值，使用persistableBundle传递给JobService类。当用户使用应用程序时（即应用程序位于前台），它可以正常工作。一旦应用程序被刷出或销毁，MainActivity的最后更新值将一直通过作业调度程序重复上载（即，作业调度程序始终获得相同的值，融合位置提供程序不起作用）。即使应用程序不在前台，我该怎么做才能使它工作？ （PS。它在应用程序最小化时有效。即，它可以在最近的应用程序列表中看到，但问题一旦从列表中删除就会出现）
MainActivity.class
public class MainActivity extends AppCompatActivity implements GoogleApiClient.ConnectionCallbacks,
GoogleApiClient.OnConnectionFailedListener {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// JobScheduler starts
btnStartJob = (Button)findViewById(R.id.startjob);
jobScheduler = (JobScheduler)getSystemService(JOB_SCHEDULER_SERVICE);
btnStartJob.setOnClickListener(new View.OnClickListener(){
@Override
public void onClick(View v) {
ComponentName jobService =
new ComponentName(getPackageName(), MyJobService.class.getName());
PersistableBundle bundle = new PersistableBundle();
bundle.putString("lat", latitude+"");
bundle.putString("lon", longitude+"");
JobInfo jobInfo =
new JobInfo.Builder(MYJOBID, jobService).setPeriodic(10000).
setRequiredNetworkType(JobInfo.NETWORK_TYPE_ANY).
setRequiresCharging(false).
setRequiresDeviceIdle(false).
setPersisted(true).
setExtras(bundle).
build();
int jobId = jobScheduler.schedule(jobInfo);
if(jobScheduler.schedule(jobInfo)>0){
}else{
}
}
});
}
protected synchronized void buildGoogleApiClient() {
mGoogleApiClient = new GoogleApiClient.Builder(this)
.addConnectionCallbacks(this)
.addOnConnectionFailedListener(this)
.addApi(LocationServices.API)
.build();
}
private boolean checkPlayServices() {
int resultCode = GooglePlayServicesUtil.isGooglePlayServicesAvailable(this);
if (resultCode != ConnectionResult.SUCCESS) {
if (GooglePlayServicesUtil.isUserRecoverableError(resultCode)) {
GooglePlayServicesUtil.getErrorDialog(resultCode, this,
PLAY_SERVICES_RESOLUTION_REQUEST).show();
} else {
Toast.makeText(getApplicationContext(),
"This device is not supported.", Toast.LENGTH_LONG)
.show();
finish();
}
return false;
}
return true;
}
@Override
public void onConnected(Bundle bundle) {
createLocationRequest(bundle);
}
protected void createLocationRequest(Bundle bundle) {
mLocationRequest = new LocationRequest();
mLocationRequest.setInterval(10000);
mLocationRequest.setFastestInterval(5000);
mLocationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);
LocationServices.FusedLocationApi.requestLocationUpdates(mGoogleApiClient, mLocationRequest, new LocationCallback() {
@Override
public void onLocationResult(final LocationResult locationResult) {
latitude = locationResult.getLastLocation().getLatitude() + "";
longitude = locationResult.getLastLocation().getLongitude() + "";
Log.e("onLocationResult lat", latitude);
Log.e("onLocationResult Lon", longitude);
}
@Override
public void onLocationAvailability(LocationAvailability locationAvailability) {
}
}, null);
}
@Override
public void onConnectionSuspended(int i) {
mGoogleApiClient.connect();
}
@Override
public void onConnectionFailed(ConnectionResult result) {
Log.i(TAG, "Connection failed: ConnectionResult.getErrorCode() = "
+ result.getErrorCode());
}
@Override
protected void onPause() {
super.onPause();
}
@Override
protected void onResume() {
super.onResume();
checkPlayServices();
}
@Override
protected void onStart() {
super.onStart();
if (mGoogleApiClient != null) {
mGoogleApiClient.connect();
Log.i(TAG, "mGoogleApiClient.connect()");
}
}
@Override
public void onDestroy() {
super.onDestroy();
}
}
MyJobService类
public class MyJobService extends JobService {
@Override
public boolean onStartJob(JobParameters jobParameters) {
latitude = jobParameters.getExtras().getString("lat");
longitude = jobParameters.getExtras().getString("lon");
Log.e("service1",latitude + "");
Log.e("service2",longitude + "");
return true;
}
}
更新1：
尝试在Jobservice中实现融合位置但不起作用
public class MyJobService extends JobService implements GoogleApiClient.ConnectionCallbacks,
GoogleApiClient.OnConnectionFailedListener{
String latitude = null;
String longitude = null;
public MyJobService() {
}
@Override
public boolean onStartJob(JobParameters jobParameters) {
Log.d("onStart", "onStartJob() :: ");
return false;
}
@Override
public boolean onStopJob(JobParameters jobParameters) {
Toast.makeText(this,
"MyJobService.onStopJob()",
Toast.LENGTH_SHORT).show();
return false;
}
//fused location provider starts
private GoogleApiClient mGoogleApiClient;
private final static int PLAY_SERVICES_RESOLUTION_REQUEST = 1000;
private LocationRequest mLocationRequest;
private static final String TAG = "zzzz";
protected synchronized void buildGoogleApiClient() {
mGoogleApiClient = new GoogleApiClient.Builder(this)
.addConnectionCallbacks(this)
.addOnConnectionFailedListener(this)
.addApi(LocationServices.API)
.build();
}
private boolean checkPlayServices() {
int resultCode = GooglePlayServicesUtil.isGooglePlayServicesAvailable(this);
if (resultCode != ConnectionResult.SUCCESS) {
if (GooglePlayServicesUtil.isUserRecoverableError(resultCode)) {
// GooglePlayServicesUtil.getErrorDialog(resultCode, this,
// PLAY_SERVICES_RESOLUTION_REQUEST).show();
Log.e("GooglePlayServices", resultCode + "");
} else {
Toast.makeText(getApplicationContext(),
"This device is not supported.", Toast.LENGTH_LONG)
.show();
stopSelf();
}
return false;
}
return true;
}
@Override
public void onConnected(Bundle bundle) {
createLocationRequest(bundle);
}
protected void createLocationRequest(Bundle bundle) {
mLocationRequest = new LocationRequest();
mLocationRequest.setInterval(5000);
mLocationRequest.setFastestInterval(5000);
mLocationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);
if (ActivityCompat.checkSelfPermission(this, android.Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this, android.Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
return;
}
LocationServices.FusedLocationApi.requestLocationUpdates(mGoogleApiClient, mLocationRequest, new LocationCallback() {
@Override
public void onLocationResult(final LocationResult locationResult) {
latitude = locationResult.getLastLocation().getLatitude() + "";
longitude = locationResult.getLastLocation().getLongitude() + "";
Log.e("onLocationResult lat", latitude);
Log.e("onLocationResult Lon", longitude);
}
@Override
public void onLocationAvailability(LocationAvailability locationAvailability) {
}
}, null);
}
@Override
public void onConnectionSuspended(int i) {
mGoogleApiClient.connect();
}
@Override
public void onConnectionFailed(ConnectionResult result) {
Log.i(TAG, "Connection failed: ConnectionResult.getErrorCode() = "
+ result.getErrorCode());
}
// fused location provider ends
}
答案 0 :(得分：2)
我不知道您是否仍在尝试解决此问题，但是问题是作业调度程序在应用程序被销毁时总是会得到错误的数据（旧数据）。 解决方案可能是在手机上缓冲 sqlite 数据库。由于销毁应用程序时不会擦除数据库，因此您可以将最新的GPS数据放入数据库中，然后让调度程序从那里获取。它应该可以正常工作。
请客气，这是我第一次尝试提供帮助；）
答案 1 :(得分：0)
您需要将融合位置服务逻辑放在作业服务中，因为当您关闭应用程序时，您的位置监听器也会被破坏，因此当您的应用程序在前台或后台不可用时，您需要在作业服务中获取新位置，当您的工作服务调用您决定的时间时，您需要实现获取位置的逻辑，以及更新位置的逻辑，
您可以使用上一个已知位置获取位置。
答案 2 :(得分：0)
即使应用程序处于后台，也可以使用此服务连续获取位置。使用此课程而不是Jobscheduler
public class LocationTracker extends Service implements
GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener, com.google.android.gms.location.LocationListener,android.location.LocationListener {
private GoogleApiClient mGoogleApiClient;
private Location mLastLocation;
private LocationRequest mLocationRequest;
// The minimum distance to change Updates in meters
private static final long MIN_DISTANCE_CHANGE_FOR_UPDATES = 100; // 100 meters
// The minimum time between updates in milliseconds
private static final long MIN_TIME_BW_UPDATES = 1000 * 60 *2; // 1 minute
//Location Request code
private final int REQUEST_LOCATION = 2;
//Location manager for location services
private LocationManager mLocationManager;
@Override
public void onConnectionFailed(ConnectionResult connectionResult) {
getLocation();
}
@Override
public void onConnected(Bundle bundle) {
mLocationRequest = LocationRequest.create();
mLocationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);
mLocationRequest.setInterval(60000*2);// Update location every second
mLocationRequest.setSmallestDisplacement(100);
mLocationManager = (LocationManager) getSystemService(LOCATION_SERVICE);
createLocationRequest();
if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED) {
LocationServices.FusedLocationApi.requestLocationUpdates(mGoogleApiClient, mLocationRequest, this);
mLastLocation = LocationServices.FusedLocationApi.getLastLocation(
mGoogleApiClient);
if (mLastLocation != null) {
updateProviderLocation(mLastLocation);
}
}
}
@Override
public IBinder onBind(Intent intent) {
if (mGoogleApiClient == null) {
mGoogleApiClient = new GoogleApiClient.Builder(this)
.addConnectionCallbacks(this)
.addOnConnectionFailedListener(this)
.addApi(LocationServices.API)
.build();
}
return null;
}
@Override
public void onCreate() {
super.onCreate();
if (mGoogleApiClient == null) {
mGoogleApiClient = new GoogleApiClient.Builder(this)
.addConnectionCallbacks(this)
.addOnConnectionFailedListener(this)
.addApi(LocationServices.API)
.build();
}
}
private void createLocationRequest() {
Log.i("TAG", "CreateLocationRequest");
mLocationRequest = new LocationRequest();
long UPDATE_INTERVAL = 60 * 1000 *2;
mLocationRequest.setInterval(UPDATE_INTERVAL);
long FASTEST_INTERVAL = 10000;
mLocationRequest.setFastestInterval(FASTEST_INTERVAL);
mLocationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY);
LocationSettingsRequest.Builder builder = new LocationSettingsRequest.Builder()
.addLocationRequest(mLocationRequest);
//**************************
builder.setAlwaysShow(true); //this is the key ingredient
//**************************
}
@Override
public void onConnectionSuspended(int i) {
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
mGoogleApiClient.connect();
return super.onStartCommand(intent, flags, startId);
}
@Override
public void onDestroy() {
mGoogleApiClient.disconnect();
stopLocationUpdates();
super.onDestroy();
}
@Override
public void onLocationChanged(Location location) {
//Log.d("Location", location.getLatitude() + "," + location.getLongitude());
try {
if (mLastLocation.getLatitude()!=location.getLatitude()||mLastLocation.getLongitude()!=location.getLongitude()) {
updateProviderLocation(location);
mLastLocation = location;
}
}catch (Exception e){
}
}
@Override
public void onStatusChanged(String s, int i, Bundle bundle) {
}
@Override
public void onProviderEnabled(String s) {
}
@Override
public void onProviderDisabled(String s) {
}
private void updateProviderLocation(Location location){
//Upload to your server
}
private void stopLocationUpdates() {
try {
if (mGoogleApiClient.isConnected())
LocationServices.FusedLocationApi.removeLocationUpdates(mGoogleApiClient, this);
if (mLocationManager != null) {
mLocationManager.removeUpdates(this);
}
} catch (Exception e) {
e.printStackTrace();
}
}
public void getLocation() {
try {
// getting GPS status
Boolean isGPSEnabled = mLocationManager
.isProviderEnabled(LocationManager.GPS_PROVIDER);
// getting network status
Boolean isNetworkEnabled = mLocationManager
.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
if (!isGPSEnabled && !isNetworkEnabled) {
Log.e("Location", "No provider enabled");
} else {
if (ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED && ActivityCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
// TODO: Consider calling
// ActivityCompat#requestPermissions
// here to request the missing permissions, and then overriding
// public void onRequestPermissionsResult(int requestCode, String[] permissions,
// int[] grantResults)
// to handle the case where the user grants the permission. See the documentation
// for ActivityCompat#requestPermissions for more details.
return;
}
if (isGPSEnabled) {
if (mLocationManager != null) {
mLocationManager.requestLocationUpdates(
LocationManager.GPS_PROVIDER,
MIN_TIME_BW_UPDATES,
MIN_DISTANCE_CHANGE_FOR_UPDATES, this);
Log.d("GPS Enabled", "GPS Enabled");
}
}else if (isNetworkEnabled) {
if (mLocationManager != null) {
mLocationManager.requestLocationUpdates(
LocationManager.NETWORK_PROVIDER,
MIN_TIME_BW_UPDATES,
MIN_DISTANCE_CHANGE_FOR_UPDATES, this);
Log.d("Network", "Network");
}
}
// if GPS Enabled get lat/long using GPS Services
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
答案 3 :(得分：0)
基于更新和以前的答案，我终于能够使它工作。
通过在我的工作计划程序的 onStartJob 中向fusedLocationProvider调用getLastKnownLocation。
请参见以下代码
ComponentName jobServiceComponent = new ComponentName(context, LocationJobService.class);
JobInfo.Builder jobInfoBuilder = new JobInfo.Builder(0, jobServiceComponent);
jobInfoBuilder.setPeriodic(Constants.JOB_SERVICE_INTERVAL);
jobInfoBuilder.setRequiredNetworkType(JobInfo.NETWORK_TYPE_ANY);
jobInfoBuilder.setRequiresCharging(false);
jobInfoBuilder.setRequiresDeviceIdle(false);
jobInfoBuilder.setPersisted(true);
JobScheduler scheduler = (JobScheduler) context.getSystemService(JOB_SCHEDULER_SERVICE);
int resultCode = scheduler.schedule(jobInfoBuilder.build());
并启动此工作计划程序
@Override
public boolean onStartJob(JobParameters params) {
updateBackgroundLocation(params);
return true;
}
private void updateBackgroundLocation(JobParameters params) {
if (jobCancelled) { return; }
new Thread(new Runnable() {
@Override
public void run() {
updateLocation(params);
}
}).start();
}
private void updateLocation(JobParameters params) {
LocationServices.getFusedLocationProviderClient(getApplicationContext())
.getLastLocation().addOnSuccessListener(location -> {
//perform your update here with last known location.
}).addOnFailureListener(e -> {
e.printStackTrace();
});
jobFinished(params, true);
}
@Override
public boolean onStopJob(JobParameters params) {
jobCancelled = true;
return false;
}