當應用程序處於後臺時，地理柵欄通知不會得到。

Question

我真的被困在這一點。當應用程序處於正常狀態時，Geofence確實可以正常工作，即正常通知。但是當應用去的時候在後臺通知不來。

我想是這樣，當應用程序在後臺我的地理圍欄從來沒有過期，如果用戶是圍欄外得到通知。

還附上下面的代碼： -

public class MainActivity extends AppCompatActivity implements GoogleApiClient.ConnectionCallbacks, 
     GoogleApiClient.OnConnectionFailedListener, 
     LocationListener, 
     ResultCallback<Status> { 

    protected static final int REQUEST_CHECK_SETTINGS = 0x1; 
    GoogleApiClient googleApiClient; 
    private MapFragment mapFragment; 
    private static final String TAG = MainActivity.class.getSimpleName(); 
    private GoogleMap map; 
    private Location lastLocation; 
    private static final String NOTIFICATION_MSG = "NOTIFICATION MSG"; 
    SharedPreferences pref; 
    SharedPreferences.Editor editor; 

    public static Intent makeNotificationIntent(Context context, String msg) { 
     Intent intent = new Intent(context, MainActivity.class); 
     intent.putExtra(NOTIFICATION_MSG, msg); 
     return intent; 
    } 


    @Override 
    protected void onCreate(@Nullable Bundle savedInstanceState) { 
     super.onCreate(savedInstanceState); 
     //setContentView(R.layout.activity_geofence); 

     pref = PreferenceManager.getDefaultSharedPreferences(MainActivity.this); 
     editor = pref.edit(); 


     initGMaps(); 
     createGoogleApi(); 


    } 


    private void initGMaps() { 
     //mapFragment = (MapFragment) getFragmentManager().findFragmentById(R.id.map); 
     //mapFragment.getMapAsync(this); 
    } 


    private void createGoogleApi() { 
     Log.d(TAG, "createGoogleApi()"); 
     if (googleApiClient == null) { 
      googleApiClient = new GoogleApiClient.Builder(this) 
        .addConnectionCallbacks(this) 
        .addOnConnectionFailedListener(this) 
        .addApi(LocationServices.API) 
        .build(); 
     } 

    } 


    @Override 
    protected void onStart() { 
     super.onStart(); 
     googleApiClient.connect(); 
     settingsrequest(); 

    } 

    public void settingsrequest() { 
     LocationRequest locationRequest = LocationRequest.create(); 
     locationRequest.setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY); 
     locationRequest.setInterval(30 * 1000); 
     locationRequest.setFastestInterval(5 * 1000); 
     LocationSettingsRequest.Builder builder = new LocationSettingsRequest.Builder() 
       .addLocationRequest(locationRequest); 
     builder.setAlwaysShow(true); //this is the key ingredient 

     PendingResult<LocationSettingsResult> result = 
       LocationServices.SettingsApi.checkLocationSettings(googleApiClient, builder.build()); 
     result.setResultCallback(new ResultCallback<LocationSettingsResult>() { 
      @Override 
      public void onResult(LocationSettingsResult result) { 
       final Status status = result.getStatus(); 
       final LocationSettingsStates state = result.getLocationSettingsStates(); 
       switch (status.getStatusCode()) { 
        case LocationSettingsStatusCodes.SUCCESS: 
         // All location settings are satisfied. The client can initialize location 
         // requests here. 
         break; 
        case LocationSettingsStatusCodes.RESOLUTION_REQUIRED: 
         // Location settings are not satisfied. But could be fixed by showing the user 
         // a dialog. 
         try { 
          // Show the dialog by calling startResolutionForResult(), 
          // and check the result in onActivityResult(). 
          status.startResolutionForResult(MainActivity.this, REQUEST_CHECK_SETTINGS); 
         } catch (IntentSender.SendIntentException e) { 
          // Ignore the error. 
         } 
         break; 
        case LocationSettingsStatusCodes.SETTINGS_CHANGE_UNAVAILABLE: 
         // Location settings are not satisfied. However, we have no way to fix the 
         // settings so we won't show the dialog. 
         break; 
       } 
      } 
     }); 
    } 

    @Override 
    protected void onStop() { 
     super.onStop(); 

     // Disconnect GoogleApiClient when stopping Activity 
     googleApiClient.disconnect(); 
    } 


    @Override 
    protected void onActivityResult(int requestCode, int resultCode, Intent data) { 
     switch (requestCode) { 
// Check for the integer request code originally supplied to startResolutionForResult(). 
      case REQUEST_CHECK_SETTINGS: 
       switch (resultCode) { 
        case Activity.RESULT_OK: 
         startLocationUpdates(); 
         break; 
        case Activity.RESULT_CANCELED: 
         settingsrequest();//keep asking if imp or do whatever 
         break; 
       } 
       break; 
     } 
    } 

    @Override 
    public void onConnected(@Nullable Bundle bundle) { 


     // googleApiClient.disconnect(); 
     Log.i(TAG, "onConnected()"); 
     getLastKnownLocation(); 
     //recoverGeofenceMarker(); 
     startGeofence(); 

    } 

    private final int REQ_PERMISSION = 999; 

    // Check for permission to access Location 
    private boolean checkPermission() { 
     Log.d(TAG, "checkPermission()"); 
     // Ask for permission if it wasn't granted yet 
     return (ContextCompat.checkSelfPermission(this, android.Manifest.permission.ACCESS_FINE_LOCATION) 
       == PackageManager.PERMISSION_GRANTED); 
    } 

    // Asks for permission 
    private void askPermission() { 
     Log.d(TAG, "askPermission()"); 
     ActivityCompat.requestPermissions(
       this, 
       new String[]{android.Manifest.permission.ACCESS_FINE_LOCATION}, 
       REQ_PERMISSION 
     ); 
    } 


    private void getLastKnownLocation() { 
     Log.d(TAG, "getLastKnownLocation()"); 
     if (checkPermission()) { 
      lastLocation = LocationServices.FusedLocationApi.getLastLocation(googleApiClient); 
      if (lastLocation != null) { 
       Log.i(TAG, "LasKnown location. " + 
         "Long: " + lastLocation.getLongitude() + 
         " | Lat: " + lastLocation.getLatitude()); 
       writeLastLocation(); 
       startLocationUpdates(); 
      } else { 
       Log.w(TAG, "No location retrieved yet"); 
       startLocationUpdates(); 
      } 
     } else askPermission(); 
    } 


    private void writeActualLocation(Location location) { 
     //textLat.setText("Lat: " + location.getLatitude()); 
     //textLong.setText("Long: " + location.getLongitude()); 
     markerLocation(new LatLng(location.getLatitude(), location.getLongitude())); 
    } 

    private void writeLastLocation() { 
     writeActualLocation(lastLocation); 
    } 

    private Marker locationMarker; 

    private void markerLocation(LatLng latLng) { 
     Log.i(TAG, "markerLocation(" + latLng + ")"); 
     String title = latLng.latitude + ", " + latLng.longitude; 
     MarkerOptions markerOptions = new MarkerOptions() 
       .position(latLng) 
       .title(title); 
     if (map != null) { 
      if (locationMarker != null) 
       locationMarker.remove(); 
      locationMarker = map.addMarker(markerOptions); 
      float zoom = 14f; 
      CameraUpdate cameraUpdate = CameraUpdateFactory.newLatLngZoom(latLng, zoom); 
      map.animateCamera(cameraUpdate); 
     } 
    } 


    // Start Geofence creation process 
    private void startGeofence() { 
     Log.i(TAG, "startGeofence()"); 
     Geofence geofence = createGeofence(); 
     GeofencingRequest geofenceRequest = createGeofenceRequest(geofence); 
     addGeofence(geofenceRequest); 
    } 

    private static final long GEO_DURATION = 60 * 60 * 1000; 
    private static final String GEOFENCE_REQ_ID = "My Geofence"; 
    private static final float GEOFENCE_RADIUS = 500.0f; // in meters 

    // Create a Geofence 
    private Geofence createGeofence() { 
     Log.d(TAG, "createGeofence"); 

     //Intent i = getIntent(); 
     //double la = i.getDoubleExtra("latitude", 0); 
     //double lo = i.getDoubleExtra("longitude", 0); 

     return new Geofence.Builder() 
       .setRequestId(GEOFENCE_REQ_ID) 
       .setCircularRegion(18.457532, 73.867746, GEOFENCE_RADIUS) 
       .setExpirationDuration(Geofence.NEVER_EXPIRE) 
       .setTransitionTypes(Geofence.GEOFENCE_TRANSITION_EXIT) 
       .build(); 
    } 

    // Create a Geofence Request 
    private GeofencingRequest createGeofenceRequest(Geofence geofence) { 
     Log.d(TAG, "createGeofenceRequest"); 
     return new GeofencingRequest.Builder() 
       .setInitialTrigger(GeofencingRequest.INITIAL_TRIGGER_EXIT) 
       .addGeofence(geofence) 
       .build(); 
    } 

    private PendingIntent geoFencePendingIntent; 
    private static final int GEOFENCE_REQ_CODE = 0; 

    private PendingIntent createGeofencePendingIntent() { 
     Log.d(TAG, "createGeofencePendingIntent"); 
     if (geoFencePendingIntent != null) 
      return geoFencePendingIntent; 

     Intent intent = new Intent("com.aol.android.geofence.ACTION_RECEIVE_GEOFENCE"); 
     return PendingIntent.getBroadcast(
       this, GEOFENCE_REQ_CODE, intent, PendingIntent.FLAG_UPDATE_CURRENT); 
    } 

    // Add the created GeofenceRequest to the device's monitoring list 
    private void addGeofence(GeofencingRequest request) { 
     Log.d(TAG, "addGeofence"); 
     if (checkPermission()) 
      LocationServices.GeofencingApi.addGeofences(
        googleApiClient, 
        request, 
        createGeofencePendingIntent() 
      ).setResultCallback(this); 
    } 


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

    @Override 
    public void onConnectionFailed(@NonNull ConnectionResult connectionResult) { 

     Log.w(TAG, "onConnectionFailed()"); 
    } 




    private LocationRequest locationRequest; 
    // Defined in mili seconds. 
    // This number in extremely low, and should be used only for debug 
    private final int UPDATE_INTERVAL = 1000; 
    private final int FASTEST_INTERVAL = 900; 

    // Start location Updates 
    private void startLocationUpdates() { 
     Log.i(TAG, "startLocationUpdates()"); 
     locationRequest = LocationRequest.create() 
       .setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY) 
       .setInterval(UPDATE_INTERVAL) 
       .setFastestInterval(FASTEST_INTERVAL); 

     if (checkPermission()) 
      LocationServices.FusedLocationApi.requestLocationUpdates(googleApiClient, locationRequest, this); 
    } 

    @Override 
    public void onLocationChanged(Location location) { 
     Log.d(TAG, "onLocationChanged [" + location + "]"); 
     lastLocation = location; 
     writeActualLocation(location); 
    } 


    @Override 
    public void onResult(@NonNull Status status) { 


     Log.i(TAG, "onResult: " + status); 
     if (status.isSuccess()) { 
//   saveGeofence(); 
      //drawGeofence(); 
     } else { 
      // inform about fail 
     } 

    } 


} 

還附上Reciever代碼： -

public class GeofenceReciever extends BroadcastReceiver { 


    private static final String TAG = "BootReceiver"; 
    Context contextBootReceiver; 
    Intent intent; 
    public static final int GEOFENCE_NOTIFICATION_ID = 0; 
    SharedPreferences pref; 
    SharedPreferences.Editor editor; 

    @Override 
    public void onReceive(Context context, Intent intent) { 
     this.contextBootReceiver = context; 
     this.intent = intent; 
     pref = PreferenceManager.getDefaultSharedPreferences(context); 
     editor = pref.edit(); 


     GeofencingEvent geofencingEvent = GeofencingEvent.fromIntent(intent); 
     // Handling errors 
     if (geofencingEvent.hasError()) { 
      String errorMsg = getErrorString(geofencingEvent.getErrorCode()); 
      Log.e(TAG, errorMsg); 
      return; 
     } 

     int geoFenceTransition = geofencingEvent.getGeofenceTransition(); 
     // Check if the transition type is of interest 
     if (geoFenceTransition == Geofence.GEOFENCE_TRANSITION_EXIT) { 
      // Get the geofence that were triggered 
      Log.d("Trnsition", "Exited"); 
      List<Geofence> triggeringGeofences = geofencingEvent.getTriggeringGeofences(); 

      String geofenceTransitionDetails = getGeofenceTrasitionDetails(geoFenceTransition, triggeringGeofences); 
      // Send notification details as a String 
      //if (feedback.equalsIgnoreCase("F;1;")) { 
      // String temp = feedback; 


       sendNotification(geofenceTransitionDetails); 


     } 


    } 


    private String getGeofenceTrasitionDetails(int geoFenceTransition, List<Geofence> triggeringGeofences) { 
     // get the ID of each geofence triggered 
     ArrayList<String> triggeringGeofencesList = new ArrayList<>(); 
     for (Geofence geofence : triggeringGeofences) { 
      triggeringGeofencesList.add(geofence.getRequestId()); 
     } 

     String status = "Some switches are on"; 
     if (geoFenceTransition == Geofence.GEOFENCE_TRANSITION_ENTER) 
      System.out.println(status); 
     return status + TextUtils.join(", ", triggeringGeofencesList); 
    } 

    private void sendNotification(String msg) { 


     //intent = new Intent(contextBootReceiver, MainActivity.class); 
     //intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK); 
     //intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP); 
     //contextBootReceiver.startActivity(intent); 

     Log.i(TAG, "sendNotification: " + msg); 


     // Intent to start the main Activity 
     Intent notificationIntent = MainActivity.makeNotificationIntent(
       contextBootReceiver, msg 
     ); 

     TaskStackBuilder stackBuilder = TaskStackBuilder.create(contextBootReceiver); 
     stackBuilder.addParentStack(MainActivity.class); 
     stackBuilder.addNextIntent(notificationIntent); 
     PendingIntent notificationPendingIntent = stackBuilder.getPendingIntent(0, PendingIntent.FLAG_UPDATE_CURRENT); 


     // Creating and sending Notification 
     NotificationManager notificatioMng = 
       (NotificationManager) contextBootReceiver.getSystemService(Context.NOTIFICATION_SERVICE); 
     notificatioMng.notify(
       GEOFENCE_NOTIFICATION_ID, 
       createNotification(msg, notificationPendingIntent)); 

    } 

    // Create notification 
    private Notification createNotification(String msg, PendingIntent notificationPendingIntent) { 
     NotificationCompat.Builder notificationBuilder = new NotificationCompat.Builder(contextBootReceiver); 
     notificationBuilder 
       .setSmallIcon(R.drawable.ic_action_location) 
       .setColor(Color.RED) 
       .setContentTitle(msg) 
       .setContentText("Droidhomes Notification!") 
       .setContentIntent(notificationPendingIntent) 
       .setDefaults(Notification.DEFAULT_LIGHTS | Notification.DEFAULT_VIBRATE | Notification.DEFAULT_SOUND) 
       .setAutoCancel(true); 
     return notificationBuilder.build(); 
    } 


    private static String getErrorString(int errorCode) { 
     switch (errorCode) { 
      case GeofenceStatusCodes.GEOFENCE_NOT_AVAILABLE: 
       return "GeoFence not available"; 
      case GeofenceStatusCodes.GEOFENCE_TOO_MANY_GEOFENCES: 
       return "Too many GeoFences"; 
      case GeofenceStatusCodes.GEOFENCE_TOO_MANY_PENDING_INTENTS: 
       return "Too many pending intents"; 
      default: 
       return "Unknown error."; 
     } 
    } 


} 

Answer 1

寫您的服務是這樣的：

public class GeoFencingService extends Service{ 

@Override 
    public int onStartCommand(Intent intent, int flags, int startId) { 
     //write your notification code here 
//use START_STICKY if you want your service keep running else use START_NOT_STICKY 
     return Service.START_STICKY; 
    } 

    @Override 
    public IBinder onBind(Intent intent) { 
    //use this method to communicate with your activity 
    return null; 
    } 
} 

詳細解釋看看在這兩個鏈接：

https://developer.android.com/guide/components/services.html 
http://www.vogella.com/tutorials/AndroidServices/article.html 

讓我知道，如果有更多的幫助，需要