react-native-background-geolocation 4.17.6 → 4.18.1

package/android/src/main/java/com/transistorsoft/rnbackgroundgeolocation/HeadlessTaskManager.java

@@ -0,0 +1,460 @@
+package com.transistorsoft.rnbackgroundgeolocation;
+
+import android.content.Context;
+import android.os.Handler;
+import android.os.Looper;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.infer.annotation.Assertions;
+import com.facebook.react.ReactApplication;
+import com.facebook.react.ReactInstanceEventListener;
+import com.facebook.react.ReactInstanceManager;
+import com.facebook.react.ReactNativeHost;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.UiThreadUtil;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.jstasks.HeadlessJsTaskConfig;
+import com.facebook.react.jstasks.HeadlessJsTaskContext;
+import com.facebook.react.jstasks.HeadlessJsTaskEventListener;
+import com.transistorsoft.locationmanager.logger.TSLog;
+
+import java.lang.reflect.Method;
+
+import java.util.Set;
+import java.util.concurrent.CopyOnWriteArraySet;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * This is a general singleton for managing invoking RN headless-tasks.  This class could be copied and implemented in any plugin.
+ *
+ * RN headless-tasks have no mechanism for the Javascript to signal completion of their tasks:  you can either configure a timeout for
+ * your tasks (letting each task timeout) or provide no timeout at all, which will cause a memory leak in RN's HeadlessJsContext.java
+ * https://github.com/facebook/react-native/blob/bc0b5ca5df5d2cf12c791b0332ef2fb4e29d6d2d/packages/react-native/ReactAndroid/src/main/java/com/facebook/react/jstasks/HeadlessJsTaskContext.java#L53-L55
+ *
+ * Without providing a timeout for your headless-tasks, those collections in HeadlessJsContext will continue grow and never be cleared.
+ *
+ * Because there's only one instance of this class, we have to be mindful that we can possibly receive events rapidly,
+ * so we store them in a Queue (#mTaskQueue).
+ *
+ * We also have to be mindful that it's a heavy operation to do the initial launch the ReactNative Host, so several events
+ * might build up in the queue before the Host is finally launched, when we drain the queue (see #drainTaskQueue).
+ *
+ * For finally sending events to the client, we wrap the RN HeadlessJsTaskConfig with our own TaskConfig class.  This class
+ * adds our own auto-incremented "taskId" field to maintain a mapping between our taskId and RN's.  See #invokeStartTask.
+ * This class appends our custom taskId into the the event params sent to Javascript, for the following purpose:
+ *
+ * ```javascript
+ * const BackgroundGeolocationHeadlessTask = async (event) => {
+ *   console.log('[HeadlessTask] taskId: ', event.taskId);  // <-- here's our custom taskId.
+ *
+ *   await doWork();  // <-- perform some arbitrarily long process (eg: http request).
+ *
+ *   BackgroundGeolocation.finishHeadlessTask(event.taskId);  // <-- $$$ Here's the money $$$
+ * }
+ * ```
+ *
+ * See "Here's the $money" above: We want to signal back to this native HeadlessTask instance , that our JS task is now complete.
+ * This is a pretty easy task to do via EventBus -- Just create a new instance of FinishHeadlessTaskEvent(params.taskId);
+ *
+ * The code then looks up a TaskConfig from mEventQueue using the given event.taskId.
+ *
+ * All this extra fussing with taking care to finish our RN HeadlessTasks seems to be more important with RN's "new architecture", where before,
+ * RN seemed to automatically complete its tasks seemingly when the Javascript function stopped executing.  This is why it was always so
+ * important to await one's Promises and do all the work before the the last line of the function executed.
+ *
+ * Now, the Javascript must explicitly call back to the native side to say "I'M DONE" -- BackgroundGeolocation.finishHeadlessTask(taskId)
+ */
+public class HeadlessTaskManager implements HeadlessJsTaskEventListener {
+    private static final String TAG = "TSLocationManager";
+
+    private static HeadlessTaskManager sInstance;
+    public static HeadlessTaskManager getInstance() {
+        if (sInstance == null) {
+            sInstance = getInstanceSynchronized();
+        }
+        return sInstance;
+    }
+
+    private static synchronized HeadlessTaskManager getInstanceSynchronized() {
+        if (sInstance == null) sInstance = new HeadlessTaskManager();
+        return sInstance;
+    }
+
+    private final Set<Task> mTaskQueue = new CopyOnWriteArraySet<>();
+    private final AtomicBoolean mIsReactContextInitialized = new AtomicBoolean(false);
+    private final AtomicBoolean mIsInitializingReactContext = new AtomicBoolean(false);
+    private final AtomicBoolean mIsHeadlessJsTaskListenerRegistered = new AtomicBoolean(false);
+
+    /**
+     * Start a task. This method handles starting a new React instance if required.
+     *
+     * Has to be called on the UI thread.
+     *
+     * @param context Application Context
+     * @param task The Task instance
+     */
+    public void startTask(Context context, Task task) throws AssertionError {
+        UiThreadUtil.assertOnUiThread();
+
+        addTask(task);
+
+        if (!mIsReactContextInitialized.get()) {
+            createReactContextAndScheduleTask(context);
+        } else {
+            boolean success = invokeStartTask(getReactContext(context), task);
+            if (!success) {
+                removeTask(task);
+            }
+        }
+    }
+
+    public void finishTask(Context context, int taskId) throws TaskNotFoundError, ContextError {
+        if (!mIsReactContextInitialized.get()) {
+            throw new ContextError(getClass().getName() + ".finishTask:  ReactContext not initialized");
+        }
+        ReactContext reactContext = getReactContext(context.getApplicationContext());
+        if (reactContext != null) {
+            Task task = findTask(taskId);
+            if (task != null) {
+                HeadlessJsTaskContext headlessJsTaskContext = HeadlessJsTaskContext.getInstance(reactContext);
+                if (headlessJsTaskContext.isTaskRunning(task.getReactTaskId())) {
+                    headlessJsTaskContext.finishTask(task.getReactTaskId());
+                }
+            } else {
+                throw new TaskNotFoundError(taskId);
+            }
+        } else {
+            throw new ContextError(getClass().getName() + ".finishTask ReactContext is null");
+        }
+    }
+
+    private boolean invokeStartTask(ReactContext reactContext, final Task task) {
+        final HeadlessJsTaskContext headlessJsTaskContext = HeadlessJsTaskContext.getInstance(reactContext);
+        if (mIsHeadlessJsTaskListenerRegistered.compareAndSet(false, true)) {
+            // Register the RN HeadlessJSTaskEventListener just once.
+            // TODO we might use a LifeCycle event-listener here to remove the listener when the app is launched to foreground.
+            headlessJsTaskContext.addTaskEventListener(this);
+        }
+        try {
+            return task.invoke(reactContext);
+        } catch (Exception e) {
+            task.onError(e);
+            return false;
+        }
+    }
+
+    @Override
+    public void onHeadlessJsTaskStart(int taskId) {}
+
+    // The only purpose of this listener is to clear events from the queue.  The RN task is assumed to have had its .stopTask(taskId) method called, which is why this event has fired.
+    // WARNING:  this listener seems to receive events from ANY OTHER plugin's Headless events.
+    @Override
+    public void onHeadlessJsTaskFinish(int taskId) {
+        Task task = findTaskByReactId(taskId);
+        if (task == null) {
+            return;
+        }
+        removeTask(task);
+        task.onFinish();
+
+        TSLog.logger.debug("[onHeadlessJsTaskFinish] taskId: " + taskId);
+    }
+
+    private ReactNativeHost getReactNativeHost(Context context) {
+        return ((ReactApplication) context.getApplicationContext()).getReactNativeHost();
+    }
+
+    /**
+     * Get the {ReactHost} used by this app. ure and returns null if not.
+     */
+    private @Nullable Object getReactHost(Context context) {
+        context = context.getApplicationContext();
+        try {
+            Method getReactHost = context.getClass().getMethod("getReactHost");
+            return getReactHost.invoke(context);
+        } catch (Exception e) {
+            return null;
+        }
+    }
+
+    private ReactContext getReactContext(Context context) {
+        if (isBridglessArchitectureEnabled()) {
+            Object reactHost = getReactHost(context);
+            Assertions.assertNotNull(reactHost, "getReactHost() is null in New Architecture");
+            try {
+                Method getCurrentReactContext = reactHost.getClass().getMethod("getCurrentReactContext");
+                return (ReactContext) getCurrentReactContext.invoke(reactHost);
+            } catch (Exception e) {
+                TSLog.logger.error(TSLog.error( "Reflection error getCurrentReactContext: " + e.getMessage()), e);
+            }
+        }
+        final ReactInstanceManager reactInstanceManager = getReactNativeHost(context).getReactInstanceManager();
+        return reactInstanceManager.getCurrentReactContext();
+    }
+
+    private void createReactContextAndScheduleTask(Context context) {
+        // ReactContext could have already been initialized by another plugin (eg: background-fetch).
+        // If we get a non-null ReactContext here, we're good to go!
+        ReactContext reactContext = getReactContext(context);
+        if (reactContext != null && !mIsInitializingReactContext.get()) {
+            mIsReactContextInitialized.set(true);
+            drainTaskQueue(reactContext);
+            return;
+        }
+        if (mIsInitializingReactContext.compareAndSet(false, true)) {
+            TSLog.logger.debug( "[createReactContextAndScheduleTask] initialize ReactContext");
+            final Object reactHost = getReactHost(context);
+            if (isBridglessArchitectureEnabled()) { // NEW arch
+                ReactInstanceEventListener callback = new ReactInstanceEventListener() {
+                    @Override
+                    public void onReactContextInitialized(@NonNull ReactContext reactContext) {
+                        mIsReactContextInitialized.set(true);
+                        drainTaskQueue(reactContext);
+                        try {
+                            Method removeReactInstanceEventListener = reactHost.getClass().getMethod("removeReactInstanceEventListener", ReactInstanceEventListener.class);
+                            removeReactInstanceEventListener.invoke(reactHost, this);
+                        } catch (Exception e) {
+                            TSLog.logger.error(TSLog.error("HeadlessTask reflection error removeReactInstanceEventListener: ") + e);
+                        }
+                    }
+                };
+                try {
+                    Method addReactInstanceEventListener = reactHost.getClass().getMethod("addReactInstanceEventListener", ReactInstanceEventListener.class);
+                    addReactInstanceEventListener.invoke(reactHost, callback);
+                    Method startReactHost = reactHost.getClass().getMethod("start");
+                    startReactHost.invoke(reactHost);
+                } catch (Exception e) {
+                    TSLog.logger.error(TSLog.error("HeadlessTask reflection error ReactHost start: " + e.getMessage()), e);
+                }
+            } else { // OLD arch
+                final ReactInstanceManager reactInstanceManager = getReactNativeHost(context).getReactInstanceManager();
+                reactInstanceManager.addReactInstanceEventListener(new ReactInstanceEventListener() {
+                    @Override
+                    public void onReactContextInitialized(@NonNull ReactContext reactContext) {
+                        mIsReactContextInitialized.set(true);
+                        drainTaskQueue(reactContext);
+                        reactInstanceManager.removeReactInstanceEventListener(this);
+                    }
+                });
+                reactInstanceManager.createReactContextInBackground();
+            }
+        }
+    }
+
+    /**
+     * Return true if this app is running with RN's bridgeless architecture.
+     * Cheers to @mikehardy for this idea.
+     * @return
+     */
+    private boolean isBridglessArchitectureEnabled() {
+        try {
+            Class<?> entryPoint = Class.forName("com.facebook.react.defaults.DefaultNewArchitectureEntryPoint");
+            Method bridgelessEnabled = entryPoint.getMethod("getBridgelessEnabled");
+            Object result = bridgelessEnabled.invoke(null);
+            return (result == Boolean.TRUE);
+        } catch (Exception e) {
+            return false;
+        }
+    }
+
+    /**
+     * Invokes HeadlessEvents queued while waiting for the ReactContext to initialize.
+     * @param reactContext
+     */
+    private void drainTaskQueue(final ReactContext reactContext) {
+        new Handler(Looper.getMainLooper()).postDelayed(() -> {
+            mTaskQueue.forEach((Task task) -> {
+                boolean success = invokeStartTask(reactContext, task);
+                if (!success) {
+                    removeTask(task);
+                }
+            });
+        }, 250);
+    }
+
+    // Find a task in the queue.
+    public Task findTask(int taskId) {
+        Task found = null;
+        // Locate the TaskConfig instance by our local taskId.
+        synchronized (mTaskQueue) {
+            for (Task task : mTaskQueue) {
+                if (task.getId() == taskId) {
+                    found = task;
+                    break;
+                }
+            }
+        }
+        return found;
+    }
+
+    private Task findTaskByReactId(int reactTaskId) {
+        Task found = null;
+        // Locate the TaskConfig instance by our local taskId.
+        synchronized (mTaskQueue) {
+            for (Task config : mTaskQueue) {
+                if (config.getReactTaskId() == reactTaskId) {
+                    found = config;
+                    break;
+                }
+            }
+        }
+        return found;
+    }
+    // Add a task to queue.
+    private void addTask(Task config) {
+        // push this HeadlessEvent onto the taskQueue, to be drained once the React context is finished initializing,
+        // or executed immediately if Context exists currently.
+        synchronized (mTaskQueue) {
+            mTaskQueue.add(config);
+        }
+    }
+
+    // Remove TaskConfig from queue.
+    private void removeTask(Task task) {
+        synchronized (mTaskQueue) {
+            mTaskQueue.remove(task);
+        }
+    }
+
+    // Any tasks in the queue?
+    private boolean hasTasks() {
+        synchronized (mTaskQueue) {
+            return !mTaskQueue.isEmpty();
+        }
+    }
+
+    /**
+     * Wrapper for a client event.  Inserts our custom taskId into the RN ClientEvent params.
+     */
+    public static class Task {
+        private static final AtomicInteger sLastTaskId = new AtomicInteger(0);
+        synchronized static int getNextTaskId() {
+            return sLastTaskId.incrementAndGet();
+        }
+
+        private final int mId;
+        private final String mTaskName;
+        private int mReactTaskId;
+        private final OnInvokeCallback mOnInvokeCallback;
+        private final OnFinishCallback mOnFinishCallback;
+        private final OnErrorCallback mOnErrorCallback;
+        private final int mTimeout;
+        private final WritableMap mParams;
+
+        Task(Builder builder) {
+            mTaskName = builder.name;
+            mId = getNextTaskId();
+            mOnInvokeCallback = builder.onInvokeCallback;
+            mOnFinishCallback = builder.onFinishCallback;
+            mOnErrorCallback = builder.onErrorCallback;
+            mTimeout = builder.timeout;
+            mParams = builder.params;
+            // append our custom headless taskId.
+            mParams.putInt("_transistorHeadlessTaskId", mId);
+        }
+
+
+        boolean invoke(ReactContext reactContext) throws IllegalStateException {
+            HeadlessJsTaskContext headlessJsTaskContext = HeadlessJsTaskContext.getInstance(reactContext);
+            // Provide the RN taskId to our private TaskConfig instance, mapping the RN taskId to our TaskConfig's internal taskId.
+
+            mReactTaskId = headlessJsTaskContext.startTask(buildTaskConfig());
+            if (mOnInvokeCallback != null) {
+                mOnInvokeCallback.onInvoke(reactContext, this);
+            }
+            return true;
+        }
+
+        public int getId() {
+            return mId;
+        }
+
+        private int getReactTaskId() {
+            return mReactTaskId;
+        }
+
+        private HeadlessJsTaskConfig buildTaskConfig() {
+            return new HeadlessJsTaskConfig(mTaskName, mParams, mTimeout);
+        }
+
+        void onFinish() {
+            if (mOnFinishCallback != null) {
+                mOnFinishCallback.onFinish(mId);
+            }
+        }
+
+        void onError(Exception e) {
+            if (mOnErrorCallback != null) {
+                mOnErrorCallback.onError(this, e);
+            }
+        }
+
+        public String toString() {
+            return "[HeadlessTaskManager.Task name: " + mTaskName + " " + mParams + "]";
+        }
+
+        public static class Builder {
+            private static final int DEFAULT_TIMEOUT = 60000;
+
+            private String name;
+            private OnInvokeCallback onInvokeCallback;
+            private OnFinishCallback onFinishCallback;
+            private OnErrorCallback onErrorCallback;
+            private WritableMap params;
+            private int timeout = DEFAULT_TIMEOUT;
+
+            public Builder setName(String name) {
+                this.name = name;
+                return this;
+            }
+            public Builder setOnInvokeCallback(OnInvokeCallback callback) {
+                this.onInvokeCallback = callback;
+                return this;
+            }
+            public Builder setOnFinishCallback(OnFinishCallback callback) {
+                this.onFinishCallback = callback;
+                return this;
+            }
+            public Builder setOnErrorCallback(OnErrorCallback callback) {
+                this.onErrorCallback = callback;
+                return this;
+            }
+            public Builder setParams(WritableMap params) {
+                this.params = params;
+                return this;
+            }
+            public Builder setTimeout(int timeout) {
+                this.timeout = timeout;
+                return this;
+            }
+            public Task build() {
+                return new Task(this);
+            }
+        }
+    }
+
+    public static class TaskNotFoundError extends Exception {
+        public TaskNotFoundError(int taskId) {
+            super(HeadlessTaskManager.class.getName() + " failed to find task: " + taskId);
+        }
+    }
+
+    public static class ContextError extends Exception {
+        public ContextError(String message) {
+            super(message);
+        }
+    }
+
+    public interface OnInvokeCallback {
+        void onInvoke(ReactContext reactContext, Task task);
+    }
+    public interface OnFinishCallback {
+        void onFinish(int taskId);
+    }
+    public interface OnErrorCallback {
+        void onError(Task task, Exception e);
+    }
+}

package/android/src/main/java/com/transistorsoft/rnbackgroundgeolocation/RNBackgroundGeolocationModule.java

@@ -23,10 +23,13 @@ import com.facebook.react.bridge.WritableNativeArray;
 import com.facebook.react.bridge.WritableNativeMap;
 import com.facebook.react.modules.core.RCTNativeAppEventEmitter;
 
+import org.greenrobot.eventbus.EventBus;
 import org.json.JSONArray;
 import org.json.JSONException;
 import org.json.JSONObject;
 
+import com.transistorsoft.locationmanager.event.FinishHeadlessTaskEvent;
+import com.transistorsoft.locationmanager.event.HeadlessEvent;
 import com.transistorsoft.xms.g.common.ExtensionApiAvailability;
 
 import com.transistorsoft.locationmanager.adapter.BackgroundGeolocation;
@@ -822,6 +825,28 @@ public class RNBackgroundGeolocationModule extends ReactContextBaseJavaModule im
         success.invoke(taskId);
     }
 
+    /**
+     * Called by user's registered HeadlessTask when they call BackgroundGeolocation.finishHeadlessTask(event.taskId)
+     * @param taskId
+     * @param success
+     * @param failure
+     */
+    @ReactMethod
+    public void finishHeadlessTask(int taskId, Callback success, Callback failure) {
+        EventBus eventBus = EventBus.getDefault();
+        if (!eventBus.hasSubscriberForEvent(HeadlessEvent.class)) {
+            // This shouldn't happen.  In order for this method to even be called, it MUST have been executed from within the consumer's
+            // registered HeadlessTask.  In order for that headless-task to have even be called, HeadlessEvent MUST have been registered with EventBus.
+            String message = "finishHeadlessTask failed to find an EventBus subscriber for HeadlessEvent";
+            TSLog.error(TSLog.warn(message));
+            failure.invoke(message);
+            return;
+        }
+        FinishHeadlessTaskEvent event = new FinishHeadlessTaskEvent(getReactApplicationContext(), taskId);
+        eventBus.post(event);
+        success.invoke();
+    }
+
     @ReactMethod
     public void getTransistorToken(String orgname, String username, String url, final Callback success, final Callback failure) {
 

package/expo/plugin/build/androidPlugin.js

@@ -83,14 +83,6 @@ const applyAppGradle = (buildGradle) => {
         offset: 1,
         comment: "//",
     }).contents;
-    buildGradle = (0, generateCode_1.mergeContents)({
-        tag: `${MODULE_NAME}-proguard`,
-        src: buildGradle,
-        newSrc: `\t    proguardFiles "\${background_geolocation.projectDir}/proguard-rules.pro"`,
-        anchor: /\"proguard-rules.pro\"/,
-        offset: 1,
-        comment: "//",
-    }).contents;
     return buildGradle;
 };
 /**

package/expo/plugin/build/androidPlugin.js.map

@@ -1 +1 @@
-{"version":3,"file":"androidPlugin.js","sourceRoot":"","sources":["../src/androidPlugin.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"androidPlugin.js","sourceRoot":"","sources":["../src/androidPlugin.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-background-geolocation",
-  "version": "4.17.6",
+  "version": "4.18.1",
   "description": "The most sophisticated cross-platform background location-tracking & geofencing module with battery-conscious motion-detection intelligence",
   "scripts": {
     "build": "yarn run build:expo",
@@ -30,7 +30,7 @@
   },
   "homepage": "https://www.transistorsoft.com/shop/products/react-native-background-geolocation",
   "dependencies": {
-    "react-native-background-fetch": "~4.2.5"
+    "react-native-background-fetch": "~4.2.6"
   },
   "devDependencies": {
     "@expo/config-plugins": "^4.1.0",

package/src/NativeModule.js

@@ -309,7 +309,6 @@ export default class NativeModule {
     });
   }
 
-  // TODO Rename native methods #finish -> #stopBackgroundTask
   static stopBackgroundTask(taskId) {
     return new Promise((resolve, reject) => {
       if (!taskId) {
@@ -322,6 +321,18 @@ export default class NativeModule {
     });
   }
 
+  static finishHeadlessTask(taskId) {
+    return new Promise((resolve, reject) => {
+      if (!taskId) {
+        reject('INVALID_TASK_ID: ' + taskId);
+        return;
+      }
+      let success = () => { resolve() }
+      let failure = (error) =>  { reject(error) }
+      RNBackgroundGeolocation.finishHeadlessTask(taskId, success, failure);
+    });
+  }
+  
   /**
   * Geolocation Methods
   */