@thelacanians/vue-native-cli 0.4.3 → 0.4.4

package/native/ios/VueNativeCore/Sources/VueNativeCore/Modules/PermissionsModule.swift

@@ -0,0 +1,190 @@
+#if canImport(UIKit)
+import UIKit
+import AVFoundation
+import Photos
+import CoreLocation
+import UserNotifications
+
+/// Native module for checking and requesting system permissions.
+///
+/// Supported permissions: "camera", "microphone", "photos", "location",
+///                        "locationAlways", "notifications"
+///
+/// Status strings: "granted", "denied", "restricted", "limited", "notDetermined"
+final class PermissionsModule: NativeModule {
+    var moduleName: String { "Permissions" }
+
+    func invoke(method: String, args: [Any], callback: @escaping (Any?, String?) -> Void) {
+        switch method {
+        case "check":
+            guard let permission = args.first as? String else {
+                callback(nil, "PermissionsModule: missing permission name"); return
+            }
+            checkPermission(permission, callback: callback)
+        case "request":
+            guard let permission = args.first as? String else {
+                callback(nil, "PermissionsModule: missing permission name"); return
+            }
+            requestPermission(permission, callback: callback)
+        default:
+            callback(nil, "PermissionsModule: Unknown method '\(method)'")
+        }
+    }
+
+    // MARK: - Check
+
+    private func checkPermission(_ permission: String, callback: @escaping (Any?, String?) -> Void) {
+        switch permission {
+        case "camera":
+            callback(statusString(avStatus: AVCaptureDevice.authorizationStatus(for: .video)), nil)
+        case "microphone":
+            callback(statusString(avStatus: AVCaptureDevice.authorizationStatus(for: .audio)), nil)
+        case "photos":
+            callback(statusString(photoStatus: PHPhotoLibrary.authorizationStatus(for: .readWrite)), nil)
+        case "location", "locationAlways":
+            // CLLocationManager.authorizationStatus() instance method must be called on main thread.
+            DispatchQueue.main.async {
+                let mgr = CLLocationManager()
+                callback(self.statusString(locationStatus: mgr.authorizationStatus), nil)
+            }
+        case "notifications":
+            UNUserNotificationCenter.current().getNotificationSettings { settings in
+                callback(self.statusString(notifStatus: settings.authorizationStatus), nil)
+            }
+        default:
+            callback("notDetermined", nil)
+        }
+    }
+
+    // MARK: - Request
+
+    private func requestPermission(_ permission: String, callback: @escaping (Any?, String?) -> Void) {
+        switch permission {
+        case "camera":
+            AVCaptureDevice.requestAccess(for: .video) { granted in
+                callback(granted ? "granted" : "denied", nil)
+            }
+        case "microphone":
+            AVCaptureDevice.requestAccess(for: .audio) { granted in
+                callback(granted ? "granted" : "denied", nil)
+            }
+        case "photos":
+            PHPhotoLibrary.requestAuthorization(for: .readWrite) { status in
+                callback(self.statusString(photoStatus: status), nil)
+            }
+        case "location":
+            // LocationPermissionRequester is @MainActor — must dispatch to main.
+            DispatchQueue.main.async {
+                LocationPermissionRequester.shared.request(always: false, callback: callback)
+            }
+        case "locationAlways":
+            DispatchQueue.main.async {
+                LocationPermissionRequester.shared.request(always: true, callback: callback)
+            }
+        case "notifications":
+            UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .badge, .sound]) { granted, _ in
+                callback(granted ? "granted" : "denied", nil)
+            }
+        default:
+            callback("notDetermined", nil)
+        }
+    }
+
+    // MARK: - Status helpers
+
+    private func statusString(avStatus: AVAuthorizationStatus) -> String {
+        switch avStatus {
+        case .authorized: return "granted"
+        case .denied: return "denied"
+        case .restricted: return "restricted"
+        case .notDetermined: return "notDetermined"
+        @unknown default: return "notDetermined"
+        }
+    }
+
+    private func statusString(photoStatus: PHAuthorizationStatus) -> String {
+        switch photoStatus {
+        case .authorized: return "granted"
+        case .denied: return "denied"
+        case .restricted: return "restricted"
+        case .notDetermined: return "notDetermined"
+        case .limited: return "limited"
+        @unknown default: return "notDetermined"
+        }
+    }
+
+    private func statusString(locationStatus: CLAuthorizationStatus) -> String {
+        switch locationStatus {
+        case .authorizedWhenInUse, .authorizedAlways: return "granted"
+        case .denied: return "denied"
+        case .restricted: return "restricted"
+        case .notDetermined: return "notDetermined"
+        @unknown default: return "notDetermined"
+        }
+    }
+
+    private func statusString(notifStatus: UNAuthorizationStatus) -> String {
+        switch notifStatus {
+        case .authorized, .provisional, .ephemeral: return "granted"
+        case .denied: return "denied"
+        case .notDetermined: return "notDetermined"
+        @unknown default: return "notDetermined"
+        }
+    }
+
+    func invokeSync(method: String, args: [Any]) -> Any? { nil }
+}
+
+// MARK: - Location permission helper
+
+/// CLLocationManager must be created and used on the main thread.
+/// This helper lives on @MainActor and drives the one-shot request flow.
+@MainActor
+private final class LocationPermissionRequester: NSObject, CLLocationManagerDelegate {
+    static let shared = LocationPermissionRequester()
+
+    private var manager: CLLocationManager?
+    private var pendingCallback: ((Any?, String?) -> Void)?
+
+    func request(always: Bool, callback: @escaping (Any?, String?) -> Void) {
+        // If already determined, return immediately without showing the system dialog.
+        let probe = CLLocationManager()
+        let current = probe.authorizationStatus
+        if current != .notDetermined {
+            callback(statusString(current), nil)
+            return
+        }
+        pendingCallback = callback
+        let mgr = CLLocationManager()
+        mgr.delegate = self
+        manager = mgr
+        if always {
+            mgr.requestAlwaysAuthorization()
+        } else {
+            mgr.requestWhenInUseAuthorization()
+        }
+    }
+
+    private func statusString(_ status: CLAuthorizationStatus) -> String {
+        switch status {
+        case .authorizedWhenInUse, .authorizedAlways: return "granted"
+        case .denied: return "denied"
+        case .restricted: return "restricted"
+        case .notDetermined: return "notDetermined"
+        @unknown default: return "notDetermined"
+        }
+    }
+
+    // nonisolated because CLLocationManagerDelegate methods arrive on arbitrary threads;
+    // we hop back to @MainActor via Task for state access.
+    nonisolated func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
+        Task { @MainActor in
+            let status = manager.authorizationStatus
+            guard let cb = self.pendingCallback else { return }
+            self.pendingCallback = nil
+            self.manager = nil
+            cb(self.statusString(status), nil)
+        }
+    }
+}
+#endif

package/native/ios/VueNativeCore/Sources/VueNativeCore/Modules/SecureStorageModule.swift

@@ -0,0 +1,118 @@
+#if canImport(UIKit)
+import Foundation
+import Security
+
+/// Native module providing secure key-value storage backed by iOS Keychain.
+///
+/// Methods:
+///   - get(key: String) -> String?
+///   - set(key: String, value: String)
+///   - remove(key: String)
+///   - clear()
+final class SecureStorageModule: NativeModule {
+    let moduleName = "SecureStorage"
+
+    private let service = "com.vuenative.securestorage"
+
+    func invoke(method: String, args: [Any], callback: @escaping (Any?, String?) -> Void) {
+        DispatchQueue.global(qos: .userInitiated).async { [weak self] in
+            guard let self = self else { return }
+            switch method {
+            case "get":
+                guard let key = args.first as? String else {
+                    callback(nil, "get: missing key")
+                    return
+                }
+                let query: [String: Any] = [
+                    kSecClass as String: kSecClassGenericPassword,
+                    kSecAttrService as String: self.service,
+                    kSecAttrAccount as String: key,
+                    kSecReturnData as String: true,
+                    kSecMatchLimit as String: kSecMatchLimitOne,
+                ]
+                var result: AnyObject?
+                let status = SecItemCopyMatching(query as CFDictionary, &result)
+                if status == errSecSuccess, let data = result as? Data,
+                   let value = String(data: data, encoding: .utf8) {
+                    callback(value, nil)
+                } else if status == errSecItemNotFound {
+                    callback(nil, nil)
+                } else {
+                    callback(nil, "get: Keychain error \(status)")
+                }
+
+            case "set":
+                guard args.count >= 2,
+                      let key = args[0] as? String,
+                      let value = args[1] as? String else {
+                    callback(nil, "set: missing key or value")
+                    return
+                }
+                guard let data = value.data(using: .utf8) else {
+                    callback(nil, "set: failed to encode value")
+                    return
+                }
+
+                // Try to update first
+                let searchQuery: [String: Any] = [
+                    kSecClass as String: kSecClassGenericPassword,
+                    kSecAttrService as String: self.service,
+                    kSecAttrAccount as String: key,
+                ]
+                let updateAttributes: [String: Any] = [
+                    kSecValueData as String: data,
+                ]
+                let updateStatus = SecItemUpdate(searchQuery as CFDictionary, updateAttributes as CFDictionary)
+
+                if updateStatus == errSecItemNotFound {
+                    // Item doesn't exist yet, add it
+                    var addQuery = searchQuery
+                    addQuery[kSecValueData as String] = data
+                    let addStatus = SecItemAdd(addQuery as CFDictionary, nil)
+                    if addStatus == errSecSuccess {
+                        callback(nil, nil)
+                    } else {
+                        callback(nil, "set: Keychain add error \(addStatus)")
+                    }
+                } else if updateStatus == errSecSuccess {
+                    callback(nil, nil)
+                } else {
+                    callback(nil, "set: Keychain update error \(updateStatus)")
+                }
+
+            case "remove":
+                guard let key = args.first as? String else {
+                    callback(nil, "remove: missing key")
+                    return
+                }
+                let query: [String: Any] = [
+                    kSecClass as String: kSecClassGenericPassword,
+                    kSecAttrService as String: self.service,
+                    kSecAttrAccount as String: key,
+                ]
+                let status = SecItemDelete(query as CFDictionary)
+                if status == errSecSuccess || status == errSecItemNotFound {
+                    callback(nil, nil)
+                } else {
+                    callback(nil, "remove: Keychain error \(status)")
+                }
+
+            case "clear":
+                let query: [String: Any] = [
+                    kSecClass as String: kSecClassGenericPassword,
+                    kSecAttrService as String: self.service,
+                ]
+                let status = SecItemDelete(query as CFDictionary)
+                if status == errSecSuccess || status == errSecItemNotFound {
+                    callback(nil, nil)
+                } else {
+                    callback(nil, "clear: Keychain error \(status)")
+                }
+
+            default:
+                callback(nil, "SecureStorageModule: Unknown method '\(method)'")
+            }
+        }
+    }
+}
+#endif

package/native/ios/VueNativeCore/Sources/VueNativeCore/Modules/SensorsModule.swift

@@ -0,0 +1,103 @@
+#if canImport(UIKit)
+import CoreMotion
+import Foundation
+
+/// Native module for accelerometer and gyroscope sensor data.
+/// Dispatches continuous events via bridge.dispatchGlobalEvent.
+final class SensorsModule: NativeModule {
+    let moduleName = "Sensors"
+
+    private let motionManager = CMMotionManager()
+    private weak var bridge: NativeBridge?
+    private let queue = OperationQueue()
+
+    init(bridge: NativeBridge) {
+        self.bridge = bridge
+        queue.name = "vue-native.sensors"
+        queue.maxConcurrentOperationCount = 1
+    }
+
+    func invoke(method: String, args: [Any], callback: @escaping (Any?, String?) -> Void) {
+        switch method {
+        case "startAccelerometer":
+            let interval = (args.first as? Double ?? 100) / 1000.0
+            startAccelerometer(interval: interval, callback: callback)
+        case "stopAccelerometer":
+            stopAccelerometer(callback: callback)
+        case "startGyroscope":
+            let interval = (args.first as? Double ?? 100) / 1000.0
+            startGyroscope(interval: interval, callback: callback)
+        case "stopGyroscope":
+            stopGyroscope(callback: callback)
+        case "isAvailable":
+            let sensorType = args.first as? String ?? "accelerometer"
+            let available: Bool
+            switch sensorType {
+            case "gyroscope":
+                available = motionManager.isGyroAvailable
+            default:
+                available = motionManager.isAccelerometerAvailable
+            }
+            callback(["available": available], nil)
+        default:
+            callback(nil, "SensorsModule: unknown method '\(method)'")
+        }
+    }
+
+    // MARK: - Accelerometer
+
+    private func startAccelerometer(interval: TimeInterval, callback: @escaping (Any?, String?) -> Void) {
+        guard motionManager.isAccelerometerAvailable else {
+            callback(nil, "Accelerometer not available on this device")
+            return
+        }
+        motionManager.accelerometerUpdateInterval = interval
+        motionManager.startAccelerometerUpdates(to: queue) { [weak self] data, error in
+            guard let data = data, let bridge = self?.bridge else { return }
+            if error != nil { return }
+            DispatchQueue.main.async {
+                bridge.dispatchGlobalEvent("sensor:accelerometer", payload: [
+                    "x": data.acceleration.x,
+                    "y": data.acceleration.y,
+                    "z": data.acceleration.z,
+                    "timestamp": data.timestamp,
+                ])
+            }
+        }
+        callback(nil, nil)
+    }
+
+    private func stopAccelerometer(callback: @escaping (Any?, String?) -> Void) {
+        motionManager.stopAccelerometerUpdates()
+        callback(nil, nil)
+    }
+
+    // MARK: - Gyroscope
+
+    private func startGyroscope(interval: TimeInterval, callback: @escaping (Any?, String?) -> Void) {
+        guard motionManager.isGyroAvailable else {
+            callback(nil, "Gyroscope not available on this device")
+            return
+        }
+        motionManager.gyroUpdateInterval = interval
+        motionManager.startGyroUpdates(to: queue) { [weak self] data, error in
+            guard let data = data, let bridge = self?.bridge else { return }
+            if error != nil { return }
+            DispatchQueue.main.async {
+                bridge.dispatchGlobalEvent("sensor:gyroscope", payload: [
+                    "x": data.rotationRate.x,
+                    "y": data.rotationRate.y,
+                    "z": data.rotationRate.z,
+                    "timestamp": data.timestamp,
+                ])
+            }
+        }
+        callback(nil, nil)
+    }
+
+    private func stopGyroscope(callback: @escaping (Any?, String?) -> Void) {
+        motionManager.stopGyroUpdates()
+        callback(nil, nil)
+    }
+}
+#endif

package/native/ios/VueNativeCore/Sources/VueNativeCore/Modules/ShareModule.swift

@@ -0,0 +1,49 @@
+#if canImport(UIKit)
+import UIKit
+
+final class ShareModule: NativeModule {
+    var moduleName: String { "Share" }
+
+    func invoke(method: String, args: [Any], callback: @escaping (Any?, String?) -> Void) {
+        switch method {
+        case "share":
+            guard let content = args.first as? [String: Any] else {
+                callback(nil, "Invalid content")
+                return
+            }
+            var items: [Any] = []
+            if let message = content["message"] as? String { items.append(message) }
+            if let urlStr = content["url"] as? String, let u = URL(string: urlStr) { items.append(u) }
+            if items.isEmpty { callback(nil, "No shareable content"); return }
+
+            DispatchQueue.main.async {
+                let vc = UIActivityViewController(activityItems: items, applicationActivities: nil)
+                if let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene,
+                   let rootVC = windowScene.windows.first?.rootViewController {
+                    // iPad popover support
+                    if let popover = vc.popoverPresentationController {
+                        popover.sourceView = rootVC.view
+                        popover.sourceRect = CGRect(
+                            x: rootVC.view.bounds.midX,
+                            y: rootVC.view.bounds.midY,
+                            width: 0,
+                            height: 0
+                        )
+                        popover.permittedArrowDirections = []
+                    }
+                    rootVC.present(vc, animated: true)
+                    vc.completionWithItemsHandler = { _, completed, _, _ in
+                        callback(["shared": completed], nil)
+                    }
+                } else {
+                    callback(nil, "No root view controller")
+                }
+            }
+        default:
+            callback(nil, "Unknown method: \(method)")
+        }
+    }
+
+    func invokeSync(method: String, args: [Any]) -> Any? { nil }
+}
+#endif