@ammarahmed/react-native-background-fetch 4.2.1

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

@@ -0,0 +1,40 @@
+package com.transistorsoft.tsbackgroundfetch;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.os.PowerManager;
+import android.util.Log;
+
+import static android.content.Context.POWER_SERVICE;
+
+/**
+ * Created by chris on 2018-01-11.
+ */
+
+public class FetchAlarmReceiver extends BroadcastReceiver {
+
+    @Override
+    public void onReceive(final Context context, Intent intent) {
+        PowerManager powerManager = (PowerManager) context.getSystemService(POWER_SERVICE);
+        final PowerManager.WakeLock wakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, BackgroundFetch.TAG + "::" + intent.getAction());
+        // WakeLock expires in MAX_TIME + 4s buffer.
+        wakeLock.acquire((BGTask.MAX_TIME + 4000));
+
+        final String taskId = intent.getAction();
+
+        final FetchJobService.CompletionHandler completionHandler = new FetchJobService.CompletionHandler() {
+            @Override
+            public void finish() {
+                if (wakeLock.isHeld()) {
+                    wakeLock.release();
+                    Log.d(BackgroundFetch.TAG, "- FetchAlarmReceiver finish");
+                }
+            }
+        };
+
+        BGTask task = new BGTask(context, taskId, completionHandler, 0);
+
+        BackgroundFetch.getInstance(context.getApplicationContext()).onFetch(task);
+    }
+}

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

@@ -0,0 +1,106 @@
+package com.transistorsoft.tsbackgroundfetch;
+
+import android.annotation.TargetApi;
+import android.app.job.JobParameters;
+import android.app.job.JobService;
+import android.os.PersistableBundle;
+import android.util.Log;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Created by chris on 2018-01-11.
+ */
+@TargetApi(21)
+public class FetchJobService extends JobService {
+
+    // Queue of recently run jobs.
+    private static final List<ExecutedJob> sExecutedJobs = new ArrayList<>();
+
+    @Override
+    public boolean onStartJob(final JobParameters params) {
+        PersistableBundle extras = params.getExtras();
+        long scheduleAt = extras.getLong("scheduled_at");
+        long dt = System.currentTimeMillis() - scheduleAt;
+        // Scheduled < 1s ago?  Ignore.
+        if (dt < 1000) {
+            // JobScheduler always immediately fires an initial event on Periodic jobs -- We IGNORE these.
+            jobFinished(params, false);
+            return false;
+        }
+
+        final String taskId = extras.getString(BackgroundFetchConfig.FIELD_TASK_ID);
+
+        // Is this a duplicate event?
+        // JobScheduler has a bug in Android N that causes duplicate Jobs to fire within a few milliseconds.
+        // We keep a Queue of the last 5 tasks so we can see if this task has executed in the last 5000ms.
+        synchronized (sExecutedJobs) {
+            for (ExecutedJob job : sExecutedJobs) {
+                if (job.isDuplicate(taskId)) {
+                    Log.d(BackgroundFetch.TAG, "- Caught duplicate Job " + taskId + ": [IGNORED]");
+                    jobFinished(params, false);
+                    return false;
+                }
+            }
+            // Not found?  Add this task to the Queue.
+            sExecutedJobs.add(new ExecutedJob(taskId));
+            if (sExecutedJobs.size() > 5) {
+                sExecutedJobs.remove(0);
+            }
+        }
+        // Good to go:  Execute the task.
+        CompletionHandler completionHandler = () -> {
+            Log.d(BackgroundFetch.TAG, "- jobFinished");
+            jobFinished(params, false);
+        };
+        BGTask task = new BGTask(this, taskId, completionHandler, params.getJobId());
+        BackgroundFetch.getInstance(getApplicationContext()).onFetch(task);
+
+        return true;
+    }
+
+    @Override
+    public boolean onStopJob(final JobParameters params) {
+        Log.d(BackgroundFetch.TAG, "- onStopJob");
+
+        PersistableBundle extras = params.getExtras();
+        final String taskId = extras.getString(BackgroundFetchConfig.FIELD_TASK_ID);
+
+        BGTask task = BGTask.getTask(taskId);
+        if (task != null) {
+            task.onTimeout(getApplicationContext());
+        }
+        jobFinished(params, false);
+        return true;
+    }
+
+    public interface CompletionHandler {
+        void finish();
+    }
+
+    private static class ExecutedJob {
+        private static final long OFFSET_TIME = 5000L;
+
+        private final String mTaskId;
+        private final long mTimestamp;
+
+        ExecutedJob(String taskId) {
+            mTaskId = taskId;
+            mTimestamp = System.currentTimeMillis();
+        }
+
+        boolean isDuplicate(String taskId) {
+            if (!taskId.equalsIgnoreCase(mTaskId)) {
+                return false;
+            }
+            long dt = System.currentTimeMillis() - mTimestamp;
+            return (dt < OFFSET_TIME);
+        }
+
+        @Override
+        public String toString() {
+            return "[LastJob taskId: " + mTaskId + ", timestamp: " + mTimestamp + "]";
+        }
+    }
+}

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

@@ -0,0 +1,225 @@
+package com.transistorsoft.tsbackgroundfetch;
+
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.lifecycle.DefaultLifecycleObserver;
+import androidx.lifecycle.LifecycleOwner;
+import androidx.lifecycle.ProcessLifecycleOwner;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * Component for managing app life-cycle changes, including headless-mode.
+ */
+public class LifecycleManager implements DefaultLifecycleObserver, Runnable {
+    private static LifecycleManager sInstance;
+
+    public static LifecycleManager getInstance() {
+        if (sInstance == null) {
+            sInstance = getInstanceSynchronized();
+        }
+        return sInstance;
+    }
+
+    private static synchronized LifecycleManager getInstanceSynchronized() {
+        if (sInstance == null) sInstance = new LifecycleManager();
+        return sInstance;
+    }
+
+    private final List<OnHeadlessChangeCallback> mHeadlessChangeCallbacks = new ArrayList<>();
+    private final List<OnStateChangeCallback> mStateChangeCallbacks = new ArrayList<>();
+    private final Handler mHandler;
+    private Runnable mHeadlessChangeEvent;
+
+    private final AtomicBoolean mIsBackground   = new AtomicBoolean(true);
+    private final AtomicBoolean mIsHeadless     = new AtomicBoolean(true);
+    private final AtomicBoolean mStarted        = new AtomicBoolean(false);
+    private final AtomicBoolean mPaused         = new AtomicBoolean(false);
+
+    private LifecycleManager() {
+        mHandler    = new Handler(Looper.getMainLooper());
+        onHeadlessChange(isHeadless -> {
+            if (isHeadless) {
+                Log.d(BackgroundFetch.TAG, "☯️  HeadlessMode? " + isHeadless);
+            }
+        });
+    }
+
+    /**
+     * Temporarily disable responding to pause/resume events.  This was placed here for handling TSLocationManagerActivity events
+     * whose presentation causes onPause / onResume events that we don't want to react to.
+     */
+    public void pause() {
+        mPaused.set(true);
+    }
+
+    /**
+     * Re-engage responding to pause/resume events.
+     */
+    public void resume() {
+        mPaused.set(false);
+    }
+    /**
+     * Are we in the background?
+     * @return boolean
+     */
+    public boolean isBackground() {
+        return mIsBackground.get();
+    }
+    /**
+     * Are we headless
+     * @return boolean
+     */
+    public boolean isHeadless() {
+        return mIsHeadless.get();
+    }
+    /**
+     * Explicitly state that we are headless.  Probably called when MainActivity is known to have been destroyed.
+     * @param value boolean
+     */
+    public void setHeadless(boolean value) {
+        mIsHeadless.set(value);
+        if (mIsHeadless.get()) {
+            Log.d(BackgroundFetch.TAG,"☯️  HeadlessMode? " + mIsHeadless);
+        }
+        if (mHeadlessChangeEvent != null) {
+            mHandler.removeCallbacks(mHeadlessChangeEvent);
+            mStarted.set(true);
+            fireHeadlessChangeListeners();
+        }
+    }
+    /**
+     * Register Headless-mode change listener.
+     */
+    public void onHeadlessChange(OnHeadlessChangeCallback callback) {
+        if (mStarted.get()) {
+            callback.onChange(mIsHeadless.get());
+            return;
+        }
+        synchronized (mHeadlessChangeCallbacks) {
+            mHeadlessChangeCallbacks.add(callback);
+        }
+    }
+    /**
+     * Register pause/resume listener.
+     */
+    public void onStateChange(OnStateChangeCallback callback) {
+        synchronized (mStateChangeCallbacks) {
+            mStateChangeCallbacks.add(callback);
+        }
+    }
+
+    /**
+     * Regiser the LifecycleObserver
+     */
+    @Override
+    public void run() {
+        ProcessLifecycleOwner.get().getLifecycle().addObserver(this);
+    }
+
+    @Override
+    public void onCreate(@NonNull LifecycleOwner owner) {
+        Log.d(BackgroundFetch.TAG,"☯️  onCreate");
+        // If this 50ms Timer fires before onStart, we are headless
+        mHeadlessChangeEvent = new Runnable() {
+            @Override public void run() {
+                mStarted.set(true);
+                fireHeadlessChangeListeners();
+            }
+        };
+
+        mHandler.postDelayed(mHeadlessChangeEvent, 50);
+        mIsHeadless.set(true);
+        mIsBackground.set(true);
+    }
+
+    @Override
+    public void onStart(@NonNull LifecycleOwner owner) {
+        Log.d(BackgroundFetch.TAG, "☯️  onStart");
+        // Cancel StateChange Timer.
+        if (mPaused.get()) {
+            return;
+        }
+        if (mHeadlessChangeEvent != null) {
+            mHandler.removeCallbacks(mHeadlessChangeEvent);
+        }
+
+        mStarted.set(true);
+        mIsHeadless.set(false);
+        mIsBackground.set(false);
+
+        // Fire listeners.
+        fireHeadlessChangeListeners();
+    }
+
+    @Override
+    public void onDestroy(@NonNull LifecycleOwner owner) {
+        Log.d(BackgroundFetch.TAG, "☯️  onDestroy");
+        mIsBackground.set(true);
+        mIsHeadless.set(true);
+    }
+
+    @Override
+    public void onStop(@NonNull LifecycleOwner owner) {
+        Log.d(BackgroundFetch.TAG, "☯️  onStop");
+        if (mPaused.compareAndSet(true, false)) {
+            return;
+        }
+        mIsBackground.set(true);
+
+    }
+
+    @Override
+    public void onPause(@NonNull LifecycleOwner owner) {
+        Log.d(BackgroundFetch.TAG, "☯️  onPause");
+        mIsBackground.set(true);
+        fireStateChangeListeners(false);
+    }
+
+    @Override
+    public void onResume(@NonNull LifecycleOwner owner) {
+        Log.d(BackgroundFetch.TAG, "☯️  onResume");
+        if (mPaused.get()) {
+            return;
+        }
+        mIsBackground.set(false);
+        mIsHeadless.set(false);
+        fireStateChangeListeners(true);
+    }
+
+    /// Fire pause/resume change listeners
+    private void fireStateChangeListeners(boolean isForeground) {
+        synchronized (mStateChangeCallbacks) {
+            for (OnStateChangeCallback callback : mStateChangeCallbacks) {
+                callback.onChange(isForeground);
+            }
+        }
+    }
+
+    /// Fire headless mode change listeners.
+    private void fireHeadlessChangeListeners() {
+        if (mHeadlessChangeEvent != null) {
+            mHandler.removeCallbacks(mHeadlessChangeEvent);
+            mHeadlessChangeEvent = null;
+        }
+        synchronized (mHeadlessChangeCallbacks) {
+            for (OnHeadlessChangeCallback callback : mHeadlessChangeCallbacks) {
+                callback.onChange(mIsHeadless.get());
+            }
+            mHeadlessChangeCallbacks.clear();
+        }
+    }
+
+    public interface OnHeadlessChangeCallback {
+        void onChange(boolean isHeadless);
+    }
+
+    public interface OnStateChangeCallback {
+        void onChange(boolean isForeground);
+    }
+}

package/app.plugin.js

@@ -0,0 +1 @@
+module.exports = require('./expo/plugin/build');

package/index.d.ts

@@ -0,0 +1,185 @@
+declare module "react-native-background-fetch" {
+
+	interface AbstractConfig {
+		/**
+		* [Android only] Set false to continue background-fetch events after user terminates the app.  Default to true.
+		*/
+		stopOnTerminate?:boolean;
+		/**
+		* [Android only] Set true to initiate background-fetch events when the device is rebooted.  Defaults to false.
+		*/
+		startOnBoot?:boolean;
+		/**
+		* [Android only] Set true to enable Headless mechanism for handling fetch events after app termination.
+		*/
+		enableHeadless?:boolean;
+		/**
+		* [Android only]
+		*/
+		forceAlarmManager?:boolean;
+		/**
+		* [Android only] Set detailed description of the kind of network your job requires.
+		*
+		* If your job doesn't need a network connection, you don't need to use this option, as the default is [[BackgroundFetch.NEWORK_TYPE_NONE]].
+		*
+		* Calling this method defines network as a strict requirement for your job. If the network requested is not available your job will never run.
+		*/
+		requiredNetworkType?:NetworkType;
+		/**
+		* [Android only] Specify that to run this job, the device's battery level must not be low.
+		*
+		* This defaults to false. If true, the job will only run when the battery level is not low, which is generally the point where the user is given a "low battery" warning.
+		*/
+		requiresBatteryNotLow?:boolean;
+		/**
+		* [Android only] Specify that to run this job, the device's available storage must not be low.
+		*
+		* This defaults to false. If true, the job will only run when the device is not in a low storage state, which is generally the point where the user is given a "low storage" warning.
+		*/
+		requiresStorageNotLow?:boolean;
+		/**
+		* [Android only] Specify that to run this job, the device must be charging (or be a non-battery-powered device connected to permanent power, such as Android TV devices). This defaults to false.
+		*/
+		requiresCharging?:boolean;
+		/**
+		* [Android only] When set true, ensure that this job will not run if the device is in active use.
+		*
+		* The default state is false: that is, the for the job to be runnable even when someone is interacting with the device.
+		*
+		* This state is a loose definition provided by the system. In general, it means that the device is not currently being used interactively, and has not been in use for some time. As such, it is a good time to perform resource heavy jobs. Bear in mind that battery usage will still be attributed to your application, and surfaced to the user in battery stats.
+		*/
+		requiresDeviceIdle?:boolean;
+	}
+
+	interface TaskConfig extends AbstractConfig {
+		/**
+		* The name of the task.  This will be used with [[BackgroundFetch.finish]] to signal task-completion.
+		*/
+		taskId:string;
+		/**
+		* The minimum interval in milliseconds to execute this task.
+		*/
+		delay:number;
+		/**
+		* Whether this task will continue executing or just a "one-shot".
+		*/
+		periodic?:boolean;
+		/**
+		* When set true, ensure that this job will run if the device has network connection.
+		*/
+		requiresNetworkConnectivity?:boolean;
+	}
+
+	interface BackgroundFetchConfig extends AbstractConfig {
+		/**
+		* The minimum interval in minutes to execute background fetch events.  Defaults to 15 minutes.  Minimum is 15 minutes.
+		*/
+		minimumFetchInterval?:number;
+	}
+
+	/**
+	* | BackgroundFetchStatus              | Description                                     |
+	* |------------------------------------|-------------------------------------------------|
+	* | BackgroundFetch.STATUS_RESTRICTED  | Background fetch updates are unavailable and the user cannot enable them again. For example, this status can occur when parental controls are in effect for the current user. |
+	* | BackgroundFetch.STATUS_DENIED      | The user explicitly disabled background behavior for this app or for the whole system. |
+	* | BackgroundFetch.STATUS_AVAILABLE   | Background fetch is available and enabled.      |
+	*/
+	type BackgroundFetchStatus = 0 | 1 | 2;
+
+	/**
+	* | NetworkType                           | Description                                                   |
+	* |---------------------------------------|---------------------------------------------------------------|
+	* | BackgroundFetch.NETWORK_TYPE_NONE     | This job doesn't care about network constraints, either any or none.                         |
+	* | BackgroundFetch.NETWORK_TYPE_ANY  	  | This job requires network connectivity.                          |
+	* | BackgroundFetch.NETWORK_TYPE_CELLULAR | This job requires network connectivity that is a cellular network. |
+	* | BackgroundFetch.NETWORK_TYPE_UNMETERED | This job requires network connectivity that is unmetered. |
+	* | BackgroundFetch.NETWORK_TYPE_NOT_ROAMING | This job requires network connectivity that is not roaming. |
+	*/
+	type NetworkType = 0 | 1 | 2 | 3 | 4;
+
+	export interface HeadlessEvent {
+		/**
+		* The name of the task.  This will be used with [[BackgroundFetch.finish]] to signal task-completion.
+		*/
+		taskId: string;
+		/**
+		* Whether this event is a timeout event or not. If true stop all processing and call [[BackgroundFetch.finish]] immediately.
+		*/
+		timeout: boolean;
+	}
+
+	/**
+	* BackgroundFetch is a module to receive periodic callbacks (min every 15 min) while your app is running in the background or terminated.
+	*/
+	export default class BackgroundFetch {
+		/**
+		* Background fetch updates are unavailable and the user cannot enable them again. For example, this status can occur when parental controls are in effect for the current user.
+		*/
+		static STATUS_RESTRICTED: BackgroundFetchStatus;
+		/**
+		* The user explicitly disabled background behavior for this app or for the whole system.
+		*/
+		static STATUS_DENIED: BackgroundFetchStatus;
+		/**
+		* Background fetch is available and enabled.
+		*/
+		static STATUS_AVAILABLE: BackgroundFetchStatus;
+		/**
+		* This job doesn't care about network constraints, either any or none.
+		*/
+		static NETWORK_TYPE_NONE: NetworkType;
+		/**
+		* This job requires network connectivity.
+		*/
+		static NETWORK_TYPE_ANY: NetworkType;
+		/**
+		* This job requires network connectivity that is a cellular network.
+		*/
+		static NETWORK_TYPE_CELLULAR: NetworkType;
+		/**
+		* This job requires network connectivity that is unmetered.
+		*/
+		static NETWORK_TYPE_UNMETERED: NetworkType;
+		/**
+		* This job requires network connectivity that is not roaming.
+		*/
+		static NETWORK_TYPE_NOT_ROAMING: NetworkType;
+
+		/**
+		* Initial configuration of BackgroundFetch, including config-options and Fetch-callback.  The [[start]] method will automatically be executed.
+		*/
+		static configure(config:BackgroundFetchConfig, onEvent:(taskId:string) => void, onTimeout?:(taskId:string) => void):Promise<BackgroundFetchStatus>;
+		/**
+		* Add an extra fetch event listener in addition to the one initially provided to [[configure]].
+		* @event
+		*/
+		static scheduleTask(config:TaskConfig):Promise<boolean>;
+
+		/**
+		* Start subscribing to fetch events.
+		*/
+		static start():Promise<BackgroundFetchStatus>;
+		/**
+		* Stop subscribing to fetch events.
+		*/
+		static stop(taskId?:string):Promise<boolean>;
+		/**
+		* You must execute [[finish]] within your fetch-callback to signal completion of your task.
+		*/
+		static finish(taskId?:string):void;
+		/**
+		* Query the BackgroundFetch API status
+		*
+		* | BackgroundFetchStatus              | Description                                     |
+		* |------------------------------------|-------------------------------------------------|
+		* | BackgroundFetch.STATUS_RESTRICTED  | Background fetch updates are unavailable and the user cannot enable them again. For example, this status can occur when parental controls are in effect for the current user. |
+		* | BackgroundFetch.STATUS_DENIED      | The user explicitly disabled background behavior for this app or for the whole system. |
+		* | BackgroundFetch.STATUS_AVAILABLE   | Background fetch is available and enabled.      |
+		*/
+		static status(callback?:(status:BackgroundFetchStatus) => void):Promise<BackgroundFetchStatus>;
+		/**
+		* [Android only] Register a function to execute when the app is terminated.  Requires stopOnTerminate: false.
+		*/
+		static registerHeadlessTask(task:(event:HeadlessEvent) => Promise<void>):void;
+	}
+}

package/index.js

@@ -0,0 +1,119 @@
+'use strict'
+
+import {
+  NativeModules,
+  NativeEventEmitter,
+  AppRegistry
+} from "react-native";
+
+const RNBackgroundFetch = NativeModules.RNBackgroundFetch;
+const EventEmitter = new NativeEventEmitter(RNBackgroundFetch);
+
+const EVENT_FETCH = "fetch";
+const TAG         = "RNBackgroundFetch";
+const EVENTS      = ["fetch"];
+
+const STATUS_RESTRICTED = 0;
+const STATUS_DENIED     = 1;
+const STATUS_AVAILABLE  = 2;
+
+const NETWORK_TYPE_NONE         = 0;
+const NETWORK_TYPE_ANY          = 1;
+const NETWORK_TYPE_UNMETERED    = 2;
+const NETWORK_TYPE_NOT_ROAMING  = 3;
+const NETWORK_TYPE_CELLULAR     = 4;
+
+export default class BackgroundFetch {
+  static get STATUS_RESTRICTED() { return STATUS_RESTRICTED; }
+  static get STATUS_DENIED() { return STATUS_DENIED; }
+  static get STATUS_AVAILABLE() { return STATUS_AVAILABLE; }
+
+  static get NETWORK_TYPE_NONE() { return NETWORK_TYPE_NONE; }
+  static get NETWORK_TYPE_ANY() { return NETWORK_TYPE_ANY; }
+  static get NETWORK_TYPE_UNMETERED() { return NETWORK_TYPE_UNMETERED; }
+  static get NETWORK_TYPE_NOT_ROAMING() { return NETWORK_TYPE_NOT_ROAMING; }
+  static get NETWORK_TYPE_CELLULAR() { return NETWORK_TYPE_CELLULAR; }
+
+  static configure(config, onEvent, onTimeout) {
+    if (typeof(onEvent) !== 'function') {
+      throw "BackgroundFetch requires an event callback at 2nd argument";
+    }
+    if (typeof(onTimeout) !== 'function') {
+      console.warn("[BackgroundFetch] configure:  You did not provide a 3rd argument onTimeout callback.  This callback is a signal from the OS that your allowed background time is about to expire.  Use this callback to finish what you're doing and immediately call BackgroundFetch.finish(taskId)");
+      onTimeout = (taskId) => {
+        console.warn('[BackgroundFetch] default onTimeout callback fired.  You should provide your own onTimeout callback to .configure(options, onEvent, onTimeout)');
+        BackgroundFetch.finish(taskId);
+      }
+    }
+    EventEmitter.removeAllListeners(EVENT_FETCH);
+
+    EventEmitter.addListener(EVENT_FETCH, (event) => {
+      if (!event.timeout) {
+        onEvent(event.taskId);
+      } else {
+        onTimeout(event.taskId);
+      }
+    });
+
+    config = config || {};
+
+    return new Promise((resolve, reject) => {
+      let success = (status) => { resolve(status) };
+      let failure = (status) => { reject(status) };
+      RNBackgroundFetch.configure(config, success, failure);
+    });
+  }
+
+  static scheduleTask(config) {
+    return new Promise((resolve, reject) => {
+      let success = (success) => { resolve(success) }
+      let failure = (error) => { reject(error) }
+      RNBackgroundFetch.scheduleTask(config, success, failure);
+    });
+  }
+
+  /**
+  * Register HeadlessTask
+  */
+  static registerHeadlessTask(task) {
+    AppRegistry.registerHeadlessTask("BackgroundFetch", () => task);
+  }
+
+  static start() {
+    return new Promise((resolve, reject) => {
+      let success = (status) => {
+        resolve(status);
+      }
+      let failure = (error) => {
+        reject(error);
+      }
+      RNBackgroundFetch.start(success, failure);
+    })
+  }
+
+  static stop(taskId) {
+    return new Promise((resolve, reject) => {
+      let success = (success) => {
+        resolve(success);
+      }
+      let failure = (error) => {
+        reject(error);
+      }
+      RNBackgroundFetch.stop(taskId, success, failure);
+    });
+  }
+
+  static finish(taskId) {
+    RNBackgroundFetch.finish(taskId);
+  }
+
+  static status(callback) {
+    if (typeof(callback) === 'function') {
+      return RNBackgroundFetch.status(callback);
+    }
+    return new Promise((resolve, reject) => {
+      RNBackgroundFetch.status(resolve);
+    })
+  }
+}
+

package/ios/RNBackgroundFetch/RNBackgroundFetch+AppDelegate.m

@@ -0,0 +1,22 @@
+//
+//  RNBackgroundGeolocation+AppDelegate.m
+//  RNBackgroundGeolocationSample
+//
+//  Created by Christopher Scott on 2016-08-01.
+//  Copyright © 2016 Facebook. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "AppDelegate.h"
+#import <TSBackgroundFetch/TSBackgroundFetch.h>
+
+@implementation AppDelegate(AppDelegate)
+
+-(void)application:(UIApplication *)application performFetchWithCompletionHandler:(void (^)(UIBackgroundFetchResult))completionHandler
+{
+    NSLog(@"RNBackgroundFetch AppDelegate received fetch event");
+    TSBackgroundFetch *fetchManager = [TSBackgroundFetch sharedInstance];
+    [fetchManager performFetchWithCompletionHandler:completionHandler applicationState:application.applicationState];
+}
+
+@end