@craft-native/ios 0.0.177 → 0.0.178

package/dist/cli.js

@@ -871,6 +871,7 @@ function writeShell(output, config) {
   cpSync(join3(TEMPLATES_DIR, "CraftNativeActions.swift"), join3(output, "Sources", "CraftNativeActions.swift"));
   cpSync(join3(TEMPLATES_DIR, "CraftHealth.swift"), join3(output, "Sources", "CraftHealth.swift"));
   cpSync(join3(TEMPLATES_DIR, "CraftMusic.swift"), join3(output, "Sources", "CraftMusic.swift"));
+  cpSync(join3(TEMPLATES_DIR, "CraftBluetooth.swift"), join3(output, "Sources", "CraftBluetooth.swift"));
   cpSync(join3(TEMPLATES_DIR, "CraftHeartRate.swift"), join3(output, "Sources", "CraftHeartRate.swift"));
   cpSync(join3(TEMPLATES_DIR, "CraftScheduledWorkouts.swift"), join3(output, "Sources", "CraftScheduledWorkouts.swift"));
   cpSync(join3(TEMPLATES_DIR, "CraftNativeMutation.swift"), join3(output, "Sources", "CraftNativeMutation.swift"));

package/dist/index.js

@@ -1003,6 +1003,7 @@ function writeShell(output, config) {
   cpSync(join3(TEMPLATES_DIR, "CraftNativeActions.swift"), join3(output, "Sources", "CraftNativeActions.swift"));
   cpSync(join3(TEMPLATES_DIR, "CraftHealth.swift"), join3(output, "Sources", "CraftHealth.swift"));
   cpSync(join3(TEMPLATES_DIR, "CraftMusic.swift"), join3(output, "Sources", "CraftMusic.swift"));
+  cpSync(join3(TEMPLATES_DIR, "CraftBluetooth.swift"), join3(output, "Sources", "CraftBluetooth.swift"));
   cpSync(join3(TEMPLATES_DIR, "CraftHeartRate.swift"), join3(output, "Sources", "CraftHeartRate.swift"));
   cpSync(join3(TEMPLATES_DIR, "CraftScheduledWorkouts.swift"), join3(output, "Sources", "CraftScheduledWorkouts.swift"));
   cpSync(join3(TEMPLATES_DIR, "CraftNativeMutation.swift"), join3(output, "Sources", "CraftNativeMutation.swift"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@craft-native/ios",
-  "version": "0.0.177",
+  "version": "0.0.178",
   "homepage": "https://github.com/craft-native/craft/tree/main/packages/ios#readme",
   "repository": {
     "type": "git",

package/templates/CraftApp.swift

@@ -2564,6 +2564,17 @@ struct CraftWebView: UIViewRepresentable {
                     rejectCallback(callbackId, error: "Local database is disabled", code: "CAPABILITY_DISABLED")
                 }
             // MARK: - Bluetooth
+            case "bluetoothChannel":
+                guard config.enableBluetooth else {
+                    rejectCallback(callbackId, error: "Bluetooth is disabled", code: "CAPABILITY_DISABLED")
+                    break
+                }
+                CraftBluetooth.shared.perform(method: body["method"] as? String ?? "", args: [body["options"] as? [String: Any] ?? [:]]) { [weak self] result in
+                    switch result {
+                    case .success(let value): self?.resolveCallback(callbackId, result: value)
+                    case .failure(let error): self?.rejectCallback(callbackId, error: error.message, code: error.code)
+                    }
+                }
             case "startBluetoothScan":
                 if config.enableBluetooth {
                     startBluetoothScan(callbackId: callbackId)
@@ -5288,6 +5299,14 @@ struct CraftWebView: UIViewRepresentable {
                 // natively, screen locked or app closed, until stopRecording().
                 (function() {
                     function heartRate(method, options) { return craft._invoke('heartRate', {method: method, options: options || {}}); }
+                    craft.bluetooth = {
+                        getState: function() { return craft._invoke('bluetoothChannel', {method: 'getState'}); },
+                        scan: function(options) { return craft._invoke('bluetoothChannel', {method: 'scan', options: options || {}}); },
+                        stopScan: function() { return craft._invoke('bluetoothChannel', {method: 'stopScan'}); },
+                        connect: function(options) { return craft._invoke('bluetoothChannel', {method: 'connect', options: options || {}}); },
+                        exchange: function(options) { return craft._invoke('bluetoothChannel', {method: 'exchange', options: options || {}}); },
+                        disconnect: function() { return craft._invoke('bluetoothChannel', {method: 'disconnect'}); }
+                    };
                     craft.heartRate = {
                         getState: function() { return heartRate('getState'); },
                         requestAuthorization: function() { return craft._invoke('heartRateRequestAuthorization'); },

package/templates/CraftBluetooth.swift

@@ -0,0 +1,243 @@
+import CoreBluetooth
+import Foundation
+
+struct CraftBluetoothError: Error {
+    let message: String
+    let code: String
+}
+
+/// One explicitly chosen GATT channel. Scanning is user initiated; no vendor API.
+final class CraftBluetooth: NSObject, CBCentralManagerDelegate, CBPeripheralDelegate {
+    typealias Completion = (Result<Any, CraftBluetoothError>) -> Void
+    static let shared = CraftBluetooth()
+    private var central: CBCentralManager?
+    private var devices: [String: CBPeripheral] = [:]
+    private var names: [String: String] = [:]
+    private var strengths: [String: Int] = [:]
+    private var scanServices: [CBUUID] = []
+    private var namePrefix = ""
+    private var scanCompletion: Completion?
+    private var scanTimer: DispatchWorkItem?
+    private var peripheral: CBPeripheral?
+    private var serviceUUID: CBUUID?
+    private var writeUUID: CBUUID?
+    private var notifyUUID: CBUUID?
+    private var writer: CBCharacteristic?
+    private var notifier: CBCharacteristic?
+    private var connectCompletion: Completion?
+    private var connectTimer: DispatchWorkItem?
+    private var exchangeCompletion: Completion?
+    private var exchangeTimer: DispatchWorkItem?
+    private var responsePrefix = Data()
+    private var connected = false
+
+    func perform(method: String, args: [Any], completion: @escaping Completion) {
+        if !Thread.isMainThread {
+            DispatchQueue.main.async { self.perform(method: method, args: args, completion: completion) }
+            return
+        }
+        let options = args.first as? [String: Any] ?? [:]
+        switch method {
+        case "getState":
+            completion(.success(["available": true, "connected": connected, "scanning": scanCompletion != nil]))
+        case "scan": scan(options, completion)
+        case "stopScan": stopScan(); completion(.success(true))
+        case "connect": connect(options, completion)
+        case "exchange": exchange(options, completion)
+        case "disconnect": disconnect(); completion(.success(true))
+        default: reject(completion, "Unsupported Bluetooth method", "UNKNOWN_ACTION")
+        }
+    }
+
+    private func reject(_ completion: Completion, _ message: String, _ code: String) {
+        completion(.failure(CraftBluetoothError(message: message, code: code)))
+    }
+
+    private func ensureCentral() {
+        if central == nil { central = CBCentralManager(delegate: self, queue: .main) }
+    }
+
+    private func scan(_ options: [String: Any], _ completion: @escaping Completion) {
+        guard scanCompletion == nil, connectCompletion == nil, exchangeCompletion == nil else {
+            return reject(completion, "A Bluetooth operation is already running", "BUSY")
+        }
+        guard let services = options["services"] as? [String], !services.isEmpty, services.count <= 8,
+              services.allSatisfy({ UUID(uuidString: $0) != nil }) else {
+            return reject(completion, "Scan needs full service UUIDs", "INVALID_ARGUMENT")
+        }
+        let timeout = min(20, max(1, (options["timeoutMs"] as? Double ?? 10000) / 1000))
+        scanServices = services.map(CBUUID.init(string:))
+        namePrefix = options["namePrefix"] as? String ?? ""
+        devices.removeAll(); names.removeAll(); strengths.removeAll()
+        scanCompletion = completion
+        ensureCentral()
+        if central?.state == .poweredOn { startScan() }
+        else if let state = central?.state, state != .unknown, state != .resetting { rejectRadio(state); return }
+        let timer = DispatchWorkItem { [weak self] in self?.finishScan() }
+        scanTimer = timer
+        DispatchQueue.main.asyncAfter(deadline: .now() + timeout, execute: timer)
+    }
+
+    private func startScan() {
+        guard scanCompletion != nil else { return }
+        central?.scanForPeripherals(withServices: scanServices, options: [CBCentralManagerScanOptionAllowDuplicatesKey: false])
+    }
+
+    private func finishScan() {
+        central?.stopScan(); scanTimer?.cancel(); scanTimer = nil
+        let completion = scanCompletion; scanCompletion = nil
+        let rows: [[String: Any]] = devices.keys.sorted().map { ["id": $0, "name": names[$0] ?? "", "rssi": strengths[$0] ?? -127] }
+        completion?(.success(rows))
+    }
+
+    private func stopScan() {
+        central?.stopScan(); scanTimer?.cancel(); scanTimer = nil
+        let completion = scanCompletion; scanCompletion = nil
+        if let completion { reject(completion, "Bluetooth scan cancelled", "CANCELLED") }
+    }
+
+    private func rejectRadio(_ state: CBManagerState) {
+        let code = state == .unauthorized ? "NOT_AUTHORIZED" : state == .poweredOff ? "BLUETOOTH_OFF" : "UNSUPPORTED"
+        let failure = CraftBluetoothError(message: "Bluetooth is not available", code: code)
+        central?.stopScan(); scanTimer?.cancel(); scanTimer = nil
+        let scan = scanCompletion; scanCompletion = nil; scan?(.failure(failure))
+        settleConnect(.failure(failure)); settleExchange(.failure(failure))
+        connected = false
+    }
+
+    func centralManagerDidUpdateState(_ central: CBCentralManager) {
+        if central.state == .poweredOn { startScan() }
+        else if central.state != .unknown, central.state != .resetting { rejectRadio(central.state) }
+    }
+
+    func centralManager(_ central: CBCentralManager, didDiscover peripheral: CBPeripheral, advertisementData: [String: Any], rssi RSSI: NSNumber) {
+        guard scanCompletion != nil, devices.count < 64 else { return }
+        let name = advertisementData[CBAdvertisementDataLocalNameKey] as? String ?? peripheral.name ?? ""
+        guard namePrefix.isEmpty || name.lowercased().hasPrefix(namePrefix.lowercased()) else { return }
+        let id = peripheral.identifier.uuidString
+        devices[id] = peripheral; names[id] = name; strengths[id] = RSSI.intValue
+    }
+
+    private func connect(_ options: [String: Any], _ completion: @escaping Completion) {
+        guard scanCompletion == nil, connectCompletion == nil, exchangeCompletion == nil else {
+            return reject(completion, "A Bluetooth operation is already running", "BUSY")
+        }
+        guard let id = options["id"] as? String, let found = devices[id],
+              let service = options["service"] as? String, UUID(uuidString: service) != nil,
+              let write = options["write"] as? String, UUID(uuidString: write) != nil,
+              let notify = options["notify"] as? String, UUID(uuidString: notify) != nil else {
+            return reject(completion, "Choose a nearby device and its GATT channel", "INVALID_ARGUMENT")
+        }
+        guard central?.state == .poweredOn else { return reject(completion, "Bluetooth is off", "BLUETOOTH_OFF") }
+        disconnect()
+        peripheral = found; serviceUUID = CBUUID(string: service); writeUUID = CBUUID(string: write); notifyUUID = CBUUID(string: notify)
+        found.delegate = self; connectCompletion = completion
+        central?.connect(found, options: nil)
+        let timer = DispatchWorkItem { [weak self] in
+            guard let self else { return }
+            self.settleConnect(.failure(CraftBluetoothError(message: "Device did not connect; wake it and try again", code: "TIMEOUT")))
+            self.disconnect()
+        }
+        connectTimer = timer
+        DispatchQueue.main.asyncAfter(deadline: .now() + 15, execute: timer)
+    }
+
+    private func settleConnect(_ result: Result<Any, CraftBluetoothError>) {
+        connectTimer?.cancel(); connectTimer = nil
+        let completion = connectCompletion; connectCompletion = nil; completion?(result)
+    }
+
+    func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) {
+        guard peripheral === self.peripheral, let serviceUUID else { return }
+        peripheral.discoverServices([serviceUUID])
+    }
+
+    func centralManager(_ central: CBCentralManager, didFailToConnect peripheral: CBPeripheral, error: Error?) {
+        guard peripheral === self.peripheral else { return }
+        settleConnect(.failure(CraftBluetoothError(message: "Bluetooth connection failed", code: "CONNECT_FAILED")))
+        disconnect()
+    }
+
+    func centralManager(_ central: CBCentralManager, didDisconnectPeripheral peripheral: CBPeripheral, error: Error?) {
+        guard peripheral === self.peripheral else { return }
+        connected = false; writer = nil; notifier = nil
+        settleConnect(.failure(CraftBluetoothError(message: "Bluetooth device disconnected", code: "DISCONNECTED")))
+        settleExchange(.failure(CraftBluetoothError(message: "Bluetooth device disconnected", code: "DISCONNECTED")))
+    }
+
+    func peripheral(_ peripheral: CBPeripheral, didDiscoverServices error: Error?) {
+        guard peripheral === self.peripheral else { return }
+        guard error == nil, let service = peripheral.services?.first(where: { $0.uuid == serviceUUID }), let writeUUID, let notifyUUID else {
+            settleConnect(.failure(CraftBluetoothError(message: "The selected GATT service is missing", code: "UNSUPPORTED_DEVICE"))); disconnect(); return
+        }
+        peripheral.discoverCharacteristics([writeUUID, notifyUUID], for: service)
+    }
+
+    func peripheral(_ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error: Error?) {
+        guard peripheral === self.peripheral else { return }
+        writer = service.characteristics?.first(where: { $0.uuid == writeUUID })
+        notifier = service.characteristics?.first(where: { $0.uuid == notifyUUID })
+        guard error == nil, let writer, let notifier, writer.properties.contains(.write) || writer.properties.contains(.writeWithoutResponse), notifier.properties.contains(.notify) else {
+            settleConnect(.failure(CraftBluetoothError(message: "The selected GATT channel is missing", code: "UNSUPPORTED_DEVICE"))); disconnect(); return
+        }
+        peripheral.setNotifyValue(true, for: notifier)
+    }
+
+    func peripheral(_ peripheral: CBPeripheral, didUpdateNotificationStateFor characteristic: CBCharacteristic, error: Error?) {
+        guard peripheral === self.peripheral, characteristic === notifier else { return }
+        guard error == nil, characteristic.isNotifying else {
+            settleConnect(.failure(CraftBluetoothError(message: "Could not subscribe to the device", code: "CONNECT_FAILED"))); disconnect(); return
+        }
+        connected = true
+        let id = peripheral.identifier.uuidString
+        settleConnect(.success(["id": id, "name": names[id] ?? peripheral.name ?? ""]))
+    }
+
+    private func exchange(_ options: [String: Any], _ completion: @escaping Completion) {
+        guard exchangeCompletion == nil else { return reject(completion, "A Bluetooth request is already running", "BUSY") }
+        guard connected, let peripheral, let writer else { return reject(completion, "Bluetooth device is disconnected", "DISCONNECTED") }
+        guard let bytes = options["bytes"] as? [Int], !bytes.isEmpty, bytes.count <= 182, bytes.allSatisfy({ (0...255).contains($0) }),
+              let prefix = options["responsePrefix"] as? [Int], !prefix.isEmpty, prefix.count <= 16, prefix.allSatisfy({ (0...255).contains($0) }) else {
+            return reject(completion, "Invalid Bluetooth request bytes", "INVALID_ARGUMENT")
+        }
+        let type: CBCharacteristicWriteType = writer.properties.contains(.write) ? .withResponse : .withoutResponse
+        guard bytes.count <= peripheral.maximumWriteValueLength(for: type) else { return reject(completion, "Bluetooth request exceeds the negotiated MTU", "MTU_TOO_SMALL") }
+        if type == .withoutResponse, !peripheral.canSendWriteWithoutResponse { return reject(completion, "Bluetooth write queue is busy; retry", "BUSY") }
+        responsePrefix = Data(prefix.map(UInt8.init)); exchangeCompletion = completion
+        let timeout = min(20, max(1, (options["timeoutMs"] as? Double ?? 10000) / 1000))
+        let timer = DispatchWorkItem { [weak self] in self?.settleExchange(.failure(CraftBluetoothError(message: "Bluetooth device did not answer", code: "TIMEOUT"))) }
+        exchangeTimer = timer
+        DispatchQueue.main.asyncAfter(deadline: .now() + timeout, execute: timer)
+        peripheral.writeValue(Data(bytes.map(UInt8.init)), for: writer, type: type)
+    }
+
+    private func settleExchange(_ result: Result<Any, CraftBluetoothError>) {
+        exchangeTimer?.cancel(); exchangeTimer = nil
+        let completion = exchangeCompletion; exchangeCompletion = nil; responsePrefix = Data(); completion?(result)
+    }
+
+    func peripheral(_ peripheral: CBPeripheral, didWriteValueFor characteristic: CBCharacteristic, error: Error?) {
+        guard peripheral === self.peripheral, characteristic === writer, error != nil else { return }
+        settleExchange(.failure(CraftBluetoothError(message: "Bluetooth write failed", code: "WRITE_FAILED")))
+    }
+
+    func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic, error: Error?) {
+        guard peripheral === self.peripheral, characteristic === notifier, exchangeCompletion != nil else { return }
+        guard error == nil, let data = characteristic.value else {
+            settleExchange(.failure(CraftBluetoothError(message: "Bluetooth notification failed", code: "READ_FAILED"))); return
+        }
+        guard data.starts(with: responsePrefix) else { return }
+        guard data.count <= 4096 else {
+            settleExchange(.failure(CraftBluetoothError(message: "Bluetooth response is too large", code: "INVALID_RESPONSE"))); return
+        }
+        settleExchange(.success(data.map(Int.init)))
+    }
+
+    private func disconnect() {
+        stopScan()
+        settleConnect(.failure(CraftBluetoothError(message: "Bluetooth connection cancelled", code: "CANCELLED")))
+        settleExchange(.failure(CraftBluetoothError(message: "Bluetooth request cancelled", code: "CANCELLED")))
+        if let peripheral { central?.cancelPeripheralConnection(peripheral); peripheral.delegate = nil }
+        peripheral = nil; writer = nil; notifier = nil; connected = false
+    }
+}

package/templates/CraftNativeActions.swift

@@ -70,6 +70,7 @@ enum CraftNativeActions {
         // A heart-rate strap is the app's own service (CraftHeartRate.swift),
         // so it needs no web view.
         if config.enableHeartRate { values.append("heartRate") }
+        if config.enableBluetooth { values.append("bluetooth") }
         // Workouts on the paired Apple Watch (CraftScheduledWorkouts.swift),
         // also the app's own service.
         if config.enableScheduledWorkouts { values.append("scheduledWorkouts") }
@@ -401,6 +402,15 @@ enum CraftNativeActions {
             }
             CraftWebServices.perform(action: action, body: args.first as? [String: Any] ?? [:]) { complete(requestToken, $0, completion) }
             return
+        case ("Bluetooth", _):
+            guard config.enableBluetooth else {
+                complete(requestToken, failure("CAPABILITY_DISABLED", "Bluetooth is disabled"), completion)
+                return
+            }
+            CraftBluetooth.shared.perform(method: method, args: args) { result in
+                complete(requestToken, result.mapError { CraftNativeActionError(code: $0.code, message: $0.message) }, completion)
+            }
+            return
         case ("HeartRate", _):
             // A Bluetooth heart-rate strap, the same service as a page's
             // `craft.heartRate`: one connection and one recording, whichever