@mentra/bluetooth-sdk 0.1.17 → 0.1.19

package/ios/Source/status/DeviceStatus.swift

@@ -580,10 +580,6 @@ struct BluetoothStatus: CustomStringConvertible {
         boolValue(values, "should_send_transcript") ?? false
     }
 
-    var offlineCaptionsRunning: Bool {
-        boolValue(values, "offline_captions_running") ?? false
-    }
-
     var localSttFallbackActive: Bool {
         boolValue(values, "local_stt_fallback_active") ?? false
     }
@@ -948,10 +944,6 @@ struct BluetoothStatusUpdate: CustomStringConvertible {
         optionalBoolValue(values, "should_send_transcript")
     }
 
-    var offlineCaptionsRunning: Bool? {
-        optionalBoolValue(values, "offline_captions_running")
-    }
-
     var localSttFallbackActive: Bool? {
         optionalBoolValue(values, "local_stt_fallback_active")
     }

package/ios/Source/utils/BleJsonCompact.swift

@@ -0,0 +1,395 @@
+import Foundation
+
+/// BLE Wire Protocol v2 JSON compaction: short keys, enum ints, omitted defaults, config diff.
+enum BleJsonCompact {
+    static let keyResolvedConfigHash = "rch"
+
+    private static let longToShort: [String: String] = [
+        "type": "t",
+        "requestId": "r",
+        "timestamp": "ts",
+        "status": "s",
+        "kind": "k",
+        "source": "src",
+        "requestedCaptureConfig": "rcc",
+        "meteredPreview": "mp",
+        "exposureTimeNs": "etn",
+        "captureMetadata": "cm",
+        "aeStateName": "aes",
+        "transferMethod": "tm",
+        "manual": "m",
+        "reconnecting": "rc",
+    ]
+
+    private static let shortToLong: [String: String] = {
+        var map: [String: String] = [:]
+        for (longKey, shortKey) in longToShort {
+            map[shortKey] = longKey
+        }
+        return map
+    }()
+
+    private static let photoStatusToInt: [String: Int] = [
+        "accepted": 0, "queued": 1, "configuring": 2, "capturing": 3,
+        "captured": 4, "uploading": 5, "uploaded": 6, "failed": 7,
+    ]
+    private static let photoStatusFromInt: [Int: String] = {
+        var map: [Int: String] = [:]
+        for (key, value) in photoStatusToInt { map[value] = key }
+        return map
+    }()
+
+    private static let kindToInt = ["lifecycle": 0, "snapshot": 1]
+    private static let kindFromInt: [Int: String] = [0: "lifecycle", 1: "snapshot"]
+
+    private static let sourceToInt = ["sdk": 0, "button": 1]
+    private static let sourceFromInt: [Int: String] = [0: "sdk", 1: "button"]
+
+    private static let aeStateToInt: [String: Int] = [
+        "CONVERGED": 0, "SEARCHING": 1, "INACTIVE": 2,
+        "LOCKED": 3, "FLASH_REQUIRED": 4, "PRECAPTURE": 5,
+    ]
+    private static let aeStateFromInt: [Int: String] = {
+        var map: [Int: String] = [:]
+        for (key, value) in aeStateToInt { map[value] = key }
+        return map
+    }()
+
+    private static var sessionConnectEpochMs: Int64 = 0
+    private static var resolvedConfigSent = false
+    private static var currentSessionResolvedConfigHash: String?
+    private static var resolvedConfigByHash: [String: [String: Any]] = [:]
+
+    private static let highRoiMessageTypes: Set<String> = [
+        "photo_status",
+        "stream_status",
+        "wifi_scan_result",
+        "start_stream",
+        "photo_response",
+    ]
+
+    private static let chunkMessageTypes: Set<String> = ["ck", "chunked_msg"]
+
+    static func shouldCompactOutbound(_ messageType: String) -> Bool {
+        highRoiMessageTypes.contains(messageType)
+    }
+
+    static func supportsCompactInbound(_ messageType: String) -> Bool {
+        !messageType.isEmpty
+            && (highRoiMessageTypes.contains(messageType) || chunkMessageTypes.contains(messageType))
+    }
+
+    static func isCompactWireForm(_ json: [String: Any]) -> Bool {
+        json["t"] != nil && json["type"] == nil
+    }
+
+    static func extractMessageType(_ json: [String: Any]) -> String {
+        if let type = stringValue(json["type"]) {
+            return type
+        }
+        if let compactType = stringValue(json["t"]) {
+            return compactType
+        }
+        return ""
+    }
+
+    static func resetSession() {
+        sessionConnectEpochMs = 0
+        resolvedConfigSent = false
+        currentSessionResolvedConfigHash = nil
+        resolvedConfigByHash.removeAll()
+    }
+
+    static func markSessionConnected(epochMs: Int64) {
+        resetSession()
+        sessionConnectEpochMs = epochMs
+    }
+
+    static func isCameraCommandJson(_ jsonData: String) -> Bool {
+        jsonData.contains("cs_pho")
+            || jsonData.contains("cs_cpho")
+            || jsonData.contains("cs_vid")
+            || jsonData.contains("\"type\":\"take_photo\"")
+    }
+
+    static func encode(_ json: [String: Any]) -> [String: Any] {
+        if isCameraCommandJson(jsonString(json) ?? "") {
+            return json
+        }
+        let messageType = extractMessageType(json)
+        if !shouldCompactOutbound(messageType) {
+            return json
+        }
+        return compactObject(json, topLevel: true)
+    }
+
+    static func encode(jsonString: String) -> [String: Any]? {
+        guard let data = jsonString.data(using: .utf8),
+              let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+        else {
+            return nil
+        }
+        return encode(json)
+    }
+
+    static func decode(_ json: [String: Any]) -> [String: Any] {
+        if isCameraCommandJson(jsonString(json) ?? "") {
+            return json
+        }
+        return expandObject(json, topLevel: true)
+    }
+
+    static func decodeIfSupported(_ json: [String: Any]) -> [String: Any]? {
+        if isCameraCommandJson(jsonString(json) ?? "") {
+            return json
+        }
+        if !isCompactWireForm(json) {
+            return json
+        }
+        let compactType = stringValue(json["t"]) ?? ""
+        if !supportsCompactInbound(compactType) {
+            return nil
+        }
+        return expandObject(json, topLevel: true)
+    }
+
+    static func decode(jsonString: String) -> [String: Any]? {
+        guard let data = jsonString.data(using: .utf8),
+              let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+        else {
+            return nil
+        }
+        return decode(json)
+    }
+
+    private static func compactObject(_ input: [String: Any], topLevel: Bool) -> [String: Any] {
+        var output: [String: Any] = [:]
+        let messageType = stringValue(input["type"]) ?? stringValue(input["t"]) ?? ""
+        var skipResolvedConfig = false
+
+        if topLevel, shouldDiffResolvedConfig(messageType),
+           let resolvedConfig = input["resolvedConfig"] as? [String: Any]
+        {
+            let hash = hashConfig(resolvedConfig)
+            resolvedConfigByHash[hash] = resolvedConfig
+            if resolvedConfigSent, hash == currentSessionResolvedConfigHash {
+                output[keyResolvedConfigHash] = hash
+                skipResolvedConfig = true
+            } else {
+                currentSessionResolvedConfigHash = hash
+                resolvedConfigSent = true
+            }
+        }
+
+        for (key, value) in input {
+            if skipResolvedConfig, key == "resolvedConfig" { continue }
+            let shortKey = longToShort[key] ?? key
+            guard let compacted = compactValue(longKey: key, value: value, messageType: messageType),
+                  !shouldOmit(compacted)
+            else {
+                continue
+            }
+            output[shortKey] = compacted
+        }
+
+        if topLevel {
+            compactTimestamp(&output)
+        }
+        return output
+    }
+
+    private static func shouldDiffResolvedConfig(_ messageType: String) -> Bool {
+        messageType == "photo_status" || messageType == "stream_status"
+    }
+
+    private static func compactValue(longKey: String, value: Any, messageType: String) -> Any? {
+        if value is NSNull { return nil }
+        if let nested = value as? [String: Any] {
+            return compactObject(nested, topLevel: false)
+        }
+        if let array = value as? [Any] {
+            return array.map { item -> Any in
+                if let nested = item as? [String: Any] {
+                    return compactObject(nested, topLevel: false)
+                }
+                return item
+            }
+        }
+        if let boolValue = value as? Bool { return boolValue }
+        if let number = value as? NSNumber, CFGetTypeID(number) != CFBooleanGetTypeID() {
+            return number
+        }
+        if let str = value as? String {
+            if longKey == "status", messageType == "photo_status", let code = photoStatusToInt[str] {
+                return code
+            }
+            if longKey == "kind", let code = kindToInt[str] { return code }
+            if longKey == "source", let code = sourceToInt[str] { return code }
+            if longKey == "aeStateName", let code = aeStateToInt[str] { return code }
+            return str
+        }
+        return value
+    }
+
+    private static func shouldOmit(_ value: Any) -> Bool {
+        if value is NSNull { return true }
+        if let boolValue = value as? Bool, !boolValue { return true }
+        if let dict = value as? [String: Any], dict.isEmpty { return true }
+        if let array = value as? [Any], array.isEmpty { return true }
+        return false
+    }
+
+    private static func compactTimestamp(_ output: inout [String: Any]) {
+        let tsKey: String?
+        if output["timestamp"] != nil {
+            tsKey = "timestamp"
+        } else if output["ts"] != nil {
+            tsKey = "ts"
+        } else {
+            tsKey = nil
+        }
+        guard let key = tsKey else { return }
+        let absolute = int64Value(output[key]) ?? 0
+        guard absolute > 0 else { return }
+        if sessionConnectEpochMs <= 0 {
+            sessionConnectEpochMs = absolute
+        }
+        output["ts"] = absolute - sessionConnectEpochMs
+        if key != "ts" {
+            output.removeValue(forKey: key)
+        }
+    }
+
+    private static func expandObject(_ input: [String: Any], topLevel: Bool) -> [String: Any] {
+        var output: [String: Any] = [:]
+        let messageType = stringValue(input["type"]) ?? stringValue(input["t"]) ?? ""
+
+        for (key, value) in input {
+            if topLevel, key == "ts" {
+                output["ts"] = value
+                continue
+            }
+            let longKey = shortToLong[key] ?? key
+            guard let expanded = expandValue(longKey: longKey, value: value, messageType: messageType) else {
+                continue
+            }
+            output[longKey] = expanded
+        }
+
+        if topLevel {
+            expandTimestamp(&output)
+            expandResolvedConfigHash(&output)
+            cacheResolvedConfigIfPresent(&output)
+        }
+        return output
+    }
+
+    private static func cacheResolvedConfigIfPresent(_ output: inout [String: Any]) {
+        guard let resolvedConfig = output["resolvedConfig"] as? [String: Any] else { return }
+        let hash = hashConfig(resolvedConfig)
+        resolvedConfigByHash[hash] = resolvedConfig
+        currentSessionResolvedConfigHash = hash
+        resolvedConfigSent = true
+    }
+
+    private static func expandResolvedConfigHash(_ output: inout [String: Any]) {
+        guard output["resolvedConfig"] == nil,
+              let hash = output[keyResolvedConfigHash] as? String,
+              let cached = resolvedConfigByHash[hash]
+        else {
+            return
+        }
+        output["resolvedConfig"] = cached
+        output.removeValue(forKey: keyResolvedConfigHash)
+    }
+
+    private static func expandValue(longKey: String, value: Any, messageType: String) -> Any? {
+        if value is NSNull { return nil }
+        if let nested = value as? [String: Any] {
+            return expandObject(nested, topLevel: false)
+        }
+        if let array = value as? [Any] {
+            return array.map { item -> Any in
+                if let nested = item as? [String: Any] {
+                    return expandObject(nested, topLevel: false)
+                }
+                return item
+            }
+        }
+        if longKey == "status", messageType == "photo_status", let code = value as? Int {
+            return photoStatusFromInt[code] ?? value
+        }
+        if longKey == "kind", let code = value as? Int {
+            return kindFromInt[code] ?? value
+        }
+        if longKey == "source", let code = value as? Int {
+            return sourceFromInt[code] ?? value
+        }
+        if longKey == "aeStateName", let code = value as? Int {
+            return aeStateFromInt[code] ?? value
+        }
+        return value
+    }
+
+    private static func expandTimestamp(_ output: inout [String: Any]) {
+        guard output["timestamp"] == nil, let delta = int64Value(output["ts"]) else { return }
+        let absolute = sessionConnectEpochMs > 0 ? sessionConnectEpochMs + delta : delta
+        output["timestamp"] = absolute
+        output.removeValue(forKey: "ts")
+        if sessionConnectEpochMs <= 0 {
+            sessionConnectEpochMs = absolute - delta
+        }
+    }
+
+    static func hashConfig(_ config: [String: Any]) -> String {
+        fnv1a32Hex(canonicalJsonString(config))
+    }
+
+    private static func canonicalJsonString(_ object: [String: Any]) -> String {
+        let sortedKeys = object.keys.sorted()
+        var parts: [String] = []
+        for key in sortedKeys {
+            guard let value = object[key] else { continue }
+            let encodedValue: String
+            if let nested = value as? [String: Any] {
+                encodedValue = canonicalJsonString(nested)
+            } else if let str = value as? String {
+                encodedValue = "\"\(str)\""
+            } else if let boolValue = value as? Bool {
+                encodedValue = boolValue ? "true" : "false"
+            } else if let number = value as? NSNumber {
+                encodedValue = "\(number)"
+            } else {
+                encodedValue = "null"
+            }
+            parts.append("\"\(key)\":\(encodedValue)")
+        }
+        return "{\(parts.joined(separator: ","))}"
+    }
+
+    private static func fnv1a32Hex(_ value: String) -> String {
+        var hash: UInt32 = 0x811c9dc5
+        for byte in value.utf8 {
+            hash ^= UInt32(byte)
+            hash = hash &* 0x01000193
+        }
+        return String(format: "%08x", hash)
+    }
+
+    private static func stringValue(_ value: Any?) -> String? {
+        if let str = value as? String { return str }
+        if let number = value as? NSNumber { return number.stringValue }
+        return nil
+    }
+
+    private static func int64Value(_ value: Any?) -> Int64? {
+        if let number = value as? NSNumber { return number.int64Value }
+        if let str = value as? String, let parsed = Int64(str) { return parsed }
+        return nil
+    }
+
+    private static func jsonString(_ json: [String: Any]) -> String? {
+        guard let data = try? JSONSerialization.data(withJSONObject: json) else { return nil }
+        return String(data: data, encoding: .utf8)
+    }
+}

package/ios/Source/utils/BleWireProtocol.swift

@@ -0,0 +1,92 @@
+import Foundation
+
+/// BLE Wire Protocol v2 shared constants and binary frame helpers.
+/// All multi-byte fields use little-endian byte order.
+enum BleWireProtocol {
+    static let cmdTypeBinaryMsg: UInt8 = 0x40
+
+    static let flagFirstFrag: UInt8 = 0x01
+    static let flagLastFrag: UInt8 = 0x02
+    static let flagWake: UInt8 = 0x04
+    static let flagHandshake: UInt8 = 0x08
+    static let flagAckRequested: UInt8 = 0x10
+
+    static let binaryHeaderSize = 7
+    static let maxFragmentPayload = 480
+    static let mtuTarget = 509
+
+    static let handshakePayloadV2 = "v2"
+    static let protocolV1 = 1
+    static let protocolV2 = 2
+
+    struct BinaryFragmentInfo {
+        let flags: UInt8
+        let msgId: UInt16
+        let fragIdx: UInt8
+        let fragCount: UInt8
+        let payload: Data
+    }
+
+    static func isBinaryFrame(_ data: Data) -> Bool {
+        guard data.count >= 7 else { return false }
+        let bytes = [UInt8](data)
+        return bytes[0] == 0x23 && bytes[1] == 0x23 && bytes[2] == cmdTypeBinaryMsg
+    }
+
+    static func packBinaryFragment(
+        flags: UInt8,
+        msgId: UInt16,
+        fragIdx: UInt8,
+        fragCount: UInt8,
+        payload: Data
+    ) -> Data? {
+        var inner = Data(capacity: binaryHeaderSize + payload.count)
+        inner.append(flags)
+        inner.append(UInt8(msgId & 0xFF))
+        inner.append(UInt8((msgId >> 8) & 0xFF))
+        inner.append(fragIdx)
+        inner.append(fragCount)
+        let payloadLen = UInt16(payload.count)
+        inner.append(UInt8(payloadLen & 0xFF))
+        inner.append(UInt8((payloadLen >> 8) & 0xFF))
+        inner.append(payload)
+        return packDataToK900(inner, cmdType: cmdTypeBinaryMsg)
+    }
+
+    static func extractBinaryFragmentInfo(_ frame: Data) -> BinaryFragmentInfo? {
+        guard isBinaryFrame(frame) else { return nil }
+        let bytes = [UInt8](frame)
+        let innerLen = Int(bytes[3]) | (Int(bytes[4]) << 8)
+        guard innerLen >= binaryHeaderSize, frame.count >= 7 + innerLen else { return nil }
+
+        let offset = 5
+        let payloadLen = Int(bytes[offset + 5]) | (Int(bytes[offset + 6]) << 8)
+        guard binaryHeaderSize + payloadLen <= innerLen else { return nil }
+
+        let payload = frame.subdata(in: (offset + binaryHeaderSize) ..< (offset + binaryHeaderSize + payloadLen))
+        return BinaryFragmentInfo(
+            flags: bytes[offset],
+            msgId: UInt16(bytes[offset + 1]) | (UInt16(bytes[offset + 2]) << 8),
+            fragIdx: bytes[offset + 3],
+            fragCount: bytes[offset + 4],
+            payload: payload
+        )
+    }
+
+    static func isHandshakeV2(_ info: BinaryFragmentInfo) -> Bool {
+        guard (info.flags & flagHandshake) != 0 else { return false }
+        return String(data: info.payload, encoding: .utf8) == handshakePayloadV2
+    }
+
+    private static func packDataToK900(_ data: Data, cmdType: UInt8) -> Data? {
+        var result = Data(capacity: data.count + 7)
+        result.append(contentsOf: [0x23, 0x23])
+        result.append(cmdType)
+        let dataLength = UInt16(data.count)
+        result.append(UInt8(dataLength & 0xFF))
+        result.append(UInt8((dataLength >> 8) & 0xFF))
+        result.append(data)
+        result.append(contentsOf: [0x24, 0x24])
+        return result
+    }
+}

package/ios/Source/utils/MessageChunkReassembler.swift

@@ -6,6 +6,46 @@ final class MessageChunkReassembler {
 
     private var activeSessions: [String: ChunkSession] = [:]
 
+    private var activeBinarySessions: [UInt16: BinarySession] = [:]
+
+    func addBinaryFragment(msgId: UInt16, fragIdx: Int, fragCount: Int, data: Data) -> Data? {
+        cleanupTimedOutSessions()
+
+        guard fragCount > 0, fragIdx >= 0, fragIdx < fragCount else {
+            print("MessageChunkReassembler: Dropping invalid binary fragment for msgId \(msgId)")
+            return nil
+        }
+
+        if let existing = activeBinarySessions[msgId], existing.fragCount != fragCount {
+            activeBinarySessions.removeValue(forKey: msgId)
+        }
+
+        if activeBinarySessions.count >= Self.maxConcurrentSessions,
+           activeBinarySessions[msgId] == nil
+        {
+            removeOldestBinarySession()
+        }
+
+        let isNewSession = activeBinarySessions[msgId] == nil
+        let session = activeBinarySessions[msgId] ?? BinarySession(msgId: msgId, fragCount: fragCount)
+
+        guard session.addFragment(index: fragIdx, data: data) else {
+            return nil
+        }
+        if isNewSession {
+            activeBinarySessions[msgId] = session
+        }
+
+        guard session.isComplete else {
+            return nil
+        }
+
+        let reassembled = session.reassemble()
+        activeBinarySessions.removeValue(forKey: msgId)
+        print("MessageChunkReassembler: Reassembled \(reassembled.count) bytes from \(fragCount) binary fragments")
+        return reassembled
+    }
+
     func addChunk(_ info: MessageChunker.ChunkInfo) -> String? {
         cleanupTimedOutSessions()
 
@@ -57,6 +97,7 @@ final class MessageChunkReassembler {
 
     func clear() {
         activeSessions.removeAll()
+        activeBinarySessions.removeAll()
     }
 
     private func cleanupTimedOutSessions() {
@@ -64,6 +105,16 @@ final class MessageChunkReassembler {
         activeSessions = activeSessions.filter { entry in
             now - entry.value.createdAtMs <= Self.chunkTimeoutMs
         }
+        activeBinarySessions = activeBinarySessions.filter { entry in
+            now - entry.value.createdAtMs <= Self.chunkTimeoutMs
+        }
+    }
+
+    private func removeOldestBinarySession() {
+        guard let oldest = activeBinarySessions.min(by: { $0.value.createdAtMs < $1.value.createdAtMs }) else {
+            return
+        }
+        activeBinarySessions.removeValue(forKey: oldest.key)
     }
 
     private func removeOldestSession() {
@@ -105,4 +156,35 @@ final class MessageChunkReassembler {
             return result
         }
     }
+
+    private final class BinarySession {
+        let msgId: UInt16
+        let fragCount: Int
+        let createdAtMs: TimeInterval
+        private var fragments: [Int: Data] = [:]
+
+        init(msgId: UInt16, fragCount: Int) {
+            self.msgId = msgId
+            self.fragCount = fragCount
+            self.createdAtMs = Date().timeIntervalSince1970 * 1000
+        }
+
+        func addFragment(index: Int, data: Data) -> Bool {
+            guard index >= 0, index < fragCount else { return false }
+            fragments[index] = data
+            return true
+        }
+
+        var isComplete: Bool {
+            fragments.count == fragCount
+        }
+
+        func reassemble() -> Data {
+            var result = Data()
+            for index in 0 ..< fragCount {
+                result.append(fragments[index] ?? Data())
+            }
+            return result
+        }
+    }
 }

package/ios/Source/utils/MessageChunker.swift

@@ -24,6 +24,8 @@ class MessageChunker {
     private static let MIN_CHUNK_DATA_SIZE = 4
     private static let MAX_PACKED_CHUNK_SIZE = 253
     private static let K900_FRAME_OVERHEAD = 7
+    private static let MAX_BINARY_FRAGMENT_PAYLOAD = BleWireProtocol.maxFragmentPayload
+    private static let MAX_BINARY_FRAME_SIZE = BleWireProtocol.mtuTarget
 
     /**
      * Check if a message needs to be chunked
@@ -204,6 +206,77 @@ class MessageChunker {
         )
     }
 
+    static func needsBinaryFragmenting(_ payload: Data) -> Bool {
+        payload.count > MAX_BINARY_FRAGMENT_PAYLOAD
+    }
+
+    static func needsBinaryFragmenting(_ json: String) -> Bool {
+        guard let data = json.data(using: .utf8) else { return false }
+        return needsBinaryFragmenting(data)
+    }
+
+    struct BinaryFragment {
+        let flags: UInt8
+        let msgId: UInt16
+        let fragIdx: UInt8
+        let fragCount: UInt8
+        let payload: Data
+    }
+
+    static func createBinaryFragments(
+        payload: Data,
+        msgId: UInt16 = 0,
+        wakeUp: Bool = false,
+        ackRequested: Bool = false
+    ) -> [BinaryFragment] {
+        let fragCount = max(1, (payload.count + MAX_BINARY_FRAGMENT_PAYLOAD - 1) / MAX_BINARY_FRAGMENT_PAYLOAD)
+        guard fragCount <= 255 else { return [] }
+
+        var fragments: [BinaryFragment] = []
+        for i in 0 ..< fragCount {
+            let offset = i * MAX_BINARY_FRAGMENT_PAYLOAD
+            let end = min(offset + MAX_BINARY_FRAGMENT_PAYLOAD, payload.count)
+            let fragPayload = payload.subdata(in: offset ..< end)
+
+            var flags: UInt8 = 0
+            if i == 0 { flags |= BleWireProtocol.flagFirstFrag }
+            if i == fragCount - 1 { flags |= BleWireProtocol.flagLastFrag }
+            if wakeUp, i == 0 { flags |= BleWireProtocol.flagWake }
+            if ackRequested, i == fragCount - 1 { flags |= BleWireProtocol.flagAckRequested }
+
+            fragments.append(
+                BinaryFragment(
+                    flags: flags,
+                    msgId: msgId,
+                    fragIdx: UInt8(i),
+                    fragCount: UInt8(fragCount),
+                    payload: fragPayload
+                )
+            )
+        }
+
+        print("MessageChunker: Created \(fragments.count) binary fragments for \(payload.count) bytes")
+        return fragments
+    }
+
+    static func allBinaryFragmentsFit(_ fragments: [BinaryFragment]) -> Bool {
+        for fragment in fragments {
+            guard let packed = BleWireProtocol.packBinaryFragment(
+                flags: fragment.flags,
+                msgId: fragment.msgId,
+                fragIdx: fragment.fragIdx,
+                fragCount: fragment.fragCount,
+                payload: fragment.payload
+            ) else {
+                return false
+            }
+            if packed.count > MAX_BINARY_FRAME_SIZE {
+                return false
+            }
+        }
+        return true
+    }
+
     /**
      * Container for chunk information
      */