Geofence działa, ale po chwili przestaje się uruchamiać

Question

Moja geofence działa na starcie, ale nagle po dniu lub dwóch przestojach, czy jest jakiś problem po stronie Google tutaj lub mój kod?

Po rozruchu i uruchamiania aplikacji używam IntentService który następnie rejestruje się Geofence:

public class RegisterGeoIntentService extends IntentService implements 
GoogleApiClient.ConnectionCallbacks, 
    GoogleApiClient.OnConnectionFailedListener, ResultCallback<Status> { 

private static final String TAG = "RegisterGeoIS"; 

private static final long TIME_OUT = 100; 
protected GoogleApiClient mGoogleApiClient; 
protected ArrayList<Geofence> mGeofenceList; 
private PendingIntent mGeofencePendingIntent; 

public RegisterGeoIntentService() { 
    super(TAG); 
} 

@Override 
public void onCreate() { 
    super.onCreate(); 
    Log.i(TAG, "Creating Register Geo Intent service"); 
    mGeofenceList = new ArrayList<Geofence>(); 
    mGeofencePendingIntent = null; 
} 

@Override 
protected void onHandleIntent(Intent intent) { 
    buildGoogleApiClient(); 
    populateGeofenceList(); 
    mGoogleApiClient.blockingConnect(TIME_OUT, TimeUnit.MILLISECONDS); 
    String connected = mGoogleApiClient.isConnected() ? "connected" : "disconnected"; 
    Log.i(TAG, "Restoring geofence - status: " + connected); 

    String mode = null; 
    if(intent != null) { 
     mode = intent.getStringExtra(GEOFENCE_MODE); 
     if(mode.equals(GEOFENCE_MODE_START)) { 
      removeGeofencesButtonHandler(); 
      addGeofencesButtonHandler(); 
     } else { 
      removeGeofencesButtonHandler(); 
     } 
    } else { 
     Log.e(TAG, "No Intent data, could not start Geo"); 
    } 
} 

@Override 
public void onConnected(Bundle bundle) { 
    Log.i(TAG, "Connected to GoogleApiClient"); 
} 

@Override 
public void onConnectionSuspended(int i) { 
    Log.i(TAG, "Connection suspended"); 
} 

@Override 
public void onConnectionFailed(ConnectionResult result) { 
    Log.i(TAG, "Connection failed: ConnectionResult.getErrorCode() = " + result.getErrorCode()); 
} 

@Override 
public void onResult(Status status) {  // Not used, using await 
    if(status.isSuccess()) { 
     Log.i(TAG, "Geofences added"); 
     mGoogleApiClient.disconnect(); 
    } else { 
     Log.i(TAG, "Geofences not successful"); 
     String errorMessage = GeoErrorMessages.getErrorString(this, status.getStatusCode()); 
     Log.e(TAG, errorMessage); 
    } 
} 

public void addGeofencesButtonHandler() { 
    if(!mGoogleApiClient.isConnected()) { 
     Toast.makeText(this, getString(R.string.not_connected), Toast.LENGTH_SHORT).show(); 
     return; 
    } 
    Status result = null; 
    try { 
     result = LocationServices.GeofencingApi.addGeofences(
      mGoogleApiClient, 
      getGeofencingRequest(), 
      getGeofencePendingIntent() 
     ).await(TIME_OUT, TimeUnit.MILLISECONDS); 
    } catch (SecurityException securityException) { // TODO Catch if manually disabled 
     // Catch exception generated if the app does not use ACCESS_FINE_LOCATION permission. 
     logSecurityException(securityException); 
    } 
    if(result != null) { 
     Log.i(TAG, "Trying to add Geofences - result: " + result.toString()); 
    } else { 
     Log.i(TAG, "Trying to add Geofences - result: is null"); 
    } 
} 

public void removeGeofencesButtonHandler() { 
    if(!mGoogleApiClient.isConnected()) { 
     Toast.makeText(this, getString(R.string.not_connected), Toast.LENGTH_SHORT).show(); 
     return; 
    } 
    Status result = null; 
    try { 
     result = LocationServices.GeofencingApi.removeGeofences(mGoogleApiClient, getGeofencePendingIntent() 
     ).await(TIME_OUT, TimeUnit.MILLISECONDS); 
    } catch (SecurityException securityException) { // TODO Catch if manually disabled 
     // Catch exception generated if the app does not use ACCESS_FINE_LOCATION permission. 
     logSecurityException(securityException); 
    } 
    if(result != null) { 
     Log.i(TAG, "Trying to remove Geofences - result: " + result.toString()); 
    } else { 
     Log.i(TAG, "Trying to remove Geofences - result: is null"); 
    } 
} 

private GeofencingRequest getGeofencingRequest() { 
    GeofencingRequest.Builder builder = new GeofencingRequest.Builder(); 
    // The INITIAL_TRIGGER_ENTER flag indicates that geofencing service should trigger a 
    // GEOFENCE_TRANSITION_ENTER notification when the geofence is added and if the device 
    // is already inside that geofence. 
    builder.setInitialTrigger(GeofencingRequest.INITIAL_TRIGGER_ENTER); 
    builder.addGeofences(mGeofenceList); 
    return builder.build(); 
} 

private PendingIntent getGeofencePendingIntent() { 
    if(mGeofencePendingIntent != null) { 
     return mGeofencePendingIntent; 
    } 
    // We use FLAG_UPDATE_CURRENT so that we get the same pending intent back when calling 
    // addGeofences() and removeGeofences(). 
    // Removed, using Broadcast now 
    // Intent intent = new Intent(this, GeoTransitionsIntentService.class); 
    // return PendingIntent.getService(this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT); 
    Intent intent = new Intent("com.xyz.app.ACTION_RECEIVE_GEOFENCE"); 
    return PendingIntent.getBroadcast(this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT); 
} 

private void logSecurityException(SecurityException securityException) { 
    Log.e(TAG, "Invalid location permission. You need to use ACCESS_FINE_LOCATION with geofences", securityException); 
} 

public void populateGeofenceList() { 
    RealmHelper realmHelper = RealmHelper.getInstance(this); 
    for(Map.Entry<String, LatLng> entry : realmHelper.queryLandMarks().entrySet()) { 
     mGeofenceList.add(new Geofence.Builder() 
     .setRequestId(entry.getKey()) 
     .setCircularRegion(
      entry.getValue().latitude, 
      entry.getValue().longitude, 
      Constants.GEOFENCE_RADIUS_IN_METERS) 
     .setExpirationDuration(Geofence.NEVER_EXPIRE) 
     .setTransitionTypes(Geofence.GEOFENCE_TRANSITION_ENTER | Geofence.GEOFENCE_TRANSITION_EXIT) 
     .build()); 
    } 
} 

protected synchronized void buildGoogleApiClient() { 
    mGoogleApiClient = new GoogleApiClient.Builder(this) 
     .addConnectionCallbacks(this) 
     .addOnConnectionFailedListener(this) 
     .addApi(LocationServices.API) 
     .build(); 
} 
} 

a to:

public class GeofenceReceiver extends BroadcastReceiver { 
... 

@Override 
public void onReceive(Context context, Intent intent) { 
this.context = context; 

GeofencingEvent geofencingEvent = GeofencingEvent.fromIntent(intent); 
if(geofencingEvent.hasError()) { 
    String errorMessage = GeoErrorMessages.getErrorString(context, geofencingEvent.getErrorCode()); 
    Log.e(TAG, errorMessage); 
    return; 
} 

int geofenceTransition = geofencingEvent.getGeofenceTransition(); 

if(geofenceTransition == Geofence.GEOFENCE_TRANSITION_ENTER || geofenceTransition == Geofence.GEOFENCE_TRANSITION_EXIT) { 

// Do stuff 
} 
... 

zobacz także moją odpowiedź, co starałem i myślałem stałe. Ale to nie pomogło.

Answer 1

Należy pamiętać, to w rzeczywistości nie pomoże

Moja Geofence zawsze wyzwalany ale IntentService był problem

private PendingIntent getGeofencePendingIntent() { 
    if(mGeofencePendingIntent != null) { 
     return mGeofencePendingIntent; 
    } 
    Intent intent = new Intent(this, GeoTransitionsIntentService.class); 
    // We use FLAG_UPDATE_CURRENT so that we get the same pending intent back  when calling 
    // addGeofences() and removeGeofences(). 
    return PendingIntent.getService(this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT); 
} 

zmieniony za pomocą BroadcastReceiver zdefiniowany w AndroidManifest jak

private PendingIntent getGeofencePendingIntent() { 
    if(mGeofencePendingIntent != null) { 
     return mGeofencePendingIntent; 
    } 
    // We use FLAG_UPDATE_CURRENT so that we get the same pending intent back when calling 
    // addGeofences() and removeGeofences(). 
    // Removed, using Broadcast now 
    // Intent intent = new Intent(this, GeoTransitionsIntentService.class); 
    // return PendingIntent.getService(this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT); 
    Intent intent = new Intent("com.xyz.myapp.ACTION_RECEIVE_GEOFENCE"); 
    return PendingIntent.getBroadcast(this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT); 
}