@thelacanians/vue-native-cli 0.4.3 → 0.4.4

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

@@ -0,0 +1,215 @@
+#if canImport(UIKit)
+import UIKit
+import UserNotifications
+
+/// Native module for local and remote (push) notifications.
+///
+/// Methods:
+///   - requestPermission() -> Bool
+///   - getPermissionStatus() -> "granted"|"denied"|"notDetermined"
+///   - scheduleLocal(notification: Object) -> notificationId: String
+///   - cancel(id: String)
+///   - cancelAll()
+///   - registerForPush() -> Void (registers for APNS remote notifications)
+///   - getToken() -> String? (returns cached APNS device token)
+///
+/// Global events dispatched on bridge:
+///   "notification:received" -- when a notification arrives in foreground or is tapped
+///   "push:token"            -- when APNS device token is received { token }
+///   "push:received"         -- when a remote push notification arrives { title, body, data }
+final class NotificationsModule: NativeModule {
+    var moduleName: String { "Notifications" }
+    private weak var bridge: NativeBridge?
+
+    /// Serial queue for thread-safe access to the device token.
+    private let tokenQueue = DispatchQueue(label: "com.vuenative.notifications.token")
+    /// Backing storage for deviceToken. Access only via the computed property.
+    private var _deviceToken: String?
+    /// Cached APNS device token (hex string). Thread-safe.
+    private var deviceToken: String? {
+        get { tokenQueue.sync { _deviceToken } }
+        set { tokenQueue.sync { _deviceToken = newValue } }
+    }
+
+    init(bridge: NativeBridge) {
+        self.bridge = bridge
+        setupForegroundHandler()
+    }
+
+    private func setupForegroundHandler() {
+        UNUserNotificationCenter.current().delegate = NotificationCenterDelegate.shared
+        // Capture bridge weakly; dispatch to main actor because dispatchGlobalEvent is @MainActor.
+        let weakBridge = bridge
+        NotificationCenterDelegate.shared.onNotification = { payload in
+            DispatchQueue.main.async {
+                weakBridge?.dispatchGlobalEvent("notification:received", payload: payload)
+            }
+        }
+        NotificationCenterDelegate.shared.onPushReceived = { payload in
+            DispatchQueue.main.async {
+                weakBridge?.dispatchGlobalEvent("push:received", payload: payload)
+            }
+        }
+    }
+
+    func invoke(method: String, args: [Any], callback: @escaping (Any?, String?) -> Void) {
+        switch method {
+        case "requestPermission":
+            UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .badge, .sound]) { granted, error in
+                callback(granted, error?.localizedDescription)
+            }
+        case "getPermissionStatus":
+            UNUserNotificationCenter.current().getNotificationSettings { settings in
+                callback(self.statusString(settings.authorizationStatus), nil)
+            }
+        case "scheduleLocal":
+            guard let notification = args.first as? [String: Any] else {
+                callback(nil, "NotificationsModule: invalid notification object"); return
+            }
+            scheduleLocal(notification, callback: callback)
+        case "cancel":
+            if let id = args.first as? String {
+                UNUserNotificationCenter.current().removePendingNotificationRequests(withIdentifiers: [id])
+            }
+            callback(nil, nil)
+        case "cancelAll":
+            UNUserNotificationCenter.current().removeAllPendingNotificationRequests()
+            callback(nil, nil)
+        case "registerForPush":
+            DispatchQueue.main.async {
+                UIApplication.shared.registerForRemoteNotifications()
+            }
+            callback(true, nil)
+        case "getToken":
+            callback(deviceToken, nil)
+        default:
+            callback(nil, "NotificationsModule: Unknown method '\(method)'")
+        }
+    }
+
+    // MARK: - Push token handling (called from AppDelegate)
+
+    /// Call this from your AppDelegate's `application(_:didRegisterForRemoteNotificationsWithDeviceToken:)`
+    func didRegisterForRemoteNotifications(deviceToken data: Data) {
+        let token = data.map { String(format: "%02x", $0) }.joined()
+        self.deviceToken = token
+        DispatchQueue.main.async { [weak self] in
+            self?.bridge?.dispatchGlobalEvent("push:token", payload: ["token": token])
+        }
+    }
+
+    /// Call this from your AppDelegate's `application(_:didFailToRegisterForRemoteNotificationsWithError:)`
+    func didFailToRegisterForRemoteNotifications(error: Error) {
+        DispatchQueue.main.async { [weak self] in
+            self?.bridge?.dispatchGlobalEvent("push:error", payload: [
+                "message": error.localizedDescription
+            ])
+        }
+    }
+
+    // MARK: - Schedule local notification
+
+    private func scheduleLocal(_ notification: [String: Any], callback: @escaping (Any?, String?) -> Void) {
+        let content = UNMutableNotificationContent()
+        content.title = notification["title"] as? String ?? ""
+        content.body = notification["body"] as? String ?? ""
+
+        if let sound = notification["sound"] as? String, sound == "default" {
+            content.sound = .default
+        }
+        if let badge = notification["badge"] as? Int {
+            content.badge = NSNumber(value: badge)
+        }
+        if let data = notification["data"] as? [String: Any] {
+            content.userInfo = data
+        }
+
+        let delay = max((notification["delay"] as? Double) ?? 0.1, 0.1)
+        let trigger = UNTimeIntervalNotificationTrigger(timeInterval: delay, repeats: false)
+        let id = (notification["id"] as? String) ?? UUID().uuidString
+        let request = UNNotificationRequest(identifier: id, content: content, trigger: trigger)
+
+        UNUserNotificationCenter.current().add(request) { error in
+            if let error = error {
+                callback(nil, error.localizedDescription)
+            } else {
+                callback(id, nil)
+            }
+        }
+    }
+
+    // MARK: - Status helper
+
+    private func statusString(_ status: UNAuthorizationStatus) -> String {
+        switch status {
+        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: - UNUserNotificationCenterDelegate
+
+/// Singleton delegate that forwards foreground and tapped notifications
+/// to whoever has set `onNotification`.
+private final class NotificationCenterDelegate: NSObject, UNUserNotificationCenterDelegate {
+    static let shared = NotificationCenterDelegate()
+    /// Called for local notifications and tapped notifications.
+    var onNotification: (([String: Any]) -> Void)?
+    /// Called specifically for remote push notifications arriving in foreground.
+    var onPushReceived: (([String: Any]) -> Void)?
+
+    /// Show banners/sounds/badges even when the app is in foreground.
+    func userNotificationCenter(_ center: UNUserNotificationCenter,
+                                willPresent notification: UNNotification,
+                                withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
+        let request = notification.request
+        if request.trigger is UNPushNotificationTrigger {
+            onPushReceived?(makePushPayload(from: request))
+        } else {
+            onNotification?(makePayload(from: request))
+        }
+        completionHandler([.banner, .sound, .badge])
+    }
+
+    /// Called when the user taps a notification.
+    func userNotificationCenter(_ center: UNUserNotificationCenter,
+                                didReceive response: UNNotificationResponse,
+                                withCompletionHandler completionHandler: @escaping () -> Void) {
+        let request = response.notification.request
+        if request.trigger is UNPushNotificationTrigger {
+            var payload = makePushPayload(from: request)
+            payload["action"] = response.actionIdentifier
+            onPushReceived?(payload)
+        } else {
+            var payload = makePayload(from: request)
+            payload["action"] = response.actionIdentifier
+            onNotification?(payload)
+        }
+        completionHandler()
+    }
+
+    private func makePayload(from request: UNNotificationRequest) -> [String: Any] {
+        [
+            "id": request.identifier,
+            "title": request.content.title,
+            "body": request.content.body,
+            "data": request.content.userInfo
+        ]
+    }
+
+    private func makePushPayload(from request: UNNotificationRequest) -> [String: Any] {
+        [
+            "id": request.identifier,
+            "title": request.content.title,
+            "body": request.content.body,
+            "data": request.content.userInfo,
+            "remote": true
+        ]
+    }
+}
+#endif

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

@@ -0,0 +1,281 @@
+#if canImport(UIKit)
+import UIKit
+import CommonCrypto
+
+/// Native module for Over-The-Air (OTA) JS bundle updates.
+///
+/// Methods:
+///   - checkForUpdate(serverUrl) — check for available updates
+///   - downloadUpdate(url, hash) — download a new bundle and verify integrity
+///   - applyUpdate() — swap to downloaded bundle on next launch
+///   - rollback() — revert to the embedded bundle
+///   - getCurrentVersion() — get current bundle version info
+///
+/// Events:
+///   - ota:downloadProgress — payload: { progress: 0.0-1.0, bytesDownloaded, totalBytes }
+final class OTAModule: NativeModule {
+    var moduleName: String { "OTA" }
+
+    private let defaults = UserDefaults.standard
+    private let keyPrefix = "VueNative.OTA."
+
+    // UserDefaults keys
+    private var currentVersionKey: String { keyPrefix + "currentVersion" }
+    private var bundlePathKey: String { keyPrefix + "bundlePath" }
+    private var previousBundlePathKey: String { keyPrefix + "previousBundlePath" }
+    private var previousVersionKey: String { keyPrefix + "previousVersion" }
+
+    private weak var bridge: NativeBridge?
+
+    init(bridge: NativeBridge) {
+        self.bridge = bridge
+    }
+
+    func invoke(method: String, args: [Any], callback: @escaping (Any?, String?) -> Void) {
+        switch method {
+        case "checkForUpdate":
+            guard let serverUrl = args.first as? String else {
+                callback(nil, "checkForUpdate: missing serverUrl")
+                return
+            }
+            checkForUpdate(serverUrl: serverUrl, callback: callback)
+
+        case "downloadUpdate":
+            guard args.count >= 1,
+                  let url = args[0] as? String else {
+                callback(nil, "downloadUpdate: missing url")
+                return
+            }
+            let expectedHash = args.count >= 2 ? args[1] as? String : nil
+            downloadUpdate(url: url, expectedHash: expectedHash, callback: callback)
+
+        case "applyUpdate":
+            applyUpdate(callback: callback)
+
+        case "rollback":
+            rollback(callback: callback)
+
+        case "getCurrentVersion":
+            getCurrentVersion(callback: callback)
+
+        default:
+            callback(nil, "OTAModule: Unknown method '\(method)'")
+        }
+    }
+
+    // MARK: - Check for update
+
+    private func checkForUpdate(serverUrl: String, callback: @escaping (Any?, String?) -> Void) {
+        guard let url = URL(string: serverUrl) else {
+            callback(nil, "Invalid server URL")
+            return
+        }
+
+        let currentVersion = defaults.string(forKey: currentVersionKey) ?? "0"
+
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.setValue(currentVersion, forHTTPHeaderField: "X-Current-Version")
+        request.setValue("ios", forHTTPHeaderField: "X-Platform")
+        request.setValue(Bundle.main.bundleIdentifier ?? "unknown", forHTTPHeaderField: "X-App-Id")
+
+        URLSession.shared.dataTask(with: request) { data, response, error in
+            if let error = error {
+                callback(nil, "Network error: \(error.localizedDescription)")
+                return
+            }
+
+            guard let data = data,
+                  let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+                callback(nil, "Invalid response from update server")
+                return
+            }
+
+            let updateAvailable = json["updateAvailable"] as? Bool ?? false
+            let result: [String: Any] = [
+                "updateAvailable": updateAvailable,
+                "version": json["version"] as? String ?? "",
+                "downloadUrl": json["downloadUrl"] as? String ?? "",
+                "hash": json["hash"] as? String ?? "",
+                "size": json["size"] as? Int ?? 0,
+                "releaseNotes": json["releaseNotes"] as? String ?? "",
+            ]
+            callback(result, nil)
+        }.resume()
+    }
+
+    // MARK: - Download update
+
+    private func downloadUpdate(url: String, expectedHash: String?, callback: @escaping (Any?, String?) -> Void) {
+        guard let downloadUrl = URL(string: url) else {
+            callback(nil, "Invalid download URL")
+            return
+        }
+
+        let session = URLSession(configuration: .default, delegate: DownloadDelegate(bridge: bridge), delegateQueue: nil)
+        let task = session.downloadTask(with: downloadUrl) { [weak self] tempUrl, response, error in
+            guard let self = self else { return }
+
+            if let error = error {
+                callback(nil, "Download failed: \(error.localizedDescription)")
+                return
+            }
+
+            guard let tempUrl = tempUrl else {
+                callback(nil, "Download failed: no file received")
+                return
+            }
+
+            do {
+                // Read downloaded data
+                let data = try Data(contentsOf: tempUrl)
+
+                // Verify hash if provided
+                if let expectedHash = expectedHash, !expectedHash.isEmpty {
+                    let actualHash = self.sha256(data: data)
+                    if actualHash.lowercased() != expectedHash.lowercased() {
+                        callback(nil, "Bundle integrity check failed. Expected: \(expectedHash), got: \(actualHash)")
+                        return
+                    }
+                }
+
+                // Save to Documents directory
+                let docsDir = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
+                let bundleDir = docsDir.appendingPathComponent("VueNativeOTA", isDirectory: true)
+                try FileManager.default.createDirectory(at: bundleDir, withIntermediateDirectories: true)
+
+                let bundlePath = bundleDir.appendingPathComponent("bundle.js")
+
+                // Remove old pending download if exists
+                if FileManager.default.fileExists(atPath: bundlePath.path) {
+                    try FileManager.default.removeItem(at: bundlePath)
+                }
+
+                try data.write(to: bundlePath)
+
+                // Store the path for applyUpdate
+                self.defaults.set(bundlePath.path, forKey: self.keyPrefix + "pendingBundlePath")
+
+                callback(["path": bundlePath.path, "size": data.count], nil)
+            } catch {
+                callback(nil, "Failed to save bundle: \(error.localizedDescription)")
+            }
+        }
+        task.resume()
+    }
+
+    // MARK: - Apply update
+
+    private func applyUpdate(callback: @escaping (Any?, String?) -> Void) {
+        guard let pendingPath = defaults.string(forKey: keyPrefix + "pendingBundlePath"),
+              FileManager.default.fileExists(atPath: pendingPath) else {
+            callback(nil, "No pending update to apply")
+            return
+        }
+
+        // Save current bundle path for rollback
+        if let currentPath = defaults.string(forKey: bundlePathKey) {
+            defaults.set(currentPath, forKey: previousBundlePathKey)
+        }
+        if let currentVersion = defaults.string(forKey: currentVersionKey) {
+            defaults.set(currentVersion, forKey: previousVersionKey)
+        }
+
+        // Set the new bundle as current
+        defaults.set(pendingPath, forKey: bundlePathKey)
+        defaults.removeObject(forKey: keyPrefix + "pendingBundlePath")
+
+        // Increment version tracker
+        let currentVersion = defaults.integer(forKey: currentVersionKey)
+        defaults.set(currentVersion + 1, forKey: currentVersionKey)
+
+        callback(["applied": true], nil)
+    }
+
+    // MARK: - Rollback
+
+    private func rollback(callback: @escaping (Any?, String?) -> Void) {
+        guard let previousPath = defaults.string(forKey: previousBundlePathKey) else {
+            // Rollback to embedded bundle
+            defaults.removeObject(forKey: bundlePathKey)
+            if let prevVersion = defaults.string(forKey: previousVersionKey) {
+                defaults.set(prevVersion, forKey: currentVersionKey)
+            } else {
+                defaults.removeObject(forKey: currentVersionKey)
+            }
+            callback(["rolledBack": true, "toEmbedded": true], nil)
+            return
+        }
+
+        defaults.set(previousPath, forKey: bundlePathKey)
+        if let prevVersion = defaults.string(forKey: previousVersionKey) {
+            defaults.set(prevVersion, forKey: currentVersionKey)
+        }
+        defaults.removeObject(forKey: previousBundlePathKey)
+        defaults.removeObject(forKey: previousVersionKey)
+
+        callback(["rolledBack": true, "toEmbedded": false], nil)
+    }
+
+    // MARK: - Get current version
+
+    private func getCurrentVersion(callback: @escaping (Any?, String?) -> Void) {
+        let version = defaults.string(forKey: currentVersionKey) ?? "embedded"
+        let bundlePath = defaults.string(forKey: bundlePathKey)
+        let isUsingOTA = bundlePath != nil && FileManager.default.fileExists(atPath: bundlePath!)
+
+        callback([
+            "version": version,
+            "isUsingOTA": isUsingOTA,
+            "bundlePath": bundlePath ?? "",
+        ], nil)
+    }
+
+    // MARK: - SHA-256
+
+    private func sha256(data: Data) -> String {
+        var hash = [UInt8](repeating: 0, count: Int(CC_SHA256_DIGEST_LENGTH))
+        data.withUnsafeBytes { buffer in
+            _ = CC_SHA256(buffer.baseAddress, CC_LONG(data.count), &hash)
+        }
+        return hash.map { String(format: "%02x", $0) }.joined()
+    }
+
+    func invokeSync(method: String, args: [Any]) -> Any? { nil }
+}
+
+// MARK: - Download delegate for progress reporting
+
+private class DownloadDelegate: NSObject, URLSessionDownloadDelegate {
+    private weak var bridge: NativeBridge?
+
+    init(bridge: NativeBridge?) {
+        self.bridge = bridge
+    }
+
+    func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask,
+                    didWriteData bytesWritten: Int64, totalBytesWritten: Int64,
+                    totalBytesExpectedToWrite: Int64) {
+        let progress: Double
+        if totalBytesExpectedToWrite > 0 {
+            progress = Double(totalBytesWritten) / Double(totalBytesExpectedToWrite)
+        } else {
+            progress = 0
+        }
+
+        let bridge = bridge
+        DispatchQueue.main.async {
+            bridge?.dispatchGlobalEvent("ota:downloadProgress", payload: [
+                "progress": progress,
+                "bytesDownloaded": totalBytesWritten,
+                "totalBytes": totalBytesExpectedToWrite,
+            ])
+        }
+    }
+
+    func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask,
+                    didFinishDownloadingTo location: URL) {
+        // Handled in the completion handler of the download task
+    }
+}
+#endif

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

@@ -0,0 +1,138 @@
+#if canImport(UIKit)
+import UIKit
+
+/// Native module for performance profiling.
+/// Tracks FPS via CADisplayLink, memory usage via task_info, and bridge operation counts.
+/// Dispatches `perf:metrics` global events every 1 second while profiling is active.
+final class PerformanceModule: NativeModule {
+
+    let moduleName = "Performance"
+
+    private weak var bridge: NativeBridge?
+    private var displayLink: CADisplayLink?
+    private var isProfiling = false
+
+    // FPS tracking
+    private var frameCount = 0
+    private var lastTimestamp: CFTimeInterval = 0
+    private var currentFPS: Double = 0
+
+    // Metrics timer
+    private var metricsTimer: Timer?
+
+    // Bridge operation count
+    private var bridgeOpsCount: Int = 0
+
+    init(bridge: NativeBridge) {
+        self.bridge = bridge
+    }
+
+    func invoke(method: String, args: [Any], callback: @escaping (Any?, String?) -> Void) {
+        switch method {
+        case "startProfiling":
+            startProfiling(callback: callback)
+        case "stopProfiling":
+            stopProfiling(callback: callback)
+        case "getMetrics":
+            let metrics = collectMetrics()
+            callback(metrics, nil)
+        default:
+            callback(nil, "PerformanceModule: unknown method '\(method)'")
+        }
+    }
+
+    // MARK: - Start / Stop
+
+    private func startProfiling(callback: @escaping (Any?, String?) -> Void) {
+        guard !isProfiling else { callback(true, nil); return }
+        isProfiling = true
+        frameCount = 0
+        lastTimestamp = 0
+        currentFPS = 0
+        bridgeOpsCount = 0
+
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+
+            // CADisplayLink for FPS measurement
+            let link = CADisplayLink(target: self, selector: #selector(self.handleDisplayLink(_:)))
+            link.add(to: .main, forMode: .common)
+            self.displayLink = link
+
+            // Timer for periodic metrics dispatch (every 1 second)
+            self.metricsTimer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
+                self?.dispatchMetrics()
+            }
+
+            callback(true, nil)
+        }
+    }
+
+    private func stopProfiling(callback: @escaping (Any?, String?) -> Void) {
+        guard isProfiling else { callback(true, nil); return }
+        isProfiling = false
+
+        DispatchQueue.main.async { [weak self] in
+            self?.displayLink?.invalidate()
+            self?.displayLink = nil
+            self?.metricsTimer?.invalidate()
+            self?.metricsTimer = nil
+            callback(true, nil)
+        }
+    }
+
+    // MARK: - CADisplayLink handler
+
+    @objc private func handleDisplayLink(_ link: CADisplayLink) {
+        if lastTimestamp == 0 {
+            lastTimestamp = link.timestamp
+            frameCount = 0
+            return
+        }
+
+        frameCount += 1
+        let elapsed = link.timestamp - lastTimestamp
+
+        // Calculate FPS every 0.5 seconds for smoother readings
+        if elapsed >= 0.5 {
+            currentFPS = Double(frameCount) / elapsed
+            frameCount = 0
+            lastTimestamp = link.timestamp
+        }
+    }
+
+    // MARK: - Metrics collection
+
+    private func collectMetrics() -> [String: Any] {
+        return [
+            "fps": round(currentFPS * 10) / 10,
+            "memoryMB": getMemoryUsageMB(),
+            "bridgeOps": bridgeOpsCount,
+            "timestamp": Date().timeIntervalSince1970 * 1000,
+        ]
+    }
+
+    private func dispatchMetrics() {
+        guard isProfiling else { return }
+        bridgeOpsCount += 1 // Count the metrics dispatch itself
+        let metrics = collectMetrics()
+        bridge?.dispatchGlobalEvent("perf:metrics", payload: metrics)
+    }
+
+    // MARK: - Memory measurement
+
+    private func getMemoryUsageMB() -> Double {
+        var info = mach_task_basic_info()
+        var count = mach_msg_type_number_t(MemoryLayout<mach_task_basic_info>.size) / 4
+        let result = withUnsafeMutablePointer(to: &info) {
+            $0.withMemoryRebound(to: integer_t.self, capacity: Int(count)) {
+                task_info(mach_task_self_, task_flavor_t(MACH_TASK_BASIC_INFO), $0, &count)
+            }
+        }
+        if result == KERN_SUCCESS {
+            return Double(info.resident_size) / (1024 * 1024)
+        }
+        return 0
+    }
+}
+#endif