@ammarahmed/react-native-background-fetch 4.2.2 → 4.2.3

package/android/src/main/java/com/transistorsoft/rnbackgroundfetch/HeadlessTask.java

@@ -4,7 +4,12 @@ import android.content.Context;
 import android.os.Handler;
 import android.util.Log;
 
+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;
@@ -13,50 +18,34 @@ import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.bridge.WritableNativeMap;
 import com.facebook.react.jstasks.HeadlessJsTaskConfig;
 import com.facebook.react.jstasks.HeadlessJsTaskContext;
-import com.facebook.react.jstasks.HeadlessJsTaskEventListener;
+
 import com.transistorsoft.tsbackgroundfetch.BGTask;
 import com.transistorsoft.tsbackgroundfetch.BackgroundFetch;
 import com.facebook.react.common.LifecycleState;
 
+import java.lang.reflect.Method;
+
 /**
  * Created by chris on 2018-01-17.
  */
 
-public class HeadlessTask implements HeadlessJsTaskEventListener {
-    private static String HEADLESS_TASK_NAME = "BackgroundFetch";
-    private static Handler mHandler = new Handler();
-    private ReactNativeHost mReactNativeHost;
-    private HeadlessJsTaskContext mActiveTaskContext;
+public class HeadlessTask {
+    private static final String HEADLESS_TASK_NAME = "BackgroundFetch";
+    private static final Handler mHandler = new Handler();
 
+    private final BGTask mBGTask;
     public HeadlessTask(Context context, BGTask task) {
-        try {
-            ReactApplication reactApplication = ((ReactApplication) context.getApplicationContext());
-            mReactNativeHost = reactApplication.getReactNativeHost();
-        } catch (AssertionError | ClassCastException e) {
-            Log.e(BackgroundFetch.TAG, "Failed to fetch ReactApplication.  Task ignored.");
-            return;  // <-- Do nothing.  Just return
-        }
+        mBGTask = task;
         WritableMap clientEvent = new WritableNativeMap();
         clientEvent.putString("taskId", task.getTaskId());
         clientEvent.putBoolean("timeout", task.getTimedOut());
         HeadlessJsTaskConfig config = new HeadlessJsTaskConfig(HEADLESS_TASK_NAME, clientEvent, 30000);
-        startTask(config);
-    }
-
-    public void finish() {
-        if (mActiveTaskContext != null) {
-            mActiveTaskContext.removeTaskEventListener(this);
+        try {
+            startTask(config, context);
+        } catch (AssertionError e) {
+            Log.d(BackgroundFetch.TAG, "[HeadlessTask] Failed invoke HeadlessTask: " + e.getMessage());
         }
     }
-    @Override
-    public void onHeadlessJsTaskStart(int taskId) {
-        Log.d(BackgroundFetch.TAG,"onHeadlessJsTaskStart: " + taskId);
-    }
-    @Override
-    public void onHeadlessJsTaskFinish(int taskId) {
-        Log.d(BackgroundFetch.TAG, "onHeadlessJsTaskFinish: " + taskId);
-        mActiveTaskContext.removeTaskEventListener(this);
-    }
 
     /**
      * Start a task. This method handles starting a new React instance if required.
@@ -65,27 +54,13 @@ public class HeadlessTask implements HeadlessJsTaskEventListener {
      *
      * @param taskConfig describes what task to start and the parameters to pass to it
      */
-    protected void startTask(final HeadlessJsTaskConfig taskConfig) {
+    protected void startTask(final HeadlessJsTaskConfig taskConfig, Context context) {
         UiThreadUtil.assertOnUiThread();
-        final ReactInstanceManager reactInstanceManager = mReactNativeHost.getReactInstanceManager();
-        ReactContext reactContext = reactInstanceManager.getCurrentReactContext();
+
+        ReactContext reactContext = getReactContext(context);
+
         if (reactContext == null) {
-            reactInstanceManager.addReactInstanceEventListener(new ReactInstanceManager.ReactInstanceEventListener() {
-                @Override
-                public void onReactContextInitialized(final ReactContext reactContext) {
-                    // Hack to fix unknown problem executing asynchronous BackgroundTask when ReactContext is created *first time*.  Fixed by adding short delay before #invokeStartTask
-                    mHandler.postDelayed(new Runnable() {
-                        @Override
-                        public void run() {
-                            invokeStartTask(reactContext, taskConfig);
-                        }
-                    }, 500);
-                    reactInstanceManager.removeReactInstanceEventListener(this);
-                }
-            });
-            if (!reactInstanceManager.hasStartedCreatingInitialContext()) {
-                reactInstanceManager.createReactContextInBackground();
-            }
+            createReactContextAndScheduleTask(taskConfig, context);
         } else {
             invokeStartTask(reactContext, taskConfig);
         }
@@ -96,24 +71,86 @@ public class HeadlessTask implements HeadlessJsTaskEventListener {
             return;
         }
         final HeadlessJsTaskContext headlessJsTaskContext = HeadlessJsTaskContext.getInstance(reactContext);
-        headlessJsTaskContext.addTaskEventListener(this);
-        mActiveTaskContext = headlessJsTaskContext;
+
+        UiThreadUtil.runOnUiThread(() -> {
+            try {
+                final int taskId = headlessJsTaskContext.startTask(taskConfig);
+                Log.d(BackgroundFetch.TAG, "[HeadlessTask] start taskId: " + taskId);
+                // Add a BGTask.finish(taskId) listener.  This is executed when the user runs BackgroundFetch.finish(taskId).
+                // We use this to finish the RN headless task.
+                mBGTask.setCompletionHandler(() -> {
+                    Log.d(BackgroundFetch.TAG, "[HeadlessTask] end taskId: " + taskId);
+                    if (headlessJsTaskContext.isTaskRunning(taskId)) {
+                        headlessJsTaskContext.finishTask(taskId);
+                    }
+                });
+            } catch (IllegalStateException exception) {
+                Log.e(BackgroundFetch.TAG, "[HeadlessTask] task attempted to run in the foreground.  Task ignored.");
+            }
+        });
+    }
+
+    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 {
-            UiThreadUtil.runOnUiThread(new Runnable() {
+            Method getReactHost = context.getClass().getMethod("getReactHost");
+            return getReactHost.invoke(context);
+            // Original non-reflection return:
+            //return ((ReactApplication) context.getApplicationContext()).getReactHost();
+        } catch (Exception e) {
+            Log.d(BackgroundFetch.TAG, "[HeadlessTask] Reflection error ReactHost: " + e);
+            return null;
+        }
+    }
+
+    private ReactContext getReactContext(Context context) {
+
+            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) {
+                Log.e(BackgroundFetch.TAG, "[HeadlessTask] Reflection error getCurrentReactContext: " + e);
+                return null;
+            }
+    }
+
+    private void createReactContextAndScheduleTask(final HeadlessJsTaskConfig taskConfig, Context context) {
+        Log.d(BackgroundFetch.TAG, "[HeadlessTask] initializing ReactContext");
+
+            final Object reactHost = getReactHost(context);
+
+            ReactInstanceEventListener callback = new ReactInstanceEventListener() {
                 @Override
-                public void run() {
+                public void onReactContextInitialized(@NonNull ReactContext reactContext) {
+                    mHandler.postDelayed(() -> invokeStartTask(reactContext, taskConfig), 500);
                     try {
-                        int taskId = headlessJsTaskContext.startTask(taskConfig);
-                    } catch (IllegalStateException exception) {
-                        Log.e(BackgroundFetch.TAG, "Headless task attempted to run in the foreground.  Task ignored.");
-                        return;  // <-- Do nothing.  Just return
+                        Method removeReactInstanceEventListener = reactHost.getClass().getMethod("removeReactInstanceEventListener", ReactInstanceEventListener.class);
+                        removeReactInstanceEventListener.invoke(reactHost, this);
+                    } catch (Exception e) {
+                        Log.e(BackgroundFetch.TAG, "[HeadlessTask] reflection error removeReactInstanceEventListener" + e);
                     }
                 }
-            });
-        } catch (IllegalStateException exception) {
-            Log.e(BackgroundFetch.TAG, "Headless task attempted to run in the foreground.  Task ignored.");
-            return;  // <-- Do nothing.  Just return
-        }
+            };
+
+            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) {
+                Log.e(BackgroundFetch.TAG, "[HeadlessTask] reflection error addReactInstanceEventListener: " + e);
+            }
 
     }
-}
+
+
+}

package/android/src/main/java/com/transistorsoft/tsbackgroundfetch/BGTask.java

@@ -65,6 +65,7 @@ public class BGTask {
         }
     }
 
+    private final List<FetchJobService.CompletionHandler> mCompletionHandlers = new ArrayList<>();
     private FetchJobService.CompletionHandler mCompletionHandler;
     private String mTaskId;
     private int mJobId;
@@ -73,7 +74,8 @@ public class BGTask {
 
     BGTask(final Context context, String taskId, FetchJobService.CompletionHandler handler, int jobId) {
         mTaskId = taskId;
-        mCompletionHandler = handler;
+        //mCompletionHandler = handler;
+        mCompletionHandlers.add(handler);
         mJobId = jobId;
 
         mTimeoutTask = new Runnable() {
@@ -96,18 +98,30 @@ public class BGTask {
         return ((mTaskId != null) && mTaskId.equalsIgnoreCase(taskId));
     }
 
-    void setCompletionHandler(FetchJobService.CompletionHandler handler) {
-        mCompletionHandler = handler;
+    public void setCompletionHandler(FetchJobService.CompletionHandler handler) {
+        synchronized (mCompletionHandlers) {
+            mCompletionHandlers.add(handler);
+        }
+        //mCompletionHandler = handler;
     }
 
     void finish() {
+        synchronized (mCompletionHandlers) {
+            for (FetchJobService.CompletionHandler handler : mCompletionHandlers) {
+                handler.finish();
+            }
+            mCompletionHandlers.clear();
+        }
+        /*
         if (mCompletionHandler != null) {
             mCompletionHandler.finish();
         }
+         */
         if (mTimeoutTask != null) {
             BackgroundFetch.getUiHandler().removeCallbacks(mTimeoutTask);
         }
-        mCompletionHandler = null;
+
+        //mCompletionHandler = null;
         removeTask(mTaskId);
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ammarahmed/react-native-background-fetch",
-  "version": "4.2.2",
+  "version": "4.2.3",
   "description": "iOS & Android BackgroundFetch API implementation for React Native",
   "scripts": {
     "build": "yarn run build:expo",