craft-native 0.0.177 → 0.0.178

package/dist/android/src/index.d.ts

@@ -25,6 +25,7 @@ export interface CraftAndroidConfig {
     enableSecureStorage?: boolean;
     enableGeolocation?: boolean;
     enableBackgroundLocation?: boolean;
+    enableBluetooth?: boolean;
     enableHealthConnect?: boolean;
     /**
      * The Health Connect data the app reads and writes, by the shared type

package/dist/android/src/index.js

@@ -183,6 +183,7 @@ var DEFAULT_CONFIG = {
   enableSecureStorage: false,
   enableGeolocation: false,
   enableBackgroundLocation: false,
+  enableBluetooth: false,
   enableHealthConnect: false,
   enableKeepAwake: false,
   enableDeepLinks: false,
@@ -371,7 +372,15 @@ function renderAndroidPermissions(config) {
     healthConnectPermissions(config).forEach((permission) => permissions.add(permission));
   if (config.renderer === "native" && config.backgroundRefresh?.enabled)
     permissions.add("android.permission.RECEIVE_BOOT_COMPLETED");
-  return [...permissions].map((permission) => `    <uses-permission android:name="${permission}" />`).join(`
+  const bluetooth = config.enableBluetooth ? [
+    '    <uses-permission android:name="android.permission.BLUETOOTH" android:maxSdkVersion="30" />',
+    '    <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" android:maxSdkVersion="30" />',
+    '    <uses-permission android:name="android.permission.BLUETOOTH_SCAN" android:usesPermissionFlags="neverForLocation" />',
+    '    <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />',
+    ...config.enableGeolocation ? [] : ['    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" android:maxSdkVersion="30" />']
+  ].join(`
+`) : "";
+  return [bluetooth, ...[...permissions].map((permission) => `    <uses-permission android:name="${permission}" />`)].filter(Boolean).join(`
 `);
 }
 function writeNativeShellSources(output, packagePath, packageName, config) {
@@ -380,6 +389,7 @@ function writeNativeShellSources(output, packagePath, packageName, config) {
     const source = readFileSync(join(TEMPLATES_DIR, template), "utf-8").replace(/\{\{PACKAGE_NAME\}\}/g, packageName);
     writeFileSync(join(javaDir, file), replace(source));
   };
+  write("CraftBluetooth.kt.template", "CraftBluetooth.kt");
   write("CraftNativeShell.kt.template", "CraftNativeShell.kt");
   write("CraftNativeBackground.kt.template", "CraftNativeBackground.kt");
   write(config.enableHealthConnect ? "CraftNativeHealth.kt.template" : "CraftNativeHealthStub.kt.template", "CraftNativeHealth.kt");

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

@@ -0,0 +1,211 @@
+package {{PACKAGE_NAME}}
+
+import android.Manifest
+import android.app.Activity
+import android.bluetooth.*
+import android.bluetooth.le.*
+import android.content.Context
+import android.content.pm.PackageManager
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.os.ParcelUuid
+import androidx.core.app.ActivityCompat
+import androidx.core.content.ContextCompat
+import org.json.JSONArray
+import org.json.JSONObject
+import java.util.UUID
+
+/** A selected GATT channel; one request/notification exchange at a time. */
+@Suppress("MissingPermission", "DEPRECATION")
+internal class CraftBluetooth(private val context: Context) {
+    private val handler = Handler(Looper.getMainLooper())
+    private val adapter get() = (context.getSystemService(Context.BLUETOOTH_SERVICE) as? BluetoothManager)?.adapter
+    private val devices = linkedMapOf<String, BluetoothDevice>()
+    private val rows = linkedMapOf<String, JSONObject>()
+    private var scanDone: ((CraftNativeCapabilityResult) -> Unit)? = null
+    private var permissionScan: JSONObject? = null
+    private var prefix = ""
+    private var gatt: BluetoothGatt? = null
+    private var writer: BluetoothGattCharacteristic? = null
+    private var notifier: BluetoothGattCharacteristic? = null
+    private var serviceId: UUID? = null
+    private var writeId: UUID? = null
+    private var notifyId: UUID? = null
+    private var connected = false
+    private var mtu = 23
+    private var connectDone: ((CraftNativeCapabilityResult) -> Unit)? = null
+    private var exchangeDone: ((CraftNativeCapabilityResult) -> Unit)? = null
+    private var responsePrefix = byteArrayOf()
+    private var scanTimer: Runnable? = null
+    private var connectTimer: Runnable? = null
+    private var exchangeTimer: Runnable? = null
+    private fun failure(code: String, message: String) = CraftNativeCapabilityResult(code = code, message = message)
+    private fun timer(ms: Long, action: () -> Unit) = Runnable(action).also { handler.postDelayed(it, ms) }
+    private fun permitted() = permissions().all { ContextCompat.checkSelfPermission(context, it) == PackageManager.PERMISSION_GRANTED }
+    private fun permissions() = if (Build.VERSION.SDK_INT >= 31) arrayOf(Manifest.permission.BLUETOOTH_SCAN, Manifest.permission.BLUETOOTH_CONNECT) else arrayOf(Manifest.permission.ACCESS_FINE_LOCATION)
+
+    fun perform(method: String, args: JSONArray, done: (CraftNativeCapabilityResult) -> Unit) {
+        handler.post {
+            val options = args.optJSONObject(0) ?: JSONObject()
+            try {
+                when (method) {
+                    "getState" -> done(CraftNativeCapabilityResult(JSONObject().put("available", adapter != null).put("connected", connected).put("scanning", scanDone != null)))
+                    "scan" -> scan(options, done)
+                    "stopScan" -> { stopScan(failure("CANCELLED", "Bluetooth scan cancelled")); done(CraftNativeCapabilityResult(true)) }
+                    "connect" -> connect(options, done)
+                    "exchange" -> exchange(options, done)
+                    "disconnect" -> { disconnect(); done(CraftNativeCapabilityResult(true)) }
+                    else -> done(failure("UNKNOWN_ACTION", "Unsupported Bluetooth method"))
+                }
+            } catch (_: SecurityException) { disconnect(); done(failure("NOT_AUTHORIZED", "Bluetooth permission is required")) }
+              catch (_: IllegalArgumentException) { done(failure("INVALID_ARGUMENT", "Invalid Bluetooth channel options")) }
+        }
+    }
+
+    private fun scan(options: JSONObject, done: (CraftNativeCapabilityResult) -> Unit) {
+        if (scanDone != null || connectDone != null || exchangeDone != null) { done(failure("BUSY", "A Bluetooth operation is running")); return }
+        val services = options.optJSONArray("services") ?: throw IllegalArgumentException()
+        require(services.length() in 1..8)
+        (0 until services.length()).forEach { UUID.fromString(services.getString(it)) }
+        scanDone = done
+        if (!permitted()) {
+            val activity = context as? Activity
+            if (activity == null) { stopScan(failure("NEEDS_ACTIVITY", "Bluetooth setup needs a screen")); return }
+            permissionScan = options
+            ActivityCompat.requestPermissions(activity, permissions(), 4317)
+            return
+        }
+        startScan(options)
+    }
+
+    fun onPermissions(requestCode: Int) {
+        if (requestCode != 4317) return
+        val options = permissionScan ?: return
+        permissionScan = null
+        if (!permitted()) stopScan(failure("NOT_AUTHORIZED", "Allow Nearby devices to find your bottle"))
+        else try { startScan(options) } catch (_: Exception) { stopScan(failure("SCAN_FAILED", "Bluetooth scan could not start")) }
+    }
+
+    private fun startScan(options: JSONObject) {
+        val radio = adapter
+        if (radio == null || !radio.isEnabled) { stopScan(failure("BLUETOOTH_OFF", "Turn on Bluetooth")); return }
+        devices.clear(); rows.clear()
+        prefix = options.optString("namePrefix")
+        val services = options.getJSONArray("services")
+        val filters = (0 until services.length()).map { ScanFilter.Builder().setServiceUuid(ParcelUuid(UUID.fromString(services.getString(it)))).build() }
+        radio.bluetoothLeScanner.startScan(filters, ScanSettings.Builder().setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY).build(), scanner)
+        scanTimer = timer(options.optLong("timeoutMs", 10000).coerceIn(1000, 20000)) {
+            stopScan(CraftNativeCapabilityResult(JSONArray(rows.values.toList())))
+        }
+    }
+    private val scanner = object : ScanCallback() {
+        override fun onScanResult(callbackType: Int, result: ScanResult) {
+            handler.post {
+                if (scanDone == null || rows.size >= 64) return@post
+                val name = result.scanRecord?.deviceName ?: ""
+                if (!name.startsWith(prefix, ignoreCase = true)) return@post
+                val id = result.device.address
+                devices[id] = result.device
+                rows[id] = JSONObject().put("id", id).put("name", name).put("rssi", result.rssi)
+            }
+        }
+        override fun onScanFailed(errorCode: Int) { handler.post { stopScan(failure("SCAN_FAILED", "Bluetooth scan failed ($errorCode)")) } }
+    }
+    private fun stopScan(result: CraftNativeCapabilityResult) {
+        if (permitted()) runCatching { adapter?.bluetoothLeScanner?.stopScan(scanner) }
+        scanTimer?.let(handler::removeCallbacks); scanTimer = null; permissionScan = null
+        val done = scanDone; scanDone = null; done?.invoke(result)
+    }
+
+    private fun connect(options: JSONObject, done: (CraftNativeCapabilityResult) -> Unit) {
+        if (scanDone != null || connectDone != null || exchangeDone != null) { done(failure("BUSY", "A Bluetooth operation is running")); return }
+        if (!permitted()) { done(failure("NOT_AUTHORIZED", "Bluetooth permission is required")); return }
+        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"))
+        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") }
+    }
+    private fun finishConnect(result: CraftNativeCapabilityResult) {
+        connectTimer?.let(handler::removeCallbacks); connectTimer = null
+        val done = connectDone; connectDone = null; done?.invoke(result)
+    }
+    private fun failConnection(code: String, message: String) { finishConnect(failure(code, message)); disconnect() }
+    private val callbacks = object : BluetoothGattCallback() {
+        override fun onConnectionStateChange(peer: BluetoothGatt, status: Int, newState: Int) { handler.post {
+            if (peer !== gatt) return@post
+            if (status != BluetoothGatt.GATT_SUCCESS || newState == BluetoothProfile.STATE_DISCONNECTED) { failConnection("DISCONNECTED", "Bluetooth device disconnected"); return@post }
+            if (newState == BluetoothProfile.STATE_CONNECTED && !peer.requestMtu(247)) failConnection("MTU_TOO_SMALL", "Could not negotiate Bluetooth MTU")
+        } }
+        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 }
+            mtu = value
+            if (!peer.discoverServices()) failConnection("CONNECT_FAILED", "Could not discover Bluetooth services")
+        } }
+        override fun onServicesDiscovered(peer: BluetoothGatt, status: Int) { handler.post {
+            if (peer !== gatt) return@post
+            val service = serviceId?.let(peer::getService)
+            writer = writeId?.let { service?.getCharacteristic(it) }; notifier = notifyId?.let { service?.getCharacteristic(it) }
+            val write = writer; val notify = notifier
+            if (status != BluetoothGatt.GATT_SUCCESS || write == null || notify == null || write.properties and (BluetoothGattCharacteristic.PROPERTY_WRITE or BluetoothGattCharacteristic.PROPERTY_WRITE_NO_RESPONSE) == 0 || notify.properties and BluetoothGattCharacteristic.PROPERTY_NOTIFY == 0) { failConnection("UNSUPPORTED_DEVICE", "The selected GATT channel is missing"); return@post }
+            val descriptor = notify.getDescriptor(UUID.fromString("00002902-0000-1000-8000-00805f9b34fb"))
+            if (descriptor == null || !peer.setCharacteristicNotification(notify, true)) { failConnection("CONNECT_FAILED", "Could not subscribe to the device"); return@post }
+            descriptor.value = BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE
+            if (!peer.writeDescriptor(descriptor)) failConnection("CONNECT_FAILED", "Could not enable notifications")
+        } }
+        override fun onDescriptorWrite(peer: BluetoothGatt, descriptor: BluetoothGattDescriptor, status: Int) { handler.post {
+            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)))
+        } }
+        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"))
+        } }
+        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 (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 })))
+            }
+        }
+    }
+    private fun byteArray(options: JSONObject, name: String, max: Int): ByteArray {
+        val values = options.getJSONArray(name)
+        require(values.length() in 1..max)
+        return ByteArray(values.length()) { index ->
+            val value = values.get(index)
+            require(value is Number && value.toDouble() == value.toInt().toDouble() && value.toInt() in 0..255)
+            value.toInt().toByte()
+        }
+    }
+    private fun exchange(options: JSONObject, done: (CraftNativeCapabilityResult) -> Unit) {
+        if (exchangeDone != null) { done(failure("BUSY", "A Bluetooth request is running")); 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)
+        require(bytes.size <= mtu - 3)
+        responsePrefix = byteArray(options, "responsePrefix", 16)
+        exchangeDone = done
+        exchangeTimer = timer(options.optLong("timeoutMs", 10000).coerceIn(1000, 20000)) { finishExchange(failure("TIMEOUT", "Bluetooth device did not answer")) }
+        write.writeType = if (write.properties and BluetoothGattCharacteristic.PROPERTY_WRITE != 0) BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT else BluetoothGattCharacteristic.WRITE_TYPE_NO_RESPONSE
+        write.value = bytes
+        if (!peer.writeCharacteristic(write)) finishExchange(failure("WRITE_FAILED", "Bluetooth write queue is busy"))
+    }
+    private fun finishExchange(result: CraftNativeCapabilityResult) {
+        exchangeTimer?.let(handler::removeCallbacks); exchangeTimer = null; responsePrefix = byteArrayOf()
+        val done = exchangeDone; exchangeDone = null; done?.invoke(result)
+    }
+    fun disconnect() {
+        stopScan(failure("CANCELLED", "Bluetooth scan cancelled"))
+        finishConnect(failure("CANCELLED", "Bluetooth connection cancelled"))
+        finishExchange(failure("DISCONNECTED", "Bluetooth device disconnected"))
+        val old = gatt; gatt = null; connected = false; writer = null; notifier = null; mtu = 23
+        runCatching { old?.disconnect(); old?.close() }
+    }
+}

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

@@ -63,6 +63,8 @@ internal class CraftNativeCapabilities(
 ) {
     /** The screen's activity; null in a background refresh, where nothing can be shown. */
     private val activity: MainActivity? get() = context as? MainActivity
+    private val bluetooth by lazy { CraftBluetooth(context) }
+    fun onBluetoothPermissions(requestCode: Int) { if (config.optBoolean("enableBluetooth")) bluetooth.onPermissions(requestCode) }
     private val mainHandler = android.os.Handler(android.os.Looper.getMainLooper())
     private val storage = context.getSharedPreferences("craft-native-storage", Context.MODE_PRIVATE)
     // The typed native renderer has no CraftNative Zig holder. Keep its
@@ -111,6 +113,7 @@ internal class CraftNativeCapabilities(
 
     fun names(): JSONArray = JSONArray().apply {
         listOf("device", "clipboard", "haptics", "storage", "lifecycle", "fetch", "files").forEach(::put)
+        if (config.optBoolean("enableBluetooth")) put("bluetooth")
         if (config.optBoolean("enableBiometric")) put("biometric")
         if (config.optBoolean("enableSecureStorage")) put("secureStorage")
         if (config.optBoolean("enableLocalDatabase")) put("database")
@@ -132,6 +135,10 @@ internal class CraftNativeCapabilities(
             return
         }
         when (module) {
+            "Bluetooth" -> {
+                if (!config.optBoolean("enableBluetooth")) complete(requestToken, failure("CAPABILITY_DISABLED", "Bluetooth is disabled"), completion)
+                else bluetooth.perform(method, args) { complete(requestToken, it, completion) }
+            }
             "Storage" -> complete(requestToken, storage(method, args), completion)
             "SecureStorage" -> {
                 if (!config.optBoolean("enableSecureStorage")) complete(requestToken, failure("CAPABILITY_DISABLED", "Secure storage is disabled"), completion)
@@ -177,6 +184,7 @@ internal class CraftNativeCapabilities(
     }
 
     fun close() {
+        if (config.optBoolean("enableBluetooth")) bluetooth.disconnect()
         databaseExecutor.shutdownNow()
         networkExecutor.shutdownNow()
         fetchConnections.values.forEach(HttpURLConnection::disconnect)

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

@@ -856,15 +856,18 @@ private class CraftNativeFlexLayout(context: Context) : LinearLayout(context) {
         requestLayout()
     }
 
-    private fun invalidateMeasurementAncestors(start: ViewParent?) {
-        var ancestor = start
-        while (ancestor != null) {
-            when (ancestor) {
-                is CraftNativeFlexLayout -> ancestor.invalidateMeasurements()
-                is CraftNativeKeyboardAvoidingView -> ancestor.content.invalidateMeasurements()
-                is CraftNativeScrollView -> ancestor.invalidateContentLayout()
+    companion object {
+        /** Clears the memoized measurements of every flex host above `start`. The activity calls it too (an image whose source changed). */
+        fun invalidateMeasurementAncestors(start: ViewParent?) {
+            var ancestor = start
+            while (ancestor != null) {
+                when (ancestor) {
+                    is CraftNativeFlexLayout -> ancestor.invalidateMeasurements()
+                    is CraftNativeKeyboardAvoidingView -> ancestor.content.invalidateMeasurements()
+                    is CraftNativeScrollView -> ancestor.invalidateContentLayout()
+                }
+                ancestor = (ancestor as? View)?.parent
             }
-            ancestor = (ancestor as? View)?.parent
         }
     }
 
@@ -4086,7 +4089,7 @@ class MainActivity : AppCompatActivity() {
                 includeFontPadding = false
                 configureText(this, craftNativeOptionalString(props.opt("title")) ?: childText(children), style)
                 val linkColor = craftNativeOptionalString(props.opt("color")) ?: craftNativeOptionalString(style.opt("color"))
-                setTextColor(color(linkColor, Color.rgb(33, 150, 243)))
+                setTextColor(color(linkColor.orEmpty(), Color.rgb(33, 150, 243)))
                 paintFlags = paintFlags or Paint.UNDERLINE_TEXT_FLAG
                 isEnabled = !props.optBoolean("disabled", false)
                 isClickable = true
@@ -4369,7 +4372,7 @@ class MainActivity : AppCompatActivity() {
                     } else {
                         craftNativeOptionalString(events.opt("onDismiss"))
                     }
-                    if (lifecycleHandler.isNotBlank() && !suppressDismiss) {
+                    if (!lifecycleHandler.isNullOrBlank() && !suppressDismiss) {
                         // Deliver lifecycle callbacks after reconciliation returns to
                         // the queue; the handler may immediately schedule another
                         // render against this native view.
@@ -5452,7 +5455,7 @@ class MainActivity : AppCompatActivity() {
     private fun imageDidChange(view: ImageView) {
         view.invalidate()
         view.requestLayout()
-        invalidateMeasurementAncestors(view.parent)
+        CraftNativeFlexLayout.invalidateMeasurementAncestors(view.parent)
     }
 
     private fun emitImageEvent(screen: Screen, view: ImageView, handler: String?, nativeEvent: JSONObject = JSONObject()) {
@@ -5774,6 +5777,7 @@ class MainActivity : AppCompatActivity() {
 
     override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<out String>, grantResults: IntArray) {
         super.onRequestPermissionsResult(requestCode, permissions, grantResults)
+        if (::capabilities.isInitialized) capabilities.onBluetoothPermissions(requestCode)
         if (::services.isInitialized) services.onRequestPermissionsResult(requestCode)
     }
 

package/dist/cli.js

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

package/dist/index.cjs

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

package/dist/index.js

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

package/dist/ios/src/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/dist/ios/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/dist/ios/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/dist/ios/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

package/package.json

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