craft-native 0.0.352 → 0.0.353

package/dist/android/templates/CraftBluetooth.kt.template

@@ -33,6 +33,13 @@ internal class CraftBluetooth(private val context: Context) {
     private var writeId: UUID? = null
     private var notifyId: UUID? = null
     private var connected = false
+    private var streaming = false
+    private val notifications = java.util.ArrayDeque<ByteArray>()
+    private var notificationBytes = 0
+    private var readDone: ((CraftNativeCapabilityResult) -> Unit)? = null
+    private var writeDone: ((CraftNativeCapabilityResult) -> Unit)? = null
+    private var readTimer: Runnable? = null
+    private var writeTimer: Runnable? = null
     private var mtu = 23
     private var connectDone: ((CraftNativeCapabilityResult) -> Unit)? = null
     private var exchangeDone: ((CraftNativeCapabilityResult) -> Unit)? = null
@@ -50,11 +57,13 @@ internal class CraftBluetooth(private val context: Context) {
             val options = args.optJSONObject(0) ?: JSONObject()
             try {
                 when (method) {
-                    "getState" -> done(CraftNativeCapabilityResult(JSONObject().put("available", adapter != null).put("connected", connected).put("scanning", scanDone != null)))
+                    "getState" -> done(CraftNativeCapabilityResult(JSONObject().put("available", adapter != null).put("connected", connected).put("scanning", scanDone != null).put("streaming", true)))
                     "scan" -> scan(options, done)
                     "stopScan" -> { stopScan(failure("CANCELLED", "Bluetooth scan cancelled")); done(CraftNativeCapabilityResult(true)) }
                     "connect" -> connect(options, done)
                     "exchange" -> exchange(options, done)
+                    "read" -> read(options, done)
+                    "write" -> write(options, done)
                     "disconnect" -> { disconnect(); done(CraftNativeCapabilityResult(true)) }
                     else -> done(failure("UNKNOWN_ACTION", "Unsupported Bluetooth method"))
                 }
@@ -124,6 +133,7 @@ internal class CraftBluetooth(private val context: Context) {
         val device = devices[options.optString("id")] ?: throw IllegalArgumentException()
         disconnect()
         serviceId = UUID.fromString(options.getString("service")); writeId = UUID.fromString(options.getString("write")); notifyId = UUID.fromString(options.getString("notify"))
+        streaming = options.optBoolean("stream")
         connectDone = done
         gatt = device.connectGatt(context, false, callbacks, BluetoothDevice.TRANSPORT_LE)
         connectTimer = timer(15000) { failConnection("TIMEOUT", "Device did not connect; wake it and try again") }
@@ -141,7 +151,7 @@ internal class CraftBluetooth(private val context: Context) {
         } }
         override fun onMtuChanged(peer: BluetoothGatt, value: Int, status: Int) { handler.post {
             if (peer !== gatt) return@post
-            if (status != BluetoothGatt.GATT_SUCCESS || value < 185) { failConnection("MTU_TOO_SMALL", "Bluetooth MTU is too small for sensor history"); return@post }
+            if (status != BluetoothGatt.GATT_SUCCESS || value < (if (streaming) 23 else 185)) { failConnection("MTU_TOO_SMALL", "Bluetooth MTU is too small for sensor history"); return@post }
             mtu = value
             if (!peer.discoverServices()) failConnection("CONNECT_FAILED", "Could not discover Bluetooth services")
         } }
@@ -160,15 +170,27 @@ internal class CraftBluetooth(private val context: Context) {
             if (peer !== gatt || descriptor.characteristic !== notifier) return@post
             if (status != BluetoothGatt.GATT_SUCCESS) { failConnection("CONNECT_FAILED", "Could not enable notifications"); return@post }
             connected = true
-            finishConnect(CraftNativeCapabilityResult(JSONObject().put("id", peer.device.address)))
+            finishConnect(CraftNativeCapabilityResult(JSONObject().put("id", peer.device.address).put("maxWrite", minOf(182, mtu - 3))))
         } }
         override fun onCharacteristicWrite(peer: BluetoothGatt, characteristic: BluetoothGattCharacteristic, status: Int) { handler.post {
-            if (peer === gatt && characteristic === writer && status != BluetoothGatt.GATT_SUCCESS) finishExchange(failure("WRITE_FAILED", "Bluetooth write failed"))
+            if (peer !== gatt || characteristic !== writer) return@post
+            if (status != BluetoothGatt.GATT_SUCCESS) {
+                finishWrite(failure("WRITE_FAILED", "Bluetooth write failed"))
+                finishExchange(failure("WRITE_FAILED", "Bluetooth write failed"))
+            } else finishWrite(CraftNativeCapabilityResult(true))
         } }
         override fun onCharacteristicChanged(peer: BluetoothGatt, characteristic: BluetoothGattCharacteristic) {
             val bytes = characteristic.value?.copyOf() ?: return
             handler.post {
-                if (peer !== gatt || characteristic !== notifier || exchangeDone == null) return@post
+                if (peer !== gatt || characteristic !== notifier) return@post
+                if (streaming) {
+                    if (bytes.isEmpty() || bytes.size > 4096) { disconnect(); return@post }
+                    if (readDone != null) { finishRead(CraftNativeCapabilityResult(JSONArray(bytes.map { it.toInt() and 255 }))); return@post }
+                    if (notifications.size >= 512 || notificationBytes + bytes.size > 1048576) { disconnect(); return@post }
+                    notifications.addLast(bytes); notificationBytes += bytes.size
+                    return@post
+                }
+                if (exchangeDone == null) return@post
                 if (bytes.size < responsePrefix.size || !bytes.take(responsePrefix.size).toByteArray().contentEquals(responsePrefix)) return@post
                 if (bytes.size > 4096) finishExchange(failure("INVALID_RESPONSE", "Bluetooth response is too large"))
                 else finishExchange(CraftNativeCapabilityResult(JSONArray(bytes.map { it.toInt() and 255 })))
@@ -185,7 +207,7 @@ internal class CraftBluetooth(private val context: Context) {
         }
     }
     private fun exchange(options: JSONObject, done: (CraftNativeCapabilityResult) -> Unit) {
-        if (exchangeDone != null) { done(failure("BUSY", "A Bluetooth request is running")); return }
+        if (streaming || exchangeDone != null) { done(failure("BUSY", "A Bluetooth request is running or streaming")); return }
         val peer = gatt; val write = writer
         if (!connected || peer == null || write == null) { done(failure("DISCONNECTED", "Bluetooth device is disconnected")); return }
         val bytes = byteArray(options, "bytes", 182)
@@ -201,10 +223,43 @@ internal class CraftBluetooth(private val context: Context) {
         exchangeTimer?.let(handler::removeCallbacks); exchangeTimer = null; responsePrefix = byteArrayOf()
         val done = exchangeDone; exchangeDone = null; done?.invoke(result)
     }
+    private fun finishRead(result: CraftNativeCapabilityResult) {
+        readTimer?.let(handler::removeCallbacks); readTimer = null
+        val done = readDone; readDone = null; done?.invoke(result)
+    }
+    private fun finishWrite(result: CraftNativeCapabilityResult) {
+        writeTimer?.let(handler::removeCallbacks); writeTimer = null
+        val done = writeDone; writeDone = null; done?.invoke(result)
+    }
+    private fun read(options: JSONObject, done: (CraftNativeCapabilityResult) -> Unit) {
+        if (!streaming || !connected) { done(failure("DISCONNECTED", "Bluetooth stream disconnected")); return }
+        if (readDone != null) { done(failure("BUSY", "A Bluetooth read is running")); return }
+        if (!notifications.isEmpty()) {
+            val bytes = notifications.removeFirst(); notificationBytes -= bytes.size
+            done(CraftNativeCapabilityResult(JSONArray(bytes.map { it.toInt() and 255 }))); return
+        }
+        readDone = done
+        readTimer = timer(options.optLong("timeoutMs", 10000).coerceIn(1, 20000)) { finishRead(failure("TIMEOUT", "Bluetooth read timed out")) }
+    }
+    private fun write(options: JSONObject, done: (CraftNativeCapabilityResult) -> Unit) {
+        val peer = gatt; val write = writer
+        if (!streaming || !connected || peer == null || write == null) { done(failure("DISCONNECTED", "Bluetooth stream disconnected")); return }
+        if (writeDone != null) { done(failure("BUSY", "A Bluetooth write is running")); return }
+        val bytes = byteArray(options, "bytes", 182)
+        require(bytes.size <= mtu - 3)
+        write.writeType = if (write.properties and BluetoothGattCharacteristic.PROPERTY_WRITE != 0) BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT else BluetoothGattCharacteristic.WRITE_TYPE_NO_RESPONSE
+        writeDone = done
+        writeTimer = timer(10000) { finishWrite(failure("TIMEOUT", "Bluetooth write timed out")); disconnect() }
+        write.value = bytes
+        if (!peer.writeCharacteristic(write)) finishWrite(failure("WRITE_FAILED", "Bluetooth write queue is busy"))
+    }
     fun disconnect() {
         stopScan(failure("CANCELLED", "Bluetooth scan cancelled"))
         finishConnect(failure("CANCELLED", "Bluetooth connection cancelled"))
         finishExchange(failure("DISCONNECTED", "Bluetooth device disconnected"))
+        finishRead(failure("DISCONNECTED", "Bluetooth stream closed"))
+        finishWrite(failure("DISCONNECTED", "Bluetooth stream closed"))
+        notifications.clear(); notificationBytes = 0; streaming = false
         val old = gatt; gatt = null; connected = false; writer = null; notifier = null; mtu = 23
         runCatching { old?.disconnect(); old?.close() }
     }

package/dist/cli.js

@@ -3047,7 +3047,7 @@ function pinCraftNativeDependency(packagePath, craftVersion) {
 `);
 }
 // package.json
-var version = "0.0.352";
+var version = "0.0.353";
 
 // bin/cli.ts
 var spawnedFrom = process6.env[CRAFT_CLI_SPAWN_MARKER];

package/dist/index.cjs

@@ -375,7 +375,7 @@ function craftBinaryNotFoundMessage(triedPath) {
 `);
 }
 // package.json
-var version = "0.0.352";
+var version = "0.0.353";
 
 // src/sdk-version.ts
 var SDK_VERSION = version;

package/dist/index.js

@@ -117,7 +117,7 @@ function craftBinaryNotFoundMessage(triedPath) {
 `);
 }
 // package.json
-var version = "0.0.352";
+var version = "0.0.353";
 
 // src/sdk-version.ts
 var SDK_VERSION = version;

package/dist/ios/templates/CraftApp.swift

@@ -6011,6 +6011,8 @@ struct CraftWebView: UIViewRepresentable {
                         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 || {}}); },
+                        read: function(options) { return craft._invoke('bluetoothChannel', {method: 'read', options: options || {}}); },
+                        write: function(options) { return craft._invoke('bluetoothChannel', {method: 'write', options: options || {}}); },
                         disconnect: function() { return craft._invoke('bluetoothChannel', {method: 'disconnect'}); }
                     };
                     craft.heartRate = {

package/dist/ios/templates/CraftBluetooth.swift

@@ -30,6 +30,13 @@ final class CraftBluetooth: NSObject, CBCentralManagerDelegate, CBPeripheralDele
     private var exchangeTimer: DispatchWorkItem?
     private var responsePrefix = Data()
     private var connected = false
+    private var streaming = false
+    private var notifications: [Data] = []
+    private var notificationBytes = 0
+    private var readCompletion: Completion?
+    private var readTimer: DispatchWorkItem?
+    private var writeCompletion: Completion?
+    private var writeTimer: DispatchWorkItem?
 
     func perform(method: String, args: [Any], completion: @escaping Completion) {
         if !Thread.isMainThread {
@@ -39,11 +46,13 @@ final class CraftBluetooth: NSObject, CBCentralManagerDelegate, CBPeripheralDele
         let options = args.first as? [String: Any] ?? [:]
         switch method {
         case "getState":
-            completion(.success(["available": true, "connected": connected, "scanning": scanCompletion != nil]))
+            completion(.success(["available": true, "connected": connected, "scanning": scanCompletion != nil, "streaming": true]))
         case "scan": scan(options, completion)
         case "stopScan": stopScan(); completion(.success(true))
         case "connect": connect(options, completion)
         case "exchange": exchange(options, completion)
+        case "write": write(options, completion)
+        case "read": read(options, completion)
         case "disconnect": disconnect(); completion(.success(true))
         default: reject(completion, "Unsupported Bluetooth method", "UNKNOWN_ACTION")
         }
@@ -102,6 +111,8 @@ final class CraftBluetooth: NSObject, CBCentralManagerDelegate, CBPeripheralDele
         central?.stopScan(); scanTimer?.cancel(); scanTimer = nil
         let scan = scanCompletion; scanCompletion = nil; scan?(.failure(failure))
         settleConnect(.failure(failure)); settleExchange(.failure(failure))
+        settleRead(.failure(failure)); settleWrite(.failure(failure))
+        notifications.removeAll(); notificationBytes = 0
         connected = false
     }
 
@@ -131,6 +142,7 @@ final class CraftBluetooth: NSObject, CBCentralManagerDelegate, CBPeripheralDele
         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)
+        streaming = options["stream"] as? Bool == true
         found.delegate = self; connectCompletion = completion
         central?.connect(found, options: nil)
         let timer = DispatchWorkItem { [weak self] in
@@ -161,6 +173,9 @@ final class CraftBluetooth: NSObject, CBCentralManagerDelegate, CBPeripheralDele
     func centralManager(_ central: CBCentralManager, didDisconnectPeripheral peripheral: CBPeripheral, error: Error?) {
         guard peripheral === self.peripheral else { return }
         connected = false; writer = nil; notifier = nil
+        settleRead(.failure(CraftBluetoothError(message: "Bluetooth device disconnected", code: "DISCONNECTED")))
+        settleWrite(.failure(CraftBluetoothError(message: "Bluetooth device disconnected", code: "DISCONNECTED")))
+        notifications.removeAll(); notificationBytes = 0
         settleConnect(.failure(CraftBluetoothError(message: "Bluetooth device disconnected", code: "DISCONNECTED")))
         settleExchange(.failure(CraftBluetoothError(message: "Bluetooth device disconnected", code: "DISCONNECTED")))
     }
@@ -190,11 +205,11 @@ final class CraftBluetooth: NSObject, CBCentralManagerDelegate, CBPeripheralDele
         }
         connected = true
         let id = peripheral.identifier.uuidString
-        settleConnect(.success(["id": id, "name": names[id] ?? peripheral.name ?? ""]))
+        settleConnect(.success(["id": id, "name": names[id] ?? peripheral.name ?? "", "maxWrite": min(182, peripheral.maximumWriteValueLength(for: writer?.properties.contains(.write) == true ? .withResponse : .withoutResponse))]))
     }
 
     private func exchange(_ options: [String: Any], _ completion: @escaping Completion) {
-        guard exchangeCompletion == nil else { return reject(completion, "A Bluetooth request is already running", "BUSY") }
+        guard !streaming, exchangeCompletion == nil else { return reject(completion, "A Bluetooth request is already running or streaming", "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 {
@@ -217,12 +232,28 @@ final class CraftBluetooth: NSObject, CBCentralManagerDelegate, CBPeripheralDele
     }
 
     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")))
+        guard peripheral === self.peripheral, characteristic === writer else { return }
+        if let error {
+            let failure = CraftBluetoothError(message: error.localizedDescription, code: "WRITE_FAILED")
+            settleWrite(.failure(failure)); settleExchange(.failure(failure))
+        } else { settleWrite(.success(true)) }
     }
 
     func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic, error: Error?) {
-        guard peripheral === self.peripheral, characteristic === notifier, exchangeCompletion != nil else { return }
+        guard peripheral === self.peripheral, characteristic === notifier else { return }
+        if streaming {
+            guard error == nil, let data = characteristic.value, !data.isEmpty, data.count <= 4096 else {
+                disconnect(); return
+            }
+            if readCompletion != nil { settleRead(.success(data.map(Int.init))); return }
+            guard notifications.count < 512, notificationBytes + data.count <= 1048576 else {
+                settleRead(.failure(CraftBluetoothError(message: "Bluetooth receive queue overflow", code: "OVERFLOW")))
+                disconnect(); return
+            }
+            notifications.append(data); notificationBytes += data.count
+            return
+        }
+        guard exchangeCompletion != nil else { return }
         guard error == nil, let data = characteristic.value else {
             settleExchange(.failure(CraftBluetoothError(message: "Bluetooth notification failed", code: "READ_FAILED"))); return
         }
@@ -233,8 +264,51 @@ final class CraftBluetooth: NSObject, CBCentralManagerDelegate, CBPeripheralDele
         settleExchange(.success(data.map(Int.init)))
     }
 
+    private func settleRead(_ result: Result<Any, CraftBluetoothError>) {
+        readTimer?.cancel(); readTimer = nil
+        let completion = readCompletion; readCompletion = nil; completion?(result)
+    }
+    private func settleWrite(_ result: Result<Any, CraftBluetoothError>) {
+        writeTimer?.cancel(); writeTimer = nil
+        let completion = writeCompletion; writeCompletion = nil; completion?(result)
+    }
+    private func read(_ options: [String: Any], _ completion: @escaping Completion) {
+        guard streaming, connected else { return reject(completion, "Bluetooth stream disconnected", "DISCONNECTED") }
+        guard readCompletion == nil else { return reject(completion, "A Bluetooth read is running", "BUSY") }
+        if !notifications.isEmpty {
+            let data = notifications.removeFirst(); notificationBytes -= data.count
+            completion(.success(data.map(Int.init))); return
+        }
+        readCompletion = completion
+        let timeout = min(20, max(0.001, (options["timeoutMs"] as? Double ?? 10000) / 1000))
+        let timer = DispatchWorkItem { [weak self] in self?.settleRead(.failure(CraftBluetoothError(message: "Bluetooth read timed out", code: "TIMEOUT"))) }
+        readTimer = timer
+        DispatchQueue.main.asyncAfter(deadline: .now() + timeout, execute: timer)
+    }
+    private func write(_ options: [String: Any], _ completion: @escaping Completion) {
+        guard streaming, connected, let peripheral, let writer else { return reject(completion, "Bluetooth stream disconnected", "DISCONNECTED") }
+        guard writeCompletion == nil else { return reject(completion, "A Bluetooth write is running", "BUSY") }
+        guard let bytes = options["bytes"] as? [Int], !bytes.isEmpty, bytes.count <= 182, bytes.allSatisfy({ (0...255).contains($0) }) else { return reject(completion, "Invalid Bluetooth bytes", "INVALID_ARGUMENT") }
+        let type: CBCharacteristicWriteType = writer.properties.contains(.write) ? .withResponse : .withoutResponse
+        guard bytes.count <= peripheral.maximumWriteValueLength(for: type) else { return reject(completion, "Bluetooth write exceeds MTU", "MTU_TOO_SMALL") }
+        if type == .withoutResponse, !peripheral.canSendWriteWithoutResponse { return reject(completion, "Bluetooth queue busy", "BUSY") }
+        if type == .withResponse {
+            writeCompletion = completion
+            let timer = DispatchWorkItem { [weak self] in
+                self?.settleWrite(.failure(CraftBluetoothError(message: "Bluetooth write timed out", code: "TIMEOUT")))
+                self?.disconnect()
+            }
+            writeTimer = timer
+            DispatchQueue.main.asyncAfter(deadline: .now() + 10, execute: timer)
+        }
+        peripheral.writeValue(Data(bytes.map(UInt8.init)), for: writer, type: type)
+        if type == .withoutResponse { completion(.success(true)) }
+    }
     private func disconnect() {
         stopScan()
+        settleRead(.failure(CraftBluetoothError(message: "Bluetooth stream closed", code: "DISCONNECTED")))
+        settleWrite(.failure(CraftBluetoothError(message: "Bluetooth stream closed", code: "DISCONNECTED")))
+        notifications.removeAll(); notificationBytes = 0; streaming = false
         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 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "craft-native",
-  "version": "0.0.352",
+  "version": "0.0.353",
   "type": "module",
   "description": "Build desktop apps with web languages - TypeScript SDK for Craft",
   "author": "Chris Breuer <chris@stacksjs.org>",