@zykeco/expo-background-task 1.0.0

package/build/ExpoBackgroundTaskModule.d.ts

@@ -0,0 +1,14 @@
+import { type NativeModule } from 'expo';
+import { BackgroundTaskOptions, BackgroundTaskStatus } from './BackgroundTask.types';
+type ExpoBackgroundTaskEvents = {
+    onTasksExpired(): void;
+};
+declare class ExpoBackgroundTaskModule extends NativeModule<ExpoBackgroundTaskEvents> {
+    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,KAAK,wBAAwB,GAAG;IAC9B,cAAc,IAAI,IAAI,CAAC;CACxB,CAAC;AAEF,OAAO,OAAO,wBAAyB,SAAQ,YAAY,CAAC,wBAAwB,CAAC;IACnF,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;AAe9D,eAAe,mBAAmB,CAA2B,oBAAoB,CAAC,CAAC","sourcesContent":["import { requireNativeModule, type NativeModule } from 'expo';\n\nimport { BackgroundTaskOptions, BackgroundTaskStatus } from './BackgroundTask.types';\n\ntype ExpoBackgroundTaskEvents = {\n  onTasksExpired(): void;\n};\n\ndeclare class ExpoBackgroundTaskModule extends NativeModule<ExpoBackgroundTaskEvents> {\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,OAAO,CAAC,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,10 @@
+{
+  "platforms": ["apple", "android"],
+  "apple": {
+    "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,74 @@
+// 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")
+          // Send message to Expo module
+          NotificationCenter.default.post(name: onTasksExpiredNotification, object: self, userInfo: [:])
+          task.setTaskCompleted(success: false)
+          self.reschedule()
+        }
+
+        // FIX: EXTaskService singleton lookup
+        //
+        // The original upstream code used:
+        //   ModuleRegistryProvider.singletonModules().first(where: { $0 is EXTaskServiceInterface })
+        //
+        // This never works because EXTaskService registers itself via the +shared class
+        // method (a standard ObjC singleton pattern), NOT via EX_REGISTER_SINGLETON_MODULE.
+        // As a result, singletonModules() never contains it, the handler falls through to
+        // the else branch, task.setTaskCompleted(success: false) is called, and the JS
+        // callback never executes — even though iOS successfully launched the background task.
+        //
+        // We resolve this by looking up EXTaskService via the ObjC runtime:
+        //   1. NSClassFromString("EXTaskService") — finds the class by name
+        //   2. responds(to: "shared") — safely checks the +shared selector exists
+        //   3. perform("shared").takeUnretainedValue() — calls +shared to get the singleton
+        //
+        // We intentionally avoid KVC (value(forKey:)) here because a missing key would
+        // throw an NSUnknownKeyException — an ObjC exception that Swift cannot catch,
+        // causing an unrecoverable crash.
+        let sharedSelector = NSSelectorFromString("shared")
+        if let taskServiceClass = NSClassFromString("EXTaskService") as? NSObject.Type,
+           taskServiceClass.responds(to: sharedSelector),
+           let taskService = taskServiceClass.perform(sharedSelector)?.takeUnretainedValue() 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)
+            self.reschedule()
+          })
+        } else {
+          task.setTaskCompleted(success: false)
+          log.error("Expo Background Tasks: Could not find TaskService module")
+        }
+      }
+
+      // Signal to the scheduler that we're done.
+      BackgroundTaskScheduler.bgTaskSchedulerDidFinishRegister()
+    }
+
+    return true
+  }
+
+  private func reschedule() {
+    // 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)")
+      }
+    }
+  }
+}

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,62 @@
+// 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,
+      requiresNetwork: self.task?.options?["requiresNetworkConnectivity"] as? Bool,
+      taskType: self.task?.options?["iosTaskType"] as? String,
+      requiresExternalPower: self.task?.options?["requiresExternalPower"] as? Bool
+    )
+  }
+
+  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,80 @@
+// Copyright 2024-present 650 Industries. All rights reserved.
+import ExpoModulesCore
+
+private let onTasksExpired = "onTasksExpired"
+public let onTasksExpiredNotification = Notification.Name(onTasksExpired)
+
+public class BackgroundTaskModule: Module {
+  private lazy var taskManager: EXTaskManagerInterface? = appContext?.legacyModule(implementing: EXTaskManagerInterface.self)
+
+  public func definition() -> ModuleDefinition {
+    Name("ExpoBackgroundTask")
+
+    Events(onTasksExpired)
+
+    OnStartObserving(onTasksExpired) {
+      NotificationCenter.default.addObserver(
+        self,
+        selector: #selector(handleTasksExpiredNotification),
+        name: onTasksExpiredNotification,
+        object: nil)
+    }
+
+    OnStopObserving(onTasksExpired) {
+      // swiftlint:disable:next notification_center_detachment
+      NotificationCenter.default.removeObserver(self)
+    }
+
+    AsyncFunction("triggerTaskWorkerForTestingAsync") {
+      BackgroundTaskDebugHelper.triggerBackgroundTaskTest()
+    }
+
+    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()
+      }
+
+      try EXUtilities.catchException {
+        taskManager.unregisterTask(withName: name, consumerClass: BackgroundTaskConsumer.self)
+      }
+    }
+
+    AsyncFunction("getStatusAsync") {
+      return BackgroundTaskScheduler.supportsBackgroundTasks()
+        ? BackgroundTaskStatus.available : .restricted
+    }
+  }
+
+  @objc func handleTasksExpiredNotification(_ notification: Notification) {
+    guard let url = notification.userInfo?["url"] as? URL else {
+      return
+    }
+    self.sendEvent(onTasksExpired, [:])
+  }
+}

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,206 @@
+// 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
+
+  /**
+   * Task type: "refresh" (default) for BGAppRefreshTaskRequest, "processing" for BGProcessingTaskRequest
+   */
+  private static var taskType: String = "refresh"
+
+  /**
+   * Whether the task requires network connectivity
+   */
+  private static var requiresNetwork: Bool = true
+
+  /**
+   * Whether the task requires external power (only relevant for processing tasks)
+   */
+  private static var requiresExternalPower: Bool = false
+
+  /**
+   A one-time async gate that becomes ready after BGTaskScheduler registration finishes.
+   Multiple awaiters will be resumed when ready; subsequent awaiters return immediately.
+   */
+  private actor RegistrationGate {
+    private var ready: Bool = false
+    private var waiters: [CheckedContinuation<Void, Never>] = []
+
+    func awaitReady() async {
+      if ready { return }
+      await withCheckedContinuation { (continuation: CheckedContinuation<Void, Never>) in
+        if ready {
+          continuation.resume()
+        } else {
+          waiters.append(continuation)
+        }
+      }
+    }
+
+    func signalReady() {
+      guard !ready else { return }
+      ready = true
+      let continuations = waiters
+      waiters.removeAll()
+      for c in continuations {
+        c.resume()
+      }
+    }
+  }
+
+  /**
+   Registration gate that will only be signaled when the bgTaskSchedulerDidFinishRegister is called.
+   */
+  private static let registrationGate = RegistrationGate()
+
+  /**
+   Call from the BackgroundTaskAppDelegate after the call to BGTaskScheduler.shared.register has finished
+   so that we can hold back any tryScheduleWorker calls, especially the call to BGTaskScheduler.shared.submit
+   that will fail if called before the BGTaskScheduler has successfully registered its handler.
+   */
+  public static func bgTaskSchedulerDidFinishRegister() {
+    Task {
+      await registrationGate.signalReady()
+    }
+  }
+
+  /**
+   * Call when a task is registered to keep track of how many background task consumers we have
+   */
+  public static func didRegisterTask(
+    minutes: Int?,
+    requiresNetwork network: Bool? = nil,
+    taskType type: String? = nil,
+    requiresExternalPower power: Bool? = nil
+  ) {
+    if let minutes = minutes {
+      intervalSeconds = Double(minutes) * 60
+    }
+    if let network = network {
+      requiresNetwork = network
+    }
+    if let type = type {
+      taskType = type
+    }
+    if let power = power {
+      requiresExternalPower = power
+    }
+    numberOfRegisteredTasksOfThisType += 1
+
+    if numberOfRegisteredTasksOfThisType == 1 {
+      Task {
+        // Only schedule if no pending request exists.
+        // Task restoration on cold start must not cancel-and-resubmit,
+        // otherwise earliestBeginDate gets reset on every app start
+        // and the task never fires.
+        if await !isWorkerRunning() {
+          try await tryScheduleWorker()
+        }
+      }
+    }
+  }
+
+  /**
+   * Call when a task is unregistered to keep track of how many background task consumers we have
+   */
+  public static func didUnregisterTask() {
+    numberOfRegisteredTasksOfThisType -= 1
+    if numberOfRegisteredTasksOfThisType == 0 {
+      Task {
+        await stopWorker()
+      }
+    }
+  }
+
+  /**
+   * 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
+    }
+
+    // Wait until BGTaskScheduler registration has completed.
+    await registrationGate.awaitReady()
+
+    // Stop existing tasks
+    await stopWorker()
+
+    // Create request based on task type
+    let request: BGTaskRequest
+
+    if taskType == "processing" {
+      let processingRequest = BGProcessingTaskRequest(
+        identifier: BackgroundTaskConstants.BackgroundWorkerIdentifier
+      )
+      processingRequest.requiresNetworkConnectivity = requiresNetwork
+      processingRequest.requiresExternalPower = requiresExternalPower
+      request = processingRequest
+    } else {
+      // Default: refresh
+      request = BGAppRefreshTaskRequest(
+        identifier: BackgroundTaskConstants.BackgroundWorkerIdentifier
+      )
+    }
+
+    // Set up minimum 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,33 @@
+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',
+    :tvos => '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,42 @@
+{
+  "name": "@zykeco/expo-background-task",
+  "version": "1.0.0",
+  "description": "Expo Android and iOS module for Background Task APIs",
+  "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"
+  },
+  "license": "MIT",
+  "homepage": "https://docs.expo.dev/versions/latest/sdk/background-task/",
+  "dependencies": {
+    "expo-task-manager": "~55.0.9"
+  },
+  "devDependencies": {
+    "expo-module-scripts": "^55.0.2"
+  },
+  "peerDependencies": {
+    "expo": ">=55.0.0"
+  }
+}

package/plugin/build/withBackgroundTask.d.ts

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