@ammarahmed/react-native-background-fetch 4.2.1

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

@@ -0,0 +1,119 @@
+package com.transistorsoft.rnbackgroundfetch;
+
+import android.content.Context;
+import android.os.Handler;
+import android.util.Log;
+
+import com.facebook.react.ReactApplication;
+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.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;
+
+/**
+ * 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 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
+        }
+        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);
+        }
+    }
+    @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.
+     *
+     * Has to be called on the UI thread.
+     *
+     * @param taskConfig describes what task to start and the parameters to pass to it
+     */
+    protected void startTask(final HeadlessJsTaskConfig taskConfig) {
+        UiThreadUtil.assertOnUiThread();
+        final ReactInstanceManager reactInstanceManager = mReactNativeHost.getReactInstanceManager();
+        ReactContext reactContext = reactInstanceManager.getCurrentReactContext();
+        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();
+            }
+        } else {
+            invokeStartTask(reactContext, taskConfig);
+        }
+    }
+
+    private void invokeStartTask(ReactContext reactContext, final HeadlessJsTaskConfig taskConfig) {
+        if (reactContext.getLifecycleState() == LifecycleState.RESUMED) {
+            return;
+        }
+        final HeadlessJsTaskContext headlessJsTaskContext = HeadlessJsTaskContext.getInstance(reactContext);
+        headlessJsTaskContext.addTaskEventListener(this);
+        mActiveTaskContext = headlessJsTaskContext;
+        try {
+            UiThreadUtil.runOnUiThread(new Runnable() {
+                @Override
+                public void run() {
+                    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
+                    }
+                }
+            });
+        } catch (IllegalStateException exception) {
+            Log.e(BackgroundFetch.TAG, "Headless task attempted to run in the foreground.  Task ignored.");
+            return;  // <-- Do nothing.  Just return
+        }
+
+    }
+}

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

@@ -0,0 +1,185 @@
+package com.transistorsoft.rnbackgroundfetch;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.util.Log;
+
+import com.facebook.react.bridge.*;
+import com.facebook.react.modules.core.RCTNativeAppEventEmitter;
+import com.transistorsoft.tsbackgroundfetch.BackgroundFetch;
+import com.transistorsoft.tsbackgroundfetch.BackgroundFetchConfig;
+import com.transistorsoft.tsbackgroundfetch.LifecycleManager;
+
+public class RNBackgroundFetchModule extends ReactContextBaseJavaModule implements ActivityEventListener, LifecycleEventListener {
+    public static final String TAG = "RNBackgroundFetch";
+    private static final String EVENT_FETCH = "fetch";
+    private static final String JOB_SERVICE_CLASS = HeadlessTask.class.getName();
+    private static final String FETCH_TASK_ID = "react-native-background-fetch";
+    private boolean initialized = false;
+
+    public RNBackgroundFetchModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        Log.d(BackgroundFetch.TAG, "[RNBackgroundFetch initialize]");
+        BackgroundFetch.getInstance(reactContext.getApplicationContext());
+        reactContext.addLifecycleEventListener(this);
+    }
+
+    @Override
+    public String getName() {
+        return TAG;
+    }
+
+    @ReactMethod
+    public void configure(ReadableMap options, final Callback success, final Callback failure) {
+        BackgroundFetch adapter = getAdapter();
+
+        BackgroundFetch.Callback callback = new BackgroundFetch.Callback() {
+            @Override public void onFetch(String taskId) {
+                WritableMap params = new WritableNativeMap();
+                params.putString("taskId", taskId);
+                params.putBoolean("timeout", false);
+                getReactApplicationContext().getJSModule(RCTNativeAppEventEmitter.class).emit(EVENT_FETCH, params);
+            }
+            @Override public void onTimeout(String taskId) {
+                WritableMap params = new WritableNativeMap();
+                params.putString("taskId", taskId);
+                params.putBoolean("timeout", true);
+                getReactApplicationContext().getJSModule(RCTNativeAppEventEmitter.class).emit(EVENT_FETCH, params);
+            }
+        };
+        adapter.configure(buildConfig(options)
+                .setTaskId(FETCH_TASK_ID)
+                .setIsFetchTask(true)
+                .build(), callback);
+
+        success.invoke(BackgroundFetch.STATUS_AVAILABLE);
+    }
+
+    @ReactMethod
+    public void scheduleTask(ReadableMap options, final Callback success, final Callback failure) {
+        BackgroundFetch adapter = getAdapter();
+        adapter.scheduleTask(buildConfig(options).build());
+        success.invoke(true);
+    }
+
+    @ReactMethod
+    public void start(Callback success, Callback failure) {
+        BackgroundFetch adapter = getAdapter();
+        adapter.start(FETCH_TASK_ID);
+        success.invoke(adapter.status());
+    }
+
+    @ReactMethod
+    public void stop(String taskId, Callback success, Callback failure) {
+        if (taskId == null) taskId = FETCH_TASK_ID;
+        BackgroundFetch adapter = getAdapter();
+        adapter.stop(taskId);
+        success.invoke(true);
+    }
+
+    @ReactMethod
+    public void status(Callback success) {
+        BackgroundFetch adapter = getAdapter();
+        success.invoke(adapter.status());
+    }
+
+    @ReactMethod
+    public void finish(String taskId) {
+        BackgroundFetch adapter = getAdapter();
+        adapter.finish(taskId);
+    }
+
+    @ReactMethod
+    public void addListener(String event) {
+        // Keep:  Required for RN built-in NativeEventEmitter calls.
+    }
+
+    @ReactMethod
+    public void removeListeners(Integer count) {
+        // Keep:  Required for RN built-in NativeEventEmitter calls.
+    }
+
+    @Override
+    public void onHostResume() {
+        if (!initialized) {
+            initializeBackgroundFetch();
+        }
+    }
+
+    @Override
+    public void onHostPause() {
+    }
+
+    @Override
+    public void onNewIntent(Intent intent) {
+    }
+
+    @Override
+    public void onHostDestroy() {
+        LifecycleManager.getInstance().setHeadless(true);
+        initialized = false;
+    }
+
+    @Override
+    public void onActivityResult(Activity activity, int requestCode, int resultCode, Intent data) {
+
+    }
+
+    private BackgroundFetchConfig.Builder buildConfig(ReadableMap options) {
+        BackgroundFetchConfig.Builder config = new BackgroundFetchConfig.Builder();
+        if (options.hasKey(BackgroundFetchConfig.FIELD_MINIMUM_FETCH_INTERVAL)) {
+            config.setMinimumFetchInterval(options.getInt(BackgroundFetchConfig.FIELD_MINIMUM_FETCH_INTERVAL));
+        }
+        if (options.hasKey(BackgroundFetchConfig.FIELD_TASK_ID)) {
+            config.setTaskId(options.getString(BackgroundFetchConfig.FIELD_TASK_ID));
+        }
+        if (options.hasKey(BackgroundFetchConfig.FIELD_DELAY)) {
+            Integer delay = options.getInt(BackgroundFetchConfig.FIELD_DELAY);
+            config.setDelay(delay.longValue());
+        }
+        if (options.hasKey(BackgroundFetchConfig.FIELD_STOP_ON_TERMINATE)) {
+            config.setStopOnTerminate(options.getBoolean(BackgroundFetchConfig.FIELD_STOP_ON_TERMINATE));
+        }
+        if (options.hasKey(BackgroundFetchConfig.FIELD_FORCE_ALARM_MANAGER)) {
+            config.setForceAlarmManager(options.getBoolean(BackgroundFetchConfig.FIELD_FORCE_ALARM_MANAGER));
+        }
+        if (options.hasKey(BackgroundFetchConfig.FIELD_START_ON_BOOT)) {
+            config.setStartOnBoot(options.getBoolean(BackgroundFetchConfig.FIELD_START_ON_BOOT));
+        }
+        if (options.hasKey("enableHeadless") && options.getBoolean("enableHeadless")) {
+            config.setJobService(JOB_SERVICE_CLASS);
+        }
+        if (options.hasKey(BackgroundFetchConfig.FIELD_REQUIRED_NETWORK_TYPE)) {
+            config.setRequiredNetworkType(options.getInt(BackgroundFetchConfig.FIELD_REQUIRED_NETWORK_TYPE));
+        }
+        if (options.hasKey(BackgroundFetchConfig.FIELD_REQUIRES_BATTERY_NOT_LOW)) {
+            config.setRequiresBatteryNotLow(options.getBoolean(BackgroundFetchConfig.FIELD_REQUIRES_BATTERY_NOT_LOW));
+        }
+        if (options.hasKey(BackgroundFetchConfig.FIELD_REQUIRES_CHARGING)) {
+            config.setRequiresCharging(options.getBoolean(BackgroundFetchConfig.FIELD_REQUIRES_CHARGING));
+        }
+        if (options.hasKey(BackgroundFetchConfig.FIELD_REQUIRES_DEVICE_IDLE)) {
+            config.setRequiresDeviceIdle(options.getBoolean(BackgroundFetchConfig.FIELD_REQUIRES_DEVICE_IDLE));
+        }
+        if (options.hasKey(BackgroundFetchConfig.FIELD_REQUIRES_STORAGE_NOT_LOW)) {
+            config.setRequiresStorageNotLow(options.getBoolean(BackgroundFetchConfig.FIELD_REQUIRES_STORAGE_NOT_LOW));
+        }
+        if (options.hasKey(BackgroundFetchConfig.FIELD_PERIODIC)) {
+            config.setPeriodic(options.getBoolean(BackgroundFetchConfig.FIELD_PERIODIC));
+        }
+        return config;
+    }
+
+    private void initializeBackgroundFetch() {
+        Activity activity = getCurrentActivity();
+        if (activity == null) {
+            return;
+        }
+        initialized = true;
+    }
+
+    private BackgroundFetch getAdapter() {
+        return BackgroundFetch.getInstance(getReactApplicationContext());
+    }
+
+}

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

@@ -0,0 +1,29 @@
+package com.transistorsoft.rnbackgroundfetch;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.JavaScriptModule;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class RNBackgroundFetchPackage implements ReactPackage {
+	@Override 
+	public List<NativeModule> createNativeModules (ReactApplicationContext reactContext) {
+        List<NativeModule> modules = new ArrayList<>();
+        modules.add(new RNBackgroundFetchModule(reactContext));
+        return modules;
+    }
+
+	public List<Class<? extends JavaScriptModule>> createJSModules() {
+        return Collections.emptyList();
+    }
+    
+    @Override
+    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+        return Collections.emptyList();
+    }
+}

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

@@ -0,0 +1,305 @@
+package com.transistorsoft.tsbackgroundfetch;
+
+import android.annotation.SuppressLint;
+import android.app.AlarmManager;
+import android.app.PendingIntent;
+import android.app.job.JobInfo;
+import android.app.job.JobScheduler;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Build;
+import android.os.PersistableBundle;
+import android.util.Log;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
+
+public class BGTask {
+    static int MAX_TIME = 60000;
+
+    private static final List<BGTask> mTasks = new ArrayList<>();
+
+    static BGTask getTask(String taskId) {
+        synchronized (mTasks) {
+            for (BGTask task : mTasks) {
+                if (task.hasTaskId(taskId)) return task;
+            }
+        }
+        return null;
+    }
+
+    static void addTask(BGTask task) {
+        synchronized (mTasks) {
+            mTasks.add(task);
+        }
+    }
+
+    static void removeTask(String taskId) {
+        synchronized (mTasks) {
+            BGTask found = null;
+            for (BGTask task : mTasks) {
+                if (task.hasTaskId(taskId)) {
+                    found = task;
+                    break;
+                }
+            }
+            if (found != null) {
+                mTasks.remove(found);
+            }
+        }
+    }
+
+    static void clear() {
+        synchronized (mTasks) {
+            mTasks.clear();
+        }
+    }
+
+    private FetchJobService.CompletionHandler mCompletionHandler;
+    private String mTaskId;
+    private int mJobId;
+    private Runnable mTimeoutTask;
+    private boolean mTimedout = false;
+
+    BGTask(final Context context, String taskId, FetchJobService.CompletionHandler handler, int jobId) {
+        mTaskId = taskId;
+        mCompletionHandler = handler;
+        mJobId = jobId;
+
+        mTimeoutTask = new Runnable() {
+            @Override public void run() {
+                onTimeout(context);
+            }
+        };
+        BackgroundFetch.getUiHandler().postDelayed(mTimeoutTask, MAX_TIME);
+    }
+
+    public boolean getTimedOut() {
+        return mTimedout;
+    }
+
+    public String getTaskId() { return mTaskId; }
+
+    int getJobId() { return mJobId; }
+
+    boolean hasTaskId(String taskId) {
+        return ((mTaskId != null) && mTaskId.equalsIgnoreCase(taskId));
+    }
+
+    void setCompletionHandler(FetchJobService.CompletionHandler handler) {
+        mCompletionHandler = handler;
+    }
+
+    void finish() {
+        if (mCompletionHandler != null) {
+            mCompletionHandler.finish();
+        }
+        if (mTimeoutTask != null) {
+            BackgroundFetch.getUiHandler().removeCallbacks(mTimeoutTask);
+        }
+        mCompletionHandler = null;
+        removeTask(mTaskId);
+    }
+
+    static void reschedule(Context context, BackgroundFetchConfig existing, BackgroundFetchConfig config) {
+        BGTask existingTask = BGTask.getTask(existing.getTaskId());
+        if (existingTask != null) {
+            existingTask.finish();
+        }
+        cancel(context, existing.getTaskId(), existing.getJobId());
+
+        schedule(context, config);
+    }
+
+    static void schedule(Context context, BackgroundFetchConfig config) {
+        Log.d(BackgroundFetch.TAG, config.toString());
+
+        long interval = (config.isFetchTask()) ? (TimeUnit.MINUTES.toMillis(config.getMinimumFetchInterval())) : config.getDelay();
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP && !config.getForceAlarmManager()) {
+            // API 21+ uses new JobScheduler API
+
+            JobScheduler jobScheduler = (JobScheduler) context.getSystemService(Context.JOB_SCHEDULER_SERVICE);
+            @SuppressLint("WrongConstant")
+            JobInfo.Builder builder = new JobInfo.Builder(config.getJobId(), new ComponentName(context, FetchJobService.class))
+                    .setRequiredNetworkType(config.getRequiredNetworkType())
+                    .setRequiresDeviceIdle(config.getRequiresDeviceIdle())
+                    .setRequiresCharging(config.getRequiresCharging())
+                    .setPersisted(config.getStartOnBoot() && !config.getStopOnTerminate());
+
+            if (config.getPeriodic()) {
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+                    builder.setPeriodic(interval, interval);
+                } else {
+                    builder.setPeriodic(interval);
+                }
+            } else {
+                builder.setMinimumLatency(interval);
+            }
+            PersistableBundle extras = new PersistableBundle();
+            extras.putString(BackgroundFetchConfig.FIELD_TASK_ID, config.getTaskId());
+            extras.putLong("scheduled_at", System.currentTimeMillis());
+
+            builder.setExtras(extras);
+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                builder.setRequiresStorageNotLow(config.getRequiresStorageNotLow());
+                builder.setRequiresBatteryNotLow(config.getRequiresBatteryNotLow());
+            }
+            if (jobScheduler != null) {
+                jobScheduler.schedule(builder.build());
+            }
+        } else {
+            // Everyone else get AlarmManager
+            AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
+            if (alarmManager != null) {
+                PendingIntent pi = getAlarmPI(context, config.getTaskId());
+                long delay = System.currentTimeMillis() + interval;
+                if (config.getPeriodic()) {
+                    alarmManager.setRepeating(AlarmManager.RTC_WAKEUP, delay, interval, pi);
+                } else {
+                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                            if (alarmManager.canScheduleExactAlarms()) {
+                                alarmManager.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, delay, pi);
+                            } else {
+                                alarmManager.setAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, delay, pi);
+                            }
+                        } else {
+                            alarmManager.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, delay, pi);
+                        }
+                    } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
+                        alarmManager.setExact(AlarmManager.RTC_WAKEUP, delay, pi);
+                    } else {
+                        alarmManager.set(AlarmManager.RTC_WAKEUP, delay, pi);
+                    }
+                }
+            }
+        }
+    }
+
+    void onTimeout(Context context) {
+        mTimedout = true;
+        Log.d(BackgroundFetch.TAG, "[BGTask] timeout: " + mTaskId);
+
+        BackgroundFetch adapter = BackgroundFetch.getInstance(context);
+
+        if (!LifecycleManager.getInstance().isHeadless()) {
+            BackgroundFetch.Callback callback = adapter.getFetchCallback();
+            if (callback != null) {
+                callback.onTimeout(mTaskId);
+            }
+        } else {
+            BackgroundFetchConfig config = adapter.getConfig(mTaskId);
+            if (config != null) {
+                if (config.getJobService() != null) {
+                    try {
+                        fireHeadlessEvent(context, config);
+                    } catch (BGTask.Error error) {
+                        Log.e(BackgroundFetch.TAG, "Headless task error: " + error.getMessage());
+                    }
+                } else {
+                    adapter.finish(mTaskId);
+                }
+            } else {
+                Log.e(BackgroundFetch.TAG, "[BGTask] failed to load config for taskId: " + mTaskId);
+                adapter.finish(mTaskId);
+            }
+        }
+    }
+
+    // Fire a headless background-fetch event by reflecting an instance of Config.jobServiceClass.
+    // Will attempt to reflect upon two different forms of Headless class:
+    // 1:  new HeadlessTask(context, taskId)
+    //   or
+    // 2:  new HeadlessTask().onFetch(context, taskId);
+    //
+    void fireHeadlessEvent(Context context, BackgroundFetchConfig config) throws Error {
+        try {
+            // Get class via reflection.
+            Class<?> HeadlessClass = Class.forName(config.getJobService());
+            Class[] types = { Context.class, BGTask.class };
+            Object[] params = { context, this};
+            try {
+                // 1:  new HeadlessTask(context, taskId);
+                Constructor<?> constructor = HeadlessClass.getDeclaredConstructor(types);
+                constructor.newInstance(params);
+            } catch (NoSuchMethodException e) {
+                // 2:  new HeadlessTask().onFetch(context, taskId);
+                Constructor<?> constructor = HeadlessClass.getConstructor();
+                Object instance = constructor.newInstance();
+                Method onFetch = instance.getClass().getDeclaredMethod("onFetch", types);
+                onFetch.invoke(instance, params);
+            }
+        } catch (ClassNotFoundException e) {
+            throw new Error(e.getMessage());
+        } catch (NoSuchMethodException e) {
+            throw new Error(e.getMessage());
+        } catch (IllegalAccessException e) {
+            throw new Error(e.getMessage());
+        } catch (InstantiationException e) {
+            throw new Error(e.getMessage());
+        } catch (InvocationTargetException e) {
+            throw new Error(e.getMessage());
+        }
+    }
+
+    static void cancel(Context context, String taskId, int jobId) {
+        Log.i(BackgroundFetch.TAG, "- cancel taskId=" + taskId + ", jobId=" + jobId);
+        if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP && (jobId != 0)) {
+            JobScheduler jobScheduler = (JobScheduler) context.getSystemService(Context.JOB_SCHEDULER_SERVICE);
+            if (jobScheduler != null) {
+                jobScheduler.cancel(jobId);
+            }
+        } else {
+            AlarmManager alarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
+            if (alarmManager != null) {
+                alarmManager.cancel(BGTask.getAlarmPI(context, taskId));
+            }
+        }
+    }
+
+    static PendingIntent getAlarmPI(Context context, String taskId) {
+        Intent intent = new Intent(context, FetchAlarmReceiver.class);
+        intent.setAction(taskId);
+        return PendingIntent.getBroadcast(context, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT|PendingIntent.FLAG_IMMUTABLE);
+    }
+
+    public String toString() {
+        return "[BGTask taskId=" + mTaskId + "]";
+    }
+
+    public Map<String, Object> toMap() {
+        Map<String, Object> map = new HashMap<>();
+        map.put("taskId", mTaskId);
+        map.put("timeout", mTimedout);
+        return map;
+    }
+
+    public JSONObject toJson() {
+        JSONObject json = new JSONObject();
+        try {
+            json.put("taskId", mTaskId);
+            json.put("timeout", mTimedout);
+        } catch (JSONException e) {
+            e.printStackTrace();
+        }
+        return json;
+    }
+
+    static class Error extends RuntimeException {
+        public Error(String msg) {
+            super(msg);
+        }
+    }
+}