在后台应用程序时不会触发地理围栏通知

时间:2017-07-31 18:09:42

标签: android notifications android-geofence

我已经经历了很多SO帖子,但对我来说还没有任何效果。 我试图在设备进入地理围栏时触发通知。但是在应用程序打开之前它不会触发。 当应用程序处于背景状态时,如何触发通知?

区域范围设定:

public class Geofencing implements ResultCallback {

    // Constants
    public static final String TAG = Geofencing.class.getSimpleName();
    private static final float GEOFENCE_RADIUS = 50; // 50 meters
    private static final long GEOFENCE_TIMEOUT = 24 * 60 * 60 * 1000; // 24 hours

    private List<Geofence> mGeofenceList;
    private PendingIntent mGeofencePendingIntent;
    private GoogleApiClient mGoogleApiClient;
    private Context mContext;

    public Geofencing(Context context, GoogleApiClient client) {
        mContext = context;
        mGoogleApiClient = client;
        mGeofencePendingIntent = null;
        mGeofenceList = new ArrayList<>();
    }

    /***
     * Registers the list of Geofences specified in mGeofenceList with Google Place Services
     * Uses {@code #mGoogleApiClient} to connect to Google Place Services
     * Uses {@link #getGeofencingRequest} to get the list of Geofences to be registered
     * Uses {@link #getGeofencePendingIntent} to get the pending intent to launch the IntentService
     * when the Geofence is triggered
     * Triggers {@link #onResult} when the geofences have been registered successfully
     */
    public void registerAllGeofences() {
        // Check that the API client is connected and that the list has Geofences in it
        if (mGoogleApiClient == null || !mGoogleApiClient.isConnected() ||
                mGeofenceList == null || mGeofenceList.size() == 0) {
            return;
        }
        try {
            LocationServices.GeofencingApi.addGeofences(
                    mGoogleApiClient,
                    getGeofencingRequest(),
                    getGeofencePendingIntent()
            ).setResultCallback(this);
        } catch (SecurityException securityException) {
            // Catch exception generated if the app does not use ACCESS_FINE_LOCATION permission.
            Log.e(TAG, securityException.getMessage());
        }
    }

    /***
     * Unregisters all the Geofences created by this app from Google Place Services
     * Uses {@code #mGoogleApiClient} to connect to Google Place Services
     * Uses {@link #getGeofencePendingIntent} to get the pending intent passed when
     * registering the Geofences in the first place
     * Triggers {@link #onResult} when the geofences have been unregistered successfully
     */
    public void unRegisterAllGeofences() {
        if (mGoogleApiClient == null || !mGoogleApiClient.isConnected()) {
            return;
        }
        try {
            LocationServices.GeofencingApi.removeGeofences(
                    mGoogleApiClient,
                    // This is the same pending intent that was used in registerGeofences
                    getGeofencePendingIntent()
            ).setResultCallback(this);
        } catch (SecurityException securityException) {
            // Catch exception generated if the app does not use ACCESS_FINE_LOCATION permission.
            Log.e(TAG, securityException.getMessage());
        }
    }


    /***
     * Updates the local ArrayList of Geofences using data from the passed in list
     * Uses the Place ID defined by the API as the Geofence object Id
     *
     * @param places the PlaceBuffer result of the getPlaceById call
     */
    public void updateGeofencesList(PlaceBuffer places) {
        mGeofenceList = new ArrayList<>();
        if (places == null || places.getCount() == 0) return;
        for (Place place : places) {
            // Read the place information from the DB cursor
            String placeUID = place.getId();
            double placeLat = place.getLatLng().latitude;
            double placeLng = place.getLatLng().longitude;
            // Build a Geofence object
            Geofence geofence = new Geofence.Builder()
                    .setRequestId(placeUID)
                    .setExpirationDuration(GEOFENCE_TIMEOUT)
                    .setCircularRegion(placeLat, placeLng, GEOFENCE_RADIUS)
                    .setTransitionTypes(Geofence.GEOFENCE_TRANSITION_ENTER | Geofence.GEOFENCE_TRANSITION_EXIT)
                    .build();
            // Add it to the list
            mGeofenceList.add(geofence);
        }
    }

    /***
     * Creates a GeofencingRequest object using the mGeofenceList ArrayList of Geofences
     * Used by {@code #registerGeofences}
     *
     * @return the GeofencingRequest object
     */
    private GeofencingRequest getGeofencingRequest() {
        GeofencingRequest.Builder builder = new GeofencingRequest.Builder();
        builder.setInitialTrigger(GeofencingRequest.INITIAL_TRIGGER_ENTER);
        builder.addGeofences(mGeofenceList);
        return builder.build();
    }

    /***
     * Creates a PendingIntent object using the GeofenceTransitionsIntentService class
     * Used by {@code #registerGeofences}
     *
     * @return the PendingIntent object
     */
    private PendingIntent getGeofencePendingIntent() {
        // Reuse the PendingIntent if we already have it.
        if (mGeofencePendingIntent != null) {
            return mGeofencePendingIntent;
        }
        //Intent intent = new Intent(mContext, GeofenceBroadcastReceiver.class);
        Intent intent = new Intent("com.aol.android.geofence.ACTION_RECEIVE_GEOFENCE");
        mGeofencePendingIntent = PendingIntent.getBroadcast(mContext, 0, intent, PendingIntent.
                FLAG_UPDATE_CURRENT);
        return mGeofencePendingIntent;
    }

    @Override
    public void onResult(@NonNull Result result) {
        Log.e(TAG, String.format("Error adding/removing geofence : %s",
                result.getStatus().toString()));
    }

}

GeofenceBroadcastReceiver:

public class GeofenceBroadcastReceiver extends BroadcastReceiver {

    public static final String TAG = GeofenceBroadcastReceiver.class.getSimpleName();

    /***
     * Handles the Broadcast message sent when the Geofence Transition is triggered
     * Careful here though, this is running on the main thread so make sure you start an AsyncTask for
     * anything that takes longer than say 10 second to run
     *
     * @param context
     * @param intent
     */
    @Override
    public void onReceive(Context context, Intent intent) {
        // Get the Geofence Event from the Intent sent through

        Log.d("onRecccc","trt");

        GeofencingEvent geofencingEvent = GeofencingEvent.fromIntent(intent);
        if (geofencingEvent.hasError()) {
            Log.e(TAG, String.format("Error code : %d", geofencingEvent.getErrorCode()));
            return;
        }

        // Get the transition type.
        int geofenceTransition = geofencingEvent.getGeofenceTransition();
        // Check which transition type has triggered this event

        // Send the notification
        sendNotification(context, geofenceTransition);
    }


    /**
     * Posts a notification in the notification bar when a transition is detected
     * Uses different icon drawables for different transition types
     * If the user clicks the notification, control goes to the MainActivity
     *
     * @param context        The calling context for building a task stack
     * @param transitionType The geofence transition type, can be Geofence.GEOFENCE_TRANSITION_ENTER
     *                       or Geofence.GEOFENCE_TRANSITION_EXIT
     */
    private void sendNotification(Context context, int transitionType) {
        // Create an explicit content Intent that starts the main Activity.
        Intent notificationIntent = new Intent(context, MainActivity.class);

        // Construct a task stack.
        TaskStackBuilder stackBuilder = TaskStackBuilder.create(context);

        // Add the main Activity to the task stack as the parent.
        stackBuilder.addParentStack(MainActivity.class);

        // Push the content Intent onto the stack.
        stackBuilder.addNextIntent(notificationIntent);

        // Get a PendingIntent containing the entire back stack.
        PendingIntent notificationPendingIntent =
                stackBuilder.getPendingIntent(0, PendingIntent.FLAG_UPDATE_CURRENT);

        // Get a notification builder
        NotificationCompat.Builder builder = new NotificationCompat.Builder(context);

        // Check the transition type to display the relevant icon image
        if (transitionType == Geofence.GEOFENCE_TRANSITION_ENTER) {
            builder.setSmallIcon(R.drawable.ic_near_me_black_24dp)
                    .setLargeIcon(BitmapFactory.decodeResource(context.getResources(),
                            R.drawable.ic_near_me_black_24dp))
                    .setContentTitle("You have a task nearby")
                    .setSound(RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION))
                    //Vibration
                    .setVibrate(new long[]{300,300})
                    .setLights(Color.RED, 3000, 3000);
                    //LED


        } else if (transitionType == Geofence.GEOFENCE_TRANSITION_EXIT) {
            builder.setSmallIcon(R.drawable.ic_near_me_black_24dp)
                    .setLargeIcon(BitmapFactory.decodeResource(context.getResources(),
                            R.drawable.ic_near_me_black_24dp))
                    .setContentTitle(context.getString(R.string.back_to_normal));
        }

        // Continue building the notification
        builder.setContentText(context.getString(R.string.touch_to_relaunch));
        builder.setContentIntent(notificationPendingIntent);

        // Dismiss notification once the user touches it.
        builder.setAutoCancel(true);

        // Get an instance of the Notification manager
        NotificationManager mNotificationManager =
                (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);

        // Issue the notification
        mNotificationManager.notify(0, builder.build());
    }

}

编辑:

 @Override
    protected void onHandleIntent(@Nullable Intent intent) {
        //Create geofences from SharedPreferences/network responses
        //Connect to location services


        mClient = new GoogleApiClient.Builder(this)

                .addConnectionCallbacks(this)
                .addOnConnectionFailedListener(this)
                .addApi(LocationServices.API)
                .addApi(Places.GEO_DATA_API)
                .addApi(Places.PLACE_DETECTION_API)
                .build();

        mGeofencing = new Geofencing(this, mClient);
        GeofencingEvent geofencingEvent = GeofencingEvent.fromIntent(intent);
        if (geofencingEvent.hasError()) {
            Log.e("dsadsa", String.format("Error code : %d", geofencingEvent.getErrorCode()));
            return;
        }
    }


    public void onConnected(Bundle bundle) {
        //Add geofences
        mGeofencing.registerAllGeofences();

    }

到目前为止我已经这样做了,但仍然没有运气..

3 个答案:

答案 0 :(得分:3)

我有同样的问题,直到应用程序在前景地理位置完美运行并且每次设备进入/退出时触发但是当应用程序进入后台时我没有收到任何通知。

我怀疑是Android O背景限制,但它还没有开始工作 Android 7也是。

我尝试过使用Broadcaster接收器或服务,两者都在前台工作但在后台工作。必须有一些我们错过的(或错误),因为他们不可能在后台工作。

答案 1 :(得分:0)

当应用程序在后台时(用户单击“主页”按钮,或多次返回,直到他看到主屏幕),我遇到同样的问题。

我尝试通过在Manifest中注册BroadcastReceiver来解决它 而不是IntentService ..它没有多大帮助,因为我得到了相同的结果..

然后,我尝试了这个: 打开应用程序,添加地理围栏并转到主屏幕。 你可能已经明白地理围栏没有触发.. 但是当我点击谷歌地图而不是我的应用程序时......它被触发!!

因此,如果有任何应用请求,它似乎正在后台工作 用于位置更新(如谷歌地图)。

所以我尝试了这种方法: 我使用LocationServices.FusedLocationApi创建了一个粘贴服务来请求位置更新..此服务包含GoogleApiClient 并实现GoogleApiClient.ConnectionCallbacksGoogleApiClient.OnConnectionFailedListener

但是猜猜怎么着?它仍无法在后台运行:(

<强>更新 在我尝试了这么多次以使其工作之后......它终于奏效了! 我有一个带有Google Play services (version 11.3.02)的Android模拟器 和Android 7.0 如果您想要了解如何使用Geofence以及如何使用模拟器进行检查take a look at this link

现在,当应用程序在前台然后在后台运行时,我尝试使用此模拟器进行地理围栏!

当我说它在背景上对我不起作用时,Android版本就开始了 那个模拟器是Android 8。 所以我想我需要为Android 8找到解决方案 - &gt; 一个好的开始是this documentation link,他们在那里解释如何 他们现在处理背景和前台应用程序。

答案 2 :(得分:-2)

您发布的代码是关于在应用运行+处理地理围栏事件时注册地理围栏。此外,根据documentation,您应该重新注册地理围栏有五个事件:

  1. 重启设备。该应用应该监听设备的启动 完成操作,然后重新注册所需的地理围栏。
  2. 已卸载并重新安装该应用。
  3. 应用程序的数据已清除。
  4. Google Play服务数据已清除。
  5. 该应用已收到GEOFENCE_NOT_AVAILABLE提醒。这通常发生在NLP(Android的网络位置提供商)被禁用后。
  6. 让我们一个一个地弄明白:

    关于 2&amp; 3 没有任何事情可做,如果地理围栏被分配到您应用中的某种经过身份验证的活动,那么您根本就不需要它们。

    关于 4 ,它非常像2&amp; 3,我还没有尝试深入研究这一点,但我认为没有办法倾听这一事件。

    1 可以通过注册BroadcastReceiver来轻松解决:

    public class BootBroadcastReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            Intent startServiceIntent = new Intent(context, AddingGeofencesService.class);
            context.startService(startServiceIntent);
        }
    }
    

    注意AddingGeofencesService,您应该创建的服务,以便在BootBroadcastReceiver收到意图后添加地理围栏。像这样:

    public class AddingGeofencesService extends IntentService implements GoogleApiClient.ConnectionCallbacks {
    
        public AddingGeofencesService() {
            super("AddingGeofencesService");
        }
    
        @Override
        public void onCreate() {
            super.onCreate();
        }
    
        @Override
        protected void onHandleIntent(@Nullable Intent intent) {
                //Create geofences from SharedPreferences/network responses
                //Connect to location services
            }
        }
    
        public void onConnected(Bundle bundle) {
            //Add geofences
        }
        ...
    }
    

    让我们不要忘记清单代码:

    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
    
    <service android:name=".AddingGeofencesService"/>
    
    <receiver android:name=".BootBroadcastReceiver">
        <intent-filter>
            <action android:name="android.intent.action.BOOT_COMPLETED" />
        </intent-filter>
    </receiver>
    

    5 主要指的是位置提供商的变化。此案例的解决方案也是BroadcastReceiver

    public class LocationProviderChangedBroadcastReceiver extends BroadcastReceiver {
        boolean isGpsEnabled;
        boolean isNetworkEnabled;
    
        @Override
        public void onReceive(Context context, Intent intent) {
            if (intent.getAction().matches("android.location.PROVIDERS_CHANGED"))
            {
                LocationManager locationManager = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);
                isGpsEnabled = locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);
                isNetworkEnabled = locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
    
                if (isGpsEnabled || isNetworkEnabled) {
                    Intent startServiceIntent = new Intent(context, AddingGeofencesService.class);
                    context.startService(startServiceIntent);
                }
            }
        }
    }
    

    清单:

    <receiver
        android:name=".LocationProviderChangedBroadcastReceiver"
        android:exported="false" >
        <intent-filter>
            <action android:name="android.location.PROVIDERS_CHANGED" />
            <category android:name="android.intent.category.DEFAULT" />
        </intent-filter>
    </receiver>
    

    修改

    我在这里提供用于管理地理围栏的代码。它来自上面的答案。

    我排除了LocationServicesManager的与答案无关的子类。

    /*
     * This class does not handle permission checks/missing permissions. The context that's containing
     * this class is responsible of that.
     */
    public class LocationServicesManager implements
            GoogleApiClient.ConnectionCallbacks,
            GoogleApiClient.OnConnectionFailedListener {
    
        private static final String TAG = "YOURTAG";
    
        private GoogleApiClient mGoogleApiClient;
        private Context context;
    
        public GeofencesManager geofencesManager;
    
        private OnGoogleServicesConnectedListener onGoogleServicesConnectedListener;
    
        public LocationServicesManager(Context context,
                                       OnGoogleServicesConnectedListener onGoogleServicesConnectedListener) {
            this.context = context;
            this.onGoogleServicesConnectedListener = onGoogleServicesConnectedListener;
            buildGoogleApiClient(context);
        }
    
        public void GeofencesManager() {
            geofencesManager = new GeofencesManager();
        }
    
        //region Definition, handling connection
        private synchronized void buildGoogleApiClient(Context context) {
            mGoogleApiClient = new GoogleApiClient.Builder(context)
                    .addConnectionCallbacks(this)
                    .addOnConnectionFailedListener(this)
                    .addApi(LocationServices.API)
                    .build();
        }
    
        public void connect() {
            mGoogleApiClient.connect();
        }
    
        public void disconnect() {
            if (mGoogleApiClient.isConnected()) {
                mGoogleApiClient.disconnect();
            }
        }
    
        public boolean isConnected() {
            return mGoogleApiClient.isConnected();
        }
    
        @SuppressWarnings({"MissingPermission"})
        @Override
        public void onConnected(Bundle connectionHint) {
            onGoogleServicesConnectedListener.onGoogleServicesConnected();
        }
    
        @Override
        public void onConnectionFailed(@NonNull ConnectionResult result) {
            Log.i(TAG, "Connection failed: ConnectionResult.getErrorCode() = " + result.getErrorCode());
        }
    
    
        @Override
        public void onConnectionSuspended(int cause) {
            // Trying to re-establish the connection.
            Log.i(TAG, "Connection suspended");
            mGoogleApiClient.connect();
        }
        //endregion
    
        public class GeofencesManager implements ResultCallback<Status> {
    
            private ArrayList<Geofence> mGeofenceList = new ArrayList<>();
    
            private PendingIntent mGeofencePendingIntent = null;
    
            private GeofencesManager() {
    
            }
    
            public void addGeofenceToList(String key, long expirationDuration, Location location, int radius) {
                addGeofenceToList(key, expirationDuration, new LatLng(location.getLatitude(), location.getLongitude()), radius);
            }
    
            public void addGeofenceToList(String key, long expirationDuration, LatLng location, int radius) {
                if (location != null) {
                    mGeofenceList.add(new Geofence.Builder()
                            .setRequestId(key)
                            .setCircularRegion(location.latitude, location.longitude, radius)
                            .setExpirationDuration(expirationDuration)
                            .setTransitionTypes(Geofence.GEOFENCE_TRANSITION_DWELL
                                    | Geofence.GEOFENCE_TRANSITION_ENTER
                                    | Geofence.GEOFENCE_TRANSITION_EXIT)
                            .setLoiteringDelay(1000 * 30)
                            .build());
                }
            }
    
            /**
             * Runs when the result of calling addGeofences() and removeGeofences() becomes available.
             * Either method can complete successfully or with an error.
             */
            public void onResult(@NonNull Status status) {
                if (status.isSuccess()) {
                    Log.i(TAG, "onResult: " + status.toString());
                } else {
                    Log.e(TAG, getGeofenceErrorString(status.getStatusCode()));
                }
            }
    
            /**
             * Gets a PendingIntent to send with the request to add or remove Geofences. Location Services
             * issues the Intent inside this PendingIntent whenever a geofence transition occurs for the
             * current list of geofences.
             *
             * @return A PendingIntent for the IntentService that handles geofence transitions.
             */
            private PendingIntent getGeofencePendingIntent() {
                if (mGeofencePendingIntent != null) {
                    return mGeofencePendingIntent;
                }
    
                Intent intent = new Intent(context, GeofenceTransitionsIntentService.class);
                // We use FLAG_UPDATE_CURRENT so that we get the same pending intent back when calling
                return PendingIntent.getService(context, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);
            }
    
            /**
             * Builds and returns a GeofencingRequest. Specifies the list of geofences to be monitored.
             * Also specifies how the geofence notifications are initially triggered.
             */
            @NonNull
            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);
    
                // Add the geofences to be monitored by geofencing service.
                // Empty mGeofenceList leads to crash
                builder.addGeofences(mGeofenceList);
    
                return builder.build();
            }
    
            public void addGeofences() {
                if (mGeofenceList.size() > 0) {
                    try {
                        LocationServices.GeofencingApi.addGeofences(
                                mGoogleApiClient,
                                getGeofencingRequest(),
                                getGeofencePendingIntent()
                        ).setResultCallback(this);
                    } catch (SecurityException securityException) {
                        Crashlytics.logException(securityException);
                        Log.e(TAG, "Missing permission ACCESS_FINE_LOCATION", securityException);
                    }
                }
            }
    
            public void removeGeofences() {
                if (mGeofenceList.size() > 0) {
                    LocationServices.GeofencingApi.removeGeofences(
                            mGoogleApiClient,
                            getGeofencePendingIntent()
                    ).setResultCallback(this); // Result processed in onResult().
                }
            }
        }
    
        public static String getGeofenceErrorString(int errorCode) {
            switch (errorCode) {
                case GeofenceStatusCodes.GEOFENCE_NOT_AVAILABLE:
                    return "Geofence service is not available now";
                case GeofenceStatusCodes.GEOFENCE_TOO_MANY_GEOFENCES:
                    return "Your app has registered too many geofences";
                case GeofenceStatusCodes.GEOFENCE_TOO_MANY_PENDING_INTENTS:
                    return "You have provided too many PendingIntents to the addGeofences() call";
                default:
                    return "Unknown error: the Geofence service is not available now";
            }
        }
    }
    

    上述界面:

    public interface OnGoogleServicesConnectedListener {
        void onGoogleServicesConnected();
    }
    

    班级GeofenceTransitionsIntentService

    /**
     * Listener for geofence transition changes.
     *
     * Receives geofence transition events from Location Services in the form of an Intent containing
     * the transition type and geofence id(s) that triggered the transition. 
     */
    public class GeofenceTransitionsIntentService extends IntentService {
    
        private static final String TAG = "YOURTAG";
    
        public GeofenceTransitionsIntentService() {
            super(TAG);
        }
    
        @Override
        public void onCreate() {
            super.onCreate();
        }
    
        /**
         * Handles incoming intents.
         * @param intent sent by Location Services. This Intent is provided to Location
         *               Services (inside a PendingIntent) when addGeofences() is called.
         */
        @Override
        protected void onHandleIntent(Intent intent) {
            GeofencingEvent geofencingEvent = GeofencingEvent.fromIntent(intent);
            //Do stuff with the geofencing events
        }
    }
    

    在清单中:

    <service android:name=".GeofenceTransitionsIntentService"/>
    

    最后,总结AddingGeofencesService

    public class AddingGeofencesService extends IntentService implements OnGoogleServicesConnectedListener {
    
        private static final String TAG = "YOURTAG";
    
        LocationServicesManager locationServicesManager;
    
        public AddingGeofencesService() {
            super(TAG);
        }
    
        @Override
        public void onCreate() {
            super.onCreate();
        }
    
        @Override
        protected void onHandleIntent(@Nullable Intent intent) {
                locationServicesManager = new LocationServicesManager(this, this);
                locationServicesManager.GeofencesManager();
    
                //Fetch your geofences from somewhere
                List<YourGeofenceObject> yourGeofences = ...
    
                for (YourGeofenceObject geo : yourGeofences) {
                    locationServicesManager.geofencesManager.addGeofenceToList(geo.getKey(),
                            geo.getExpirationDuration(), geo.getLocation(), geo.getRadius());
                }
    
                locationServicesManager.connect();
            }
        }
    
        @Override
        public void onGoogleServicesConnected() {
            locationServicesManager.geofencesManager.addGeofences();
        }
    }
    

    请注意,您应该在应用运行时添加地理围栏,方法与在AddingGeofencesService中添加地理围栏相同。