@glassly/bluetooth-sdk 0.1.0-dev.26

package/ios/Source/utils/MessageChunker.swift

@@ -0,0 +1,294 @@
+import Foundation
+
+/**
+ * Handles chunking of large messages that exceed BLE transmission limits.
+ * Messages are split at the JSON layer to work within MCU protocol constraints.
+ *
+ * Uses compact keys to minimize overhead per chunk:
+ *   t  = "ck" (chunk type identifier)
+ *   id = chunk session ID
+ *   c  = chunk index (0-based)
+ *   n  = total number of chunks
+ *   d  = chunk data payload
+ *
+ * Each chunk after C-wrapping + K900 framing must fit within the BES2700's
+ * 253-byte BLE write limit. Payload size is selected by measuring the final
+ * packed chunk so JSON escaping cannot push a chunk over the BLE limit.
+ */
+class MessageChunker {
+    // Threshold: if C-wrapped message exceeds this, chunking is triggered.
+    // BES2700 limit is 253 bytes; anything over ~200 bytes packed needs chunking.
+    private static let MESSAGE_SIZE_THRESHOLD = 200
+
+    private static let INITIAL_CHUNK_DATA_SIZE = 80
+    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
+     * @param message The complete message string (already C-wrapped)
+     * @return true if message exceeds threshold and needs chunking
+     */
+    static func needsChunking(_ message: String?) -> Bool {
+        guard let message = message else {
+            return false
+        }
+
+        let messageBytes = message.data(using: .utf8)?.count ?? 0
+        let needsChunking = messageBytes > MESSAGE_SIZE_THRESHOLD
+
+        if needsChunking {
+            print("MessageChunker: Message size \(messageBytes) exceeds threshold \(MESSAGE_SIZE_THRESHOLD), will chunk")
+        }
+
+        return needsChunking
+    }
+
+    /**
+     * Create chunks from a message that's too large for single transmission.
+     * Uses compact keys to minimize per-chunk overhead.
+     * @param originalJson The original JSON string to be sent (before C-wrapping)
+     * @param messageId The message ID for ACK tracking (if applicable)
+     * @return Array of chunk dictionaries ready to be C-wrapped and sent
+     */
+    static func createChunks(originalJson: String, messageId: Int64 = -1, wakeUp: Bool = false) -> [[String: Any]] {
+        guard let messageData = originalJson.data(using: .utf8) else {
+            print("MessageChunker: Failed to convert message to data")
+            return []
+        }
+
+        let totalBytes = messageData.count
+
+        // Compact chunk session ID: messageId_timestamp (no "chunk_" prefix)
+        let chunkId = "\(messageId)_\(Int(Date().timeIntervalSince1970 * 1000))"
+
+        for chunkSize in stride(from: INITIAL_CHUNK_DATA_SIZE, through: MIN_CHUNK_DATA_SIZE, by: -1) {
+            let chunks = buildChunks(messageData, chunkId: chunkId, messageId: messageId, chunkSize: chunkSize)
+            if allChunksFit(chunks, wakeUp: wakeUp) {
+                print("MessageChunker: Creating \(chunks.count) chunks for message of size \(totalBytes) bytes using \(chunkSize)-byte UTF-8 slices")
+                return chunks
+            }
+        }
+
+        print("MessageChunker: Unable to create K900 chunks within \(MAX_PACKED_CHUNK_SIZE) bytes")
+        return []
+    }
+
+    private static func buildChunks(_ messageData: Data, chunkId: String, messageId: Int64, chunkSize: Int) -> [[String: Any]] {
+        var chunks: [[String: Any]] = []
+        let chunkStrings = splitUtf8(messageData, chunkSize: chunkSize)
+        let totalChunks = chunkStrings.count
+
+        for i in 0 ..< totalChunks {
+            let chunkString = chunkStrings[i]
+
+            // Create chunk dictionary with compact keys
+            var chunk: [String: Any] = [
+                "t": "ck",
+                "id": chunkId,
+                "c": i,
+                "n": totalChunks,
+                "d": chunkString,
+            ]
+
+            // Add message ID to final chunk only for ACK tracking
+            if i == totalChunks - 1, messageId != -1 {
+                chunk["mId"] = messageId
+            }
+
+            chunks.append(chunk)
+
+            print("MessageChunker: Created chunk \(i)/\(totalChunks - 1) with \(chunkString.data(using: .utf8)?.count ?? 0) bytes")
+        }
+
+        return chunks
+    }
+
+    private static func allChunksFit(_ chunks: [[String: Any]], wakeUp: Bool) -> Bool {
+        for (index, chunk) in chunks.enumerated() {
+            let packedLength = packedK900Length(chunk, wakeUp: wakeUp && index == 0)
+            if packedLength == nil || packedLength! > MAX_PACKED_CHUNK_SIZE {
+                print("MessageChunker: Chunk \(index) packed to \(packedLength ?? 0) bytes, exceeding \(MAX_PACKED_CHUNK_SIZE)")
+                return false
+            }
+        }
+        return true
+    }
+
+    private static func packedK900Length(_ chunk: [String: Any], wakeUp: Bool) -> Int? {
+        guard let chunkData = try? JSONSerialization.data(withJSONObject: chunk),
+              let chunkString = String(data: chunkData, encoding: .utf8)
+        else {
+            return nil
+        }
+
+        var wrapper: [String: Any] = ["C": chunkString]
+        if wakeUp {
+            wrapper["W"] = 1
+        }
+
+        guard let wrappedData = try? JSONSerialization.data(withJSONObject: wrapper) else {
+            return nil
+        }
+
+        return wrappedData.count + K900_FRAME_OVERHEAD
+    }
+
+    private static func splitUtf8(_ messageData: Data, chunkSize: Int) -> [String] {
+        var chunkStrings: [String] = []
+        var offset = 0
+        while offset < messageData.count {
+            let endIndex = findUtf8ChunkEnd(messageData, startIndex: offset, chunkSize: chunkSize)
+            let chunkData = messageData.subdata(in: offset ..< endIndex)
+            chunkStrings.append(String(data: chunkData, encoding: .utf8)!)
+            offset = endIndex
+        }
+        return chunkStrings
+    }
+
+    private static func findUtf8ChunkEnd(_ messageData: Data, startIndex: Int, chunkSize: Int) -> Int {
+        var endIndex = min(startIndex + chunkSize, messageData.count)
+        while endIndex > startIndex, endIndex < messageData.count, isUtf8ContinuationByte(messageData[endIndex]) {
+            endIndex -= 1
+        }
+        return endIndex > startIndex ? endIndex : min(startIndex + chunkSize, messageData.count)
+    }
+
+    private static func isUtf8ContinuationByte(_ value: UInt8) -> Bool {
+        (value & 0xC0) == 0x80
+    }
+
+    /**
+     * Check if a received message is a chunked message.
+     * Supports both verbose ("type":"chunked_msg") and compact ("t":"ck") formats.
+     * @param json The received dictionary (after C-unwrapping)
+     * @return true if this is a chunked message
+     */
+    static func isChunkedMessage(_ json: [String: Any]?) -> Bool {
+        guard let json = json else {
+            return false
+        }
+
+        let type = json["type"] as? String ?? json["t"] as? String ?? ""
+        return type == "chunked_msg" || type == "ck"
+    }
+
+    /**
+     * Extract chunk information from a chunked message.
+     * Supports both verbose and compact key formats.
+     */
+    static func getChunkInfo(_ json: [String: Any]) -> ChunkInfo? {
+        guard isChunkedMessage(json) else {
+            return nil
+        }
+
+        // Support both verbose and compact keys
+        guard let chunkId = (json["chunkId"] as? String) ?? (json["id"] as? String),
+              let chunkIndex = (json["chunk"] as? Int) ?? (json["c"] as? Int),
+              let totalChunks = (json["total"] as? Int) ?? (json["n"] as? Int),
+              let data = (json["data"] as? String) ?? (json["d"] as? String)
+        else {
+            print("MessageChunker: Failed to extract chunk info from JSON")
+            return nil
+        }
+
+        let messageId = json["mId"] as? Int64 ?? -1
+
+        return ChunkInfo(
+            chunkId: chunkId,
+            chunkIndex: chunkIndex,
+            totalChunks: totalChunks,
+            data: data,
+            messageId: messageId
+        )
+    }
+
+    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
+     */
+    struct ChunkInfo {
+        let chunkId: String
+        let chunkIndex: Int
+        let totalChunks: Int
+        let data: String
+        let messageId: Int64
+
+        var isFinalChunk: Bool {
+            return chunkIndex == totalChunks - 1
+        }
+    }
+}

package/ios/Source/utils/Models.swift

@@ -0,0 +1,135 @@
+//
+//  Models.swift
+//  Glassly_Manager
+//
+//  Created by Matthew Fosse on 3/3/25.
+//
+
+import Foundation
+
+struct AiResponseToG1Model {
+    var lines: [String]
+    var totalPages: UInt8
+    var newScreen: Bool
+    var currentPage: UInt8 {
+        didSet {
+            print("SET : currentPage :\(currentPage)")
+        }
+    }
+
+    var maxPages: UInt8
+    var status: DisplayStatus
+}
+
+struct ThirdPartyCloudApp {
+    let packageName: String
+    let name: String
+    let description: String
+    let webhookURL: String
+    let logoURL: String
+    let isRunning: Bool
+}
+
+/// NCSNotification structure
+struct NCSNotification: Codable {
+    let msgId: Int
+    let type: Int
+    let appIdentifier: String
+    let title: String
+    let subtitle: String
+    let message: String
+    let timeS: Int
+    let date: String
+    let displayName: String
+
+    enum CodingKeys: String, CodingKey {
+        case msgId = "msg_id"
+        case type
+        case appIdentifier = "app_identifier"
+        case title
+        case subtitle
+        case message
+        case timeS = "time_s"
+        case date
+        case displayName = "display_name"
+    }
+
+    init(msgId: Int, appIdentifier: String, title: String, subtitle: String, message: String, displayName: String, type: Int = 1) {
+        self.msgId = msgId
+        self.type = type
+        self.appIdentifier = appIdentifier
+        self.title = title
+        self.subtitle = subtitle
+        self.message = message
+        timeS = Int(Date().timeIntervalSince1970)
+
+        let dateFormatter = DateFormatter()
+        dateFormatter.dateFormat = "yyyy-MM-dd HH:mm:ss"
+        date = dateFormatter.string(from: Date())
+
+        self.displayName = displayName
+    }
+}
+
+/// Notification structure
+struct G1Notification: Codable {
+    let ncsNotification: NCSNotification
+    let type: String = "Add"
+
+    enum CodingKeys: String, CodingKey {
+        case ncsNotification = "ncs_notification"
+        case type
+    }
+
+    /// Convert to JSON dictionary
+    func toJson() -> [String: Any] {
+        guard let data = try? JSONEncoder().encode(self) else { return [:] }
+        guard let jsonObject = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+            return [:]
+        }
+        return jsonObject
+    }
+
+    /// Convert to JSON Data
+    func toData() -> Data? {
+        guard let jsonString = try? JSONEncoder().encode(self) else { return nil }
+        return jsonString
+    }
+
+    /// Build notification chunks
+    func constructNotification() async -> [[UInt8]] {
+        guard let jsonData = toData() else { return [] }
+
+        let maxChunkSize = 176 // 180 - 4 bytes for header
+        var chunks: [Data] = []
+
+        // Split data into chunks
+        var offset = 0
+        while offset < jsonData.count {
+            let endIndex = min(offset + maxChunkSize, jsonData.count)
+            let chunkData = jsonData.subdata(in: offset ..< endIndex)
+            chunks.append(chunkData)
+            offset = endIndex
+        }
+
+        let totalChunks = UInt8(chunks.count)
+        var encodedChunks: [[UInt8]] = []
+
+        // Create packets with headers
+        for (index, chunk) in chunks.enumerated() {
+            let notifyId: UInt8 = 0 // Set appropriate notification ID
+            let header: [UInt8] = [0x4B, notifyId, totalChunks, UInt8(index)]
+
+            // Convert chunk data to array of bytes
+            var chunkBytes = [UInt8](chunk)
+
+            // Combine header and chunk
+            var encodedChunk = header
+            encodedChunk.append(contentsOf: chunkBytes)
+
+            encodedChunks.append(encodedChunk)
+        }
+
+        return encodedChunks
+    }
+}

package/ios/Source/utils/PhoneAudioMonitor.swift

@@ -0,0 +1,230 @@
+//
+//  PhoneAudioMonitor.swift
+//  AOS
+//
+//  Monitors iOS system audio playback state
+//
+//  Used to detect when the phone is playing audio (music, podcasts, etc.)
+//  so we can temporarily suspend the LC3 microphone on MentraLive glasses
+//  to avoid overloading the MCU when both A2DP output and LC3 mic input
+//  are active simultaneously.
+//
+//  This class mirrors the Android PhoneAudioMonitor.kt implementation.
+//
+
+import AVFoundation
+import Foundation
+
+/// Listener protocol for phone audio state changes
+protocol PhoneAudioMonitorListener: AnyObject {
+    func onPhoneAudioStateChanged(isPlaying: Bool)
+}
+
+/// Monitors system audio playback to detect when the phone is playing audio
+class PhoneAudioMonitor {
+    /// Singleton instance
+    private static var instance: PhoneAudioMonitor?
+
+    private weak var listener: PhoneAudioMonitorListener?
+    private var isMonitoring = false
+    private var lastKnownState = false
+
+    /// Track our own app's audio playback state
+    /// isOtherAudioPlaying only detects OTHER apps, not our own
+    private var ownAppAudioPlaying = false
+
+    // Polling timer for fallback detection
+    private var pollingTimer: Timer?
+    private let pollingIntervalSeconds: TimeInterval = 1.0
+
+    private init() {
+        Bridge.log("PhoneAudioMonitor: Initialized")
+    }
+
+    static func getInstance() -> PhoneAudioMonitor {
+        if instance == nil {
+            instance = PhoneAudioMonitor()
+        }
+        return instance!
+    }
+
+    /// Check if any audio is currently playing on the device (including our own app)
+    func isPlaying() -> Bool {
+        let session = AVAudioSession.sharedInstance()
+        // Combine: other apps playing OR our own app playing
+        return session.isOtherAudioPlaying || ownAppAudioPlaying
+    }
+
+    func isOwnAppAudioPlaying() -> Bool {
+        ownAppAudioPlaying
+    }
+
+    /// Notify the monitor that our own app started/stopped playing audio
+    /// Called from RN AudioPlaybackService via Bridge
+    func setOwnAppAudioPlaying(_ playing: Bool) {
+        guard ownAppAudioPlaying != playing else { return }
+
+        ownAppAudioPlaying = playing
+        Bridge.log("PhoneAudioMonitor: Own app audio -> \(playing ? "PLAYING" : "STOPPED")")
+
+        // Immediately notify listener if overall state changed
+        notifyIfStateChanged(isPlaying())
+    }
+
+    /// Start monitoring for phone audio playback changes
+    ///
+    /// - Parameter listener: Callback to receive audio state change notifications
+    func startMonitoring(listener: PhoneAudioMonitorListener) {
+        guard !isMonitoring else {
+            Bridge.log("PhoneAudioMonitor: Already monitoring")
+            return
+        }
+
+        self.listener = listener
+        lastKnownState = isPlaying()
+        isMonitoring = true
+
+        Bridge.log(
+            "PhoneAudioMonitor: Starting audio playback monitoring (initial state: \(lastKnownState ? "playing" : "not playing"))"
+        )
+
+        // Register for silenceSecondaryAudioHint notification
+        // This is fired when other apps start/stop playing audio
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(handleSilenceSecondaryAudioHint),
+            name: AVAudioSession.silenceSecondaryAudioHintNotification,
+            object: nil
+        )
+
+        // Also register for interruption notifications as a supplement
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(handleAudioInterruption),
+            name: AVAudioSession.interruptionNotification,
+            object: nil
+        )
+
+        // Start polling as a fallback mechanism
+        // Some audio sources might not trigger notifications reliably
+        startPolling()
+    }
+
+    /// Stop monitoring for phone audio playback changes
+    func stopMonitoring() {
+        guard isMonitoring else {
+            Bridge.log("PhoneAudioMonitor: Not currently monitoring")
+            return
+        }
+
+        Bridge.log("PhoneAudioMonitor: Stopping audio playback monitoring")
+
+        NotificationCenter.default.removeObserver(
+            self,
+            name: AVAudioSession.silenceSecondaryAudioHintNotification,
+            object: nil
+        )
+
+        NotificationCenter.default.removeObserver(
+            self,
+            name: AVAudioSession.interruptionNotification,
+            object: nil
+        )
+
+        stopPolling()
+
+        listener = nil
+        isMonitoring = false
+    }
+
+    /// Handle silenceSecondaryAudioHint notification
+    @objc private func handleSilenceSecondaryAudioHint(_ notification: Notification) {
+        guard let userInfo = notification.userInfo,
+              let typeValue = userInfo[AVAudioSessionSilenceSecondaryAudioHintTypeKey] as? UInt,
+              let type = AVAudioSession.SilenceSecondaryAudioHintType(rawValue: typeValue)
+        else {
+            return
+        }
+
+        let isPlaying: Bool
+        switch type {
+        case .begin:
+            // Another app started playing audio
+            isPlaying = true
+            Bridge.log("PhoneAudioMonitor: Received silenceSecondaryAudioHint - begin")
+        case .end:
+            // Another app stopped playing audio
+            isPlaying = false
+            Bridge.log("PhoneAudioMonitor: Received silenceSecondaryAudioHint - end")
+        @unknown default:
+            // Check actual state for unknown types
+            isPlaying = self.isPlaying()
+        }
+
+        notifyIfStateChanged(isPlaying)
+    }
+
+    /// Handle audio interruption notifications
+    @objc private func handleAudioInterruption(_ notification: Notification) {
+        guard let userInfo = notification.userInfo,
+              let typeValue = userInfo[AVAudioSessionInterruptionTypeKey] as? UInt,
+              let type = AVAudioSession.InterruptionType(rawValue: typeValue)
+        else {
+            return
+        }
+
+        switch type {
+        case .began:
+            // Audio was interrupted (e.g., phone call, other app took audio focus)
+            Bridge.log("PhoneAudioMonitor: Audio interruption began")
+            // Don't necessarily mean audio is playing - check actual state
+            notifyIfStateChanged(isPlaying())
+        case .ended:
+            Bridge.log("PhoneAudioMonitor: Audio interruption ended")
+            // Small delay to let audio state settle
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) { [weak self] in
+                guard let self = self else { return }
+                self.notifyIfStateChanged(self.isPlaying())
+            }
+        @unknown default:
+            break
+        }
+    }
+
+    /// Start polling isOtherAudioPlaying as a fallback mechanism
+    private func startPolling() {
+        pollingTimer = Timer.scheduledTimer(
+            withTimeInterval: pollingIntervalSeconds,
+            repeats: true
+        ) { [weak self] _ in
+            guard let self = self, self.isMonitoring else { return }
+
+            let currentState = self.isPlaying()
+            self.notifyIfStateChanged(currentState)
+        }
+    }
+
+    /// Stop the polling mechanism
+    private func stopPolling() {
+        pollingTimer?.invalidate()
+        pollingTimer = nil
+    }
+
+    /// Notify listener if state has changed
+    private func notifyIfStateChanged(_ isPlaying: Bool) {
+        guard isPlaying != lastKnownState else { return }
+
+        lastKnownState = isPlaying
+        Bridge.log("PhoneAudioMonitor: Audio state changed -> \(isPlaying ? "PLAYING" : "STOPPED")")
+
+        DispatchQueue.main.async { [weak self] in
+            self?.listener?.onPhoneAudioStateChanged(isPlaying: isPlaying)
+        }
+    }
+
+    /// Clean up resources
+    func destroy() {
+        stopMonitoring()
+        PhoneAudioMonitor.instance = nil
+    }
+}