@capacitor/background-runner 1.0.0-rc.1

package/ios/Plugin/CapacitorAPI/Geolocation.swift

@@ -0,0 +1,190 @@
+import Foundation
+import JavaScriptCore
+import CoreLocation
+
+@objc protocol CapacitorGeolocationExports: JSExport {
+    var isWatchingPosition: Bool { get }
+    func startWatchingPosition(_ highAccuracy: Bool)
+    func stopWatchingPosition()
+    func getCurrentPosition() -> [String: Any]?
+}
+
+enum CapacitorGeolocationErrors: Error, Equatable {
+    case unauthorized
+}
+
+class CapacitorGeolocation: NSObject, CapacitorGeolocationExports, CLLocationManagerDelegate {
+    private weak var context: Context?
+    private var pendingCurrentLocationCalls: [Int: (Result<CLLocation?, Error>) -> Void] = [:]
+    private var isWatchingLocation: Bool = false
+    private let locationManager: CLLocationManager
+
+    private var permissionContinuation: CheckedContinuation<Void, Error>?
+
+    var isWatchingPosition: Bool {
+        return isWatchingLocation
+    }
+
+    init(context: Context? = nil) {
+        self.locationManager = CLLocationManager()
+        super.init()
+
+        self.context = context
+        self.locationManager.delegate = self
+
+        self.locationManager.allowsBackgroundLocationUpdates = true
+        self.locationManager.desiredAccuracy = kCLLocationAccuracyKilometer
+        self.locationManager.pausesLocationUpdatesAutomatically = false
+    }
+
+    static func getCurrentKnownLocation() -> CLLocation? {
+        return CLLocationManager().location
+    }
+
+    static func checkPermission() -> String {
+        if !CLLocationManager.locationServicesEnabled() {
+            return "denied"
+        }
+
+        var permission: String = "prompt"
+
+        switch CLLocationManager.authorizationStatus() {
+        case .authorized, .authorizedWhenInUse, .authorizedAlways:
+            permission = "granted"
+        case .notDetermined:
+            permission = "prompt"
+        case .denied, .restricted:
+            permission = "denied"
+        default:
+            permission = "prompt"
+        }
+
+        return permission
+    }
+
+    func requestPermission() async throws {
+        if !CLLocationManager.locationServicesEnabled() {
+            return
+        }
+
+        if CLLocationManager.authorizationStatus() != .notDetermined {
+            return
+        }
+
+        return try await withCheckedThrowingContinuation({ (continuation: CheckedContinuation<Void, Error>) in
+            permissionContinuation = continuation
+
+            DispatchQueue.main.async {
+                self.locationManager.requestAlwaysAuthorization()
+            }
+        })
+    }
+
+    func startWatchingPosition(_ highAccuracy: Bool) {
+        do {
+            if CapacitorGeolocation.checkPermission() != "granted" {
+                throw CapacitorGeolocationErrors.unauthorized
+            }
+
+            DispatchQueue.main.sync {
+                if highAccuracy {
+                    self.locationManager.startUpdatingLocation()
+                } else {
+                    self.locationManager.startMonitoringSignificantLocationChanges()
+                }
+            }
+
+            self.isWatchingLocation = true
+        } catch {
+            JSContext.current().exception = JSValue(newErrorFromMessage: "\(error)", in: JSContext.current())
+        }
+    }
+
+    func stopWatchingPosition() {
+        DispatchQueue.main.sync {
+            self.locationManager.stopUpdatingLocation()
+            self.locationManager.stopMonitoringSignificantLocationChanges()
+        }
+
+        self.isWatchingLocation = false
+    }
+
+    func getCurrentPosition() -> [String: Any]? {
+        do {
+            if CapacitorGeolocation.checkPermission() != "granted" {
+                throw CapacitorGeolocationErrors.unauthorized
+            }
+
+            guard let lastLocation = self.locationManager.location else {
+                return nil
+            }
+
+            return buildLocationDict(location: lastLocation)
+        } catch {
+            JSContext.current().exception = JSValue(newErrorFromMessage: "\(error)", in: JSContext.current())
+
+            return nil
+        }
+    }
+
+    func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
+        if let context = self.context, self.isWatchingLocation {
+            let locations: [[String: Any]] = locations.map { location in
+                return buildLocationDict(location: location)
+            }
+
+            var details: [String: Any] = [:]
+            details["locations"] = locations
+
+            try? context.dispatchEvent(event: "currentLocation", details: details)
+        }
+
+        pendingCurrentLocationCalls.forEach { (callId: Int, callback: (Result<CLLocation?, Error>) -> Void) in
+            pendingCurrentLocationCalls.removeValue(forKey: callId)
+            callback(.success(locations.last))
+        }
+
+        if let location = locations.last {
+            print("\(location.coordinate.latitude),\(location.coordinate.longitude)")
+        }
+    }
+
+    func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
+        if let continuation = permissionContinuation {
+            continuation.resume(throwing: error)
+            permissionContinuation = nil
+        }
+
+        if let context = context, self.isWatchingLocation {
+            var details: [String: Any] = [:]
+            details["error"] = error
+
+            try? context.dispatchEvent(event: "currentLocation", details: details)
+        }
+
+        pendingCurrentLocationCalls.forEach { (callId: Int, callback: (Result<CLLocation?, Error>) -> Void) in
+            pendingCurrentLocationCalls.removeValue(forKey: callId)
+            callback(.failure(error))
+        }
+    }
+
+    func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
+        if let continuation = permissionContinuation {
+            continuation.resume()
+            permissionContinuation = nil
+        }
+    }
+
+    private func buildLocationDict(location: CLLocation) -> [String: Any] {
+        var coords: [String: Any] = [:]
+        coords["latitude"] = location.coordinate.latitude
+        coords["longitude"] = location.coordinate.longitude
+        coords["accuracy"] = location.horizontalAccuracy
+        coords["altitude"] = location.altitude
+        coords["altitudeAccuracy"] = location.verticalAccuracy
+        coords["speed"] = location.speed
+        coords["heading"] = location.course
+
+        return coords
+    }
+}

package/ios/Plugin/CapacitorAPI/KV.swift

@@ -0,0 +1,22 @@
+import Foundation
+import JavaScriptCore
+
+@objc protocol CapacitorKVStoreExports: JSExport {
+    static func set(_ key: String, _ value: String)
+    static func get(_ key: String) -> String?
+    static func remove(_ key: String)
+}
+
+class CapacitorKVStore: NSObject, CapacitorKVStoreExports {
+    static func set(_ key: String, _ value: String) {
+        UserDefaults.standard.set(value, forKey: key)
+    }
+
+    static func get(_ key: String) -> String? {
+        return UserDefaults.standard.string(forKey: key)
+    }
+
+    static func remove(_ key: String) {
+        return UserDefaults.standard.removeObject(forKey: key)
+    }
+}

package/ios/Plugin/CapacitorAPI/Notifications.swift

@@ -0,0 +1,165 @@
+import Foundation
+import JavaScriptCore
+import UserNotifications
+
+enum CapacitorNotificationsErrors: Error, Equatable {
+    case invalidOptions(reason: String)
+    case unknownError(reason: String)
+    case permissionDenied
+}
+
+struct NotificationOption {
+    let id: Int
+    let title: String
+    let body: String
+    let scheduleAt: Date
+    let sound: String?
+    let actionTypeId: String?
+    let extra: [String: Any]?
+    let threadIdentifier: String?
+    let summaryArgument: String?
+    let groupSummary: String?
+
+    init(from dict: [String: Any?]) throws {
+        guard let id = dict["id"] as? Int else {
+            throw CapacitorNotificationsErrors.invalidOptions(reason: "notification id is required")
+        }
+
+        guard let title = dict["title"] as? String else {
+            throw CapacitorNotificationsErrors.invalidOptions(reason: "notification title is required")
+        }
+
+        guard let body = dict["body"] as? String else {
+            throw CapacitorNotificationsErrors.invalidOptions(reason: "notification body is required")
+        }
+
+        guard let scheduleAt = dict["scheduleAt"] as? Date else {
+            throw CapacitorNotificationsErrors.invalidOptions(reason: "notification schedule date is required")
+        }
+
+        self.id = id
+        self.title = title
+        self.body = body
+        self.scheduleAt = scheduleAt
+        self.threadIdentifier = dict["threadIdentifier"] as? String
+        self.sound = dict["sound"] as? String
+        self.actionTypeId = dict["actionTypeId"] as? String
+        self.extra = dict["extra"] as? [String: Any]
+        self.summaryArgument = dict["summaryArgument"] as? String
+        self.groupSummary = dict["groupSummary"] as? String
+    }
+}
+
+@objc protocol CapacitorNotificationsExports: JSExport {
+    static func schedule(_ options: JSValue)
+}
+
+class CapacitorNotifications: NSObject, CapacitorNotificationsExports {
+    static func checkPermission() -> String {
+        let group = DispatchGroup()
+        var permission: String = "prompt"
+
+        group.enter()
+        UNUserNotificationCenter.current().getNotificationSettings { settings in
+            switch settings.authorizationStatus {
+            case .authorized, .ephemeral, .provisional:
+                permission = "granted"
+            case .denied:
+                permission = "denied"
+            case .notDetermined:
+                permission = "prompt"
+            @unknown default:
+                permission = "prompt"
+            }
+            group.leave()
+        }
+
+        group.wait()
+
+        return permission
+    }
+
+    static func requestPermission() throws {
+        var permissionsError: CapacitorNotificationsErrors?
+
+        let group = DispatchGroup()
+
+        group.enter()
+        UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound, .badge]) { _, error in
+            if let error = error {
+                permissionsError = CapacitorNotificationsErrors.unknownError(reason: "\(error)")
+            }
+
+            group.leave()
+        }
+
+        group.wait()
+
+        if let err = permissionsError {
+            throw err
+        }
+    }
+
+    static func schedule(_ options: JSValue) {
+        do {
+            if CapacitorNotifications.checkPermission() != "granted" {
+                throw CapacitorNotificationsErrors.permissionDenied
+            }
+
+            if options.isUndefined || options.isNull {
+                throw CapacitorNotificationsErrors.invalidOptions(reason: "options are null")
+            }
+
+            if !options.isArray {
+                throw CapacitorNotificationsErrors.invalidOptions(reason: "options must be an array")
+            }
+
+            if let notificationOptions = options.toArray() as? [[String: Any?]] {
+                for option in notificationOptions {
+                    let notificationOption = try NotificationOption(from: option)
+
+                    let content = UNMutableNotificationContent()
+                    content.title = NSString.localizedUserNotificationString(forKey: notificationOption.title, arguments: nil)
+                    content.body = NSString.localizedUserNotificationString(forKey: notificationOption.body, arguments: nil)
+                    content.userInfo = [:]
+
+                    if let extra = notificationOption.extra {
+                        content.userInfo["cap_extra"] = extra
+                    }
+
+                    if let actionTypeId = notificationOption.actionTypeId {
+                        content.categoryIdentifier = actionTypeId
+                    }
+
+                    if let threadIdentifier = notificationOption.threadIdentifier {
+                        content.threadIdentifier = threadIdentifier
+                    }
+
+                    if let summaryArgument = notificationOption.summaryArgument {
+                        content.summaryArgument = summaryArgument
+                    }
+
+                    if let sound = notificationOption.sound {
+                        content.sound = UNNotificationSound(named: UNNotificationSoundName(sound))
+                    }
+
+                    var notificationDate = notificationOption.scheduleAt
+
+                    if notificationDate < Date() {
+                        notificationDate = Date()
+                    }
+
+                    let dateInfo = Calendar.current.dateComponents(in: TimeZone.current, from: notificationDate)
+                    let dateInterval = DateInterval(start: Date(), end: dateInfo.date!)
+
+                    let trigger = UNTimeIntervalNotificationTrigger(timeInterval: dateInterval.duration, repeats: false)
+                    let request = UNNotificationRequest(identifier: "\(notificationOption.id)", content: content, trigger: trigger)
+
+                    UNUserNotificationCenter.current().add(request)
+                }
+            }
+        } catch {
+            JSContext.current().exception = JSValue(newErrorFromMessage: "\(error)", in: JSContext.current())
+        }
+    }
+}