expo-background-task 0.0.0

package/build/BackgroundTask.types.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Availability status for background tasks
+ */
+export declare enum BackgroundTaskStatus {
+    /**
+     * Background tasks are unavailable.
+     */
+    Restricted = 1,
+    /**
+     * Background tasks are available for the app.
+     */
+    Available = 2
+}
+/**
+ * Return value for background tasks.
+ */
+export declare enum BackgroundTaskResult {
+    /**
+     * The task finished successfully.
+     */
+    Success = 1,
+    /**
+     * The task failed.
+     */
+    Failed = 2
+}
+/**
+ * Options for registering a background task
+ */
+export type BackgroundTaskOptions = {
+    /**
+     * Inexact interval in minutes between subsequent repeats of the background tasks. The final
+     * interval may differ from the specified one to minimize wakeups and battery usage.
+     * - Defaults to once every 12 hours (The minimum interval is 15 minutes)
+     * - On iOS, the system determines the interval for background task execution,
+     *  but will wait until the specified minimum interval has elapsed before starting a task.
+     * @platform android
+     */
+    minimumInterval?: number;
+};
+//# sourceMappingURL=BackgroundTask.types.d.ts.map

package/build/BackgroundTask.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BackgroundTask.types.d.ts","sourceRoot":"","sources":["../src/BackgroundTask.types.ts"],"names":[],"mappings":"AACA;;GAEG;AACH,oBAAY,oBAAoB;IAC9B;;OAEG;IACH,UAAU,IAAI;IACd;;OAEG;IACH,SAAS,IAAI;CACd;AAGD;;GAEG;AACH,oBAAY,oBAAoB;IAC9B;;OAEG;IACH,OAAO,IAAI;IACX;;OAEG;IACH,MAAM,IAAI;CACX;AAGD;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC"}

package/build/BackgroundTask.types.js

@@ -0,0 +1,31 @@
+// @needsAudit
+/**
+ * Availability status for background tasks
+ */
+export var BackgroundTaskStatus;
+(function (BackgroundTaskStatus) {
+    /**
+     * Background tasks are unavailable.
+     */
+    BackgroundTaskStatus[BackgroundTaskStatus["Restricted"] = 1] = "Restricted";
+    /**
+     * Background tasks are available for the app.
+     */
+    BackgroundTaskStatus[BackgroundTaskStatus["Available"] = 2] = "Available";
+})(BackgroundTaskStatus || (BackgroundTaskStatus = {}));
+// @needsAudit
+/**
+ * Return value for background tasks.
+ */
+export var BackgroundTaskResult;
+(function (BackgroundTaskResult) {
+    /**
+     * The task finished successfully.
+     */
+    BackgroundTaskResult[BackgroundTaskResult["Success"] = 1] = "Success";
+    /**
+     * The task failed.
+     */
+    BackgroundTaskResult[BackgroundTaskResult["Failed"] = 2] = "Failed";
+})(BackgroundTaskResult || (BackgroundTaskResult = {}));
+//# sourceMappingURL=BackgroundTask.types.js.map

package/build/BackgroundTask.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BackgroundTask.types.js","sourceRoot":"","sources":["../src/BackgroundTask.types.ts"],"names":[],"mappings":"AAAA,cAAc;AACd;;GAEG;AACH,MAAM,CAAN,IAAY,oBASX;AATD,WAAY,oBAAoB;IAC9B;;OAEG;IACH,2EAAc,CAAA;IACd;;OAEG;IACH,yEAAa,CAAA;AACf,CAAC,EATW,oBAAoB,KAApB,oBAAoB,QAS/B;AAED,cAAc;AACd;;GAEG;AACH,MAAM,CAAN,IAAY,oBASX;AATD,WAAY,oBAAoB;IAC9B;;OAEG;IACH,qEAAW,CAAA;IACX;;OAEG;IACH,mEAAU,CAAA;AACZ,CAAC,EATW,oBAAoB,KAApB,oBAAoB,QAS/B","sourcesContent":["// @needsAudit\n/**\n * Availability status for background tasks\n */\nexport enum BackgroundTaskStatus {\n  /**\n   * Background tasks are unavailable.\n   */\n  Restricted = 1,\n  /**\n   * Background tasks are available for the app.\n   */\n  Available = 2,\n}\n\n// @needsAudit\n/**\n * Return value for background tasks.\n */\nexport enum BackgroundTaskResult {\n  /**\n   * The task finished successfully.\n   */\n  Success = 1,\n  /**\n   * The task failed.\n   */\n  Failed = 2,\n}\n\n// @needsAudit\n/**\n * Options for registering a background task\n */\nexport type BackgroundTaskOptions = {\n  /**\n   * Inexact interval in minutes between subsequent repeats of the background tasks. The final\n   * interval may differ from the specified one to minimize wakeups and battery usage.\n   * - Defaults to once every 12 hours (The minimum interval is 15 minutes)\n   * - On iOS, the system determines the interval for background task execution,\n   *  but will wait until the specified minimum interval has elapsed before starting a task.\n   * @platform android\n   */\n  minimumInterval?: number;\n};\n"]}

package/build/ExpoBackgroundTaskModule.d.ts

@@ -0,0 +1,11 @@
+import { type NativeModule } from 'expo';
+import { BackgroundTaskOptions, BackgroundTaskStatus } from './BackgroundTask.types';
+declare class ExpoBackgroundTaskModule extends NativeModule {
+    getStatusAsync(): Promise<BackgroundTaskStatus>;
+    registerTaskAsync(name: string, options: BackgroundTaskOptions): Promise<void>;
+    unregisterTaskAsync(name: string): Promise<void>;
+    triggerTaskWorkerForTestingAsync(): Promise<boolean>;
+}
+declare const _default: ExpoBackgroundTaskModule;
+export default _default;
+//# sourceMappingURL=ExpoBackgroundTaskModule.d.ts.map

package/build/ExpoBackgroundTaskModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoBackgroundTaskModule.d.ts","sourceRoot":"","sources":["../src/ExpoBackgroundTaskModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,YAAY,EAAE,MAAM,MAAM,CAAC;AAE9D,OAAO,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAErF,OAAO,OAAO,wBAAyB,SAAQ,YAAY;IACzD,cAAc,IAAI,OAAO,CAAC,oBAAoB,CAAC;IAC/C,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC;IAC9E,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAChD,gCAAgC,IAAI,OAAO,CAAC,OAAO,CAAC;CACrD;;AAED,wBAAmF"}

package/build/ExpoBackgroundTaskModule.js

@@ -0,0 +1,3 @@
+import { requireNativeModule } from 'expo';
+export default requireNativeModule('ExpoBackgroundTask');
+//# sourceMappingURL=ExpoBackgroundTaskModule.js.map

package/build/ExpoBackgroundTaskModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoBackgroundTaskModule.js","sourceRoot":"","sources":["../src/ExpoBackgroundTaskModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAqB,MAAM,MAAM,CAAC;AAW9D,eAAe,mBAAmB,CAA2B,oBAAoB,CAAC,CAAC","sourcesContent":["import { requireNativeModule, type NativeModule } from 'expo';\n\nimport { BackgroundTaskOptions, BackgroundTaskStatus } from './BackgroundTask.types';\n\ndeclare class ExpoBackgroundTaskModule extends NativeModule {\n  getStatusAsync(): Promise<BackgroundTaskStatus>;\n  registerTaskAsync(name: string, options: BackgroundTaskOptions): Promise<void>;\n  unregisterTaskAsync(name: string): Promise<void>;\n  triggerTaskWorkerForTestingAsync(): Promise<boolean>;\n}\n\nexport default requireNativeModule<ExpoBackgroundTaskModule>('ExpoBackgroundTask');\n"]}

package/build/ExpoBackgroundTaskModule.web.d.ts

@@ -0,0 +1,6 @@
+import { BackgroundTaskStatus } from './BackgroundTask.types';
+declare const _default: {
+    getStatusAsync(): Promise<BackgroundTaskStatus>;
+};
+export default _default;
+//# sourceMappingURL=ExpoBackgroundTaskModule.web.d.ts.map

package/build/ExpoBackgroundTaskModule.web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoBackgroundTaskModule.web.d.ts","sourceRoot":"","sources":["../src/ExpoBackgroundTaskModule.web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;;sBAGpC,QAAQ,oBAAoB,CAAC;;AADvD,wBAIE"}

package/build/ExpoBackgroundTaskModule.web.js

@@ -0,0 +1,7 @@
+import { BackgroundTaskStatus } from './BackgroundTask.types';
+export default {
+    async getStatusAsync() {
+        return BackgroundTaskStatus.Restricted;
+    },
+};
+//# sourceMappingURL=ExpoBackgroundTaskModule.web.js.map

package/build/ExpoBackgroundTaskModule.web.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoBackgroundTaskModule.web.js","sourceRoot":"","sources":["../src/ExpoBackgroundTaskModule.web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAE9D,eAAe;IACb,KAAK,CAAC,cAAc;QAClB,OAAO,oBAAoB,CAAC,UAAU,CAAC;IACzC,CAAC;CACF,CAAC","sourcesContent":["import { BackgroundTaskStatus } from './BackgroundTask.types';\n\nexport default {\n  async getStatusAsync(): Promise<BackgroundTaskStatus> {\n    return BackgroundTaskStatus.Restricted;\n  },\n};\n"]}

package/expo-module.config.json

@@ -0,0 +1,11 @@
+{
+  "name": "expo-background-task",
+  "platforms": [ "ios", "android" ],
+  "ios": {
+    "appDelegateSubscribers": [ "BackgroundTaskAppDelegateSubscriber" ],
+    "modules": [ "BackgroundTaskModule" ]
+  },
+  "android": {
+    "modules": [ "expo.modules.backgroundtask.BackgroundTaskModule" ]
+  }
+}

package/ios/BackgorundTaskExceptions.swift

@@ -0,0 +1,48 @@
+// Copyright 2024-present 650 Industries. All rights reserved.
+import ExpoModulesCore
+
+internal final class BackgroundTasksNotConfigured: Exception {
+  override var reason: String {
+    "Background Task has not been configured. To enable it, add `process` to `UIBackgroundModes` in the application's Info.plist file"
+  }
+}
+
+internal final class BackgroundTasksRestricted: Exception {
+  override var reason: String {
+#if targetEnvironment(simulator)
+    "Background Task is not available on simulators. Use a device to test it."
+#else
+    "Background Task is not available in the current context."
+#endif
+  }
+}
+
+internal final class TaskManagerNotFound: Exception {
+  override var reason: String {
+    "TaskManager not found. Are you sure that Expo modules are properly linked?"
+  }
+}
+
+internal final class CouldNotRegisterWorkerTask: GenericException<String> {
+  override var reason: String {
+    "Expo BackgroundTasks: The task could not be registered: \(param)"
+  }
+}
+
+internal final class CouldNotRegisterWorker: Exception {
+  override var reason: String {
+    "Expo BackgroundTasks: Could not register native worker task"
+  }
+}
+
+internal final class ErrorInvokingTaskHandler: Exception {
+  override var reason: String {
+    "Expo BackgroundTasks: An error occured when running the task handler"
+  }
+}
+
+internal final class InvalidFinishTaskRun: Exception {
+  override var reason: String {
+    "Expo BackgroundTasks: Tried to mark task run as finished when there are no task runs active"
+  }
+}

package/ios/BackgroundTaskAppDelegate.swift

@@ -0,0 +1,44 @@
+// Copyright 2018-present 650 Industries. All rights reserved.
+
+import Foundation
+import BackgroundTasks
+import ExpoModulesCore
+
+public class BackgroundTaskAppDelegateSubscriber: ExpoAppDelegateSubscriber {
+  public func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? = nil) -> Bool {
+    if BackgroundTaskScheduler.supportsBackgroundTasks() {
+      BGTaskScheduler.shared.register(forTaskWithIdentifier: BackgroundTaskConstants.BackgroundWorkerIdentifier, using: nil) { task in
+        log.debug("Expo Background Tasks - starting background work")
+
+        // Set up expiration handler
+        task.expirationHandler = { ()
+          log.warn("Expo Background Tasks - task expired")
+          task.setTaskCompleted(success: false)
+        }
+
+        // Let's find the task service implementation and call the runTasks(withReason)
+        if let taskService = ModuleRegistryProvider.singletonModules().first(where: { $0 is EXTaskServiceInterface }) as? EXTaskServiceInterface {
+          taskService.runTasks(with: EXTaskLaunchReasonBackgroundTask, userInfo: nil, completionHandler: { _ in
+            // Mark iOS task as finished - this is important so that we can continue calling it
+            task.setTaskCompleted(success: true)
+
+            // Reschedule
+            Task {
+              do {
+                log.debug("Background task successfully finished. Rescheduling")
+                try await BackgroundTaskScheduler.tryScheduleWorker()
+              } catch {
+                log.error("Could not reschedule the worker after task finished: \(error.localizedDescription)")
+              }
+            }
+          })
+        } else {
+          task.setTaskCompleted(success: false)
+          log.error("Expo Background Tasks: Could not find TaskService module")
+        }
+      }
+    }
+
+    return true
+  }
+}

package/ios/BackgroundTaskConstants.swift

@@ -0,0 +1,13 @@
+// Copyright 2024-present 650 Industries. All rights reserved.
+import Foundation
+
+public struct BackgroundTaskConstants {
+  public static let BackgroundWorkerIdentifier = "com.expo.modules.backgroundtask.processing"
+  public static let EVENT_PERFORM_WORK = "onPerformWork"
+  public static let EVENT_WORK_DONE = "onWorkDone"
+
+  /**
+   Startup argument that will cause us to simulate starting from the background
+   */
+  public static let EXPO_RUN_BACKGROUND_TASK = "EXPO_RUN_BACKGROUND_TASK"
+}

package/ios/BackgroundTaskConsumer.swift

@@ -0,0 +1,57 @@
+// Copyright 2024-present 650 Industries. All rights reserved.
+import ExpoModulesCore
+
+class BackgroundTaskConsumer: NSObject, EXTaskConsumerInterface {
+  var task: EXTaskInterface?
+
+  static func supportsLaunchReason(_ launchReason: EXTaskLaunchReason) -> Bool {
+    return launchReason == EXTaskLaunchReasonBackgroundTask
+  }
+
+  func taskType() -> String {
+    return "backgroundTask"
+  }
+
+  func normalizeTaskResult(_ result: Any?) -> UInt {
+    guard let result = result as? Int else {
+      return UIBackgroundFetchResult.noData.rawValue
+    }
+
+    switch result {
+    case BackgroundTaskResult.success.rawValue:
+      return UIBackgroundFetchResult.newData.rawValue
+    case BackgroundTaskResult.failed.rawValue:
+      return UIBackgroundFetchResult.failed.rawValue
+    default:
+      return UIBackgroundFetchResult.newData.rawValue
+    }
+  }
+
+  func didBecomeReadyToExecute(withData data: [AnyHashable: Any]?) {
+    // Run on main thread. The task execution needs to be called on the main thread
+    // since it accesses the UIApplication's state
+    EXUtilities.performSynchronously {
+      self.task?.execute(withData: data, withError: nil)
+    }
+  }
+
+  func didRegisterTask(_ task: EXTaskInterface) {
+    self.task = task
+
+    if !BackgroundTaskScheduler.supportsBackgroundTasks() {
+      return
+    }
+
+    BackgroundTaskScheduler.didRegisterTask(minutes: self.task?.options?["minimumInterval"] as? Int)
+  }
+
+  func didUnregister() {
+    self.task = nil
+
+    if !BackgroundTaskScheduler.supportsBackgroundTasks() {
+      return
+    }
+
+    BackgroundTaskScheduler.didUnregisterTask()
+  }
+}

package/ios/BackgroundTaskDebugHelper.swift

@@ -0,0 +1,21 @@
+// Copyright 2024-present 650 Industries. All rights reserved.
+import BackgroundTasks
+
+final class BackgroundTaskDebugHelper {
+  static func triggerBackgroundTaskTest() {
+#if DEBUG
+    let selector = NSSelectorFromString("_simulate".appending("LaunchForTaskWithIdentifier:"))
+
+    if let method = class_getInstanceMethod(BGTaskScheduler.self, selector) {
+      typealias MethodImplementation = @convention(c) (AnyObject, Selector, String) -> Void
+      let implementation = unsafeBitCast(method_getImplementation(method), to: MethodImplementation.self)
+
+      implementation(BGTaskScheduler.shared, selector, BackgroundTaskConstants.BackgroundWorkerIdentifier)
+    } else {
+      print("BackgroundTaskScheduler: _simulateLaunchForTaskWithIdentifier method not found on BGTaskScheduler.")
+    }
+#else
+    fatalError("Triggering background tasks are not allowed in release builds.")
+#endif
+  }
+}

package/ios/BackgroundTaskModule.swift

@@ -0,0 +1,78 @@
+// Copyright 2024-present 650 Industries. All rights reserved.
+import ExpoModulesCore
+
+public class BackgroundTaskModule: Module {
+  private var taskManager: EXTaskManagerInterface?
+
+  public func definition() -> ModuleDefinition {
+    Name("ExpoBackgroundTask")
+
+    OnCreate {
+      taskManager = appContext?.legacyModule(implementing: EXTaskManagerInterface.self)
+    }
+
+    AsyncFunction("triggerTaskWorkerForTestingAsync") {
+      if await BackgroundTaskScheduler.isWorkerRunning() {
+        BackgroundTaskDebugHelper.triggerBackgroundTaskTest()
+        return true
+      }
+      return false
+    }
+
+    AsyncFunction("registerTaskAsync") { (name: String, options: [String: Any]) in
+      guard let taskManager else {
+        throw TaskManagerNotFound()
+      }
+
+      if !BackgroundTaskScheduler.supportsBackgroundTasks() {
+        throw BackgroundTasksRestricted()
+      }
+
+      if !taskManager.hasBackgroundModeEnabled("processing") {
+        throw BackgroundTasksNotConfigured()
+      }
+
+      // Register task
+      taskManager.registerTask(withName: name, consumer: BackgroundTaskConsumer.self, options: options)
+    }
+
+    AsyncFunction("unregisterTaskAsync") { (name: String) in
+      guard let taskManager else {
+        throw TaskManagerNotFound()
+      }
+
+      if !BackgroundTaskScheduler.supportsBackgroundTasks() {
+        throw BackgroundTasksRestricted()
+      }
+
+      if !taskManager.hasBackgroundModeEnabled("processing") {
+        throw BackgroundTasksNotConfigured()
+      }
+
+      taskManager.unregisterTask(withName: name, consumerClass: BackgroundTaskConsumer.self)
+    }
+
+    AsyncFunction("getStatusAsync") {
+      return BackgroundTaskScheduler.supportsBackgroundTasks() ?
+        BackgroundTaskStatus.available : .restricted
+    }
+
+    OnAppEntersBackground {
+      Task {
+        // Try start worker when app enters background
+        do {
+          try await BackgroundTaskScheduler.tryScheduleWorker()
+        } catch {
+          log.error("Could not schedule the worker: \(error.localizedDescription)")
+        }
+      }
+    }
+
+    OnAppEntersForeground {
+      Task {
+        // When entering foreground we'll stop the worker
+        await BackgroundTaskScheduler.stopWorker()
+      }
+    }
+  }
+}

package/ios/BackgroundTaskRecords.swift

@@ -0,0 +1,12 @@
+// Copyright 2024-present 650 Industries. All rights reserved.
+import ExpoModulesCore
+
+enum BackgroundTaskStatus: Int, Enumerable {
+  case restricted = 1
+  case available = 2
+}
+
+enum BackgroundTaskResult: Int, Enumerable {
+  case success = 1
+  case failed = 2
+}

package/ios/BackgroundTaskScheduler.swift

@@ -0,0 +1,101 @@
+// Copyright 2024-present 650 Industries. All rights reserved.
+import BackgroundTasks
+
+public class BackgroundTaskScheduler {
+  /**
+   * Keep track of number of registered task consumers
+   */
+  static var numberOfRegisteredTasksOfThisType: Int = 0
+
+  /**
+   * Interval for task scheduler. The iOS BGTaskScheduler does not guarantee that the number of minutes will be
+   * exact, but it indicates when we'd like the task to start. This will be set to at least 12 hours
+   */
+  private static var intervalSeconds: TimeInterval = 12 * 60 * 60
+
+  /**
+   * Call when a task is registered to keep track of how many background task consumers we have
+   */
+  public static func didRegisterTask(minutes: Int?) {
+    if let minutes = minutes {
+      intervalSeconds = Double(minutes) * 60
+    }
+    numberOfRegisteredTasksOfThisType += 1
+  }
+
+  /**
+   * Call when a task is unregistered to keep track of how many background task consumers we have
+   */
+  public static func didUnregisterTask() {
+    numberOfRegisteredTasksOfThisType -= 1
+  }
+
+  /**
+   * Tries to schedule the worker task to run
+   */
+  public static func tryScheduleWorker() async throws {
+    if numberOfRegisteredTasksOfThisType == 0 {
+      print("Background Task: skipping scheduling. No registered tasks")
+      return
+    }
+
+    // Stop existing tasks
+    await stopWorker()
+
+    // Create request
+    let request = BGProcessingTaskRequest(identifier: BackgroundTaskConstants.BackgroundWorkerIdentifier)
+
+    // We'll require network but accept running on battery power.
+    request.requiresNetworkConnectivity = true
+    request.requiresExternalPower = false
+
+    // Set up mimimum start date
+    request.earliestBeginDate = Date().addingTimeInterval(intervalSeconds)
+
+    do {
+      try BGTaskScheduler.shared.submit(request)
+    } catch let error as BGTaskScheduler.Error {
+      switch error.code {
+      case .unavailable:
+        throw CouldNotRegisterWorkerTask("Background task scheduling is unavailable.")
+      case .tooManyPendingTaskRequests:
+        throw CouldNotRegisterWorkerTask("Too many pending task requests.")
+      case .notPermitted:
+        throw CouldNotRegisterWorkerTask("Task request not permitted.")
+      @unknown default:
+        print("An unknown BGTaskScheduler error occurred.")
+        // Handle any future cases added by Apple
+      }
+    } catch {
+      // All other errors
+      throw CouldNotRegisterWorkerTask("Unknown error occurred.")
+    }
+  }
+
+  /**
+   Cancels the worker task
+   */
+  public static func stopWorker() async {
+    BGTaskScheduler.shared.cancel(taskRequestWithIdentifier: BackgroundTaskConstants.BackgroundWorkerIdentifier)
+  }
+
+  /**
+   Returns true if the worker task is pending
+   */
+  public static func isWorkerRunning() async -> Bool {
+    let requests = await BGTaskScheduler.shared.pendingTaskRequests()
+    return requests.contains(where: { $0.identifier == BackgroundTaskConstants.BackgroundWorkerIdentifier })
+  }
+
+  /**
+   Returns true if we're on a device that supports background tasks
+   */
+  public static func supportsBackgroundTasks() -> Bool {
+#if targetEnvironment(simulator)
+    // If we're on emulator we should definetly return restricted
+    return false
+#else
+    return true
+#endif
+  }
+}

package/ios/ExpoBackgroundTask.podspec

@@ -0,0 +1,32 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name           = 'ExpoBackgroundTask'
+  s.version        = package['version']
+  s.summary        = package['description']
+  s.description    = package['description']
+  s.license        = package['license']
+  s.author         = package['author']
+  s.homepage       = package['homepage']
+  s.platforms      = {
+    :ios => '15.1'
+  }
+  s.source         = { git: 'https://github.com/expo/expo.git' }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+  # Swift/Objective-C compatibility
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+    'SWIFT_COMPILATION_MODE' => 'wholemodule'
+  }
+
+  if !$ExpoUseSources&.include?(package['name']) && ENV['EXPO_USE_SOURCE'].to_i == 0 && File.exist?("#{s.name}.xcframework") && Gem::Version.new(Pod::VERSION) >= Gem::Version.new('1.10.0')
+    s.source_files = "**/*.h"
+    s.vendored_frameworks = "#{s.name}.xcframework"
+  else
+    s.source_files = "**/*.{h,m,swift}"
+  end
+end

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "expo-background-task",
+  "version": "0.0.0",
+  "description": "Expo universal module for BackgroundTask API",
+  "main": "build/BackgroundTask.js",
+  "types": "build/BackgroundTask.d.ts",
+  "sideEffects": false,
+  "scripts": {
+    "build": "expo-module build",
+    "clean": "expo-module clean",
+    "lint": "expo-module lint",
+    "test": "expo-module test",
+    "prepare": "expo-module prepare",
+    "prepublishOnly": "expo-module prepublishOnly",
+    "expo-module": "expo-module"
+  },
+  "keywords": [
+    "expo",
+    "react-native",
+    "background",
+    "background-task"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/expo/expo.git",
+    "directory": "packages/expo-background-task"
+  },
+  "bugs": {
+    "url": "https://github.com/expo/expo/issues"
+  },
+  "author": "650 Industries, Inc.",
+  "license": "MIT",
+  "homepage": "https://docs.expo.dev/versions/latest/sdk/background-task/",
+  "dependencies": {
+    "expo-task-manager": "~12.0.0"
+  },
+  "devDependencies": {
+    "expo-module-scripts": "^4.0.0"
+  },
+  "peerDependencies": {
+    "expo": "*"
+  }
+}

package/plugin/build/withBackgroundTask.d.ts

@@ -0,0 +1,3 @@
+import { ConfigPlugin } from 'expo/config-plugins';
+declare const _default: ConfigPlugin<void>;
+export default _default;

package/plugin/build/withBackgroundTask.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_plugins_1 = require("expo/config-plugins");
+const pkg = require('expo-background-task/package.json');
+const withBackgroundTask = (config) => {
+    return (0, config_plugins_1.withInfoPlist)(config, (config) => {
+        // Enable background mode processing
+        if (!Array.isArray(config.modResults.UIBackgroundModes)) {
+            config.modResults.UIBackgroundModes = [];
+        }
+        if (!config.modResults.UIBackgroundModes.includes('processing')) {
+            config.modResults.UIBackgroundModes.push('processing');
+        }
+        // With the new background task module we need to install the identifier in the Info.plist:
+        // BGTaskSchedulerPermittedIdentifiers should be an array of strings - we need to
+        // define our own identifier: com.expo.modules.backgroundtask.taskidentifer
+        if (!Array.isArray(config.modResults.BGTaskSchedulerPermittedIdentifiers)) {
+            config.modResults.BGTaskSchedulerPermittedIdentifiers = [];
+        }
+        if (!config.modResults.BGTaskSchedulerPermittedIdentifiers.includes('com.expo.modules.backgroundtask.processing')) {
+            config.modResults.BGTaskSchedulerPermittedIdentifiers = [
+                ...(config.modResults.BGTaskSchedulerPermittedIdentifiers || []),
+                'com.expo.modules.backgroundtask.processing',
+            ];
+        }
+        return config;
+    });
+};
+exports.default = (0, config_plugins_1.createRunOncePlugin)(withBackgroundTask, pkg.name, pkg.version);