pythonnative 0.40.0__cp313-cp313-win_amd64.whl

pythonnative/native/ios/Sources/PythonNativeKit/Modules/LifecycleModules.swift

@@ -0,0 +1,174 @@
+import Network
+import UIKit
+
+/// `AppState`: foreground / background transitions.
+///
+/// The scene delegate calls `AppStateModule.dispatch(_:)`; the module
+/// emits `change` with the state string (`"active"`, `"inactive"`,
+/// `"background"`) as the payload, which is what the Python facade reads.
+public final class AppStateModule: PNNativeModule {
+    public static let name = "AppState"
+    public private(set) static var current = "active"
+
+    public init() {}
+
+    public func call(_ method: String, args: [String: Any], promise: PNPromise) {
+        switch method {
+        case "current_state":
+            promise.resolve(AppStateModule.current)
+        default:
+            promise.reject("AppState has no method '\(method)'", code: "unknown_method")
+        }
+    }
+
+    /// Record and publish a lifecycle transition.
+    public static func dispatch(_ state: String) {
+        guard ["active", "inactive", "background"].contains(state), state != current else { return }
+        current = state
+        PNBridge.shared.whenCallbackRegistered {
+            PNBridge.shared.callPython(kind: "module", tag: 0, name: name, payload: PNJSON.encode(["event": "change", "payload": state]))
+        }
+    }
+}
+
+/// `Battery`: level / state getters plus `change` events while monitoring.
+public final class BatteryModule: PNNativeModule {
+    public static let name = "Battery"
+    private static var observers: [NSObjectProtocol] = []
+
+    public init() {
+        BatteryModule.startMonitoring()
+    }
+
+    public func call(_ method: String, args: [String: Any], promise: PNPromise) {
+        switch method {
+        case "get_level":
+            promise.resolve(Double(UIDevice.current.batteryLevel))
+        case "get_state":
+            promise.resolve(BatteryModule.stateName())
+        default:
+            promise.reject("Battery has no method '\(method)'", code: "unknown_method")
+        }
+    }
+
+    /// Enable battery monitoring and forward UIDevice notifications.
+    public static func startMonitoring() {
+        guard observers.isEmpty else { return }
+        UIDevice.current.isBatteryMonitoringEnabled = true
+        let center = NotificationCenter.default
+        for notification in [UIDevice.batteryLevelDidChangeNotification, UIDevice.batteryStateDidChangeNotification] {
+            observers.append(center.addObserver(forName: notification, object: nil, queue: .main) { _ in
+                BatteryModule.dispatch()
+            })
+        }
+    }
+
+    /// Emit the current `{"level", "state"}` snapshot.
+    public static func dispatch() {
+        PNModuleEvents.emit(module: name, event: "change", payload: [
+            "level": Double(UIDevice.current.batteryLevel),
+            "state": stateName(),
+        ])
+    }
+
+    static func stateName() -> String {
+        switch UIDevice.current.batteryState {
+        case .unplugged: return "unplugged"
+        case .charging: return "charging"
+        case .full: return "full"
+        default: return "unknown"
+        }
+    }
+}
+
+/// `NetInfo`: connectivity snapshots from `NWPathMonitor`.
+public final class NetInfoModule: PNNativeModule {
+    public static let name = "NetInfo"
+
+    private let monitor = NWPathMonitor()
+    private var last: [String: Any]?
+
+    public init() {
+        monitor.pathUpdateHandler = { [weak self] path in
+            let snapshot = NetInfoModule.snapshot(path)
+            DispatchQueue.main.async {
+                guard let self = self else { return }
+                if let last = self.last, NSDictionary(dictionary: last).isEqual(to: snapshot) { return }
+                self.last = snapshot
+                PNModuleEvents.emit(module: NetInfoModule.name, event: "change", payload: snapshot)
+            }
+        }
+        monitor.start(queue: DispatchQueue(label: "com.pythonnative.netinfo"))
+    }
+
+    deinit {
+        monitor.cancel()
+    }
+
+    public func call(_ method: String, args: [String: Any], promise: PNPromise) {
+        switch method {
+        case "fetch":
+            let snapshot = NetInfoModule.snapshot(monitor.currentPath)
+            last = snapshot
+            promise.resolve(snapshot)
+        default:
+            promise.reject("NetInfo has no method '\(method)'", code: "unknown_method")
+        }
+    }
+
+    static func snapshot(_ path: NWPath) -> [String: Any] {
+        let connected = path.status == .satisfied
+        let type: String
+        if !connected {
+            type = "none"
+        } else if path.usesInterfaceType(.wifi) {
+            type = "wifi"
+        } else if path.usesInterfaceType(.cellular) {
+            type = "cellular"
+        } else if path.usesInterfaceType(.wiredEthernet) {
+            type = "ethernet"
+        } else {
+            type = "unknown"
+        }
+        return ["is_connected": connected, "type": type, "is_internet_reachable": connected]
+    }
+}
+
+/// `Linking`: open URLs and deliver inbound deep links.
+///
+/// `deliver(url:)` buffers until Python's callback is registered so a
+/// cold-start deep link reaches `Linking.get_initial_url()`.
+public final class LinkingModule: PNNativeModule {
+    public static let name = "Linking"
+
+    public init() {}
+
+    public func call(_ method: String, args: [String: Any], promise: PNPromise) {
+        switch method {
+        case "open_url":
+            guard let url = PNProps.string(args["url"]).flatMap({ URL(string: $0) }) else { return promise.resolve(false) }
+            let app = UIApplication.shared
+            guard app.canOpenURL(url) || url.scheme?.hasPrefix("http") == true else { return promise.resolve(false) }
+            app.open(url, options: [:]) { _ in }
+            promise.resolve(true)
+        case "can_open_url":
+            guard let url = PNProps.string(args["url"]).flatMap({ URL(string: $0) }) else { return promise.resolve(false) }
+            promise.resolve(UIApplication.shared.canOpenURL(url))
+        case "open_settings":
+            guard let url = URL(string: UIApplication.openSettingsURLString) else { return promise.resolve(false) }
+            UIApplication.shared.open(url, options: [:]) { _ in }
+            promise.resolve(true)
+        default:
+            promise.reject("Linking has no method '\(method)'", code: "unknown_method")
+        }
+    }
+
+    /// Forward an inbound URL as a `url` event (payload: the URL string).
+    public static func deliver(url: String) {
+        PNBridge.shared.whenCallbackRegistered {
+            PNMain.run {
+                PNBridge.shared.callPython(kind: "module", tag: 0, name: name, payload: PNJSON.encode(["event": "url", "payload": url]))
+            }
+        }
+    }
+}

pythonnative/native/ios/Sources/PythonNativeKit/Modules/MediaModules.swift

@@ -0,0 +1,177 @@
+import CoreLocation
+import UIKit
+
+/// `Camera`: `take_photo` / `pick_from_gallery` through `UIImagePickerController`.
+public final class CameraModule: PNNativeModule {
+    public static let name = "Camera"
+
+    private var activePicker: PNImagePickerSession?
+
+    public init() {}
+
+    public func call(_ method: String, args: [String: Any], promise: PNPromise) {
+        let source: UIImagePickerController.SourceType
+        switch method {
+        case "take_photo": source = .camera
+        case "pick_from_gallery": source = .photoLibrary
+        default:
+            promise.reject("Camera has no method '\(method)'", code: "unknown_method")
+            return
+        }
+        guard UIImagePickerController.isSourceTypeAvailable(source), let top = PNWindow.topViewController() else {
+            promise.resolve(nil)
+            return
+        }
+        if activePicker != nil {
+            promise.reject("a picker is already open", code: "busy")
+            return
+        }
+        let quality = PNProps.double(args["quality"]) ?? 0.9
+        let session = PNImagePickerSession(quality: CGFloat(max(0, min(1, quality)))) { [weak self] path in
+            self?.activePicker = nil
+            promise.resolve(path)
+        }
+        activePicker = session
+        let picker = UIImagePickerController()
+        picker.sourceType = source
+        picker.allowsEditing = PNProps.bool(args["allow_editing"]) ?? false
+        picker.delegate = session
+        top.present(picker, animated: true)
+    }
+}
+
+/// Picker delegate that writes the chosen image to Caches and reports its path.
+final class PNImagePickerSession: NSObject, UIImagePickerControllerDelegate, UINavigationControllerDelegate {
+    private let quality: CGFloat
+    private let done: (String?) -> Void
+
+    init(quality: CGFloat, done: @escaping (String?) -> Void) {
+        self.quality = quality
+        self.done = done
+    }
+
+    func imagePickerController(_ picker: UIImagePickerController, didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey: Any]) {
+        picker.dismiss(animated: true)
+        let image = (info[.editedImage] as? UIImage) ?? (info[.originalImage] as? UIImage)
+        guard let image = image, let data = image.jpegData(compressionQuality: quality) else {
+            done(nil)
+            return
+        }
+        let caches = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first ?? URL(fileURLWithPath: NSTemporaryDirectory())
+        let dir = caches.appendingPathComponent("pn_camera", isDirectory: true)
+        try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+        let file = dir.appendingPathComponent("\(UUID().uuidString).jpg")
+        do {
+            try data.write(to: file, options: [.atomic])
+            done(file.path)
+        } catch {
+            PNLog.modules.error("could not save picked image: \(error.localizedDescription)")
+            done(nil)
+        }
+    }
+
+    func imagePickerControllerDidCancel(_ picker: UIImagePickerController) {
+        picker.dismiss(animated: true)
+        done(nil)
+    }
+}
+
+/// `Location`: one-shot `get_current` fix via `CLLocationManager`.
+public final class LocationModule: PNNativeModule {
+    public static let name = "Location"
+
+    private var sessions: [PNLocationSession] = []
+
+    public init() {}
+
+    public func call(_ method: String, args: [String: Any], promise: PNPromise) {
+        guard method == "get_current" else {
+            promise.reject("Location has no method '\(method)'", code: "unknown_method")
+            return
+        }
+        let timeout = PNProps.double(args["timeout"]) ?? 15
+        var session: PNLocationSession?
+        session = PNLocationSession(accuracy: PNProps.string(args["accuracy"]), timeout: timeout) { [weak self] fix in
+            if let finished = session {
+                self?.sessions.removeAll { $0 === finished }
+            }
+            promise.resolve(fix)
+        }
+        guard let started = session else { return }
+        sessions.append(started)
+        started.start()
+    }
+}
+
+/// One location request: authorization, a single fix, and a timeout.
+final class PNLocationSession: NSObject, CLLocationManagerDelegate {
+    private let manager = CLLocationManager()
+    private let done: ([String: Any]?) -> Void
+    private let timeout: TimeInterval
+    private var finished = false
+    private var timer: Timer?
+
+    init(accuracy: String?, timeout: TimeInterval, done: @escaping ([String: Any]?) -> Void) {
+        self.done = done
+        self.timeout = max(1, timeout)
+        super.init()
+        manager.delegate = self
+        switch accuracy {
+        case "high", "best": manager.desiredAccuracy = kCLLocationAccuracyBest
+        case "low", "coarse": manager.desiredAccuracy = kCLLocationAccuracyKilometer
+        default: manager.desiredAccuracy = kCLLocationAccuracyHundredMeters
+        }
+    }
+
+    func start() {
+        timer = Timer.scheduledTimer(withTimeInterval: timeout, repeats: false) { [weak self] _ in
+            self?.finish(nil)
+        }
+        switch manager.pnAuthorizationStatus {
+        case .notDetermined:
+            manager.requestWhenInUseAuthorization()
+        case .denied, .restricted:
+            finish(nil)
+        default:
+            manager.requestLocation()
+        }
+    }
+
+    func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
+        switch manager.pnAuthorizationStatus {
+        case .authorizedAlways, .authorizedWhenInUse:
+            manager.requestLocation()
+        case .denied, .restricted:
+            finish(nil)
+        default:
+            break
+        }
+    }
+
+    func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
+        guard let location = locations.last else { return }
+        var fix: [String: Any] = [
+            "latitude": location.coordinate.latitude,
+            "longitude": location.coordinate.longitude,
+            "accuracy": location.horizontalAccuracy,
+            "altitude": location.altitude,
+            "timestamp": location.timestamp.timeIntervalSince1970,
+        ]
+        if location.speed >= 0 { fix["speed"] = location.speed }
+        if location.course >= 0 { fix["heading"] = location.course }
+        finish(fix)
+    }
+
+    func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
+        PNLog.modules.error("location failed: \(error.localizedDescription)")
+        finish(nil)
+    }
+
+    private func finish(_ fix: [String: Any]?) {
+        if finished { return }
+        finished = true
+        timer?.invalidate()
+        manager.stopUpdatingLocation()
+        done(fix)
+    }
+}

pythonnative/native/ios/Sources/PythonNativeKit/Modules/PNNativeModule.swift

@@ -0,0 +1,168 @@
+import Foundation
+
+/// A named native module callable from Python through `pn_bridge_call`.
+public protocol PNNativeModule: AnyObject {
+    /// The module name Python addresses (`native_module("Clipboard")`).
+    static var name: String { get }
+    init()
+    /// Handle one method call, settling `promise` now or later.
+    func call(_ method: String, args: [String: Any], promise: PNPromise)
+}
+
+/// The settlement handle for one module call.
+///
+/// Resolving or rejecting before `call` returns answers Python inline;
+/// settling afterwards posts `callback("module", 0, module,
+/// {"call_id": n, "ok": ..., ...})` on the main thread.
+public final class PNPromise {
+    public let callId: Int64
+    public let module: String
+    public let method: String
+
+    private(set) var result: [String: Any]?
+    private var returned = false
+    private let lock = NSLock()
+    private var cancellation: (() -> Void)?
+    private(set) public var isCancelled = false
+    var onFinished: (() -> Void)?
+
+    public func onCancel(_ callback: @escaping () -> Void) {
+        lock.lock()
+        let cancelled = isCancelled
+        if !cancelled && result == nil { cancellation = callback }
+        lock.unlock()
+        if cancelled { callback() }
+    }
+
+    func cancel() {
+        lock.lock()
+        guard result == nil && !isCancelled else { lock.unlock(); return }
+        isCancelled = true
+        let callback = cancellation
+        cancellation = nil
+        lock.unlock()
+        onFinished?()
+        callback?()
+    }
+
+    init(callId: Int64, module: String, method: String) {
+        self.callId = callId
+        self.module = module
+        self.method = method
+    }
+
+    /// Whether the promise has been resolved or rejected.
+    public var isSettled: Bool {
+        lock.lock()
+        defer { lock.unlock() }
+        return result != nil || isCancelled
+    }
+
+    /// Settle successfully with `value` (JSON-encodable or `nil`).
+    public func resolve(_ value: Any?) {
+        settle(["ok": true, "value": value ?? NSNull()])
+    }
+
+    /// Settle with an error message and optional machine-readable code.
+    public func reject(_ message: String, code: String? = nil) {
+        var envelope: [String: Any] = ["ok": false, "error": message]
+        if let code = code { envelope["code"] = code }
+        settle(envelope)
+    }
+
+    /// Settle from a Swift `Error`.
+    public func reject(_ error: Error) {
+        reject(error.localizedDescription, code: (error as NSError).domain)
+    }
+
+    private func settle(_ envelope: [String: Any]) {
+        lock.lock()
+        if isCancelled { lock.unlock(); return }
+        if result != nil {
+            lock.unlock()
+            PNLog.rateLimited(PNLog.modules, key: "double-settle", "\(module).\(method) settled twice; ignoring")
+            return
+        }
+        result = envelope
+        cancellation = nil
+        let deliverAsync = returned
+        lock.unlock()
+        onFinished?()
+        if deliverAsync {
+            var payload = envelope
+            payload["call_id"] = callId
+            let module = self.module
+            PNMain.run {
+                PNBridge.shared.callPython(kind: "module", tag: 0, name: module, payload: PNJSON.encode(payload))
+            }
+        }
+    }
+
+    /// Called by the dispatcher once `call` returns: the inline result,
+    /// or `{"pending": true}` when the module will settle later.
+    func takeInlineResult() -> [String: Any] {
+        lock.lock()
+        defer { lock.unlock() }
+        returned = true
+        if let result = result { return result }
+        return ["pending": true]
+    }
+}
+
+/// Unsolicited module events: `callback("module", 0, module, {"event", "payload"})`.
+public enum PNModuleEvents {
+    /// Emit `event` from `module` with `payload` on the main thread.
+    public static func emit(module: String, event: String, payload: [String: Any]) {
+        PNMain.run {
+            PNBridge.shared.callPython(kind: "module", tag: 0, name: module, payload: PNJSON.encode(["event": event, "payload": payload]))
+        }
+    }
+}
+
+/// Main-thread hop that runs inline when already on main.
+public enum PNMain {
+    public static func run(_ block: @escaping () -> Void) {
+        if Thread.isMainThread {
+            block()
+        } else {
+            DispatchQueue.main.async(execute: block)
+        }
+    }
+}
+
+/// Routes `pn_bridge_call` to modules and shapes the reply envelope.
+public final class PNModuleDispatcher {
+    public static let shared = PNModuleDispatcher()
+
+    private init() {}
+    private var pending: [Int64: PNPromise] = [:]
+    private let pendingLock = NSLock()
+
+    private func remove(_ callId: Int64) -> PNPromise? {
+        pendingLock.lock()
+        defer { pendingLock.unlock() }
+        return pending.removeValue(forKey: callId)
+    }
+
+    /// Dispatch one call. `envelope` is `{"call_id": n, "args": {...}}`.
+    public func call(module: String, method: String, envelope: [String: Any]) -> [String: Any] {
+        let callId = Int64(PNProps.int(envelope["call_id"]) ?? 0)
+        let args = PNProps.dict(envelope["args"]) ?? [:]
+        if method == "_pn_cancel" {
+            if let id = PNProps.int(args["call_id"]), let promise = remove(Int64(id)), promise.module == module { promise.cancel() }
+            return ["ok": true, "value": NSNull()]
+        }
+        guard let instance = PNRegistry.shared.module(named: module) else {
+            return ["ok": false, "error": "unknown native module '\(module)'", "code": "unknown_module"]
+        }
+        let promise = PNPromise(callId: callId, module: module, method: method)
+        if callId > 0 {
+            pendingLock.lock()
+            pending[callId] = promise
+            pendingLock.unlock()
+            promise.onFinished = { [weak self] in _ = self?.remove(callId) }
+        }
+        instance.call(method, args: args, promise: promise)
+        return promise.takeInlineResult()
+    }
+}