Added fix for iOS when app is killed app

android/src/main/AndroidManifest.xml

@@ -3,6 +3,7 @@
 
  <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
  <uses-permission android:name="android.permission.WAKE_LOCK" />
+ <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
 
  <application>
  <!-- Services -->

android/src/main/java/com/eddieowens/services/BoundaryEventHeadlessTaskService.java

@@ -1,21 +1,119 @@
 package com.eddieowens.services;
 
+import android.app.Notification;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.content.Context;
 import android.content.Intent;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.os.Build;
 import android.os.Bundle;
-import android.support.annotation.Nullable;
+import android.util.Log;
 
+import androidx.annotation.Nullable;
+import androidx.core.app.NotificationCompat;
+import androidx.core.content.ContextCompat;
+
+import com.eddieowens.R;
 import com.facebook.react.HeadlessJsTaskService;
-import com.facebook.react.jstasks.HeadlessJsTaskConfig;
 import com.facebook.react.bridge.Arguments;
+import com.facebook.react.jstasks.HeadlessJsTaskConfig;
+
+import java.util.Map;
+import java.util.Random;
+
+import static com.eddieowens.RNBoundaryModule.TAG;
 
 public class BoundaryEventHeadlessTaskService extends HeadlessJsTaskService {
+ public static final String NOTIFICATION_CHANNEL_ID = "com.eddieowens.GEOFENCE_SERVICE_CHANNEL";
+ private static final String KEY_NOTIFICATION_TITLE = "rnboundary.notification_title";
+ private static final String KEY_NOTIFICATION_TEXT = "rnboundary.notification_text";
+ private static final String KEY_NOTIFICATION_ICON = "rnboundary.notification_icon";
+
  @Nullable
  protected HeadlessJsTaskConfig getTaskConfig(Intent intent) {
  Bundle extras = intent.getExtras();
  return new HeadlessJsTaskConfig(
- "OnBoundaryEvent",
- extras != null ? Arguments.fromBundle(extras) : null,
- 5000,
- true);
+ "OnBoundaryEvent",
+ extras != null ? Arguments.fromBundle(extras) : null,
+ 5000,
+ true);
+ }
+
+ public NotificationCompat.Builder getNotificationBuilder() {
+ Context context = getApplicationContext();
+ String title = "Geofencing in progress";
+ String text = "You're close to the configured location";
+ int iconResource = -1;
+
+ try {
+ ApplicationInfo ai = context.getPackageManager().getApplicationInfo(context.getPackageName(), PackageManager.GET_META_DATA);
+ Bundle bundle = ai.metaData;
+ title = bundle.getString(KEY_NOTIFICATION_TITLE, title);
+ text = bundle.getString(KEY_NOTIFICATION_TEXT, text);
+ iconResource = bundle.getInt(KEY_NOTIFICATION_ICON, -1);
+ } catch (Exception e) {
+ Log.e(TAG, "Cannot get application Bundle " + e.toString());
+ }
+
+
+ // Notification for the foreground service
+ NotificationCompat.Builder builder = new NotificationCompat.Builder(context, NOTIFICATION_CHANNEL_ID)
+ .setContentTitle(title)
+ .setContentText(text)
+ .setOngoing(true)
+ .setColor(ContextCompat.getColor(context, R.color.accent_material_light));
+
+ if (iconResource > -1) {
+ builder.setSmallIcon(iconResource);
+ }
+
+ return builder;
+ }
+
+ @Override
+ public void onCreate() {
+ super.onCreate();
+ startForegroundServiceNotification();
+ }
+
+ @Override
+ public int onStartCommand(Intent intent, int flags, int startId) {
+ int result = super.onStartCommand(intent, flags, startId);
+ startForegroundServiceNotification();
+ return result;
+ }
+
+ private void startForegroundServiceNotification() {
+ Context context = this.getApplicationContext();
+
+ // Channel for the foreground service notification
+ createChannel(context);
+
+ NotificationCompat.Builder builder = getNotificationBuilder();
+ Notification notification = builder.build();
+
+ Random rand = new Random();
+ int notificationId = rand.nextInt(100000);
+
+ startForeground(notificationId, notification);
+ HeadlessJsTaskService.acquireWakeLockNow(context);
+ }
+
+ private void createChannel(Context context) {
+ String NOTIFICATION_CHANNEL_NAME = "Geofence Service";
+ String NOTIFICATION_CHANNEL_DESCRIPTION = "Only used to know when you're close to a configured location.";
+
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+ NotificationChannel channel = new NotificationChannel(
+ NOTIFICATION_CHANNEL_ID,
+ NOTIFICATION_CHANNEL_NAME,
+ NotificationManager.IMPORTANCE_LOW);
+ channel.setDescription(NOTIFICATION_CHANNEL_DESCRIPTION);
+
+ NotificationManager notificationManager = context.getSystemService(NotificationManager.class);
+ notificationManager.createNotificationChannel(channel);
+ }
  }
 }

android/src/main/java/com/eddieowens/services/BoundaryEventJobIntentService.java

@@ -1,19 +1,23 @@
 package com.eddieowens.services;
 
+import android.app.ActivityManager;
 import android.content.Context;
 import android.content.Intent;
+import android.os.Build;
 import android.os.Bundle;
-import android.support.annotation.NonNull;
-import android.support.v4.app.JobIntentService;
 import android.util.Log;
 
+import androidx.annotation.NonNull;
+import androidx.core.app.JobIntentService;
+
 import com.eddieowens.RNBoundaryModule;
 import com.eddieowens.errors.GeofenceErrorMessages;
 import com.facebook.react.HeadlessJsTaskService;
 import com.google.android.gms.location.Geofence;
 import com.google.android.gms.location.GeofencingEvent;
 
 import java.util.ArrayList;
+import java.util.List;
 
 import static com.eddieowens.RNBoundaryModule.TAG;
 
@@ -68,7 +72,33 @@ private void sendEvent(Context context, String event, ArrayList<String> params)
  Intent headlessBoundaryIntent = new Intent(context, BoundaryEventHeadlessTaskService.class);
  headlessBoundaryIntent.putExtras(bundle);
 
- context.startService(headlessBoundaryIntent);
- HeadlessJsTaskService.acquireWakeLockNow(context);
+ if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O || isAppOnForeground(context)) {
+ context.startService(headlessBoundaryIntent);
+ HeadlessJsTaskService.acquireWakeLockNow(context);
+ }
+ else {
+ // Since Oreo (8.0) and up they have restricted starting background services, and it will crash the app
+ // But we can create a foreground service and bring an notification to the front
+ // http://stackoverflow.com/questions/8489993/check-android-application-is-in-foreground-or-not
+ context.startForegroundService(headlessBoundaryIntent);
+ }
+ }
+
+ private boolean isAppOnForeground(Context context) {
+ ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
+ List<ActivityManager.RunningAppProcessInfo> appProcesses =
+ activityManager.getRunningAppProcesses();
+ if (appProcesses == null) {
+ return false;
+ }
+ final String packageName = context.getPackageName();
+ for (ActivityManager.RunningAppProcessInfo appProcess : appProcesses) {
+ if (appProcess.importance ==
+ ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND &&
+ appProcess.processName.equals(packageName)) {
+ return true;
+ }
+ }
+ return false;
  }
 }

ios/RNBoundary.h

@@ -12,5 +12,14 @@
 - (bool) removeBoundary:(NSString *)boundaryId;
 - (void) removeAllBoundaries;
 @property (strong, nonatomic) CLLocationManager *locationManager;
+@property (strong, nonatomic) NSMutableSet *queuedEvents;
+@property (assign, nonatomic) bool hasListeners;
+@end
+
+
+@interface GeofenceEvent : NSObject
+- (id) initWithId:(NSString*)geofenceId forEvent:(NSString *)eventName;
+@property (strong, nonatomic) NSString *geofenceId;
+@property (strong, nonatomic) NSString *name;
+@property (strong, nonatomic) NSDate* date;
 @end
-

ios/RNBoundary.m

@@ -1,6 +1,29 @@
-
 #import "RNBoundary.h"
 
+@implementation GeofenceEvent
+- (id)initWithId:(NSString*)geofenceId forEvent:(NSString *)name {
+ self = [super init];
+ if (self) {
+ self.geofenceId = geofenceId;
+ self.name = name;
+ self.date = [NSDate date];
+ }
+
+ return self;
+}
+
+- (BOOL)isEqual:(id)anObject
+{
+ return [self.geofenceId isEqual:((GeofenceEvent *)anObject).geofenceId];
+}
+
+- (NSUInteger)hash
+{
+ return self.geofenceId;
+}
+@end
+
+
 @implementation RNBoundary
 
 RCT_EXPORT_MODULE()
@@ -11,6 +34,8 @@ -(instancetype)init
  if (self) {
  self.locationManager = [[CLLocationManager alloc] init];
  self.locationManager.delegate = self;
+
+ self.queuedEvents = [[NSMutableSet alloc] init];
  }
 
  return self;
@@ -62,6 +87,7 @@ - (void) removeAllBoundaries
  for(CLRegion *region in [self.locationManager monitoredRegions]) {
  [self.locationManager stopMonitoringForRegion:region];
  }
+ [self.queuedEvents removeAllObjects];
 }
 
 - (bool) removeBoundary:(NSString *)boundaryId
@@ -83,13 +109,49 @@ - (bool) removeBoundary:(NSString *)boundaryId
 - (void)locationManager:(CLLocationManager *)manager didEnterRegion:(CLRegion *)region
 {
  NSLog(@"didEnter : %@", region);
- [self sendEventWithName:@"onEnter" body:region.identifier];
+ if (self.hasListeners) {
+ [self sendEventWithName:@"onEnter" body:region.identifier];
+ } else {
+ GeofenceEvent *event = [[GeofenceEvent alloc] initWithId:region.identifier forEvent:@"onEnter" ];
+ [self.queuedEvents addObject:event];
+ }
 }
 
 - (void)locationManager:(CLLocationManager *)manager didExitRegion:(CLRegion *)region
 {
  NSLog(@"didExit : %@", region);
- [self sendEventWithName:@"onExit" body:region.identifier];
+ if (self.hasListeners) {
+ [self sendEventWithName:@"onExit" body:region.identifier];
+ } else {
+ GeofenceEvent *event = [[GeofenceEvent alloc] initWithId:region.identifier forEvent:@"onExit" ];
+ [self.queuedEvents addObject:event];
+ }
+}
+
+- (void)startObserving {
+ self.hasListeners = YES;
+ if ([self.queuedEvents count] > 0) {
+ for(GeofenceEvent *event in self.queuedEvents) {
+ NSTimeInterval interval = [[NSDate date] timeIntervalSinceDate:[event date]];
+ double minutesDiff = interval / 60.f;
+ // if the app was not open
+ // within 2 minutes of storing the event
+ // we discard it
+ if (minutesDiff < 2) {
+ // dispatch after 1 second
+ // as both events are not registered at the same time
+ dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 1 * NSEC_PER_SEC), dispatch_get_main_queue(), ^{
+ [self sendEventWithName:[event name] body:[event geofenceId]];
+ });
+ }
+ }
+ [self.queuedEvents removeAllObjects];
+ }
+}
+
+- (void)stopObserving {
+ self.hasListeners = NO;
+ [self.queuedEvents removeAllObjects];
 }
 
 + (BOOL)requiresMainQueueSetup
@@ -98,4 +160,3 @@ + (BOOL)requiresMainQueueSetup
 }
 
 @end
-

ios/RNBoundary.podspec

@@ -1,24 +1,20 @@
-
-Pod::Spec.new do |s|
- s.name = "RNBoundary"
- s.version = "1.0.0"
- s.summary = "RNBoundary"
- s.description = <<-DESC
- RNBoundary
- DESC
- s.homepage = ""
- s.license = "MIT"
- # s.license = { :type => "MIT", :file => "FILE_LICENSE" }
- s.author = { "author" => "author@domain.cn" }
- s.platform = :ios, "7.0"
- s.source = { :git => "https://github.com/author/RNBoundary.git", :tag => "master" }
- s.source_files = "RNBoundary/**/*.{h,m}"
- s.requires_arc = true
-
-
- s.dependency "React"
- #s.dependency "others"
-
-end
-
-
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '../package.json')))
+
+Pod::Spec.new do |s|
+ s.name = "RNBoundary"
+ s.version = package['version']
+ s.summary = package['description']
+ s.license = package['license']
+
+ s.authors = package['author']
+ s.homepage = "https://github.com/eddieowens/react-native-boundary#readme"
+ s.platform = :ios, "9.0"
+
+ s.source = { :git => "https://github.com/eddieowens/react-native-boundary.git", :tag => "#{s.version}" }
+ s.source_files = "*.{h,m}"
+ s.requires_arc = true
+
+ s.dependency 'React'
+end