react-native-mytatva-rn-sdk 1.2.20 → 1.2.22

package/ios/Support/BluetoothManager.swift

@@ -1,472 +0,0 @@
-//
-//  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)
-            }
-           
-        }
-    }
-
-}