feat: add passing data to background callback function

Author: Nishanth Bhat

README.md

@@ -1,17 +1,17 @@
-# react-native-background-sync
+# @rn-native-utils/background-sync
 
 A React Native library for performing background data syncs in Android using Android's WorkManager.
 
 ## Installation
 
 ```sh
-npm install react-native-background-sync
+npm install @rn-native-utils/background-sync
 ```
 
 or
 
 ```sh
-yarn add react-native-background-sync
+yarn add @rn-native-utils/background-sync
 ```
 
 ## Supported Platforms
@@ -127,22 +127,22 @@ MINUTES = 'MINUTES',
 
 ## Types
 The BackgroundSchedulerParams type is used to configure the background task. Refer to the library's type definitions for the exact structure and available options.
-```ts
-export interface BackgroundSchedulerParams {
-  taskKey: string;
-  type: SchedulerTypes;
-  maxRetryAttempts?: number;
-  retryDelay?: number;
-  taskTimeout?: number;
-  allowedInForeground?: boolean;
-  syncInterval?: number;
-  syncIntervalType?: TimeUnits;
-  syncFlexTime?: number;
-  syncFlexTimeType?: TimeUnits;
-  workerPolicy?: WorkerPolicy;
-}
-
-```
+### BackgroundSchedulerParams
+
+| Property | Type | Required | Description |
+|----------|------|----------|-------------|
+| taskKey | string | Yes | Unique identifier for the background task |
+| type | SchedulerTypes | Yes | Type of scheduler (PERIODIC or ONE_TIME) |
+| maxRetryAttempts | number | No | Maximum number of retry attempts if task fails |
+| retryDelay | number | No | Delay between retry attempts in milliseconds |
+| taskTimeout | number | No | Maximum time allowed for task execution |
+| allowedInForeground | boolean | No | Whether task can run while app is in foreground |
+| syncInterval | number | No | Interval between periodic syncs |
+| syncIntervalType | TimeUnits | No | Unit for syncInterval (SECOND, MINUTES, HOUR, DAY) |
+| syncFlexTime | number | No | Flex time window for periodic syncs |
+| syncFlexTimeType | TimeUnits | No | Unit for syncFlexTime |
+| workerPolicy | WorkerPolicy | No | Policy for handling existing workers
+| extras | Record<string, any> | No | Additional data to be passed to the background task |
 
 ## Error Handling
 All functions in this library throw errors if something goes wrong during execution. It's recommended to wrap calls to these functions in try-catch blocks for proper error handling.

android/src/main/java/com/backgroundsync/BackgroundSyncModule.kt

@@ -16,6 +16,7 @@ import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
 
 
 class BackgroundSyncModule(reactContext: ReactApplicationContext) :
@@ -86,7 +87,7 @@ class BackgroundSyncModule(reactContext: ReactApplicationContext) :
       if (isWorkCancelled(workManager,taskKey)) {
         promise.resolve(true)
       } else {
-        promise.reject(false as String)
+        promise.reject("CANCELLATION_ERROR", "Could not cancel task: $taskKey")
       }
     }
     catch (e:Exception){

android/src/main/java/com/backgroundsync/utils/WorkerUtils.kt

@@ -1,10 +1,12 @@
 package com.backgroundsync.utils
 
+import android.util.Log
 import androidx.work.Data
 import androidx.work.ExistingPeriodicWorkPolicy
 import androidx.work.WorkInfo
 import androidx.work.WorkManager
 import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
 import com.google.common.util.concurrent.ListenableFuture
 import java.util.concurrent.ExecutionException
 import java.util.concurrent.TimeUnit
@@ -39,6 +41,38 @@ fun generateHeadlessConfig(params: ReadableMap): Data {
   val config = Data.Builder()
     .putString("taskKey", params.getString("taskKey"))
 
+  val extras = params.getMap("extras")
+  extras?.let {
+    val iterator = it.keySetIterator()
+    while (iterator.hasNextKey()) {
+      val key = iterator.nextKey()
+      Log.d("TAG", "generateHeadlessConfig: $key")
+      when (it.getType(key)) {
+        ReadableType.String -> config.putString(key, it.getString(key))
+        ReadableType.Number -> config.putDouble(key, it.getDouble(key))
+        ReadableType.Boolean -> config.putBoolean(key, it.getBoolean(key))
+        ReadableType.Null -> config.putString(key, null)
+        ReadableType.Map -> {
+          val nestedMap = it.getMap(key)?.toHashMap()
+          nestedMap?.let { map ->
+            config.putAll(map.mapKeys { "${key}_${it.key}" })
+          }
+        }
+        ReadableType.Array -> {
+          val array = it.getArray(key)?.toArrayList()
+          array?.forEachIndexed { index, value ->
+            when (value) {
+              is String -> config.putString("${key}_$index", value)
+              is Number -> config.putDouble("${key}_$index", value.toDouble())
+              is Boolean -> config.putBoolean("${key}_$index", value)
+            }
+          }
+        }
+      }
+    }
+  }
+
+
   if(params.hasKey("maxRetryAttempts")) config.putInt("maxRetryAttempts", params.getInt("maxRetryAttempts"))
   if(params.hasKey("retryDelay")) config.putInt("retryDelay", params.getDouble("retryDelay").toInt())
   if(params.hasKey("taskTimeout")) config.putLong("taskTimeout", params.getDouble("taskTimeout").toLong())

example/src/App.tsx

@@ -5,7 +5,7 @@ import {
   TimeUnits,
   WorkerPolicy,
   cancel,
-} from 'react-native-background-sync';
+} from '@rn-native-utils/workmanager';
 
 import BackgroundCall from './task-manager';
 
@@ -14,11 +14,23 @@ export default function App() {
     const params = {
       taskKey: 'Onetime',
       type: SchedulerTypes.oneTime,
+      extras: {
+        hello: 'Hi',
+        user: 'John',
+        id: 123,
+        data: {
+          city: 'Pune',
+        },
+      },
     };
-    const result = await schedule(params, async () => {
-      BackgroundCall(params.taskKey);
-    });
-    console.log('Result:', result);
+    try {
+      const result = await schedule(params, async (data) =>
+        BackgroundCall(data)
+      );
+      console.log('Result:', result);
+    } catch (e) {
+      console.error(e);
+    }
   };
 
   const schedulePeriodic = async () => {
@@ -30,16 +42,28 @@ export default function App() {
       syncFlexTime: 5,
       syncFlexTimeType: TimeUnits.MINUTES,
       workerPolicy: WorkerPolicy.KEEP,
+      extras: {
+        hello: 'Hi',
+        user: 'John',
+        id: 123,
+        data: {
+          city: 'Pune',
+        },
+      },
     };
-    const result = await schedule(params, async () => {
-      BackgroundCall(params.taskKey);
+    const result = await schedule(params, async (data: any) => {
+      BackgroundCall(data);
     });
     console.log('Result:', result);
   };
 
   const cancelTask = async (taskKey: string) => {
-    const response = await cancel(taskKey);
-    Alert.alert(`Cancelled task for ${taskKey} : ${response}`);
+    try {
+      const response = await cancel(taskKey);
+      Alert.alert(`Cancelled task for ${taskKey} : ${response}`);
+    } catch (e) {
+      console.error(e);
+    }
   };
 
   return (

example/src/task-manager.ts

@@ -1,5 +1,8 @@
-const BackgroundCall = (name: string) => {
-  console.log(`Calling in background for task: ${name}`);
+const BackgroundCall = (data?: any) => {
+  console.log(
+    `Calling in background for task: `,
+    JSON.stringify(data, null, 2)
+  );
 };
 
 export default BackgroundCall;

index.d.ts

@@ -0,0 +1,43 @@
+export enum SchedulerTypes {
+  periodic = 'PERIODIC',
+  oneTime = 'ONE_TIME',
+}
+
+export enum WorkerPolicy {
+  KEEP = 'KEEP',
+  REPLACE = 'REPLACE',
+  UPDATE = 'UPDATE',
+}
+
+export enum TimeUnits {
+  HOUR = 'HOUR',
+  DAY = 'DAY',
+  SECOND = 'SECOND',
+  MINUTES = 'MINUTES',
+}
+
+export interface BackgroundSchedulerParams {
+  taskKey: string;
+  type: SchedulerTypes;
+  maxRetryAttempts?: number;
+  retryDelay?: number;
+  taskTimeout?: number;
+  allowedInForeground?: boolean;
+  syncInterval?: number;
+  syncIntervalType?: TimeUnits;
+  syncFlexTime?: number;
+  syncFlexTimeType?: TimeUnits;
+  workerPolicy?: WorkerPolicy;
+  extras: Record<string, unknown>;
+}
+
+export function schedule(
+  params: BackgroundSchedulerParams,
+  callback: (data: string | Record<string, unknown> | boolean) => Promise<void>
+): Promise<boolean>;
+
+export function cancel(taskKey: string): Promise<boolean>;
+
+export function disableAppIgnoringBatteryOptimization(): boolean;
+
+export type { BackgroundSchedulerParams };

ios/BackgroundSync-Bridging-Header.h

@@ -1,5 +1,5 @@
 {
-  "name": "react-native-background-sync",
+  "name": "@rn-native-utils/workmanager",
   "version": "0.1.0",
   "description": "Perform background data syncs in Android using Android's WorkManager",
   "source": "./src/index.tsx",
@@ -18,12 +18,9 @@
     }
   },
   "files": [
-    "src",
     "lib",
     "android",
-    "ios",
     "cpp",
-    "*.podspec",
     "!ios/build",
     "!android/build",
     "!android/gradle",