Device Location Awareness (DLA)

📘

Note:

DLA requires a minimum API target of 19.

1. To use locations, add the following permissions. BLUETOOTH and BLUETOOTH_ADMIN are only needed if you use beacons. On later versions of Android, you also need to request these permissions explicitly from the user. For more information, see Requesting location permissions on Android section.
   Java

   <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
   <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
   <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />
   
   <uses-permission android:name="android.permission.BLUETOOTH" />
   <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
   <uses-permission android:name="android.permission.BLUETOOTH_SCAN" />
   

📘

Note:

Android SDK 3.8.6 provides support to meet Google Play’s requirements of API level 31 (Android 12). For applications targetting Android SDK 31, Beacon support requires adding permission to the manifest.

2. Add the following services. If you don't use beacons, don't add the last two lines for MceBluetoothScanner and BeaconsVerifier services.
   Java

   <service android:name="co.acoustic.mobile.push.sdk.location.LocationRetrieveService" />
   <service android:name="co.acoustic.mobile.push.sdk.location.LocationEventsIntentService" />
   <service android:name="co.acoustic.mobile.push.sdk.location.LocationSyncAlarmListener" />
   <receiver android:name="co.acoustic.mobile.push.sdk.location.LocationUpdateCaller" />
   
   <service android:name="co.acoustic.mobile.push.sdk.beacons.MceBluetoothScanner" />
   <service android:name="co.acoustic.mobile.push.sdk.beacons.BeaconsVerifier" />
   

3. To enable location support, use the enableLocationSupport method in the co.acoustic.mobile.push.sdk.location.LocationManager class. Do not call this method before the device is registered with the Acoustic Campaign server: LocationManager.enableLocationSupport(context);
   To disable location support, use disableLocationSupport in the co.acoustic.mobile.push.sdk.location.LocationManager class: LocationManager.disableLocationSupport(context);
4. To receive location, enter, exit, and dwell events, implement the onLocationEvent method in your subclass of MceBroadcastReceiver. The onLocationEvent is called whenever a geofence or beacon enter, exit, or dwell event occurs. The following code sample shows how to implement the method.
   Java

   
   @Override
   // location type is ibeacon or geofence
   // location event type is enter, exit or dwell 
   public void onLocationEvent(Context context, MceLocation location, LocationType locationType, LocationEventType
   locationEventType) { 
    Log.d(TAG, "Location event: "+locationType.name()+" "+locationEventType.name()+" id = "+location.getId());
   // Uncomment this line to have the device display its location for testing purposes.
   // Do not ship with this uncommented.
   // showNotification(context, locationType.name()+" "+locationEventType.name(), location.getId(), locationType.name());
   }
   

5. To receive location, enter, exit, and dwell events when the device location is updated, implement the onLocationUpdate method in your subclass of MceBroadcastReceiver. The onLocationUpdate method is called when the sdk receives a device location update. The following code sample shows how to implement the method.
   Java

   
   @Override
   public void onLocationUpdate(Context context, Location location) {
    Log.d(TAG, "Location was updated "+location); 
   }
   

6. Add LocationBroadcastReceiver and GeofenceBroadcastReceiver:
   Java

   
   <receiver android:name="co.acoustic.mobile.push.sdk.location.LocationBroadcastReceiver" android:enabled="true" android:exported="true"/>
   <receiver android:name="co.acoustic.mobile.push.sdk.location.GeofenceBroadcastReceiver" android:enabled="true" android:exported="true"/>
   

Requesting location permissions on Android

With newer releases of Android, you must explicitly request location permissions. Users can optionally accept or refuse these permissions for the app. On Cordova and Xamarin, the SDK prompts users for permissions by default. However, on native Android, users need to request the permissions.

📘

Note:

For Android 11 (API level 30) or higher, Android now requires that location permissions are requested incrementally. For example, request the foreground locations access first and then the background location access. For more information, see Request location permissions
Our sample app has been updated to enable location permissions incrementally. Check it out to test how it works.

To request permissions for location on Android, do the following:

1. Enable locations in an Activity so that the parent element can display the child permissions dialog.
2. Define two different request codes for the permissions incrementally. The codes can be of any value. Example permission request codes to use when requesting permissions
   Java

   
   /*
        *  Example permission request codes to use when requesting permissions
        */
       private static final int REQUEST_LOCATION_PERMISSIONS = 0;
       private static final int REQUEST_BACKGROUND_PERMISSIONS = 1;
       

3. Because Android 11 requires the background location permissions to be requested incrementally after other location permissions, organize permissions into different lists, based on OS version and whether permission requests would be incremental or not.
   Java

   
   /*
        *  This is the list of permissions required for DLA for all versions
        *  of Android up to and including Android Pie (API Level 28)
        */
       private static final String[] LOCATION_PERMISSIONS_ANDROID_ALL_VERSION_THROUGH_P = {
               Manifest.permission.ACCESS_FINE_LOCATION,
               Manifest.permission.ACCESS_COARSE_LOCATION,
               Manifest.permission.BLUETOOTH,
               Manifest.permission.BLUETOOTH_ADMIN
       };
   
       /*
        *  This is the list of permissions required for DLA starting with
        *  Android 10 (API Level 29). Note, the ACCESS_BACKGROUND_LOCATION
        *  permission was added with Android 10.
        */
       @RequiresApi(api = Build.VERSION_CODES.Q)
       private static final String[] LOCATION_PERMISSIONS_ANDROID_Q_OR_LATER = {
               Manifest.permission.ACCESS_FINE_LOCATION,
               Manifest.permission.ACCESS_COARSE_LOCATION,
               Manifest.permission.BLUETOOTH,
               Manifest.permission.BLUETOOTH_ADMIN,
               Manifest.permission.ACCESS_BACKGROUND_LOCATION
       };
   
       /*
        *  Starting with Android 11 (API Level 30), the ACCESS_BACKGROUND_LOCATION
        *  permission must be requested separately and after the Fine and Coarse
        *  location permissions have been granted. As such, the ACCESS_BACKGROUND_LOCATION
        *  has been moved to a secondary list.
        */
       @RequiresApi(api = Build.VERSION_CODES.R)
       private static final String[] LOCATION_PERMISSIONS_ANDROID_R_OR_LATER = {
               Manifest.permission.ACCESS_FINE_LOCATION,
               Manifest.permission.ACCESS_COARSE_LOCATION,
               Manifest.permission.BLUETOOTH,
               Manifest.permission.BLUETOOTH_ADMIN
       };
   
       @RequiresApi(api = Build.VERSION_CODES.R)
       private static final String[] BACKGROUND_PERMISSIONS_ANDROID_R_OR_LATER = {
               Manifest.permission.ACCESS_BACKGROUND_LOCATION
       };
       

4. Next, check if the device was running Android 11 or not to make incremental requests.
   Java

   
   private void requestPermissions(@NonNull Activity activity) {
   
           /*
            *  Requesting permissions for Android 11 (API Level 30) or later
            */
           if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
   
               /*
                *  First check if the primary location permissions have been granted.
                *  Be sure to request these first before ACCESS_BACKGROUND_LOCATION
                */
               if (!checkSelfPermissions(activity, LOCATION_PERMISSIONS_ANDROID_R_OR_LATER)) {
                   ActivityCompat.requestPermissions(
                           activity,
                           LOCATION_PERMISSIONS_ANDROID_R_OR_LATER,
                           REQUEST_LOCATION_PERMISSIONS
                   );
   
               }
   
               /*
                *  If the primary location permissions have already been granted, be sure the
                *  ACCESS_BACKGROUND_LOCATION permission has been granted as well. Be sure to
                *  follow Android's recommended practices for requesting location permissions
                *  at run time, seen here: https://developer.android.com/training/location/permissions
                *  This would include displaying to users the rationale for granting this permission
                *  if the operating system deems this necessary.
                */
               else if (!checkSelfPermissions(activity, BACKGROUND_PERMISSIONS_ANDROID_R_OR_LATER)) {
   
                   if (ActivityCompat.shouldShowRequestPermissionRationale(activity, Manifest.permission.ACCESS_BACKGROUND_LOCATION)) {
                       displayBackgroundLocationRationale();
   
                   } else {
                       ActivityCompat.requestPermissions(
                               activity,
                               BACKGROUND_PERMISSIONS_ANDROID_R_OR_LATER,
                               REQUEST_BACKGROUND_PERMISSIONS
                       );
                   }
               }
   
               /*
                *  If all required location permissions have been granted,
                *  you may now enable location support.
                */
               else {
                   LocationManager.enableLocationSupport(getApplicationContext());
                   updateUIPermissionsGranted();
               }
           }
   
           /*
            *  Requesting Location Permissions for Android 10 (API Level 29) and before
            */
           else {
   
               /*
                *  Request the correct permissions based on the version of Android
                */
               String[] permissions = Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q
                       ? LOCATION_PERMISSIONS_ANDROID_Q_OR_LATER
                       : LOCATION_PERMISSIONS_ANDROID_ALL_VERSION_THROUGH_P;
   
               if (!checkSelfPermissions(activity, permissions)) {
                   ActivityCompat.requestPermissions(
                           activity,
                           permissions,
                           REQUEST_LOCATION_PERMISSIONS
                   );
               }
   
               /*
                *  If permissions have already been granted, you may enable location support
                */
               else {
                   LocationManager.enableLocationSupport(getApplicationContext());
                   updateUIPermissionsGranted();
               }
           }
       }
   
       private boolean checkSelfPermissions(@NonNull Context context, @NonNull String[] permissions) {
           for (String permission : permissions) {
               if (ContextCompat.checkSelfPermission(context, permission) != PackageManager.PERMISSION_GRANTED) {
                   return false;
               }
           }
   
           return true;
       }
    

5. Because Android 31 requires Beacon permissions, you must add the BLUETOOTH_SCAN permission for iBeacons to work.
Java

/*
 *  Starting with Android 12 (API Level 31), the the new BLUETOOTH_SCAN
 *  permission must be requested in order for iBeacons to work.
 */
@RequiresApi(api = Build.VERSION_CODES.S)
private static final String[] LOCATION_PERMISSIONS_ANDROID_S_OR_LATER = {
        Manifest.permission.ACCESS_FINE_LOCATION,
        Manifest.permission.ACCESS_COARSE_LOCATION,
        Manifest.permission.BLUETOOTH,
        Manifest.permission.BLUETOOTH_ADMIN,
        Manifest.permission.BLUETOOTH_SCAN
};

6. Check the request code; if it was the request code for the background permissions, and it was granted, then enable location. If it is the request code for the normal location permissions, check the Android version to identify if you need to continue with the incremental permission requests or not.
   Java

   
   @Override
       public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
   
           /*
            *  If the request was for ACCESS_BACKGROUND_LOCATIONS and the
            *  permission was granted, enable location support
            */
           if (requestCode == REQUEST_BACKGROUND_PERMISSIONS) {
               if (checkPermissionsGranted(grantResults)) {
                   LocationManager.enableLocationSupport(getApplicationContext());
                   updateUIPermissionsGranted();
               }
           }
   
           /*
            *  If the request was for the base location permissions,
            *  and the permissions were granted, check the Android version.
            *  If running Android 11 (API Level 30) or later, you may still
            *  need to request the ACCESS_BACKGROUND_LOCATION permission.
            *  Allow the user to grant this permission. For all previous
            *  versions of Android, or if ACCESS_BACKGROUND_LOCATION has
            *  been granted, you may now enable location support.
            */
           else if (requestCode == REQUEST_LOCATION_PERMISSIONS) {
               if (checkPermissionsGranted(grantResults)) {
                   if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
                       if (!checkSelfPermissions(this, BACKGROUND_PERMISSIONS_ANDROID_R_OR_LATER)) {
                           updateUIAccessBackgroundNeeded();
   
                       } else {
                           LocationManager.enableLocationSupport(getApplicationContext());
                           updateUIPermissionsGranted();
                       }
   
                   } else {
                       LocationManager.enableLocationSupport(getApplicationContext());
                       updateUIPermissionsGranted();
                   }
               }
           }
       }
   
       private boolean checkPermissionsGranted(@NonNull int[] grantResults) {
           for (int result : grantResults) {
               if (result != PackageManager.PERMISSION_GRANTED) {
                   return false;
               }
           }
   
           return true;
       }
       

The example code snippets are focused on just requesting permissions and enabling locations. Follow the best practices recommended by Android for implementing the UI for requesting incremental permissions. Those best practices are described here: Request location permissions

Introduce a new dialog

You can also introduce a new dialog to prompt users before opening the Android permissions dialog. In this dialog, you can explain why the user might want to grant permissions and request their consent. If they agree, the Android dialog can be displayed to enable location support. Even if a user does not currently want to share location, you can request it again later when required.

When configuring locations, add the files for the appropriate plug-ins to your project and then register them.

1. Add the Location Sync plug-in to Cordova projects by using the Cordova add command from the command line. For example:
   Text

   'cordova plugin add <path to downloaded directory>/plugins/co.acoustic.mobile.push.plugin.location cordova prepare'
   

2. Add the NSLocation key and string to the info.plist file.
3. Start location services by calling the manualLocationInitialization method.
   If you installed the Cordova plug-in with the AUTO_INITIALIZE_LOCATION variable set to false, you start location services and monitoring for locations by calling the manualLocationInitialization method.

iOS

To configure the Flutter SDK for DLA, you must update the Info.plist file.

1. In your project, open the Info.plist file.
2. Set the Background Modes capability and then enable the Location updates and the Background fetch.

<key>UIBackgroundModes</key>
    <array>
        <string>fetch</string>
        <string>location</string>
    </array>

3. To use location services, add the NSLocation key and string to the Info.plist file for the app project.

   The NSLocationAlwaysUsageDescription requests permission from the mobile app user to use location services when your app is running in the background. Because Apple recently started prohibiting apps from sharing location data with third parties when explicit user consent is absent, you might want to use NSLocationAlwaysUsageDescription to tell users how the SDK uses location data.

   The SDK stores location data locally on the device, and when an event is triggered, the event is sent to the MCE servers. The event does not contain raw location data. To convince users to grant permission, you might also want to inform them that battery usage is minimal when location sharing is enabled.

    <key>NSLocationAlwaysUsageDescription</key>
        <string>Permission to use location</string>
        

iOS 11 (and later)

For iOS 11, you must add both the NSLocationWhenInUseUsageDescription key and the NSLocationAlwaysAndWhenInUseUsageDescription key to the Info.plist file.

        <key>NSLocationAlwaysUsageDescription</key>
        <string>Permission to use location</string>
        <key>NSLocationWhenInUseUsageDescription</key>
        <string>Permission to use location</string>
        <key>NSLocationAlwaysAndWhenInUseUsageDescription</key>
        <string>Permission to use location</string>
        

Permission Requests

iOS 13 changes location permission requests so users can not grant "always" permission from the application. Location "always" permission can be granted one of two ways:

• The app could request the "always" permission and prompt the user to allow for "while using" permission. For example, when the app tries to use location in the background and fails for an unspecified amount of time, the user is asked if the app can have "always" location permission. This request typically occurs while the app is not running or within a day of the original request.
• The app could instruct the user to open the settings app manually, select the app's settings, and then grant the "always" location permission from there.

Android

Update the AndroidManifest.xml file to configure the Flutter SDK for DLA.

1. In your project, open the AndroidManifest.xml file.
2. To use locations, add the following permissions. BLUETOOTH and BLUETOOTH_ADMIN are only needed if you use beacons. On later versions of Android, you also need to request these permissions explicitly from the user. For more information, see Requesting location permissions on Android section.
   Java

   
   <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
   <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
   <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />
               
   <uses-permission android:name="android.permission.BLUETOOTH" />
   <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
   <uses-permission android:name="android.permission.BLUETOOTH_SCAN" />
   

3. Add the following services. If you don't use beacons, don't add the last two lines for MceBluetoothScanner and BeaconsVerifier services.
Java

<service android:name="co.acoustic.mobile.push.sdk.location.LocationRetrieveService" />
<service android:name="co.acoustic.mobile.push.sdk.location.LocationEventsIntentService" />
<service android:name="co.acoustic.mobile.push.sdk.location.LocationSyncAlarmListener" />
<receiver android:name="co.acoustic.mobile.push.sdk.location.LocationUpdateCaller" />
                
<service android:name="co.acoustic.mobile.push.sdk.beacons.MceBluetoothScanner" />
<service android:name="co.acoustic.mobile.push.sdk.beacons.BeaconsVerifier" />

Campaign provides three location plug-ins that you can use to integrate beacons and geofences with iOS and Android apps developed in Cordova.

The Location Sync plug-in enables location syncing for both beacon and geofence regions. To use either beacons or geofences with apps developed in Cordova, you must first add the Location Sync plug-in to your project.

The Location Sync plug-in uses the SYNC_RADIUS and SYNC_INTERVAL optional parameters for iOS and Android. If you do not include an optional variable in the command line, the default value is used.

1. Run the following command line to add the Geofence plug-in to Cordova projects.

   'cordova plugin add <path to downloaded directory>/plugins/co.acoustic.mobile.push.plugin.geofence
   cordova prepare' 

2. Add the Beacon plug-in to Cordova projects.The Beacon plug-in enables support for beacons in iOS and Android applications developed with Cordova. To add the Beacon plug-in to your Cordova project, run the following command line, where “8EE07E37-8EE5-4CF4-8A98-992D08285CF0” represents the UUID for your org:

   'cordova plugin add <path to downloaded directory>/plugins/co.acoustic.mobile.push.plugin.beacon
   --variable UUID=8EE07E37-8EE5-4CF4-8A98-992D08285CF0
   cordova prepare' 

1. Install the plugin

   Geofence

   Python

   
   npm install <sdk folder>/plugins/react-native-acoustic-mobile-push-geofence
   

   Beacon

   Python

   
   npm install <sdk folder>/plugins/react-native-acoustic-mobile-push-beacon
   

2. Link the plugin

   Geofence

   Python

   
   react-native link react-native-acoustic-mobile-push-geofence
   

   Beacon

   Python

   
   react-native link react-native-acoustic-mobile-push-beacon
   

3. Fill out beacon UUID in ‘MceConfig.json’ file. Some beacon vendors use a static UUID others include software to set the UUID on demand. The Acoustic Beacon Plugin uses a single UUID per application, so the beacons UUIDs should all be the same.
4. Enter the unique combinations of UUID/major/minor beacons that you will be using on the web interface.
5. Enter your geo locations and radii in the web interface.

If you are enabling beacons, you must set the UUID.

iOS

"location": {
        "The location autoInitialize flag can be set to false to delay turning on the location services until desired.": "",
        "autoInitialize": true,
        "Please note, the existince of the location key will enable geofence location support, if geofence support is not desired, remove the key": "",
        "geofence": {
            "search": {
                "maximumRadius": 2500000,
                "defaultRadius": 10000,
                "maximumCount": 100,
                "maximumQuantity": 20,
                "minimumQuantity": 1
            },
            "choose one of the following values for accuracy: ": [
                "best",
                "10m",
                "100m",
                "1km",
                "3km"
            ],
            "accuracy": "3km"
        },
        "The sync key is only used to customize the iBeacon and Geofence syncing sevice, it is not required for those features": "",
        "sync": {
            "Location Sync radius is in meters, default 100km": "",
            "syncRadius": 100000,
            "Specify how long to wait before syncing again on significant location change in seconds, default 5 minutes": "",
            "syncInterval": 300
        },
        "Please note, the existince of the ibeacon key will enable iBeacon support, if iBeacon support is not desired, remove the key": "",
        "ibeacon": {
            "UUID": "SET YOUR IBEACON UUID HERE"
        }
    },

Android

"location": {
    "The location autoInitialize flag can be set to false to delay turning on the location services until desired.": "",
    "autoInitialize": true,
    "The sync key is only used to customize the iBeacon and Geofence syncing service, it is not required for those features": "",
    "sync": {
      "Specify how long to wait before syncing again on significant location change in seconds, default 5 minutes": "",
      "syncInterval": 30,
      "Location Sync radius is in meters, default 100km": "",
      "syncRadius": 100000,
      "Specify how long to wait before retrieving a new location from the device, default 5 minutes": "",
      "locationResponsiveness": 300,
      "Specify the minimum results when looking for locations nearby, default is 1, minimum value is 1": "",
      "minLocationsForSearch": 1,
      "Specify the maximum results when looking for locations nearby, default is 20, minimum value is 1": "",
      "maxLocationsForSearch": 20,
      "Specify the location providers that will be used to retrieve the device location. 'gps' - gps location. 'network' - wifi + cellular, default is gps + network": "",
      "providerPreferences": [
        "gps",
        "network"
      ]
    },
    "Please note, unlike iOS, the existence of the ibeacon key does not enable iBeacon support, iBeacon support is enabled only if iBeacons are nearby": "",
    "ibeacon": {
      "Please note: if this is not set, iBeacon events will not be sent": "This value should never be empty. Leave the default value if you don't want to use iBeacons",
      "uuid": "SET YOUR UUID HERE",
      "Specify how much time the sdk will scan for iBeacons in every scan session while the application is in the foreground, default is 5 seconds": "",
      "beaconForegroundScanDuration": 5,
      "Specify how much time the sdk will wait between iBeacons scan sessions while the application is in the foreground, default is 30 seconds": "",
      "beaconForegroundScanInterval": 30,
      "Specify how much time the sdk will scan for iBeacons in every scan session while the application is in the background, default is 30 seconds": "",
      "beaconBackgroundScanDuration": 30,
      "Specify how much time the sdk will wait between iBeacons scan sessions while the application is in the background, default is 5 minutes": "",
      "beaconBackgroundScanInterval": 30
    }
  }

Requesting location permissions

With newer releases of Android, you must explicitly request location permissions. Users can optionally accept or refuse these permissions for the app.

For iOS, the location permission will automatically show at the launch of the app after updating Info.plist. However, with changes to iOS 13, location permission requests can no longer grant the permission "always" from the application. One way "always" can be granted would be the app could instruct the user to open the settings app manually, select the app's settings, and then grant the "always" location permission from there.

Complete the following steps to request location permission on Android and prompt the user to grant the "always" location permission on iOS:

1. Add the location plugin to the pubspec.yaml file under dependencies.
YAML

flutter_acoustic_mobile_push_location:
    path: ../../plugins/flutter_acoustic_mobile_push_location

2. Import the location plugin into the dart file.
Dart

import 'package:flutter_acoustic_mobile_push_location/location.dart';

3. Update the dart file with the following variables.
Dart

late LocationsPermission permission;

4. Add a location permission function in the dart file.
Dart

Future<void> locationPermission() async {
    permission = await Location().checkLocationPermission();

    if (permission != LocationsPermission.always) {
          showPermission();
    }
  }

5. If the permission is other than always, create a dialog to inform the user to update the location permission on their device. The following example also utilizes the location plugin to open the user's system location setting.
Dart

showPermission() {
    showDialog(
      context: context,
      useRootNavigator: false,
      builder: (BuildContext context) {
        return AlertDialog(
          title: const Text('Permission Required'),
          content: const Text(
              'This app requires your permission to access location information in the background. To grant this permission, select "Allow all the time" or "Always"'),
          actions: [
            TextButton(
              onPressed: () {
                Navigator.pop(context, false);
              },
              child: const Text('Cancel'),
            ),
            TextButton(
              onPressed: () {
                Navigator.pop(context, true);
              },
              child: const Text('Grant Permission'),
            ),
          ],
        );
      },
    ).then((exit) {
      if (exit != null) {
        Location().requestDevicePermission(exit);
      }
    });
  }

If you want to be notified when geofence or beacon events occur, implement the following delegates:

Geofence entry

MCEGeofencePlugin.setGeofenceEnterCallback(function (geofence) {
 // use geofence.latitude
 // use geofence.longitude
 // use geofence.radius
}); 

Geofence exit

MCEGeofencePlugin.setGeofenceExitCallback(function (geofence) {
 // use geofence.latitude
 // use geofence.longitude
 // use geofence.radius 
});
 

Beacon entry

MCEBeaconPlugin.setBeaconEnterCallback(function (beacon) {
 // use beacon.major
 // use beacon.minor
}) 

Beacon exit

MCEBeaconPlugin.setBeaconExitCallback(function (beacon) {
 // use beacon.major
 // use beacon.minor
})