expo-background-task 0.0.0

package/.eslintrc.js

@@ -0,0 +1,2 @@
+// @generated by expo-module-scripts
+module.exports = require('expo-module-scripts/eslintrc.base.js');

package/CHANGELOG.md

@@ -0,0 +1,17 @@
+# Changelog
+
+## Unpublished
+
+### 🛠 Breaking changes
+
+### 🎉 New features
+
+### 🐛 Bug fixes
+
+### 💡 Others
+
+## 0.0.0 — 2025-01-21
+
+### 🎉 New features
+
+- Added expo-background-task package ([#33438](https://github.com/expo/expo/pull/33438) by [@chrfalch](https://github.com/chrfalch))

package/README.md

@@ -0,0 +1,43 @@
+# expo-background-task
+
+Expo universal module for BackgroundTask API
+
+# API documentation
+
+- [Documentation for the latest stable release](https://docs.expo.dev/versions/latest/sdk/background-task/)
+- [Documentation for the main branch](https://docs.expo.dev/versions/unversioned/sdk/background-task/)
+
+# Installation in managed Expo projects
+
+For [managed](https://docs.expo.dev/archive/managed-vs-bare/) Expo projects, please follow the installation instructions in the [API documentation for the latest stable release](https://docs.expo.dev/versions/latest/sdk/background-task/).
+
+# Installation in bare React Native projects
+
+For bare React Native projects, you must ensure that you have [installed and configured the `expo` package](https://docs.expo.dev/bare/installing-expo-modules/) before continuing.
+
+### Add the package to your npm dependencies
+
+```
+npx expo install expo-background-task
+```
+
+### Configure for Android
+
+No additional set up necessary.
+
+### Configure for iOS
+
+Run `npx pod-install` after installing the npm package.
+
+In order to use `BackgroundTask` API in standalone, detached and bare apps on iOS, your app has to include the background task identifier in the `Info.plist` file. You can do this by adding the following XML snippet to your `Info.plist` file:
+
+```xml
+<key>BGTaskSchedulerPermittedIdentifiers</key>
+<array>
+  <string>com.expo.modules.backgroundtask.processing</string>
+</array>
+```
+
+# Contributing
+
+Contributions are very welcome! Please refer to guidelines described in the [contributing guide](https://github.com/expo/expo#contributing).

package/android/build.gradle

@@ -0,0 +1,24 @@
+apply plugin: 'com.android.library'
+
+group = 'host.exp.exponent'
+version = '0.0.0'
+
+def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
+apply from: expoModulesCorePlugin
+applyKotlinExpoModulesCorePlugin()
+useCoreDependencies()
+useDefaultAndroidSdkVersions()
+useExpoPublishing()
+
+dependencies {
+  implementation 'androidx.work:work-runtime-ktx:2.9.1'
+  implementation 'com.facebook.react:react-android'
+}
+
+android {
+  namespace "expo.modules.backgroundtask"
+  defaultConfig {
+    versionCode 23
+    versionName "0.0.0"
+  }
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/java/expo/modules/backgroundtask/BackgroundTaskConsumer.kt

@@ -0,0 +1,54 @@
+package expo.modules.backgroundtask
+
+import android.content.Context
+import android.util.Log
+import expo.modules.interfaces.taskManager.TaskConsumer
+import expo.modules.interfaces.taskManager.TaskConsumerInterface
+import expo.modules.interfaces.taskManager.TaskExecutionCallback
+import expo.modules.interfaces.taskManager.TaskInterface
+import expo.modules.interfaces.taskManager.TaskManagerUtilsInterface
+
+class BackgroundTaskConsumer(context: Context?, taskManagerUtils: TaskManagerUtilsInterface?) :
+  TaskConsumer(context, taskManagerUtils), TaskConsumerInterface {
+
+  companion object {
+    private const val BACKGROUND_TASK_TYPE = "expo-background-task"
+    private val TAG = BackgroundTaskConsumer::class.java.simpleName
+  }
+
+  private var task: TaskInterface? = null
+
+  override fun taskType(): String {
+    return BACKGROUND_TASK_TYPE
+  }
+
+  /**
+   * Exposing the execute task function so that the BackgroundTaskWork (WorkManager Work unit)
+   * can execute the inner task. A task is only executed if the app is in the background.
+   * This only applies when the app is in release mode.
+   */
+  fun executeTask(callback: TaskExecutionCallback) {
+    Log.d(TAG, "Executing task '${task?.name}'")
+    taskManagerUtils.executeTask(task, null, callback)
+  }
+
+  override fun didRegister(task: TaskInterface) {
+    Log.d(TAG, "didRegister: ${task.name}")
+    this.task = task
+
+    val intervalMinutes = getIntervalMinutes()
+    BackgroundTaskScheduler.registerTask(intervalMinutes)
+  }
+
+  override fun didUnregister() {
+    Log.d(TAG, "didUnregister: ${task?.name}")
+    this.task = null
+    BackgroundTaskScheduler.unregisterTask()
+  }
+
+  private fun getIntervalMinutes(): Long {
+    val options = task?.options as? Map<String, Any?>
+    return (options?.get("minimumInterval") as? Number)?.toLong()
+      ?: BackgroundTaskScheduler.DEFAULT_INTERVAL_MINUTES
+  }
+}

package/android/src/main/java/expo/modules/backgroundtask/BackgroundTaskExceptions.kt

@@ -0,0 +1,13 @@
+package expo.modules.backgroundtask
+
+import expo.modules.kotlin.exception.CodedException
+
+internal class MissingContextException : CodedException(message = "Application context not found")
+
+internal class MissingTaskServiceException : CodedException(message = "TaskService not available.")
+
+internal class MissingAppScopeKey : CodedException(message = "Could not find required appScopeKey in worker.")
+
+internal class TaskMangerInterfaceNotFoundException : CodedException(message = "TaskManagerInterface not found")
+
+internal class TestMethodNotAvailableInProductionBuild : CodedException(message = "Background tasks cannot be triggered in production builds")

package/android/src/main/java/expo/modules/backgroundtask/BackgroundTaskModule.kt

@@ -0,0 +1,66 @@
+package expo.modules.backgroundtask
+
+import android.util.Log
+import com.facebook.react.common.build.ReactBuildConfig
+import expo.modules.interfaces.taskManager.TaskManagerInterface
+import expo.modules.kotlin.functions.Coroutine
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import kotlinx.coroutines.runBlocking
+
+class BackgroundTaskModule : Module() {
+  companion object {
+    private val TAG = BackgroundTaskModule::class.java.simpleName
+  }
+
+  private val _taskManager by lazy { appContext.legacyModule<TaskManagerInterface>() }
+  private val taskManager: TaskManagerInterface
+    get() = _taskManager ?: throw TaskMangerInterfaceNotFoundException()
+
+  override fun definition() = ModuleDefinition {
+    Name("ExpoBackgroundTask")
+
+    AsyncFunction("getStatusAsync") {
+      return@AsyncFunction 2 // WorkManager is always available on Android.
+    }
+
+    AsyncFunction("triggerTaskWorkerForTestingAsync") Coroutine { ->
+      if (ReactBuildConfig.DEBUG) {
+        Log.d(TAG, "Triggering tasks for testing")
+        appContext.reactContext?.let {
+          val appScopeKey = it.packageName
+          return@Coroutine BackgroundTaskScheduler.runTasks(it, appScopeKey)
+        } ?: throw MissingContextException()
+      } else {
+        throw TestMethodNotAvailableInProductionBuild()
+      }
+    }
+
+    AsyncFunction("registerTaskAsync") { taskName: String, options: Map<String, Any?> ->
+      Log.d(TAG, "registerTaskAsync: $taskName")
+      taskManager.registerTask(taskName, BackgroundTaskConsumer::class.java, options)
+    }
+
+    AsyncFunction("unregisterTaskAsync") { taskName: String ->
+      Log.d(TAG, "unregisterTaskAsync: $taskName")
+      taskManager.unregisterTask(taskName, BackgroundTaskConsumer::class.java)
+    }
+
+    OnActivityEntersBackground {
+      appContext.reactContext?.let {
+        runBlocking {
+          val appScopeKey = it.packageName
+          BackgroundTaskScheduler.startWorker(it, appScopeKey)
+        }
+      } ?: throw MissingContextException()
+    }
+
+    OnActivityEntersForeground {
+      appContext.reactContext?.let {
+        runBlocking {
+          BackgroundTaskScheduler.stopWorker(it)
+        }
+      } ?: throw MissingContextException()
+    }
+  }
+}

package/android/src/main/java/expo/modules/backgroundtask/BackgroundTaskScheduler.kt

@@ -0,0 +1,212 @@
+package expo.modules.backgroundtask
+
+import android.content.Context
+import android.os.Build
+import android.util.Log
+import androidx.work.Constraints
+import androidx.work.Data
+import androidx.work.ExistingPeriodicWorkPolicy
+import androidx.work.NetworkType
+import androidx.work.Operation
+import androidx.work.PeriodicWorkRequestBuilder
+import androidx.work.WorkInfo
+import androidx.work.WorkManager
+import com.google.common.util.concurrent.ListenableFuture
+import expo.modules.interfaces.taskManager.TaskServiceProviderHelper
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.withContext
+import java.time.Duration
+import java.util.concurrent.TimeUnit
+
+object BackgroundTaskScheduler {
+  // Default interval
+  const val DEFAULT_INTERVAL_MINUTES = 60L * 24L // Once every day
+
+  // Unique identifier (generated by us) to identify the worker
+  private const val WORKER_IDENTIFIER = "EXPO_BACKGROUND_WORKER"
+
+  // Log tag
+  private val TAG = BackgroundTaskScheduler::class.java.simpleName
+
+  // Number of active task consumers
+  private var numberOfRegisteredTasksOfThisType = 0
+
+  // Interval
+  private var intervalMinutes: Long = DEFAULT_INTERVAL_MINUTES
+
+  /**
+   * Call when a task is registered
+   */
+  fun registerTask(intervalMinutes: Long) {
+    numberOfRegisteredTasksOfThisType += 1
+    this.intervalMinutes = intervalMinutes
+  }
+
+  /**
+   * Call when a task is unregistered
+   */
+  fun unregisterTask() {
+    numberOfRegisteredTasksOfThisType -= 1
+  }
+
+  /**
+   * Schedules the worker task to run. The worker should run periodically.
+   */
+  suspend fun startWorker(context: Context, appScopeKey: String): Boolean {
+    if (numberOfRegisteredTasksOfThisType == 0) {
+      Log.d(TAG, "Will not enqueue worker. No registered tasks to run.")
+      return false
+    }
+
+    // Stop the current worker (if any)
+    stopWorker(context)
+
+    Log.d(TAG, "Enqueuing worker with identifier $WORKER_IDENTIFIER")
+
+    // Build the work request
+    val data = Data.Builder()
+      .putString("appScopeKey", appScopeKey)
+      .build()
+    val constraints = Constraints.Builder()
+      .setRequiresBatteryNotLow(true)
+      .setRequiredNetworkType(NetworkType.CONNECTED)
+      .build()
+
+    // Create the work request
+    val builder = PeriodicWorkRequestBuilder<BackgroundTaskWork>(
+      repeatIntervalTimeUnit = TimeUnit.MINUTES,
+      repeatInterval = intervalMinutes
+    )
+      .setInputData(data)
+      .setConstraints(constraints)
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      // Add minimum interval here as well so that the work doesn't start immediately
+      builder.setInitialDelay(Duration.ofMinutes(intervalMinutes))
+    }
+
+    // Create work request
+    val workRequest = builder.build()
+
+    // Get Work manager
+    val workManager = WorkManager.getInstance(context)
+
+    // Enqueue the work
+    return try {
+      workManager.enqueueUniquePeriodicWork(
+        WORKER_IDENTIFIER,
+        ExistingPeriodicWorkPolicy.CANCEL_AND_REENQUEUE,
+        workRequest
+      ).await()
+
+      true
+    } catch (e: Exception) {
+      Log.e(TAG, "Worker failed to start with error " + e.message)
+      false
+    }
+  }
+
+  /**
+   * Cancels the worker task
+   */
+  suspend fun stopWorker(context: Context): Boolean {
+    if (!isWorkerRunning(context)) {
+      return false
+    }
+
+    Log.d(TAG, "Cancelling worker with identifier $WORKER_IDENTIFIER")
+
+    // Stop our main worker
+    val workManager = WorkManager.getInstance(context)
+    return try {
+      workManager.cancelUniqueWork(WORKER_IDENTIFIER).await()
+    } catch (e: Exception) {
+      Log.d(TAG, "Stopping worker failed with error " + e.message)
+      false
+    }
+  }
+
+  /**
+   * Returns true if the worker task is pending
+   */
+  private suspend fun isWorkerRunning(context: Context): Boolean {
+    val workInfo = getWorkerInfo(context)
+    return workInfo?.state == WorkInfo.State.RUNNING ||
+      workInfo?.state == WorkInfo.State.ENQUEUED
+  }
+
+  /**
+   * Runs tasks with the given appScopeKey
+   */
+  suspend fun runTasks(context: Context, appScopeKey: String): Boolean {
+    // Get task service
+    val taskService = TaskServiceProviderHelper.getTaskServiceImpl(context)
+      ?: throw MissingTaskServiceException()
+
+    Log.d(TAG, "runTasks: $appScopeKey")
+
+    // Get all task consumers
+    val consumers = taskService.getTaskConsumers(appScopeKey)
+    Log.d(TAG, "runTasks: number of consumers ${consumers.size}")
+
+    if (consumers.size == 0) {
+      return false
+    }
+
+    val tasks = consumers.filterIsInstance<BackgroundTaskConsumer>()
+      .map { bgTaskConsumer ->
+        Log.d(TAG, "runTasks: executing tasks for consumer of type ${bgTaskConsumer.taskType()}")
+        val taskCompletion = CompletableDeferred<Unit>()
+        bgTaskConsumer.executeTask {
+          Log.d(TAG, "Task successfully finished")
+          taskCompletion.complete(Unit)
+        }
+        taskCompletion
+      }
+    // Await all tasks to complete
+    tasks.awaitAll()
+    return true
+  }
+
+  /**
+   * Returns the worker info object from the WorkManager if the worker has been
+   * registered, otherwise returns null
+   */
+  private suspend fun getWorkerInfo(context: Context): WorkInfo? {
+    // Get work manager
+    val workManager = WorkManager.getInstance(context)
+
+    return try {
+      val workInfos = workManager.getWorkInfosForUniqueWork(WORKER_IDENTIFIER).await()
+      return workInfos.firstOrNull()
+    } catch (e: Exception) {
+      Log.d(TAG, "Calling getWorkInfosForUniqueWork failed with error " + e.message)
+      null
+    }
+  }
+
+  /**
+   * Helper function for calling functions returning an Operation
+   */
+  private suspend fun Operation.await(): Boolean = withContext(Dispatchers.IO) {
+    result.get()
+    true
+  }
+
+  /**
+   * Helper function for calling functions returning a ListenableFuture
+   */
+  private suspend fun <T> ListenableFuture<T>.await(): T = withContext(Dispatchers.IO) {
+    try {
+      get()
+    } catch (e: CancellationException) {
+      cancel(true)
+      throw e
+    } catch (e: Exception) {
+      throw e
+    }
+  }
+}

package/android/src/main/java/expo/modules/backgroundtask/BackgroundTaskWork.kt

@@ -0,0 +1,36 @@
+package expo.modules.backgroundtask
+
+import android.content.Context
+import android.util.Log
+import androidx.work.CoroutineWorker
+import androidx.work.Data
+import androidx.work.WorkerParameters
+
+class BackgroundTaskWork(context: Context, params: WorkerParameters) : CoroutineWorker(context, params) {
+  companion object {
+    private val TAG = BackgroundTaskWork::class.java.simpleName
+  }
+
+  /**
+   * The doWork function is called by the Android WorkManager to execute scheduled work.
+   */
+  override suspend fun doWork(): Result {
+    Log.i(TAG, "doWork: Running worker")
+
+    // Get the app scope key
+    val appScopeKey = inputData.getString("appScopeKey") ?: throw MissingAppScopeKey()
+
+    try {
+      BackgroundTaskScheduler.runTasks(applicationContext, appScopeKey)
+    } catch (e: Exception) {
+      // Wrap exception in Data:
+      val outputData = Data.Builder()
+        .putString("error", e.message)
+        .putString("stackTrace", e.stackTraceToString())
+        .build()
+
+      return Result.failure(outputData)
+    }
+    return Result.success()
+  }
+}

package/app.plugin.js

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

package/build/BackgroundTask.d.ts

@@ -0,0 +1,51 @@
+import { BackgroundTaskOptions, BackgroundTaskStatus } from './BackgroundTask.types';
+/**
+ * Returns the status for the Background Task API. On web, it always returns `BackgroundTaskStatus.Restricted`,
+ * while on native platforms it returns `BackgroundTaskStatus.Available`.
+ *
+ * @returns A BackgroundTaskStatus enum value or `null` if not available.
+ */
+export declare const getStatusAsync: () => Promise<BackgroundTaskStatus>;
+/**
+ * Registers a background task with the given name. Registered tasks are saved in persistent storage and restored once the app is initialized.
+ * @param taskName Name of the task to register. The task needs to be defined first - see [`TaskManager.defineTask`](task-manager/#taskmanagerdefinetasktaskname-taskexecutor)
+ * for more details.
+ * @param options An object containing the background task options.
+ *
+ * @example
+ * ```ts
+ * import * as TaskManager from 'expo-task-manager';
+ *
+ * // Register the task outside of the component
+ * TaskManager.defineTask(BACKGROUND_TASK_IDENTIFIER, () => {
+ *   try {
+ *     await AsyncStorage.setItem(LAST_TASK_DATE_KEY, Date.now().toString());
+ *   } catch (error) {
+ *     console.error('Failed to save the last fetch date', error);
+ *     return BackgroundTaskResult.Failed;
+ *   }
+ *   return BackgroundTaskResult.Success;
+ * });
+ * ```
+ *
+ * You can now use the `registerTaskAsync` function to register the task:
+ *
+ * ```ts
+ * BackgroundTask.registerTaskAsync(BACKGROUND_TASK_IDENTIFIER, {});
+ * ```
+ */
+export declare function registerTaskAsync(taskName: string, options?: BackgroundTaskOptions): Promise<void>;
+/**
+ * Unregisters a background task, so the application will no longer be executing this task.
+ * @param taskName Name of the task to unregister.
+ * @return A promise which fulfils when the task is fully unregistered.
+ */
+export declare function unregisterTaskAsync(taskName: string): Promise<void>;
+/**
+ * When in debug mode this function will trigger running the background tasks.
+ * This function will only work for apps built in debug mode.
+ * @todo(chrfalch): When we have a usable devtools plugin we can enable this function.
+ * @returns A promise which fulfils when the task is triggered.
+ */
+export { BackgroundTaskStatus, BackgroundTaskResult, BackgroundTaskOptions, } from './BackgroundTask.types';
+//# sourceMappingURL=BackgroundTask.d.ts.map

package/build/BackgroundTask.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BackgroundTask.d.ts","sourceRoot":"","sources":["../src/BackgroundTask.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAIrF;;;;;GAKG;AACH,eAAO,MAAM,cAAc,QAAa,QAAQ,oBAAoB,CAMnE,CAAC;AAGF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAsB,iBAAiB,CACrC,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,qBAA0B,GAClC,OAAO,CAAC,IAAI,CAAC,CAWf;AAGD;;;;GAIG;AACH,wBAAsB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAMzE;AAGD;;;;;GAKG;AAcH,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACpB,qBAAqB,GACtB,MAAM,wBAAwB,CAAC"}

package/build/BackgroundTask.js

@@ -0,0 +1,89 @@
+import { UnavailabilityError } from 'expo-modules-core';
+import * as TaskManager from 'expo-task-manager';
+import ExpoBackgroundTaskModule from './ExpoBackgroundTaskModule';
+// @needsAudit
+/**
+ * Returns the status for the Background Task API. On web, it always returns `BackgroundTaskStatus.Restricted`,
+ * while on native platforms it returns `BackgroundTaskStatus.Available`.
+ *
+ * @returns A BackgroundTaskStatus enum value or `null` if not available.
+ */
+export const getStatusAsync = async () => {
+    if (!ExpoBackgroundTaskModule.getStatusAsync) {
+        throw new UnavailabilityError('BackgroundTask', 'getStatusAsync');
+    }
+    return ExpoBackgroundTaskModule.getStatusAsync();
+};
+// @needsAudit
+/**
+ * Registers a background task with the given name. Registered tasks are saved in persistent storage and restored once the app is initialized.
+ * @param taskName Name of the task to register. The task needs to be defined first - see [`TaskManager.defineTask`](task-manager/#taskmanagerdefinetasktaskname-taskexecutor)
+ * for more details.
+ * @param options An object containing the background task options.
+ *
+ * @example
+ * ```ts
+ * import * as TaskManager from 'expo-task-manager';
+ *
+ * // Register the task outside of the component
+ * TaskManager.defineTask(BACKGROUND_TASK_IDENTIFIER, () => {
+ *   try {
+ *     await AsyncStorage.setItem(LAST_TASK_DATE_KEY, Date.now().toString());
+ *   } catch (error) {
+ *     console.error('Failed to save the last fetch date', error);
+ *     return BackgroundTaskResult.Failed;
+ *   }
+ *   return BackgroundTaskResult.Success;
+ * });
+ * ```
+ *
+ * You can now use the `registerTaskAsync` function to register the task:
+ *
+ * ```ts
+ * BackgroundTask.registerTaskAsync(BACKGROUND_TASK_IDENTIFIER, {});
+ * ```
+ */
+export async function registerTaskAsync(taskName, options = {}) {
+    if (!ExpoBackgroundTaskModule.registerTaskAsync) {
+        throw new UnavailabilityError('BackgroundTask', 'registerTaskAsync');
+    }
+    if (!TaskManager.isTaskDefined(taskName)) {
+        throw new Error(`Task '${taskName}' is not defined. You must define a task using TaskManager.defineTask before registering.`);
+    }
+    console.log('Calling ExpoBackgroundTaskModule.registerTaskAsync', { taskName, options });
+    await ExpoBackgroundTaskModule.registerTaskAsync(taskName, options);
+}
+// @needsAudit
+/**
+ * Unregisters a background task, so the application will no longer be executing this task.
+ * @param taskName Name of the task to unregister.
+ * @return A promise which fulfils when the task is fully unregistered.
+ */
+export async function unregisterTaskAsync(taskName) {
+    if (!ExpoBackgroundTaskModule.unregisterTaskAsync) {
+        throw new UnavailabilityError('BackgroundTask', 'unregisterTaskAsync');
+    }
+    console.log('Calling ExpoBackgroundTaskModule.unregisterTaskAsync', taskName);
+    await ExpoBackgroundTaskModule.unregisterTaskAsync(taskName);
+}
+// @needsAudit
+/**
+ * When in debug mode this function will trigger running the background tasks.
+ * This function will only work for apps built in debug mode.
+ * @todo(chrfalch): When we have a usable devtools plugin we can enable this function.
+ * @returns A promise which fulfils when the task is triggered.
+ */
+// export async function triggerTaskWorkerForTestingAsync(): Promise<boolean> {
+//   if (__DEV__) {
+//     if (!ExpoBackgroundTaskModule.triggerTaskWorkerForTestingAsync) {
+//       throw new UnavailabilityError('BackgroundTask', 'triggerTaskWorkerForTestingAsync');
+//     }
+//     console.log('Calling triggerTaskWorkerForTestingAsync');
+//     return await ExpoBackgroundTaskModule.triggerTaskWorkerForTestingAsync();
+//   } else {
+//     return Promise.resolve(false);
+//   }
+// }
+// Export types
+export { BackgroundTaskStatus, BackgroundTaskResult, } from './BackgroundTask.types';
+//# sourceMappingURL=BackgroundTask.js.map

package/build/BackgroundTask.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BackgroundTask.js","sourceRoot":"","sources":["../src/BackgroundTask.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,WAAW,MAAM,mBAAmB,CAAC;AAGjD,OAAO,wBAAwB,MAAM,4BAA4B,CAAC;AAElE,cAAc;AACd;;;;;GAKG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,KAAK,IAAmC,EAAE;IACtE,IAAI,CAAC,wBAAwB,CAAC,cAAc,EAAE;QAC5C,MAAM,IAAI,mBAAmB,CAAC,gBAAgB,EAAE,gBAAgB,CAAC,CAAC;KACnE;IAED,OAAO,wBAAwB,CAAC,cAAc,EAAE,CAAC;AACnD,CAAC,CAAC;AAEF,cAAc;AACd;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,QAAgB,EAChB,UAAiC,EAAE;IAEnC,IAAI,CAAC,wBAAwB,CAAC,iBAAiB,EAAE;QAC/C,MAAM,IAAI,mBAAmB,CAAC,gBAAgB,EAAE,mBAAmB,CAAC,CAAC;KACtE;IACD,IAAI,CAAC,WAAW,CAAC,aAAa,CAAC,QAAQ,CAAC,EAAE;QACxC,MAAM,IAAI,KAAK,CACb,SAAS,QAAQ,2FAA2F,CAC7G,CAAC;KACH;IACD,OAAO,CAAC,GAAG,CAAC,oDAAoD,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAC;IACzF,MAAM,wBAAwB,CAAC,iBAAiB,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;AACtE,CAAC;AAED,cAAc;AACd;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CAAC,QAAgB;IACxD,IAAI,CAAC,wBAAwB,CAAC,mBAAmB,EAAE;QACjD,MAAM,IAAI,mBAAmB,CAAC,gBAAgB,EAAE,qBAAqB,CAAC,CAAC;KACxE;IACD,OAAO,CAAC,GAAG,CAAC,sDAAsD,EAAE,QAAQ,CAAC,CAAC;IAC9E,MAAM,wBAAwB,CAAC,mBAAmB,CAAC,QAAQ,CAAC,CAAC;AAC/D,CAAC;AAED,cAAc;AACd;;;;;GAKG;AACH,+EAA+E;AAC/E,mBAAmB;AACnB,wEAAwE;AACxE,6FAA6F;AAC7F,QAAQ;AACR,+DAA+D;AAC/D,gFAAgF;AAChF,aAAa;AACb,qCAAqC;AACrC,MAAM;AACN,IAAI;AAEJ,eAAe;AACf,OAAO,EACL,oBAAoB,EACpB,oBAAoB,GAErB,MAAM,wBAAwB,CAAC","sourcesContent":["import { UnavailabilityError } from 'expo-modules-core';\nimport * as TaskManager from 'expo-task-manager';\n\nimport { BackgroundTaskOptions, BackgroundTaskStatus } from './BackgroundTask.types';\nimport ExpoBackgroundTaskModule from './ExpoBackgroundTaskModule';\n\n// @needsAudit\n/**\n * Returns the status for the Background Task API. On web, it always returns `BackgroundTaskStatus.Restricted`,\n * while on native platforms it returns `BackgroundTaskStatus.Available`.\n *\n * @returns A BackgroundTaskStatus enum value or `null` if not available.\n */\nexport const getStatusAsync = async (): Promise<BackgroundTaskStatus> => {\n  if (!ExpoBackgroundTaskModule.getStatusAsync) {\n    throw new UnavailabilityError('BackgroundTask', 'getStatusAsync');\n  }\n\n  return ExpoBackgroundTaskModule.getStatusAsync();\n};\n\n// @needsAudit\n/**\n * Registers a background task with the given name. Registered tasks are saved in persistent storage and restored once the app is initialized.\n * @param taskName Name of the task to register. The task needs to be defined first - see [`TaskManager.defineTask`](task-manager/#taskmanagerdefinetasktaskname-taskexecutor)\n * for more details.\n * @param options An object containing the background task options.\n *\n * @example\n * ```ts\n * import * as TaskManager from 'expo-task-manager';\n *\n * // Register the task outside of the component\n * TaskManager.defineTask(BACKGROUND_TASK_IDENTIFIER, () => {\n *   try {\n *     await AsyncStorage.setItem(LAST_TASK_DATE_KEY, Date.now().toString());\n *   } catch (error) {\n *     console.error('Failed to save the last fetch date', error);\n *     return BackgroundTaskResult.Failed;\n *   }\n *   return BackgroundTaskResult.Success;\n * });\n * ```\n *\n * You can now use the `registerTaskAsync` function to register the task:\n *\n * ```ts\n * BackgroundTask.registerTaskAsync(BACKGROUND_TASK_IDENTIFIER, {});\n * ```\n */\nexport async function registerTaskAsync(\n  taskName: string,\n  options: BackgroundTaskOptions = {}\n): Promise<void> {\n  if (!ExpoBackgroundTaskModule.registerTaskAsync) {\n    throw new UnavailabilityError('BackgroundTask', 'registerTaskAsync');\n  }\n  if (!TaskManager.isTaskDefined(taskName)) {\n    throw new Error(\n      `Task '${taskName}' is not defined. You must define a task using TaskManager.defineTask before registering.`\n    );\n  }\n  console.log('Calling ExpoBackgroundTaskModule.registerTaskAsync', { taskName, options });\n  await ExpoBackgroundTaskModule.registerTaskAsync(taskName, options);\n}\n\n// @needsAudit\n/**\n * Unregisters a background task, so the application will no longer be executing this task.\n * @param taskName Name of the task to unregister.\n * @return A promise which fulfils when the task is fully unregistered.\n */\nexport async function unregisterTaskAsync(taskName: string): Promise<void> {\n  if (!ExpoBackgroundTaskModule.unregisterTaskAsync) {\n    throw new UnavailabilityError('BackgroundTask', 'unregisterTaskAsync');\n  }\n  console.log('Calling ExpoBackgroundTaskModule.unregisterTaskAsync', taskName);\n  await ExpoBackgroundTaskModule.unregisterTaskAsync(taskName);\n}\n\n// @needsAudit\n/**\n * When in debug mode this function will trigger running the background tasks.\n * This function will only work for apps built in debug mode.\n * @todo(chrfalch): When we have a usable devtools plugin we can enable this function.\n * @returns A promise which fulfils when the task is triggered.\n */\n// export async function triggerTaskWorkerForTestingAsync(): Promise<boolean> {\n//   if (__DEV__) {\n//     if (!ExpoBackgroundTaskModule.triggerTaskWorkerForTestingAsync) {\n//       throw new UnavailabilityError('BackgroundTask', 'triggerTaskWorkerForTestingAsync');\n//     }\n//     console.log('Calling triggerTaskWorkerForTestingAsync');\n//     return await ExpoBackgroundTaskModule.triggerTaskWorkerForTestingAsync();\n//   } else {\n//     return Promise.resolve(false);\n//   }\n// }\n\n// Export types\nexport {\n  BackgroundTaskStatus,\n  BackgroundTaskResult,\n  BackgroundTaskOptions,\n} from './BackgroundTask.types';\n"]}