@capacitor/background-runner 1.0.0-rc.1

package/ios/Plugin/BackgroundRunner.swift

@@ -0,0 +1,223 @@
+import Foundation
+import Capacitor
+import BackgroundTasks
+import JavaScriptCore
+
+public class BackgroundRunner {
+    public static let shared = BackgroundRunner()
+
+    private var runner: Runner?
+    private var config: RunnerConfig?
+
+    private var context: Context?
+
+    private var started: Bool {
+        return runner != nil && context != nil
+    }
+
+    public init() {
+        do {
+            config = try self.loadRunnerConfig()
+        } catch {
+            print("could not initialize BackgroundRunner: \(error)")
+        }
+    }
+
+    public func registerBackgroundTask() {
+        guard let config = config else {
+            print("no runner to register")
+            return
+        }
+
+        if config.event == nil {
+            print("cannot register background task without a event to call")
+            return
+        }
+
+        BGTaskScheduler.shared.register(forTaskWithIdentifier: config.label, using: nil) { task in
+            do {
+                task.expirationHandler = {
+                    print("task timed out")
+                }
+
+                guard let event = config.event else {
+                    throw BackgroundRunnerPluginError.invalidRunnerConfig(reason: "runner event is missing or invalid")
+                }
+
+                _ = try BackgroundRunner.shared.execute(config: config, event: event)
+
+                task.setTaskCompleted(success: true)
+            } catch {
+                print("background task error: \(error)")
+                task.setTaskCompleted(success: false)
+            }
+        }
+    }
+
+    public func scheduleBackgroundTasks() {
+        guard let config = config else {
+            return
+        }
+
+        guard let interval = config.interval else {
+            print("cannot register background task without a configured interval")
+            return
+        }
+
+        let request = BGAppRefreshTaskRequest(identifier: config.label)
+        request.earliestBeginDate = Date(timeIntervalSinceNow: Double(interval) * 60)
+
+        do {
+            print("Scheduling \(config.label)")
+
+            try BGTaskScheduler.shared.submit(request)
+        } catch {
+            print("Could not schedule app refresh: \(error)")
+        }
+    }
+
+    public func start() throws {
+        print("starting runner and loading contexts...")
+
+        guard let config = config else {
+            print("...no runner config to start")
+            return
+        }
+
+        self.runner = Runner()
+        context = try initContext(config: config)
+
+    }
+
+    public func stop() {
+        print("...stopping runner and removing all contexts")
+        guard let runner = runner, let config = config else {
+            return
+        }
+
+        runner.destroyContext(name: config.label)
+
+        context = nil
+        self.runner = nil
+    }
+
+    public func getConfig() -> RunnerConfig? {
+        return config
+    }
+
+    public func dispatchEvent(event: String, inputArgs: [String: Any]?) throws {
+        if !started {
+            try start()
+        }
+
+        if let config = config {
+            let waitGroup = DispatchGroup()
+            waitGroup.enter()
+
+            var err: Error?
+
+            DispatchQueue.global(qos: .userInitiated).async { [unowned self] in
+                do {
+                    _ = try self.execute(config: config, event: event, inputArgs: inputArgs)
+                } catch {
+                    err = error
+                    print("[\(config.label)]: \(error)")
+                }
+
+                waitGroup.leave()
+            }
+
+            waitGroup.wait()
+
+            if let err = err {
+                throw err
+            }
+        }
+    }
+
+    public func execute(config: RunnerConfig, event: String, inputArgs: [String: Any]? = nil) throws -> [String: Any]? {
+        do {
+            if !started {
+                try self.start()
+            }
+
+            guard let context = context else {
+                throw BackgroundRunnerPluginError.runnerError(reason: "no loaded context for config")
+            }
+
+            var inputArgsWithCallback = inputArgs
+
+            if inputArgsWithCallback == nil {
+                inputArgsWithCallback = [:]
+            }
+
+            let waitGroup = DispatchGroup()
+
+            var result: [String: Any]?
+
+            let completedFunc: @convention(block)(JavaScriptCore.JSValue) -> Void = { returnObj in
+                if !returnObj.isUndefined && !returnObj.isNull {
+                    var dict: [String: Any] = [:]
+
+                    returnObj.toDictionary().forEach { key, value in
+                        dict[String(describing: key)] = value
+                    }
+
+                    result = dict
+                }
+
+                waitGroup.leave()
+                return
+            }
+
+            inputArgsWithCallback?["__ebr::completed"] = completedFunc
+
+            waitGroup.enter()
+
+            try context.dispatchEvent(event: event, details: inputArgsWithCallback)
+
+            waitGroup.wait()
+
+            return result
+        } catch {
+            print("error executing task: \(error)")
+            throw error
+        }
+    }
+
+    private func loadRunnerConfig() throws -> RunnerConfig? {
+        guard let capacitorConfigFileURL = Bundle.main.url(forResource: "capacitor.config.json", withExtension: nil) else {
+            throw BackgroundRunnerPluginError.runnerError(reason: "capacitor.config.json file not found")
+        }
+
+        let capacitorConfigFileData = try Data(contentsOf: capacitorConfigFileURL)
+
+        if let capConfig = JSTypes.coerceDictionaryToJSObject(try JSONSerialization.jsonObject(with: capacitorConfigFileData) as? [String: Any]) {
+            if let jsonConfig = capConfig[keyPath: "plugins.BackgroundRunner"] as? JSObject {
+                return try RunnerConfig(from: jsonConfig)
+            }
+        }
+
+        return nil
+    }
+
+    private func initContext(config: RunnerConfig) throws -> Context {
+        guard let runner = runner else {
+            throw BackgroundRunnerPluginError.runnerError(reason: "runner is not initialized")
+        }
+
+        guard let srcFileURL = Bundle.main.url(forResource: config.src, withExtension: nil, subdirectory: "public") else {
+            throw BackgroundRunnerPluginError.runnerError(reason: "source file not found")
+        }
+
+        let srcFile = try String(contentsOf: srcFileURL)
+
+        let context = try runner.createContext(name: config.label)
+
+        context.setupCapacitorAPI()
+
+        _ = try context.execute(code: srcFile)
+
+        return context
+    }
+}

package/ios/Plugin/BackgroundRunnerErrors.swift

@@ -0,0 +1,8 @@
+import Foundation
+
+public enum BackgroundRunnerPluginError: Error, Equatable {
+    case invalidRunnerConfig(reason: String)
+    case invalidArgument(reason: String)
+    case runnerError(reason: String)
+    case genericError(reason: String)
+}

package/ios/Plugin/BackgroundRunnerPlugin.h

@@ -0,0 +1,10 @@
+#import <UIKit/UIKit.h>
+
+//! Project version number for Plugin.
+FOUNDATION_EXPORT double PluginVersionNumber;
+
+//! Project version string for Plugin.
+FOUNDATION_EXPORT const unsigned char PluginVersionString[];
+
+// In this header, you should import all the public headers of your framework using statements like #import <Plugin/PublicHeader.h>
+

package/ios/Plugin/BackgroundRunnerPlugin.m

@@ -0,0 +1,11 @@
+#import <Foundation/Foundation.h>
+#import <Capacitor/Capacitor.h>
+
+// Define the plugin using the CAP_PLUGIN Macro, and
+// each method the plugin supports using the CAP_PLUGIN_METHOD macro.
+CAP_PLUGIN(BackgroundRunnerPlugin, "BackgroundRunner",
+    CAP_PLUGIN_METHOD(dispatchEvent, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(registerBackgroundTask, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(checkPermissions, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(requestPermissions, CAPPluginReturnPromise);
+)

package/ios/Plugin/BackgroundRunnerPlugin.swift

@@ -0,0 +1,161 @@
+import Foundation
+import Capacitor
+import WatchConnectivity
+
+@objc(BackgroundRunnerPlugin)
+public class BackgroundRunnerPlugin: CAPPlugin {
+    private let impl = BackgroundRunner()
+
+    override public func load() {
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(didEnterBackground),
+            name: UIApplication.didEnterBackgroundNotification,
+            object: nil
+        )
+        initWatchConnectivity()
+    }
+
+    @objc override public func checkPermissions(_ call: CAPPluginCall) {
+        // check geolocation permissions
+        let geolocationState = CapacitorGeolocation.checkPermission()
+
+        // check notification permissions
+        let notificationState = CapacitorNotifications.checkPermission()
+
+        call.resolve([
+            "geolocation": geolocationState,
+            "notifications": notificationState
+        ])
+    }
+
+    @objc override public func requestPermissions(_ call: CAPPluginCall) {
+        Task {
+            let permissions = call.getArray("apis") as? [String] ?? []
+
+            do {
+                if permissions.contains("notifications") {
+                    try CapacitorNotifications.requestPermission()
+                }
+
+                if permissions.contains("geolocation") {
+                    let geolocation = CapacitorGeolocation()
+                    print("geolocation requested...")
+                    try await geolocation.requestPermission()
+                    print("geolocation requested...done")
+                }
+
+                self.checkPermissions(call)
+            } catch {
+                call.reject("\(error)")
+            }
+        }
+    }
+
+    @objc func dispatchEvent(_ call: CAPPluginCall) {
+        do {
+            guard let runnerEvent = call.getString("event") else {
+                throw BackgroundRunnerPluginError.invalidArgument(reason: "event is missing or invalid")
+            }
+
+            let details = call.getObject("details", JSObject())
+
+            guard let config = impl.getConfig() else {
+                throw BackgroundRunnerPluginError.runnerError(reason: "no runner config loaded")
+            }
+
+            DispatchQueue.global(qos: .userInitiated).async { [unowned self] in
+                do {
+                    let result = try self.impl.execute(
+                        config: config,
+                        event: runnerEvent,
+                        inputArgs: details as [String: Any]
+                    )
+
+                    if let result = result {
+                        call.resolve(result)
+                        return
+                    }
+
+                    call.resolve()
+                } catch {
+                    call.reject("\(error)")
+                }
+            }
+        } catch {
+            call.reject("\(error)")
+        }
+    }
+
+    @objc func registerBackgroundTask(_ call: CAPPluginCall) {
+        call.resolve()
+    }
+
+    @objc private func didEnterBackground() {
+        impl.scheduleBackgroundTasks()
+    }
+
+    public static func registerBackgroundTask() {
+        BackgroundRunner.shared.registerBackgroundTask()
+    }
+
+    public static func dispatchEvent(event: String, eventArgs: [AnyHashable: Any], completionHandler: ((Result<Bool, Error>) -> Void)) {
+        var args: [String: Any] = [:]
+
+        eventArgs.forEach { (key: AnyHashable, value: Any) in
+            if let strKey = key as? String {
+                args[strKey] = value
+            }
+        }
+
+        do {
+            try BackgroundRunner.shared.dispatchEvent(event: event, inputArgs: args)
+            completionHandler(.success(true))
+        } catch {
+            completionHandler(.failure(error))
+        }
+    }
+
+    public static func handleApplicationDidFinishLaunching(launchOptions: [UIApplication.LaunchOptionsKey: Any]?) {
+        guard let launchOptions = launchOptions else {
+            return
+        }
+
+        var events: [String: [String: Any]?] = [:]
+
+        if launchOptions[.location] != nil {
+            // application was launched for a location event
+            var details: [String: Any] = [:]
+            details["locations"] = nil
+
+            if let location = CapacitorGeolocation.getCurrentKnownLocation() {
+                var details: [String: Any] = [:]
+                details["locations"] = [location]
+            }
+
+            events["currentLocation"] = details
+        }
+
+        print("emit events: \(events)")
+
+    }
+
+    private func initWatchConnectivity() {
+        if !WCSession.isSupported() {
+            return
+        }
+
+        guard let config = impl.getConfig() else {
+            return
+        }
+
+        if !config.enableWatchConnectivity {
+            return
+        }
+
+        WCSession.default.delegate = self
+        WCSession.default.activate()
+
+        print("Watch Connectivity Enabled")
+    }
+}

package/ios/Plugin/CapacitorAPI/Device.swift

@@ -0,0 +1,116 @@
+import Foundation
+import UIKit
+import JavaScriptCore
+
+@objc protocol CapacitorDeviceExports: JSExport {
+    func getNetworkStatus() -> [String: Any]?
+    func getBatteryStatus() -> [String: Any]
+}
+
+enum CapacitorDeviceErrors: Error, Equatable {
+    case unknownError(reason: String)
+}
+
+class CapacitorDevice: NSObject, CapacitorDeviceExports {
+    var reachability: Reachability?
+    var initError: Error?
+
+    enum Connection {
+        case unavailable, wifi, cellular
+    }
+
+    override init() {
+        super.init()
+
+        do {
+            reachability = try Reachability()
+        } catch {
+            initError = error
+        }
+    }
+
+    private func checkError() throws {
+        if let err = initError {
+            throw CapacitorDeviceErrors.unknownError(reason: "\(err)")
+        }
+
+        if reachability == nil {
+            throw CapacitorDeviceErrors.unknownError(reason: "reachability failed to initialize")
+        }
+    }
+
+    func getNetworkStatus() -> [String: Any]? {
+        do {
+            try checkError()
+
+            let status = reachability?.connection.equivalentEnum ?? Connection.unavailable
+
+            var networkStatusDict: [String: Any] = [:]
+            networkStatusDict["connected"] = status.isConnected
+            networkStatusDict["connectionType"] = status.jsStringValue
+
+            return networkStatusDict
+        } catch {
+            JSContext.current().exception = JSValue(newErrorFromMessage: "\(error)", in: JSContext.current())
+            return nil
+        }
+    }
+
+    func getBatteryStatus() -> [String: Any] {
+        UIDevice.current.isBatteryMonitoringEnabled = true
+
+        var batteryInfoDict: [String: Any] = [:]
+        batteryInfoDict["batteryLevel"] = UIDevice.current.batteryLevel
+        batteryInfoDict["isCharging"] = UIDevice.current.batteryState == .charging || UIDevice.current.batteryState == .full
+
+        UIDevice.current.isBatteryMonitoringEnabled = false
+
+        return batteryInfoDict
+    }
+}
+
+fileprivate extension Reachability.Connection {
+    var equivalentEnum: CapacitorDevice.Connection {
+        switch self {
+        case .unavailable:
+            return .unavailable
+        case .wifi:
+            return .wifi
+        case .cellular:
+            return .cellular
+        }
+    }
+}
+
+extension CapacitorDevice.Connection {
+    internal var jsStringValue: String {
+        switch self {
+        case .cellular:
+            return "cellular"
+        case .wifi:
+            return "wifi"
+        case .unavailable:
+            return "none"
+        }
+    }
+
+    internal var isConnected: Bool {
+        switch self {
+        case .cellular, .wifi:
+            return true
+        case .unavailable:
+            return false
+        }
+    }
+
+    internal var logMessage: String {
+        switch self {
+        case .cellular:
+            return "Reachable via Cellular"
+        case .wifi:
+            return "Reachable via WiFi"
+        case .unavailable:
+            return "Not reachable"
+        }
+    }
+}