@glassly/bluetooth-sdk 0.1.0-dev.26

package/ios/Source/sgcs/MentraLiveL2capChannel.swift

@@ -0,0 +1,183 @@
+import CoreBluetooth
+import Foundation
+
+/// Read-only LE L2CAP CoC fast path for Mentra Live file transfers.
+///
+/// BES sends the same K900 file frames over this channel that it otherwise
+/// sends through the FILE_READ GATT characteristic. The stream is drained on
+/// a dedicated thread so CoreBluetooth credits are returned independently of
+/// React Native and main-thread work.
+final class MentraLiveL2capChannel: NSObject, StreamDelegate {
+    private static let readChunkSize = 4096
+    private static let maxBufferSize = 64 * 1024
+    private static let frameHeaderSize = 5
+    private static let frameOverhead = 32
+    private static let maxFilePayloadSize = K900ProtocolUtils.FILE_PACK_SIZE
+
+    private let channel: CBL2CAPChannel
+    private let onFileFrame: (Data) -> Void
+    private let onClose: () -> Void
+    private let stateLock = NSLock()
+
+    private var receiveBuffer = [UInt8]()
+    private var worker: Thread?
+    private var closed = false
+    private var closeNotified = false
+
+    init(
+        channel: CBL2CAPChannel,
+        onFileFrame: @escaping (Data) -> Void,
+        onClose: @escaping () -> Void
+    ) {
+        self.channel = channel
+        self.onFileFrame = onFileFrame
+        self.onClose = onClose
+        super.init()
+    }
+
+    func start() {
+        guard worker == nil else { return }
+        let thread = Thread { [weak self] in
+            self?.runReadLoop()
+        }
+        thread.name = "MentraLive-L2CAP"
+        thread.qualityOfService = .userInitiated
+        worker = thread
+        thread.start()
+    }
+
+    func close() {
+        stateLock.lock()
+        let wasClosed = closed
+        closed = true
+        stateLock.unlock()
+
+        guard !wasClosed else { return }
+        channel.inputStream?.close()
+        channel.outputStream?.close()
+    }
+
+    private var isClosed: Bool {
+        stateLock.lock()
+        defer { stateLock.unlock() }
+        return closed
+    }
+
+    private func runReadLoop() {
+        guard let input = channel.inputStream, let output = channel.outputStream else {
+            notifyClosed()
+            return
+        }
+
+        input.delegate = self
+        input.schedule(in: .current, forMode: .default)
+        output.schedule(in: .current, forMode: .default)
+        input.open()
+        output.open()
+
+        while !isClosed {
+            _ = RunLoop.current.run(mode: .default, before: Date(timeIntervalSinceNow: 0.1))
+        }
+
+        input.close()
+        output.close()
+        input.remove(from: .current, forMode: .default)
+        output.remove(from: .current, forMode: .default)
+        input.delegate = nil
+        notifyClosed()
+    }
+
+    func stream(_ aStream: Stream, handle eventCode: Stream.Event) {
+        guard aStream === channel.inputStream else { return }
+
+        switch eventCode {
+        case .hasBytesAvailable:
+            drainInput()
+        case .endEncountered, .errorOccurred:
+            close()
+        default:
+            break
+        }
+    }
+
+    private func drainInput() {
+        guard let input = channel.inputStream else { return }
+        var chunk = [UInt8](repeating: 0, count: Self.readChunkSize)
+
+        while input.hasBytesAvailable, !isClosed {
+            let count = input.read(&chunk, maxLength: chunk.count)
+            if count > 0 {
+                appendAndDispatch(Array(chunk.prefix(count)))
+            } else if count < 0 {
+                close()
+                return
+            } else {
+                break
+            }
+        }
+    }
+
+    private func appendAndDispatch(_ bytes: [UInt8]) {
+        if receiveBuffer.count + bytes.count > Self.maxBufferSize {
+            receiveBuffer.removeAll(keepingCapacity: true)
+        }
+        guard bytes.count <= Self.maxBufferSize else { return }
+        receiveBuffer.append(contentsOf: bytes)
+
+        while true {
+            guard let start = startMarkerIndex() else {
+                if receiveBuffer.last == 0x23 {
+                    receiveBuffer = [0x23]
+                } else {
+                    receiveBuffer.removeAll(keepingCapacity: true)
+                }
+                return
+            }
+
+            if start > 0 {
+                receiveBuffer.removeFirst(start)
+            }
+            guard receiveBuffer.count >= Self.frameHeaderSize else { return }
+
+            let payloadSize = (Int(receiveBuffer[3]) << 8) | Int(receiveBuffer[4])
+            guard payloadSize <= Self.maxFilePayloadSize else {
+                receiveBuffer.removeFirst()
+                continue
+            }
+
+            let frameSize = Self.frameOverhead + payloadSize
+            guard receiveBuffer.count >= frameSize else { return }
+
+            guard receiveBuffer[frameSize - 2] == 0x24,
+                  receiveBuffer[frameSize - 1] == 0x24
+            else {
+                receiveBuffer.removeFirst()
+                continue
+            }
+
+            onFileFrame(Data(receiveBuffer.prefix(frameSize)))
+            receiveBuffer.removeFirst(frameSize)
+        }
+    }
+
+    private func startMarkerIndex() -> Int? {
+        guard receiveBuffer.count >= 2 else { return nil }
+        for index in 0 ..< (receiveBuffer.count - 1)
+            where receiveBuffer[index] == 0x23 && receiveBuffer[index + 1] == 0x23
+        {
+            return index
+        }
+        return nil
+    }
+
+    private func notifyClosed() {
+        stateLock.lock()
+        guard !closeNotified else {
+            stateLock.unlock()
+            return
+        }
+        closeNotified = true
+        stateLock.unlock()
+        onClose()
+    }
+}

package/ios/Source/sgcs/MentraLivePairingAdvertisement.swift

@@ -0,0 +1,64 @@
+import Foundation
+
+struct MentraLivePairingAdvertisement: Equatable {
+    let pairingMode: Bool
+    let pairingCode: String
+
+    private static let manufacturerId: UInt16 = 0xB822
+    private static let companyIdLength = 2
+    private static let pairingFlagOffset = 5
+    private static let pairingDiscoverable: UInt8 = 0x01
+    private static let protocolVersionOffset = pairingFlagOffset + 1
+    private static let capabilityOffset = protocolVersionOffset + 1
+    private static let codeLowOffset = capabilityOffset + 1
+    private static let codeHighOffset = codeLowOffset + 1
+    private static let magicFirstOffset = codeHighOffset + 1
+    private static let magicSecondOffset = magicFirstOffset + 1
+    private static let protocolVersionRange = 2 ... 15
+    private static let securePairingCapability = 0x01
+    private static let magicFirst: UInt8 = 0x4D // M
+    private static let magicSecond: UInt8 = 0x50 // P
+
+    /// Parses CoreBluetooth manufacturer data, including its two-byte company-id prefix.
+    ///
+    /// Legacy firmware stores an XOR'd Classic MAC where the original pairing implementation
+    /// expected version and capability bytes. Requiring the `MP` marker makes the formats
+    /// unambiguous instead of probabilistically classifying MAC bytes as a secure trailer.
+    static func parse(coreBluetoothManufacturerData data: Data?) -> MentraLivePairingAdvertisement? {
+        guard let data, data.count > companyIdLength + magicSecondOffset else {
+            return nil
+        }
+
+        let companyId = UInt16(data[0]) | (UInt16(data[1]) << 8)
+        guard companyId == manufacturerId else {
+            return nil
+        }
+
+        let payloadBase = companyIdLength
+        let version = Int(data[payloadBase + protocolVersionOffset])
+        let capability = Int(data[payloadBase + capabilityOffset])
+        guard protocolVersionRange.contains(version),
+              capability & securePairingCapability != 0,
+              data[payloadBase + magicFirstOffset] == magicFirst,
+              data[payloadBase + magicSecondOffset] == magicSecond
+        else {
+            return nil
+        }
+
+        let codeLow = Int(data[payloadBase + codeLowOffset])
+        let codeHigh = Int(data[payloadBase + codeHighOffset])
+        return MentraLivePairingAdvertisement(
+            pairingMode: data[payloadBase + pairingFlagOffset] == pairingDiscoverable,
+            pairingCode: String(format: "%02X%02X", codeHigh, codeLow)
+        )
+    }
+}
+
+enum MentraLiveConnectionAttemptPolicy {
+    static func shouldAcceptDidConnect(
+        pairingYieldActive: Bool,
+        matchesActiveAttempt: Bool
+    ) -> Bool {
+        !pairingYieldActive && matchesActiveAttempt
+    }
+}