@swiftbrowser/native 0.17.6 → 0.17.8

package/swift/Sources/SwiftBrowserNative/Host/NotificationBridge.swift

@@ -0,0 +1,304 @@
+#if canImport(SwiftUI) && canImport(UserNotifications)
+import Foundation
+import SwiftBrowserProtocol
+import UserNotifications
+#if canImport(UIKit)
+import UIKit
+#elseif canImport(AppKit)
+import AppKit
+#endif
+#if canImport(FoundationBridge)
+import FoundationBridge
+#endif
+
+/// The app's notifications (packages/native/src/notifications.ts) on
+/// UserNotifications: the permission, local notifications (the runtime's
+/// `Notification`), the badge, and remote notifications (`registerForPush`),
+/// whose device token the app delegate hands to `NativeApp` (NativeAppDelegate.swift).
+/// What the viewer does with a notification, and what arrives while the app
+/// is open, goes to the app as `__sbNotification(json)`:
+///
+/// ```
+/// { "event": "opened" | "received", "remote": bool, "id": string, "title": string, "body": string, "data": {…}, "action"?: string }
+/// ```
+///
+/// `data` is the notification's `userInfo` (a push's payload; what
+/// `new Notification(title, { data })` gave). Against the shim (the round
+/// trip) the UserNotifications here is the shim's, which shows local
+/// notifications with the page's Notification API and subscribes to Web Push
+/// through the site's service worker (docs/ops-protocol.md, "Push
+/// notifications"), so one app runs in both.
+@MainActor
+final class NotificationBridge {
+    private let send: (String, [JSONValue]) -> Void
+    /// `pushRegister` calls waiting for a device token, by id.
+    private var registering: [Int] = []
+    /// Whether the app's `__sbNotification` is there to call (`notificationsReady`).
+    private(set) var ready = false
+
+    /// `send` calls a global of the app's.
+    init(send: @escaping (String, [JSONValue]) -> Void) {
+        self.send = send
+        NotificationRouter.shared.attach(self)
+    }
+
+    /// The app listens: what came before (a tap that launched the app) is delivered.
+    func listen() {
+        ready = true
+        NotificationRouter.shared.flush()
+    }
+
+    // MARK: Permission
+
+    /// Answers `__sbNotificationPermission(id, "granted" | "denied" | "default")`,
+    /// after asking the viewer when `request` is set and the question is open.
+    func permission(id: Int, request: Bool) {
+        Task { @MainActor in
+            let center = UNUserNotificationCenter.current()
+            if request {
+                _ = try? await center.requestAuthorization(options: [.alert, .badge, .sound])
+            }
+            let settings = await center.notificationSettings()
+            let answer: String = switch settings.authorizationStatus {
+            case .authorized, .provisional, .ephemeral: "granted"
+            case .denied: "denied"
+            default: "default"
+            }
+            send("__sbNotificationPermission", [.number(Double(id)), .string(answer)])
+        }
+    }
+
+    // MARK: Local notifications
+
+    /// Shows `{ id, title, subtitle?, body?, data?, badge?, silent? }` now; the message of what was wrong, or nil.
+    func show(_ json: String) -> String? {
+        let fields: JSONObject
+        do {
+            guard let parsed = try JSONValue.parse(json).object else { return "notification: expected an object" }
+            fields = parsed
+        } catch {
+            return "notification: \(error)"
+        }
+        guard let id = fields["id"]?.string, let title = fields["title"]?.string else { return "notification: expected an id and a title" }
+        let content = UNMutableNotificationContent()
+        content.title = title
+        content.subtitle = fields["subtitle"]?.string ?? ""
+        content.body = fields["body"]?.string ?? ""
+        if let badge = fields["badge"]?.int { content.badge = NSNumber(value: badge) }
+        if fields["silent"]?.bool != true { content.sound = .default }
+        if let data = fields["data"]?.object { content.userInfo = Self.userInfo(of: data) }
+        UNUserNotificationCenter.current().add(UNNotificationRequest(identifier: id, content: content, trigger: nil)) { _ in }
+        return nil
+    }
+
+    /// Closes the notifications with these identifiers (`[id, …]`).
+    func close(_ json: String) {
+        guard let ids = (try? JSONValue.parse(json))?.array?.compactMap(\.string), !ids.isEmpty else { return }
+        let center = UNUserNotificationCenter.current()
+        center.removePendingNotificationRequests(withIdentifiers: ids)
+        center.removeDeliveredNotifications(withIdentifiers: ids)
+    }
+
+    func setBadge(_ count: Int) {
+        UNUserNotificationCenter.current().setBadgeCount(max(0, count)) { _ in }
+    }
+
+    // MARK: Remote notifications
+
+    /// Registers with the system; the token or the failure answers
+    /// `__sbPushRegistered(id, { token } | { error })` through `NativeApp`'s
+    /// delegate entry points. `applicationServerKey` is what the page
+    /// subscribes with in the round trip (the shim's Web Push); the system
+    /// needs none.
+    func registerForPush(id: Int, applicationServerKey: String?) {
+        registering.append(id)
+        Self.systemRegistration(applicationServerKey)
+    }
+
+    /// Asks the system for a device token; tests substitute it.
+    static var systemRegistration: @MainActor (_ applicationServerKey: String?) -> Void = { applicationServerKey in
+        #if canImport(FoundationBridge)
+        if let applicationServerKey { _RemoteNotifications.applicationServerKey = applicationServerKey }
+        // The page has no App file with a delegate adaptor: the token needs one.
+        if UIApplication.shared.delegate == nil { UIApplication.shared.delegate = NativeAppDelegate() }
+        #endif
+        #if canImport(UIKit)
+        UIApplication.shared.registerForRemoteNotifications()
+        #elseif canImport(AppKit)
+        NSApplication.shared.registerForRemoteNotifications()
+        #endif
+    }
+
+    func registered(token: String) {
+        answerRegistrations(.object(["token": .string(token)]))
+    }
+
+    func registrationFailed(_ message: String) {
+        answerRegistrations(.object(["error": .string(message)]))
+    }
+
+    private func answerRegistrations(_ result: JSONValue) {
+        let ids = registering
+        registering = []
+        for id in ids { send("__sbPushRegistered", [.number(Double(id)), result]) }
+    }
+
+    /// A notification event for the app.
+    func deliver(_ event: JSONValue) {
+        send("__sbNotification", [.string(event.json)])
+    }
+
+    // MARK: Conversions
+
+    nonisolated static func userInfo(of fields: JSONObject) -> [AnyHashable: Any] {
+        var info: [AnyHashable: Any] = [:]
+        for (key, value) in fields { info[key] = foundationValue(of: value) }
+        return info
+    }
+
+    nonisolated static func foundationValue(of value: JSONValue) -> Any {
+        switch value {
+        case .null: NSNull()
+        case .bool(let bool): bool
+        case .number(let number): number == number.rounded() && abs(number) < 1e15 ? Int(number) : number
+        case .string(let string): string
+        case .array(let values): values.map(foundationValue(of:))
+        case .object(let fields): fields.mapValues(foundationValue(of:))
+        }
+    }
+
+    /// `userInfo` as JSON: strings, numbers, booleans, arrays and dictionaries with string keys; the rest is left out.
+    nonisolated static func jsonValue(of value: Any) -> JSONValue? {
+        switch value {
+        case let string as String: .string(string)
+        case let bool as Bool: .bool(bool)
+        case let int as Int: .number(Double(int))
+        case let double as Double: .number(double)
+        case let number as NSNumber: .number(number.doubleValue)
+        case is NSNull: .null
+        case let values as [Any]: .array(values.compactMap(jsonValue(of:)))
+        case let fields as [AnyHashable: Any]:
+            .object(fields.reduce(into: JSONObject()) { out, entry in
+                if let key = entry.key as? String, let json = jsonValue(of: entry.value) { out[key] = json }
+            })
+        default: nil
+        }
+    }
+
+    /// The event for a notification: `opened` with the action the viewer chose, or `received`.
+    nonisolated static func event(_ name: String, _ notification: UNNotification, action: String?) -> JSONValue {
+        let request = notification.request
+        return event(name, remote: request.trigger is UNPushNotificationTrigger, id: request.identifier,
+                     title: request.content.title, body: request.content.body, userInfo: request.content.userInfo, action: action)
+    }
+
+    nonisolated static func event(_ name: String, remote: Bool, id: String, title: String, body: String, userInfo: [AnyHashable: Any], action: String?) -> JSONValue {
+        var fields: JSONObject = [
+            "event": .string(name),
+            "remote": .bool(remote),
+            "id": .string(id),
+            "title": .string(title),
+            "body": .string(body),
+            "data": jsonValue(of: userInfo) ?? .object([:]),
+        ]
+        if let action { fields["action"] = .string(action) }
+        return .object(fields)
+    }
+}
+
+/// The notification center's delegate, shared by every `NativeApp`, which
+/// routes what the center reports to the apps' bridges: what the viewer
+/// opened (`didReceive`), what arrived while the app is open (`willPresent`,
+/// shown as it would be in the background), and the device token the app
+/// delegate was handed. What comes before an app listens (a tap that
+/// launched the app) waits for the first one.
+@MainActor
+final class NotificationRouter: NSObject, UNUserNotificationCenterDelegate {
+    static let shared = NotificationRouter()
+
+    private final class Weak {
+        weak var bridge: NotificationBridge?
+        init(_ bridge: NotificationBridge) { self.bridge = bridge }
+    }
+
+    private var bridges: [Weak] = []
+    private var pending: [JSONValue] = []
+    private var installed = false
+
+    /// Makes the router the center's delegate, once; before the app finishes
+    /// launching, for a tap that launches it.
+    func install() {
+        guard !installed else { return }
+        installed = true
+        UNUserNotificationCenter.current().delegate = self
+    }
+
+    /// `install` when the process is an app: a test runner has no
+    /// notification center (`UNUserNotificationCenter.current()` raises there).
+    func installIfApp() {
+        #if canImport(FoundationBridge)
+        install()
+        #else
+        if Bundle.main.bundleURL.pathExtension == "app" { install() }
+        #endif
+    }
+
+    func attach(_ bridge: NotificationBridge) {
+        bridges.removeAll { $0.bridge == nil }
+        bridges.append(Weak(bridge))
+    }
+
+    private var listening: [NotificationBridge] { bridges.compactMap(\.bridge).filter(\.ready) }
+
+    func flush() {
+        let targets = listening
+        guard !targets.isEmpty, !pending.isEmpty else { return }
+        let events = pending
+        pending = []
+        for event in events { for bridge in targets { bridge.deliver(event) } }
+    }
+
+    func route(_ event: JSONValue) {
+        let targets = listening
+        if targets.isEmpty {
+            pending.append(event)
+            return
+        }
+        for bridge in targets { bridge.deliver(event) }
+    }
+
+    func registered(token: Data) {
+        let hex = token.map { byte in
+            let digits = Array("0123456789abcdef")
+            return String([digits[Int(byte >> 4)], digits[Int(byte & 0x0f)]])
+        }.joined()
+        for bridge in bridges.compactMap(\.bridge) { bridge.registered(token: hex) }
+    }
+
+    func registrationFailed(_ message: String) {
+        for bridge in bridges.compactMap(\.bridge) { bridge.registrationFailed(message) }
+    }
+
+    /// A push the app delegate was handed (a silent one, or one with
+    /// `content-available`); one with an alert the center reports as it shows it.
+    func received(remote userInfo: [AnyHashable: Any]) {
+        let aps = userInfo["aps"] as? [AnyHashable: Any] ?? [:]
+        guard aps["alert"] == nil else { return }
+        route(NotificationBridge.event("received", remote: true, id: (userInfo["id"] as? String) ?? "", title: "", body: "", userInfo: userInfo, action: nil))
+    }
+
+    // MARK: UNUserNotificationCenterDelegate
+
+    nonisolated func userNotificationCenter(_ center: UNUserNotificationCenter, willPresent notification: UNNotification) async -> UNNotificationPresentationOptions {
+        let event = NotificationBridge.event("received", notification, action: nil)
+        await MainActor.run { route(event) }
+        return [.banner, .list, .sound, .badge]
+    }
+
+    nonisolated func userNotificationCenter(_ center: UNUserNotificationCenter, didReceive response: UNNotificationResponse) async {
+        let action = response.actionIdentifier == UNNotificationDefaultActionIdentifier ? "" : response.actionIdentifier
+        let event = NotificationBridge.event("opened", response.notification, action: action)
+        await MainActor.run { route(event) }
+    }
+}
+#endif

package/swift/Sources/SwiftBrowserNative/Host/NowPlayingBridge.swift

@@ -0,0 +1,190 @@
+#if canImport(SwiftUI) && canImport(MediaPlayer)
+import Foundation
+import MediaPlayer
+import SwiftBrowserProtocol
+#if canImport(UIKit)
+import UIKit
+#elseif canImport(AppKit)
+import AppKit
+#endif
+#if os(iOS) && canImport(AVFoundation)
+import AVFoundation
+#endif
+#if canImport(FoundationBridge)
+import FoundationBridge
+#endif
+
+/// The app's `navigator.mediaSession` (packages/native/src/mediaSession.ts)
+/// on MediaPlayer: each `mediaSession(update)` sets `MPNowPlayingInfoCenter`
+/// (the lock screen's title, artist, album and artwork, the position the
+/// system extrapolates at the rate) and makes `MPRemoteCommandCenter`
+/// listen for exactly the commands the app handles; a command the viewer
+/// gives (a lock screen button, the media keys, the system's player
+/// controls) goes back as `__sbMediaSessionCommand(json)`. The update is
+/// the one the web renderer's `mediaSession` request carries
+/// (docs/ops-protocol.md, "Now playing"), so an app writes the same code
+/// for the page and the native app. Against the shim (the round trip) the
+/// MediaPlayer here is the shim's, which hands the same to the page.
+@MainActor
+final class NowPlayingBridge {
+    private let send: (JSONValue) -> Void
+    /// The target added to each command listened for, by the protocol's name.
+    private var targets: [String: Any] = [:]
+    private var artworkURL: String?
+    private var artwork: MPMediaItemArtwork?
+    private var artworkLoad: Task<Void, Never>?
+    private var info: [String: Any]?
+    #if os(iOS)
+    private var sessionReady = false
+    #endif
+
+    /// `send` hands a received command to the app.
+    init(send: @escaping (JSONValue) -> Void) {
+        self.send = send
+    }
+
+    /// Applies one update; the message of what was wrong with it, or nil.
+    func update(_ json: String) -> String? {
+        let parsed: JSONValue
+        do {
+            parsed = try JSONValue.parse(json)
+        } catch {
+            return "mediaSession: \(error)"
+        }
+        guard let fields = parsed.object else { return "mediaSession: expected an object" }
+        apply(fields)
+        return nil
+    }
+
+    private func apply(_ fields: JSONObject) {
+        let center = MPNowPlayingInfoCenter.default()
+        if let metadata = fields.object("metadata") {
+            var next: [String: Any] = [:]
+            if let title = metadata.string("title") { next[MPMediaItemPropertyTitle] = title }
+            if let artist = metadata.string("artist") { next[MPMediaItemPropertyArtist] = artist }
+            if let album = metadata.string("album") { next[MPMediaItemPropertyAlbumTitle] = album }
+            if let position = fields.object("position") {
+                if let duration = position.double("duration") { next[MPMediaItemPropertyPlaybackDuration] = duration }
+                if let elapsed = position.double("position") { next[MPNowPlayingInfoPropertyElapsedPlaybackTime] = elapsed }
+                if let rate = position.double("rate") { next[MPNowPlayingInfoPropertyPlaybackRate] = rate }
+            }
+            if let state = fields.string("playbackState"), fields.object("position") == nil {
+                // No position: the state alone says whether it plays, through the rate.
+                next[MPNowPlayingInfoPropertyPlaybackRate] = state == "playing" ? 1.0 : 0.0
+            }
+            info = next
+            loadArtwork(metadata.string("artwork"))
+            publish()
+        } else if fields["metadata"] == .null {
+            info = nil
+            artwork = nil
+            artworkURL = nil
+            artworkLoad?.cancel()
+            center.nowPlayingInfo = nil
+        }
+        if let state = fields.string("playbackState") {
+            #if os(macOS) || canImport(FoundationBridge)
+            center.playbackState = state == "playing" ? .playing : state == "paused" ? .paused : .unknown
+            #endif
+            #if os(iOS)
+            // The lock screen shows the app that plays through an active playback session.
+            if state == "playing" { activateAudioSession() }
+            #endif
+        }
+        if let commands = fields.array("commands") {
+            listen(for: Set(commands.compactMap(\.string)))
+        }
+    }
+
+    /// The info with the artwork, as the center takes it whole.
+    private func publish() {
+        guard var next = info else { return }
+        if let artwork { next[MPMediaItemPropertyArtwork] = artwork }
+        MPNowPlayingInfoCenter.default().nowPlayingInfo = next
+    }
+
+    /// The artwork at `url` (a `data:` URL at once, a remote one through a fetch), once per URL.
+    private func loadArtwork(_ url: String?) {
+        guard url != artworkURL else { return }
+        artworkURL = url
+        artwork = nil
+        artworkLoad?.cancel()
+        guard let url else { return }
+        if url.hasPrefix("data:") {
+            if let comma = url.firstIndex(of: ","), let data = Data(base64Encoded: String(url[url.index(after: comma)...])) {
+                artwork = Self.artwork(from: data)
+            }
+            return
+        }
+        guard let remote = URL(string: url) else { return }
+        artworkLoad = Task { [weak self] in
+            guard let (data, _) = try? await URLSession.shared.data(from: remote), !Task.isCancelled else { return }
+            guard let self, self.artworkURL == url else { return }
+            self.artwork = Self.artwork(from: data)
+            self.publish()
+        }
+    }
+
+    private static func artwork(from data: Data) -> MPMediaItemArtwork? {
+        #if canImport(UIKit)
+        guard let image = UIImage(data: data) else { return nil }
+        #elseif canImport(AppKit)
+        guard let image = NSImage(data: data) else { return nil }
+        #endif
+        return MPMediaItemArtwork(boundsSize: image.size) { _ in image }
+    }
+
+    #if os(iOS)
+    private func activateAudioSession() {
+        guard !sessionReady else { return }
+        sessionReady = true
+        let session = AVAudioSession.sharedInstance()
+        try? session.setCategory(.playback, mode: .default)
+        try? session.setActive(true)
+    }
+    #endif
+
+    // MARK: Remote commands
+
+    /// The protocol's command names and the center's commands.
+    private var commands: [(name: String, command: MPRemoteCommand)] {
+        let center = MPRemoteCommandCenter.shared()
+        return [
+            ("play", center.playCommand),
+            ("pause", center.pauseCommand),
+            ("stop", center.stopCommand),
+            ("nextTrack", center.nextTrackCommand),
+            ("previousTrack", center.previousTrackCommand),
+            ("seekTo", center.changePlaybackPositionCommand),
+            ("skipForward", center.skipForwardCommand),
+            ("skipBackward", center.skipBackwardCommand),
+        ]
+    }
+
+    /// Listens for exactly `wanted`: a target for each new one, none for the
+    /// dropped ones, and every other command disabled (the system enables them
+    /// all to begin with; the protocol says the others get no button).
+    private func listen(for wanted: Set<String>) {
+        for (name, command) in commands {
+            let listening = targets[name] != nil
+            if wanted.contains(name), !listening {
+                if let skip = command as? MPSkipIntervalCommand, skip.preferredIntervals.isEmpty { skip.preferredIntervals = [15] }
+                targets[name] = command.addTarget { [weak self] event in
+                    var fields: JSONObject = ["command": .string(name)]
+                    if let seek = event as? MPChangePlaybackPositionCommandEvent { fields["position"] = .number(seek.positionTime) }
+                    if let skip = event as? MPSkipIntervalCommandEvent { fields["interval"] = .number(skip.interval) }
+                    // Called on the main thread; a hop keeps the app's handler out of the system's callback.
+                    DispatchQueue.main.async {
+                        MainActor.assumeIsolated { self?.send(.object(fields)) }
+                    }
+                    return .success
+                }
+            } else if !wanted.contains(name), listening {
+                command.removeTarget(targets.removeValue(forKey: name))
+            }
+            let enabled = wanted.contains(name)
+            if command.isEnabled != enabled { command.isEnabled = enabled }
+        }
+    }
+}
+#endif

package/swift/Sources/SwiftBrowserNative/Host/SecureStorage.swift

@@ -0,0 +1,60 @@
+#if canImport(SwiftUI)
+import Foundation
+#if canImport(FoundationBridge)
+import FoundationBridge
+#else
+import Security
+#endif
+
+/// The app's `secureStorage` (packages/native/src/secureStorage.ts): generic
+/// password items in the Keychain under the app's service, one per key,
+/// readable after the first unlock (a background fetch can read a token).
+/// Against the shim (the round trip) there is no Keychain: the values go to
+/// `UserDefaults` under a prefix, which is the page's `localStorage`.
+enum SecureStorage {
+    #if canImport(FoundationBridge)
+    private static let prefix = "swiftbrowser.secure."
+
+    static func get(_ key: String) -> String? {
+        UserDefaults.standard.string(forKey: prefix + key)
+    }
+
+    static func set(_ key: String, _ value: String) {
+        UserDefaults.standard.set(value, forKey: prefix + key)
+    }
+
+    static func remove(_ key: String) {
+        UserDefaults.standard.removeObject(forKey: prefix + key)
+    }
+    #else
+    private static var service: String { (Bundle.main.bundleIdentifier ?? "swiftbrowser") + ".secure" }
+
+    private static func query(_ key: String) -> [String: Any] {
+        [kSecClass as String: kSecClassGenericPassword, kSecAttrService as String: service, kSecAttrAccount as String: key]
+    }
+
+    static func get(_ key: String) -> String? {
+        var query = query(key)
+        query[kSecReturnData as String] = true
+        query[kSecMatchLimit as String] = kSecMatchLimitOne
+        var item: CFTypeRef?
+        guard SecItemCopyMatching(query as CFDictionary, &item) == errSecSuccess, let data = item as? Data else { return nil }
+        return String(data: data, encoding: .utf8)
+    }
+
+    static func set(_ key: String, _ value: String) {
+        var attributes: [String: Any] = [kSecValueData as String: Data(value.utf8)]
+        #if os(iOS) || os(tvOS) || os(watchOS) || os(visionOS)
+        attributes[kSecAttrAccessible as String] = kSecAttrAccessibleAfterFirstUnlock
+        #endif
+        let status = SecItemUpdate(query(key) as CFDictionary, attributes as CFDictionary)
+        guard status == errSecItemNotFound else { return }
+        SecItemAdd(query(key).merging(attributes) { $1 } as CFDictionary, nil)
+    }
+
+    static func remove(_ key: String) {
+        SecItemDelete(query(key) as CFDictionary)
+    }
+    #endif
+}
+#endif

package/swift/Sources/SwiftBrowserNative/Host/ShimAliases.swift

@@ -17,6 +17,7 @@ public typealias RunLoop = FoundationBridge.RunLoop
 public typealias UserDefaults = FoundationBridge.UserDefaults
 public typealias Bundle = FoundationBridge.Bundle
 public typealias URLSession = FoundationBridge.URLSession
+public typealias URLSessionWebSocketTask = FoundationBridge.URLSessionWebSocketTask
 public typealias URLSessionConfiguration = FoundationBridge.URLSessionConfiguration
 public typealias URLRequest = FoundationBridge.URLRequest
 public typealias URLResponse = FoundationBridge.URLResponse
@@ -24,4 +25,6 @@ public typealias HTTPURLResponse = FoundationBridge.HTTPURLResponse
 public typealias URLCache = FoundationBridge.URLCache
 public typealias CachedURLResponse = FoundationBridge.CachedURLResponse
 public typealias DispatchQueue = FoundationBridge.DispatchQueue
+// The shim's players post their notifications through the bridge's center.
+public typealias NotificationCenter = FoundationBridge.NotificationCenter
 #endif