@psync/notifee 9.2.0

package/android/src/main/java/io/invertase/notifee/HeadlessTask.java

@@ -0,0 +1,431 @@
+/*
+ * This software has been integrated, with great appreciation, from the
+ * react-native-background-geolocation library, and was originally authored by
+ * Chris Scott @ TransistorSoft. It is published in that repository under this license,
+ * included here in it's entirety
+ *
+ * https://github.com/transistorsoft/react-native-background-geolocation/blob/master/LICENSE
+ *
+ * ----
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015 Chris Scott
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package io.invertase.notifee;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import app.notifee.core.EventSubscriber;
+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 java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/*
+ * The BackgroundGeolocation SDK creates a single instance of this class (via reflection upon Config.headlessJobService)
+ * The SDK delivers events to this instance by dropping them onto EventBus (see @Subscribe).  Because this instance is subscribed
+ * into EventBus, it's protected from GC.
+ *
+ * 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)
+ *
+ * Created by chris on 2018-01-23.
+ */
+
+public class HeadlessTask {
+  private static final String HEADLESS_TASK_NAME = "NotifeeHeadlessJS";
+  // Hard-coded time-limit for headless-tasks is 60000 @todo configurable?
+  private static final int TASK_TIMEOUT = 60000;
+  private static final AtomicInteger sLastTaskId = new AtomicInteger(0);
+
+  static synchronized int getNextTaskId() {
+    return sLastTaskId.incrementAndGet();
+  }
+
+  private final List<TaskConfig> mTaskQueue = new ArrayList<>();
+  private final AtomicBoolean mIsReactContextInitialized = new AtomicBoolean(false);
+  private final AtomicBoolean mWillDrainTaskQueue = new AtomicBoolean(false);
+  private final AtomicBoolean mIsInitializingReactContext = new AtomicBoolean(false);
+  private final AtomicBoolean mIsHeadlessJsTaskListenerRegistered = new AtomicBoolean(false);
+
+  public void stopAllTasks() {
+    for (TaskConfig task : mTaskQueue) {
+      onFinishHeadlessTask(task.getTaskId());
+    }
+  }
+
+  /**
+   * EventBus Receiver. Called when developer runs BackgroundGeolocation.finishHeadlessTask(taskId)
+   * from within their registered HeadlessTask. Calls RN's HeadlessJsTaskContext.finishTask(taskId);
+   *
+   * @param taskId the taskId returned from startTask
+   */
+  public void onFinishHeadlessTask(int taskId) {
+    if (!mIsReactContextInitialized.get()) {
+      Log.w(HEADLESS_TASK_NAME, taskId + " found no ReactContext");
+      return;
+    }
+    ReactContext reactContext = getReactContext(EventSubscriber.getContext());
+    if (reactContext != null) {
+
+      synchronized (mTaskQueue) {
+        // Locate the TaskConfig instance by our local taskId.
+        TaskConfig taskConfig = null;
+        for (TaskConfig config : mTaskQueue) {
+          if (config.getTaskId() == taskId) {
+            taskConfig = config;
+            break;
+          }
+        }
+        if (taskConfig != null) {
+          HeadlessJsTaskContext headlessJsTaskContext =
+              HeadlessJsTaskContext.getInstance(reactContext);
+          // Tell RN we're done using the mapped getReactTaskId().
+          headlessJsTaskContext.finishTask(taskConfig.getReactTaskId());
+        } else {
+          Log.w(HEADLESS_TASK_NAME, "Failed to find task: " + taskId);
+        }
+      }
+    } else {
+      Log.w(
+          HEADLESS_TASK_NAME,
+          "Failed to finishHeadlessTask: "
+              + taskId
+              + " -- HeadlessTask onFinishHeadlessTask failed to find a ReactContext.  This is"
+              + " unexpected");
+    }
+  }
+
+  /**
+   * Start a task. This method handles starting a new React instance if required.
+   *
+   * <p>Has to be called on the UI thread.
+   *
+   * @param taskConfig describes what task to start and the parameters to pass to it
+   */
+  public void startTask(Context context, final TaskConfig taskConfig) throws AssertionError {
+    UiThreadUtil.assertOnUiThread();
+
+    // 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(taskConfig);
+    }
+
+    if (!mIsReactContextInitialized.get()) {
+      createReactContextAndScheduleTask(context);
+    } else {
+      invokeStartTask(getReactContext(context), taskConfig);
+    }
+  }
+
+  private synchronized void invokeStartTask(
+      ReactContext reactContext, final TaskConfig taskConfig) {
+    if (taskConfig.mReactTaskId > 0) {
+      Log.w(HEADLESS_TASK_NAME, "Task already invoked <IGNORED>: " + this);
+      return;
+    }
+    final HeadlessJsTaskContext headlessJsTaskContext =
+        HeadlessJsTaskContext.getInstance(reactContext);
+    try {
+      if (mIsHeadlessJsTaskListenerRegistered.compareAndSet(false, true)) {
+        // Register the RN HeadlessJSTaskEventListener just once.
+        // This inline-listener is handy here as a closure around the HeadlessJsTaskContext.
+        // Otherwise, we'd have to store this Context to an instance var.
+        // 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.
+        // TODO we might use a LifeCycle event-listener here to remove the listener when the app is
+        // launched to foreground.
+        headlessJsTaskContext.addTaskEventListener(
+            new HeadlessJsTaskEventListener() {
+              @Override
+              public void onHeadlessJsTaskStart(int taskId) {}
+
+              @Override
+              public void onHeadlessJsTaskFinish(int taskId) {
+                synchronized (mTaskQueue) {
+                  if (mTaskQueue.isEmpty()) {
+                    // Nothing in queue?  This event cannot be for us.
+                    return;
+                  }
+                  // Query our queue for this event...
+                  TaskConfig taskConfig = null;
+                  for (TaskConfig config : mTaskQueue) {
+                    if (config.getReactTaskId() == taskId) {
+                      taskConfig = config;
+                      break;
+                    }
+                  }
+                  if (taskConfig != null) {
+                    // Clear it from the Queue.
+                    Log.d(HEADLESS_TASK_NAME, "completed taskId: " + taskConfig.getTaskId());
+                    mTaskQueue.remove(taskConfig);
+                    if (taskConfig.getCallback() != null) {
+                      taskConfig.getCallback().call();
+                    }
+                  } else {
+                    Log.w(HEADLESS_TASK_NAME, "Failed to find taskId: " + taskId);
+                  }
+                }
+              }
+            });
+      }
+      // Finally:  the actual launch of the RN headless-task!
+      int taskId = headlessJsTaskContext.startTask(taskConfig.getTaskConfig());
+      // Provide the RN taskId to our private TaskConfig instance, mapping the RN taskId to our
+      // TaskConfig's internal taskId.
+      taskConfig.setReactTaskId(taskId);
+      Log.d(HEADLESS_TASK_NAME, "launched taskId: " + taskId);
+    } catch (IllegalStateException e) {
+      Log.e(HEADLESS_TASK_NAME, e.getMessage(), e);
+    }
+  }
+
+  public static ReactNativeHost getReactNativeHost(Context context) {
+    return ((ReactApplication) context.getApplicationContext()).getReactNativeHost();
+  }
+
+  /** Get the {ReactHost} used by this app. ure and returns null if not. */
+  public static @Nullable Object getReactHost(Context context) {
+    context = context.getApplicationContext();
+    try {
+      Method getReactHost = context.getClass().getMethod("getReactHost");
+      return getReactHost.invoke(context);
+    } catch (Exception e) {
+      return null;
+    }
+  }
+
+  @SuppressLint("VisibleForTests")
+  public static ReactContext getReactContext(Context context) {
+    if (isBridgelessArchitectureEnabled()) {
+      Object reactHost = getReactHost(context);
+      Assertions.assertNotNull(reactHost, "getReactHost() is null in New Architecture");
+      try {
+        assert reactHost != null;
+        Method getCurrentReactContext = reactHost.getClass().getMethod("getCurrentReactContext");
+        return (ReactContext) getCurrentReactContext.invoke(reactHost);
+      } catch (Exception e) {
+        Log.e(HEADLESS_TASK_NAME, "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)) {
+      Log.d(HEADLESS_TASK_NAME, "initialize ReactContext");
+      final Object reactHost = getReactHost(context);
+      if (isBridgelessArchitectureEnabled()) { // NEW arch
+        ReactInstanceEventListener callback =
+            new ReactInstanceEventListener() {
+              @Override
+              public void onReactContextInitialized(@NonNull ReactContext reactContext) {
+                mIsReactContextInitialized.set(true);
+                drainTaskQueue(reactContext);
+                try {
+                  assert reactHost != null;
+                  Method removeReactInstanceEventListener =
+                      reactHost
+                          .getClass()
+                          .getMethod(
+                              "removeReactInstanceEventListener", ReactInstanceEventListener.class);
+                  removeReactInstanceEventListener.invoke(reactHost, this);
+                } catch (Exception e) {
+                  Log.e(HEADLESS_TASK_NAME, "reflection error A: " + e, e);
+                }
+              }
+            };
+        try {
+          assert reactHost != null;
+          Method addReactInstanceEventListener =
+              reactHost
+                  .getClass()
+                  .getMethod("addReactInstanceEventListener", ReactInstanceEventListener.class);
+          addReactInstanceEventListener.invoke(reactHost, callback);
+          Method startReactHost = reactHost.getClass().getMethod("start");
+          startReactHost.invoke(reactHost);
+        } catch (Exception e) {
+          Log.e(HEADLESS_TASK_NAME, "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();
+      }
+    }
+  }
+
+  /**
+   * Invokes HeadlessEvents queued while waiting for the ReactContext to initialize.
+   *
+   * @param reactContext context to use for task invocation
+   */
+  private void drainTaskQueue(final ReactContext reactContext) {
+    if (mWillDrainTaskQueue.compareAndSet(false, true)) {
+      new Handler(Looper.getMainLooper())
+          .postDelayed(
+              () -> {
+                synchronized (mTaskQueue) {
+                  for (TaskConfig taskConfig : mTaskQueue) {
+                    invokeStartTask(reactContext, taskConfig);
+                  }
+                }
+              },
+              500);
+    }
+  }
+
+  /**
+   * Return true if this app is running with RN's bridgeless architecture. Cheers to @mikehardy for
+   * this idea.
+   *
+   * @return true if new arch bridgeless mode is enabled
+   */
+  public static boolean isBridgelessArchitectureEnabled() {
+    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;
+    }
+  }
+
+  /** Wrapper for a client event. Inserts our custom taskId into the RN ClientEvent params. */
+  public static class TaskConfig {
+    private final String mTaskName;
+    private final long mTaskTimeout;
+    private final GenericCallback mCallback;
+    private final int mTaskId;
+    private int mReactTaskId;
+    private final WritableMap mParams;
+
+    public TaskConfig(
+        String taskName,
+        long taskTimeout,
+        WritableMap params,
+        @Nullable GenericCallback taskCompletionCallback) {
+      mTaskName = taskName;
+      mTaskTimeout = taskTimeout;
+      mCallback = taskCompletionCallback;
+      mTaskId = getNextTaskId();
+      // Insert our custom taskId for users to call finishHeadlessTask(taskId) with.
+      params.putInt("taskId", mTaskId);
+      mParams = params;
+    }
+
+    public void setReactTaskId(int taskId) {
+      mReactTaskId = taskId;
+    }
+
+    public int getTaskId() {
+      return mTaskId;
+    }
+
+    public int getReactTaskId() {
+      return mReactTaskId;
+    }
+
+    public @Nullable GenericCallback getCallback() {
+      return mCallback;
+    }
+
+    public HeadlessJsTaskConfig getTaskConfig() {
+      return new HeadlessJsTaskConfig(mTaskName, mParams, mTaskTimeout, true);
+    }
+  }
+
+  public interface GenericCallback {
+    void call();
+  }
+}