react-native-mytatva-rn-sdk 1.2.3 → 1.2.5

package/ios/Support/BluetoothManager.swift

@@ -0,0 +1,472 @@
+//
+//  BluetoothManager.swift
+//  MyTatvaCare
+//
+//  Created by Nirav Ramani on 12/05/25.
+//
+
+import CoreBluetooth
+
+protocol BluetoothManagerDelegate: AnyObject {
+    func didDiscoverDevice(_ device: CBPeripheral)
+    func didConnectDevice(_ device: CBPeripheral)
+    func didFailToConnect(_ device: CBPeripheral, error: Error?)
+    func didDisconnectDevice(_ device: CBPeripheral, error: Error?)
+}
+
+class BluetoothManager: NSObject {
+
+    static let shared = BluetoothManager()
+
+    private(set) var centralManager: CBCentralManager!
+    private(set) var discoveredDevices: [(CBPeripheral,String)] = []
+    private(set) var peripherals: [CBPeripheral] = []
+    
+    private var connectedPeripheral: CBPeripheral?
+    private var connectedDeviceName: String = ""
+    
+    weak var delegate: BluetoothManagerDelegate?
+
+    var writeReadCharacteristic: CBCharacteristic?
+    var notifyCharacteristic: CBCharacteristic?
+    var eDevice: EDevice?
+    private override init() {
+        super.init()
+        centralManager = CBCentralManager(delegate: self, queue: nil)
+    }
+
+    func startScanning() {
+        discoveredDevices.removeAll()
+        centralManager.scanForPeripherals(withServices: nil, options: nil)
+        print("Started scanning for peripherals...")
+    }
+
+    func stopScanning() {
+        centralManager.stopScan()
+        print("Stopped scanning.")
+    }
+
+    func connect(to peripheral: CBPeripheral, name: String) {
+        centralManager.connect(peripheral, options: nil)
+        peripheral.delegate = self
+        connectedPeripheral = peripheral
+        connectedDeviceName = name
+    }
+
+    func disconnect() {
+        if let peripheral = connectedPeripheral {
+            centralManager.cancelPeripheralConnection(peripheral)
+        }
+    }
+    
+    func requestResendCT3() {
+        if let eDevice = eDevice,
+           let writeReadCharacteristic = writeReadCharacteristic {
+            if let value = ProtocalTools.check_request(eDevice) {
+                connectedPeripheral?.writeValue(value,
+                                                for: writeReadCharacteristic,
+                                                type: .withoutResponse)
+            }
+        }
+        /*guard let currentDevice = currentDevice else { return }
+
+        if KLTLocalSettingManager.shareInstance.canConnectOtherDevice {
+            if let eDevice = eDevice,
+               let writeReadCharacteristic = writeReadCharacteristic {
+                if let value = ProtocalTools.check_request(eDevice) {
+                    connectedPeripheral?.writeValue(value,
+                                                    for: writeReadCharacteristic,
+                                                    type: .withoutResponse)
+                }
+            }
+        } else {
+            let maxGlucoseId = KLTDatabaseHandler.shared()
+                .getLatestAndMaxGlucoseId(of: currentDevice)
+            pullGlucouseSeriesRequest(glucoseId: maxGlucoseId)
+        }*/
+    }
+
+}
+
+// MARK: - CBCentralManagerDelegate
+
+extension BluetoothManager: CBCentralManagerDelegate {
+    func centralManagerDidUpdateState(_ central: CBCentralManager) {
+        if central.state == .poweredOn {
+            startScanning()
+        } else {
+            print("Central Manager State: \(central.state.rawValue)")
+        }
+    }
+
+    func centralManager(_ central: CBCentralManager, didDiscover peripheral: CBPeripheral,
+                        advertisementData: [String : Any], rssi RSSI: NSNumber) {
+        print("Discovered: \(peripheral.name ?? "Unknown") - RSSI: \(RSSI)",advertisementData["kCBAdvDataLocalName"])
+        guard let name = advertisementData["kCBAdvDataLocalName"] as? String, name.hasPrefix("SN") else { return }
+        if !discoveredDevices.contains(where: { $0.0 == peripheral }) {
+            discoveredDevices.append((peripheral,name))
+            print("advertisementData-kCBAdvDataLocalName",advertisementData["kCBAdvDataLocalName"])
+            eDevice = EDevice.getEnumDevice(advertisementData["kCBAdvDataLocalName"] as? String ?? "")
+            
+            delegate?.didDiscoverDevice(peripheral)
+        }
+    }
+
+    func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) {
+        print("Connected to: \(peripheral.name ?? "Unknown")")
+        delegate?.didConnectDevice(peripheral)
+        peripheral.delegate = self
+        if let eDevice = eDevice {
+            peripheral.discoverServices([CBUUID(string: eDevice.eGattMessage.uuid_SERVICE)])
+        }
+    }
+
+    func centralManager(_ central: CBCentralManager, didFailToConnect peripheral: CBPeripheral, error: Error?) {
+        print("Failed to connect: \(error?.localizedDescription ?? "Unknown error")")
+        delegate?.didFailToConnect(peripheral, error: error)
+    }
+
+    func centralManager(_ central: CBCentralManager, didDisconnectPeripheral peripheral: CBPeripheral, error: Error?) {
+        print("Disconnected from: \(peripheral.name ?? "Unknown")")
+        delegate?.didDisconnectDevice(peripheral, error: error)
+    }
+}
+
+// MARK: - CBPeripheralDelegate
+
+extension BluetoothManager: CBPeripheralDelegate {
+    func peripheral(_ peripheral: CBPeripheral, didDiscoverServices error: Error?) {
+        if let error = error {
+            print("Service discovery failed: \(error.localizedDescription)")
+            return
+        }
+        guard let services = peripheral.services else { return }
+        for service in services {
+            print("Discovered service: \(service.uuid)")
+            peripheral.discoverCharacteristics(nil, for: service)
+        }
+    }
+
+    func peripheral(_ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error: Error?) {
+        if let error = error {
+            print("Characteristic discovery failed: \(error.localizedDescription)")
+            return
+        }
+        service.characteristics?.forEach {
+            print("Discovered characteristic: \($0.uuid)")
+        }
+        guard let characteristics = service.characteristics else { return }
+
+        for characteristic in characteristics {
+            /*if characteristic.properties.contains(.notify) {
+                peripheral.setNotifyValue(true, for: characteristic)
+            }
+            
+            if characteristic.properties.contains(.read) {
+                peripheral.readValue(for: characteristic)
+            }*/
+            guard let eDevice = eDevice else { return }
+            if characteristic.uuid == CBUUID(string: eDevice.eGattMessage.uuid_WRITE) {
+                writeReadCharacteristic = characteristic
+                if eDevice.deviceType == "CT4" {
+                    // CT3 / CT4 handle first bind & reconnect logic
+                    requestResendCT3()
+                }
+            }
+
+            if characteristic.uuid == CBUUID(string: eDevice.eGattMessage.uuid_READ) {
+                notifyCharacteristic = characteristic
+                peripheral.setNotifyValue(true, for: characteristic)
+            }
+        }
+    }
+    
+    func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic, error: Error?) {
+        guard error == nil else { return }
+        //handleResendDataWithPrefix22(characteristic.value!)
+
+        guard let eDevice = eDevice else { return }
+        if characteristic.uuid == CBUUID(string: eDevice.eGattMessage.uuid_READ) {
+            guard let value = characteristic.value, !value.isEmpty else { return }
+            
+            let hex = KLTFormat.dataToHexString(value, isReverse: false)
+            let command = String(hex.prefix(2))
+            
+            switch command {
+            case "05":
+                // CT3/CT4 self-check protocol response (only checks voltage >= 3.9)
+                let ret: HW_CHECK_RET = ProtocalTools.check_response(value, andEDevice: eDevice)
+              
+                switch ret {
+                case .SUCCESS:
+                    //KLTDatabaseHandler.shared.updateDevice(currentDevice, initialBeginDate: nil, endDate: nil)
+                    if let writeReadCharacteristic = writeReadCharacteristic {
+                        if let data = ProtocalTools.setDate_request(eDevice) {
+                            peripheral.writeValue(data, for: writeReadCharacteristic, type: .withoutResponse)
+                        }
+                    }
+                case .FAIL_POWER:
+                    //NotificationCenter.default.post(name: Notification.Name(KLTAlertSelfCheckFailedNotify), object: ret.rawValue)
+                    resetBleSensorData()
+                    
+                case .FAIL:
+                    //status = .closed
+                    resetBleSensorData()
+                default:
+                    break
+                }
+
+            case "22":
+                // CT4 retransmitted data, response for pullGlucose_series_request
+                handleResendDataWithPrefix22(value)
+                
+            case "03":
+                 //CT4 set time protocol response
+                if ProtocalTools.setDate_response(value, andEDevice: eDevice) {
+                    if let writeReadCharacteristic = writeReadCharacteristic {
+                        if let data = ProtocalTools.start_init_request(eDevice) {
+                            connectedPeripheral?.writeValue(data, for: writeReadCharacteristic, type: .withoutResponse)
+                        }
+                    }
+                } else {
+                    //status = .closed
+                    resetBleSensorData()
+                }
+                break
+            case "06":
+                // Initialization protocol response
+//                if ProtocalTools.init_response(value, andEDevice: eDevice) {
+//                    KLTLocalSettingManager.shareInstance.canConnectOtherDevice = false
+//
+//                    let snLocalName = currentDevice.advertise.localName
+//                    let runLog = KLTAppDelegate.getCurrentKLTRunLog()
+//                    runLog.createNewCSV(snLocalName)
+//
+//                    status = .initialStart
+//                    isInResend = false
+//
+//                    let interval = Date().timeIntervalSinceReferenceDate + 180 * TimeInterval(eDevice.initNumber)
+//                    let newDate = Date(timeIntervalSinceReferenceDate: interval)
+//                    KLTDatabaseHandler.shared.updateDevice(currentDevice, initialBeginDate: Date().getWholeString(), endDate: newDate.getWholeString())
+//
+//                    dataType = .receiveDataBeforeSetUserReference
+//
+//                    let lowPowerData = ProtocalTools.lowPower_request(eDevice)
+//                    connectedPeripheral?.writeValue(lowPowerData, for: writeReadCharacteristic, type: .withoutResponse)
+//
+//                    let recordId = "\(snLocalName)_\(Int(Date().timeIntervalSince1970))"
+//                    UserDefaults.standard.set(recordId, forKey: "wearingRecordId")
+//                    UserDefaults.standard.synchronize()
+//                } else {
+//                    status = .closed
+//                    resetBleSensorData()
+//                }
+                break
+            case "07":
+                // Data received every 3 minutes
+                handleReceiveDataWithPrefix07(value)
+
+            case "0A":
+                // Unbind protocol response
+//                let success = ProtocalTools.unBind_response(value, andEDevice: eDevice)
+//                if success {
+//                    status = .closed
+//                    resetBleSensorData()
+//                    bluetoothDelegate?.onFindDevices(peripherals, connectedDevice: nil)
+//                }
+break
+            case "11":
+                // Reset protocol response after retransmission
+//                let resetData = ProtocalTools.reset_response2(value, andEDevice: eDevice)
+//                if resetData.isBind {
+//                    let lowPowerData = ProtocalTools.lowPower_request(eDevice)
+//                    peripheral.writeValue(lowPowerData, for: writeReadCharacteristic, type: .withoutResponse)
+//                } else {
+//                    status = .sensorLostPower
+//                }
+break
+            default:
+                break
+            }
+        }
+    }
+    
+    func peripheral(_ peripheral: CBPeripheral, didWriteValueFor characteristic: CBCharacteristic, error: (any Error)?) {
+        
+    }
+    
+    func peripheral(_ peripheral: CBPeripheral, didUpdateNotificationStateFor characteristic: CBCharacteristic, error: (any Error)?) {
+        guard let eDevice = eDevice else { return }
+        guard characteristic.uuid == CBUUID(string: eDevice.eGattMessage.uuid_READ) else {
+             return
+         }
+         
+         print(#function)  // Equivalent to KLTLog(@"%s", __FUNCTION__)
+         
+         if !characteristic.isNotifying {
+             centralManager?.cancelPeripheralConnection(peripheral)
+         }
+    }
+    // CT3/CT4 每3分钟上来的数据
+    func handleReceiveDataWithPrefix07(_ receiveData: Data) {
+        /*if status == .resendStart || isInResend {
+            // 重发数据期间不处理新收到的数据
+            return
+        }*/
+
+        //let maxGlucoseId = KLTDatabaseHandler.shared().getLatestAndMaxGlucoseId(of: currentDevice)
+        guard let gluData = ProtocalTools.getGlucose(receiveData, andEDevice: eDevice) else {
+            return
+        }
+        
+        handleReceiveDataWithPrefix07Glucose(gluData)
+        /*if gluData.gluID == maxGlucoseId + 1 {
+            handleReceiveDataWithPrefix07Glucose(gluData)
+        } else if gluData.gluID > maxGlucoseId + 1 {
+            // 如果拿到的数据大于下一条数据的gluID，证明需要重新拉取中间漏掉的数据（22拉取协议）
+            pullGlucouseSeriesRequest(withGlucoseId: maxGlucoseId)
+        }*/
+    }
+    
+    func handleReceiveDataWithPrefix07Glucose(_ gluData: Glucose) {
+        let glucoseId = gluData.gluID
+        let operatingCurrent = gluData.iw
+        let blankCurrent = gluData.ib
+        let temperature = gluData.t
+        print("glucoseId: \(glucoseId),operatingCurrent: \(operatingCurrent), blankCurrent: \(blankCurrent), temperature: \(temperature)")
+        //sendCGMLog()
+        
+        let cgmLogs = CGMLog(timeInMillis: Double(Date().timeIntervalSince1970 * 1000),
+                             countdownMinutes: 42,
+                             countdownDays: 12,
+                             hypoglycemiaEarlyWarnMinutes: 8,
+                             showGlucoseMG: 140,
+                             glucoseId: Int(glucoseId),
+                             name: connectedDeviceName,
+                             bytes: [1,2,3],
+                             showGlucose: 5.67 ,
+                             Ib: blankCurrent,
+                             Iw: operatingCurrent,
+                             countdownHours: 15,
+                             T: temperature,
+                             year: gluData.year,
+                             month: gluData.month,
+                             day: gluData.day,
+                             hour: gluData.hour,
+                             minute: gluData.minute,
+                             trendObject: TrendObject(trendId: 11, drawableId: 2103818652, widgetImg: -1, apsChangeRate: "FLAT"),
+                             glucoseStatusObject: GlucoseStatusObject(statusId: 1),
+                             errorObject: ErrorObject(errorId: 1, sound: "None"))
+        let payload = Payload(logs: [cgmLogs])
+        API.shared.postCGMData(environment: .stage, data: payload) {
+            print("Success")
+        } onFailure: { error in
+            print("Error")
+        }
+
+        /*let receive = handleCommonReceiveGluData(gluData, commandText: "07")
+        
+        NotificationCenter.default.post(name: Notification.Name("didReceiveNewData"), object: receive)
+        
+        handleCommonCT3GlucoseData(withReceiveData: receive)
+        
+        NotificationCenter.default.post(name: Notification.Name("DidHandleResendDataNoReload"), object: nil)
+        
+        let remainPoints = KLTDatabaseHandler.shared().numberOfLifeCycleSensor(
+            withDevice: currentDevice,
+            endNumber: eDevice.endNumber
+        )
+        
+        if remainPoints <= 0 {
+            closeBleSensor()
+        }*/
+    }
+
+    func resetBleSensorData() {
+        // Disconnect from peripheral and stop listening to characteristics
+        terminateConnection()
+
+        /*if let currentDevice = self.currentDevice {
+            currentDevice.userBG = nil
+            currentDevice.connectedDateTime = nil
+            currentDevice.disconnectedDateTime = nil
+            currentDevice.initialBeginDate = nil
+            currentDevice.initialEndDate = nil
+
+            KLTDatabaseHandler.shared().appDelegate.saveContext()
+        }*/
+
+        //self.currentDevice = nil
+        //self.dataType = .receiveDataBeforeSetUserReference
+        //self.resendType = .resendDataBeforeSetUserBG
+
+        self.peripherals.removeAll()
+        self.connectedPeripheral = nil
+
+        //connectTimer?.invalidate()
+        //connectTimer = nil
+        //rescanTimer?.invalidate()
+        //rescanTimer = nil
+
+        //UserDefaults.standard.removeObject(forKey: KLTLocalDeviceQRCodeInfoKey)
+        //KLTLocalSettingManager.shared.canConnectOtherDevice = true
+        UserDefaults.standard.set(nil, forKey: "silenceStart")
+        UserDefaults.standard.set(nil, forKey: "alertKindOnSilence")
+        UserDefaults.standard.synchronize()
+    }
+    func terminateConnection() {
+        for peripheral in peripherals {
+            if let services = peripheral.services {
+                for service in services {
+                    if let characteristics = service.characteristics {
+                        for characteristic in characteristics {
+                            if let eDevice = eDevice {
+                                if characteristic.uuid == CBUUID(string: eDevice.eGattMessage.uuid_READ) {
+                                    if characteristic.isNotifying {
+                                        peripheral.setNotifyValue(false, for: characteristic)
+                                        return
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        if let connectedPeripheral = connectedPeripheral {
+            centralManager.cancelPeripheralConnection(connectedPeripheral)
+        }
+    }
+    func handleResendDataWithPrefix22(_ resendData: Data) {
+        //eDevice = EDevice.getEnumDevice(connectedPeripheral?.name ?? "")
+        let glucoseList: [Glucose] = ProtocalTools.getGlucose_series(resendData, andEDevice: eDevice)
+         
+        if glucoseList.isEmpty {
+            // Resend finished
+            //self.isInResend = false
+            //self.status = .resendEnd
+            
+            NotificationCenter.default.post(name: Notification.Name("DidHandleResendData"), object: nil)
+            
+            // Send reset command (0x11) to end resend state
+            if let peripheral = connectedPeripheral, let characteristic = writeReadCharacteristic {
+                if let resetCommand = ProtocalTools.reset_request(eDevice) {
+                    peripheral.writeValue(resetCommand, for: characteristic, type: .withoutResponse)
+                }
+            }
+            
+        } else {
+            for glucose in glucoseList {
+                let glucoseId = glucose.gluID
+                let operatingCurrent = glucose.iw
+                let blankCurrent = glucose.ib
+                let temperature = glucose.t
+                
+                print(glucose)
+            }
+           
+        }
+    }
+
+}

package/ios/Support/Converter/DataConverter.swift

@@ -0,0 +1,34 @@
+//
+//  DataConverter.swift
+//  MyTatvaCare
+//
+//  Created by Nirav Ramani on 31/05/25.
+//
+
+import Foundation
+
+func ReceiveDataToLog(data: ReceiveData) -> CGMLog  {
+    
+    let cgmLogs = CGMLog(timeInMillis: Double(Date().timeIntervalSince1970 * 1000),
+                         countdownMinutes: (data.countdownMinutes as? Int) ?? 0,
+                         countdownDays: (data.countdownDays as? Int) ?? 0,
+                         hypoglycemiaEarlyWarnMinutes: 0, //missing
+                         showGlucoseMG: (data.gluADC as? Int) ?? 0,
+                         glucoseId: Int(truncating: data.glucoseId ?? 0),
+                         name: data.device?.advertise?.localName ?? "",
+                         bytes: [], //missing
+                         showGlucose: (data.glu as? Float) ?? 0 ,
+                         Ib: (data.blankCurrent as? Float) ?? 0,
+                         Iw: (data.operatingCurrent as? Float) ?? 0,
+                         countdownHours: (data.countdownHours as? Int) ?? 0,
+                         T: (data.temperature as? Float) ?? 0.0,
+                         year: (data.year as? Int32) ?? 0,
+                         month: (data.month as? Int32) ?? 0,
+                         day: (data.day as? Int32) ?? 0,
+                         hour: (data.hour as? Int32) ?? 0,
+                         minute: (data.minute as? Int32) ?? 0,
+                         trendObject: TrendObject(trendId: (data.trend as? Int) ?? 0, drawableId: 2103818652, widgetImg: -1, apsChangeRate: "FLAT"),  //missing
+                         glucoseStatusObject: GlucoseStatusObject(statusId: 1),  //missing
+                         errorObject: ErrorObject(errorId: (data.error as? Int) ?? 0, sound: "None"))
+    return cgmLogs
+}

package/ios/Support/Enum.swift

@@ -0,0 +1,37 @@
+//
+//  Enum.swift
+//  MyTatvaCare
+//
+//  Created by Nirav Ramani on 01/06/25.
+//
+
+import Foundation
+/// Represents the various CGM connection states or errors
+enum CGMConnectionStatus: String {
+    /// CGM & Bluetooth are connected (isBoundAndConnect)
+    case connected = "CONNECTED"
+
+    /// CGM is disconnected (isDisConnect)
+    case disconnected = "DISCONNECTED"
+
+    /// Moisture detected – corresponds to `ErrorCode.ERROR_FLOODING_WATER`
+    case moistureDetect = "MOISTURE_DETECT"
+
+    /// Weak signal – possible causes: `ERROR_CURRENT_SMALL`, `ERROR_NOISE`, `ERROR_SENSITIVITY_ATTENUATION`
+    case weakSignal = "WEAK_SIGNAL"
+
+    /// Sensor expired – also managed from backend when `countdownDays`, `countdownMin`, and `countdownHours` become 0
+    case expired = "EXIPRED" // Note: Typo preserved from original string; use with caution or normalize
+
+    /// Transmitter disconnected due to out-of-range issue (isBoundButDisConnect) – see Figma page 8
+    case transmitterDisconnect = "TRANSMITTER_DISCONNECT"
+
+    /// Bluetooth is turned off
+    case bluetoothOff = "BLUETOOTH_OFF"
+
+    /// Transmitter disconnected and unbound (isUnBind) – see Figma page 12
+    case transmitterDisconnectBox = "TRANSMITTER_DISCONNECT_BOX"
+
+    /// Common fallback error when no specific error code is matched
+    case errorCommon = "ERROR_COMMON"
+}

package/ios/Support/EnumDebouncer.swift

@@ -0,0 +1,55 @@
+//
+//  EnumDebouncer.swift
+//  MyTatvaCare
+//
+//  Created by Nirav Ramani on 02/06/25.
+//
+
+import Foundation
+
+class EnumDebouncer<T: Equatable> {
+    private var storedValue: T?
+    private var startTime: Date?
+    private var timer: Timer?
+    private let debounceInterval: TimeInterval = 5 * 60 // 1 hour
+
+    var onDebounceSuccess: ((T) -> Void)?
+
+    func update(with newValue: T) {
+        if storedValue == nil || storedValue != newValue {
+            reset(newValue: newValue)
+        } else if let startTime = startTime {
+            let elapsed = Date().timeIntervalSince(startTime)
+            if elapsed >= debounceInterval {
+                triggerSuccess()
+            }
+        }
+    }
+
+    private func reset(newValue: T) {
+        storedValue = newValue
+        startTime = Date()
+        timer?.invalidate()
+
+        timer = Timer.scheduledTimer(withTimeInterval: debounceInterval, repeats: false) { [weak self] _ in
+            self?.triggerSuccess()
+        }
+    }
+    
+    private func triggerSuccess() {
+        guard let value = storedValue else { return }
+        
+        onDebounceSuccess?(value)
+        
+        // Do NOT reset storedValue — just reset timer and startTime to keep watching
+        startTime = Date()
+        timer?.invalidate()
+        timer = Timer.scheduledTimer(withTimeInterval: debounceInterval, repeats: false) { [weak self] _ in
+            self?.triggerSuccess()
+        }
+    }
+   
+    deinit {
+        timer?.invalidate()
+    }
+}

package/ios/Support/Global.swift

@@ -0,0 +1,12 @@
+//
+//  GLobal.swift
+//  MyTatvaCare
+//
+//  Created by Nirav Ramani on 05/05/25.
+//
+
+import Foundation
+
+enum Enum_stroyboard: String {
+    case Main
+}