capacitor-plugin-ihealth 1.1.0

package/ios/Plugin/ihealthPlugin.swift

@@ -0,0 +1,1502 @@
+import Foundation
+import CoreBluetooth
+import Capacitor
+
+/**
+ * Please read the Capacitor iOS Plugin Development Guide
+ * here: https://capacitorjs.com/docs/plugins/ios
+ */
+@objc(ihealthPlugin)
+public class ihealthPlugin: CAPPlugin,CBCentralManagerDelegate,BG5SDelegate {
+    private var centralManager: CBCentralManager?
+    private var deviceType:HealthDeviceType?
+    private var deviceMacAddress:String?
+    
+    var myBpDevice:KN550BT?
+    var myBP5SDevice:BP5S?
+    var myBBG5SDevice:BG5S?
+    var myPO3Device:PO3?
+    var myPT3SBTDevice:PT3SBT?
+    var myHS4SDevice:HS4?
+    var myHS2SDevice:HS2S?
+    var hs2sDataArray:[Any]?
+    var hs2sUserCount = 0
+    var userIdArr:[Data] = []
+    var timerCount = 0
+    var timer:Timer?
+    var healthUser:HealthUser?
+    var onlinePO3DeviceData : [AnyHashable : Any]?
+    
+    private let implementation = ihealth()
+
+    override public func load() {
+        print("iHealthScanPlugin loaded")
+    }
+    deinit {
+        print("iHealthScanPlugin deinit called")
+        removeDeviceObserver()
+    }
+    public func centralManagerDidUpdateState(_ central: CBCentralManager) {
+        switch central.state {
+        case .unauthorized:
+            switch central.authorization {
+            case .allowedAlways:
+                print("allowedAlways")
+            case .denied:
+                print("denied")
+            case .restricted:
+                print("restricted")
+            case .notDetermined:
+                print("notDetermined")
+            }
+        case .unknown:
+            fallthrough
+        case .unsupported:
+            print("unsupported")
+        case .poweredOn:
+            print("poweredOn")
+        case .poweredOff:
+            print("poweredOff")
+        case .resetting:
+            print("resetting")
+        @unknown default:
+            break
+        }
+    }
+    @objc func initialiseCentralManager(_ call: CAPPluginCall) {
+        centralManager = CBCentralManager(delegate: self, queue: nil)
+        call.resolve(["value":"Success"])
+    }
+    @objc func isBluetoothEnabled(_ call: CAPPluginCall) {
+        //centralManager = CBCentralManager(delegate: self, queue: nil)
+        var isBleEnabled = false
+        if let centralManager = self.centralManager{
+            isBleEnabled = centralManager.state == CBManagerState.poweredOn
+        }else{
+            isBleEnabled = false
+        }
+        call.resolve(["value":isBleEnabled])
+    }
+    
+   @objc func authoriseiHealthSdk(_ call: CAPPluginCall){ //com_inlogic_Test_ios
+    
+        
+        // if let url = Bundle.main.url(forResource:"com_test_EvolMobile_ios", withExtension: "pem") {
+        if let url = Bundle.main.url(forResource:"managemyhealth_co_nz_ios", withExtension: "pem") {
+            do {
+                let data = try Data(contentsOf:url)
+                IHSDKCloudUser.commandGetSDKUserInstance().commandSDKUserValidation(withLicense: data) { deviceAccessArray in
+                    print("device supported \(deviceAccessArray)")
+                } userValidationSuccess: { UserAuthenResult in
+                    call.resolve(["value":"Success"])
+                    
+                } disposeErrorBlock: { errorID in
+                    
+                    var errorMsg = ""
+                    switch (errorID) {
+                    case UserAuthen_InputError:
+                        errorMsg = "Input error"
+                        break
+                    case UserAuthen_CertificateExpired:
+                        errorMsg = "Certificate expired"
+                        break
+                    case UserAuthen_InvalidCertificate:
+                        errorMsg = "Invalid certificate"
+                        break
+                    default:
+                        break
+                    }
+                    call.resolve(["value":"Error","message":errorMsg])
+                    
+                }
+            } catch {
+                print(error)
+            }
+        }
+    }
+    @objc func scanDiscover(_ call: CAPPluginCall) {
+        guard let options = call.options as NSDictionary? as? [String: Any] else { return }
+        
+        let deviceModel = options["deviceModel"]  as? String ?? ""
+        
+        switch deviceModel {
+        case "KN-550BT":
+            self.selectBPTrackAndScan()
+            break
+        case "BP5S":
+            self.selectBP5SAndScan()
+            break
+        case "BG5S":
+            self.selectBG5SAndScan()
+            break
+        case "PO3":
+            self.selectPO3AndScan()
+            break
+        case "PT3SBT":
+            self.selectPT3SBTAndScan()
+            break
+        case "HS4S":
+            self.selectHS4SAndScan()
+            break
+        case "HS2S":
+            self.selectHS2SAndScan()
+            break
+        default:
+            break
+        }
+       // self.bridge?.viewController?.showToast(message: "selected device:\(deviceModel)")
+       
+//
+//        DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {
+//                //call any function
+//            let data = ["deviceMacAddress": "123sk40049", "deviceName": "HS2S"]
+//            self.notifyListeners("deviceDiscover", data: data)
+//            DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
+//                    //call any function
+//                let data = ["deviceMacAddress": "123sk40049", "deviceName": "HS2S"]
+//                self.notifyListeners("deviceConnect", data: data)
+//             }
+//         }
+        
+        call.resolve([
+            "success": "success"
+        ])
+    }
+    @objc func connectDevice(_ call: CAPPluginCall) {
+        if let device = deviceType {
+            ScanDeviceController.commandGetInstance().commandStopScanDeviceType(device)
+            
+        }
+        guard let options = call.options as NSDictionary? as? [String: Any] else { return }
+        let paramDeviceModel = options["deviceModel"]  as? String ?? ""
+        let paramDeviceMacAddress = options["deviceMacAddress"] as? String ?? ""
+        
+        
+        
+        switch paramDeviceModel {
+        case "KN-550BT":
+            self.removeDeviceObserver()
+            self.deviceType = HealthDeviceType._KN550BT
+            self.addObserverWith(discover: KN550BTDiscover, connect: KN550BTConnectNoti, disconnect: KN550BTDisConnectNoti, connectfail: KN550BTConnectFailed)
+            
+            KN550BTController.share()
+            break
+        case "BP5S":
+            self.removeDeviceObserver()
+            self.deviceType = HealthDeviceType._BP5S
+            addObserverWith(discover: BP5SDiscover, connect: BP5SConnectNoti, disconnect: BP5SDisConnectNoti, connectfail: BP5SConnectFailed)
+            BP5SController.shared()
+            break
+        case "BG5S":
+            self.removeDeviceObserver()
+            self.deviceType = HealthDeviceType._BG5S
+            self.addObserverWith(discover: kNotificationNameBG5SDidDiscover, connect: kNotificationNameBG5SConnectSuccess, disconnect: kNotificationNameBG5SDidDisConnect, connectfail: kNotificationNameBG5SConnectFail)
+            
+            BG5SController.shared()
+            break
+        case "PT3SBT":
+            self.removeDeviceObserver()
+            self.deviceType = HealthDeviceType._PT3SBT
+            self.addObserverWith(discover: PT3SBTDiscover, connect: PT3SBTConnectNoti, disconnect: PT3SBTDisConnectNoti, connectfail: PT3SBTConnectFailed)
+            
+            PT3SBTController.shareIHPT()
+            discoverDevice()
+            break
+        case "PO3":
+            self.removeDeviceObserver()
+            self.deviceType = HealthDeviceType._PO3
+            self.addObserverWith(discover: PO3Discover, connect: PO3ConnectNoti, disconnect: PO3DisConnectNoti, connectfail: PO3ConnectFailed)
+            
+            PO3Controller.shareIHPO()
+            break
+        case "HS4S":
+            self.removeDeviceObserver()
+            self.deviceType = HealthDeviceType._HS4
+            self.addObserverWith(discover: HS4Discover, connect: HS4ConnectNoti, disconnect: HS4DisConnectNoti, connectfail: HS4ConnectFailed)
+            
+            HS4Controller.shareIHHs4()
+            break
+        case "HS2S":
+            self.removeDeviceObserver()
+            self.deviceType = HealthDeviceType._HS2S
+            addObserverWith(discover: HS2SDiscover, connect: HS2SConnectNoti, disconnect: HS2SDisConnectNoti, connectfail: HS2SConnectFailed)
+            HS2SController.shareIHHS()
+            break
+        default:
+            break
+        }
+        self.deviceMacAddress = paramDeviceMacAddress
+        if(paramDeviceModel != "PT3SBT"){
+            if let device = self.deviceType, let serialNumber = self.deviceMacAddress {
+                
+                ConnectDeviceController.commandGetInstance().commandContectDevice(with: device, andSerialNub: serialNumber)
+            }
+        }
+        
+        
+        call.resolve([
+            "success": "success"
+        ])
+    }
+    
+    
+    func selectBPTrackAndScan() {
+        removeDeviceObserver()
+        deviceType = HealthDeviceType._KN550BT
+        
+        addObserverWith(discover: KN550BTDiscover, connect: KN550BTConnectNoti, disconnect: KN550BTDisConnectNoti, connectfail: KN550BTConnectFailed)
+        
+        KN550BTController.share()
+        
+        discoverDevice()
+    }
+    func selectBP5SAndScan() {
+        removeDeviceObserver()
+        deviceType = HealthDeviceType._BP5S
+        
+        addObserverWith(discover: BP5SDiscover, connect: BP5SConnectNoti, disconnect: BP5SDisConnectNoti, connectfail: BP5SConnectFailed)
+        
+        BP5SController.shared()
+        
+        discoverDevice()
+    }
+    func selectBG5SAndScan(){
+        removeDeviceObserver()
+        
+        deviceType = HealthDeviceType._BG5S
+        addObserverWith(discover: kNotificationNameBG5SDidDiscover, connect: kNotificationNameBG5SConnectSuccess, disconnect: kNotificationNameBG5SDidDisConnect, connectfail: kNotificationNameBG5SConnectFail)
+        
+        BG5SController.shared()
+        
+        discoverDevice()
+    }
+    
+    func selectPO3AndScan() {
+        removeDeviceObserver()
+        deviceType = HealthDeviceType._PO3
+        addObserverWith(discover: PO3Discover, connect: PO3ConnectNoti, disconnect: PO3DisConnectNoti, connectfail: PO3ConnectFailed)
+        
+        PO3Controller.shareIHPO()
+        
+        discoverDevice()
+    }
+    
+    func selectPT3SBTAndScan() {
+        removeDeviceObserver()
+        deviceType = HealthDeviceType._PT3SBT
+        addObserverWith(discover: PT3SBTDiscover, connect: PT3SBTConnectNoti, disconnect: PT3SBTDisConnectNoti, connectfail: PT3SBTConnectFailed)
+        
+        PT3SBTController.shareIHPT()
+        
+        discoverDevice()
+    }
+    
+    func selectHS4SAndScan() {
+        removeDeviceObserver()
+        deviceType = HealthDeviceType._HS4
+        addObserverWith(discover: HS4Discover, connect: HS4ConnectNoti, disconnect: HS4DisConnectNoti, connectfail: HS4ConnectFailed)
+        
+        HS4Controller.shareIHHs4()
+        
+        discoverDevice()
+    }
+    func selectHS2SAndScan() {
+        removeDeviceObserver()
+        deviceType = HealthDeviceType._HS2S
+        addObserverWith(discover: HS2SDiscover, connect: HS2SConnectNoti, disconnect: HS2SDisConnectNoti, connectfail: HS2SConnectFailed)
+        
+        HS2SController.shareIHHS()
+        
+        discoverDevice()
+    }
+    func discoverDevice() {
+        
+        if let device = deviceType {
+            
+            ScanDeviceController.commandGetInstance().commandScanDeviceType(device)
+        }
+    }
+    
+    func removeDeviceObserver(){
+        
+    
+        NotificationCenter.default.removeObserver(self)
+    }
+    
+    func addObserverWith(discover:String,connect:String,disconnect:String,connectfail:String) {
+        
+        
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(self.deviceDiscover),
+            name: Notification.Name(discover),
+            object: nil)
+        
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(self.deviceConnect),
+            name: Notification.Name(connect),
+            object: nil)
+        
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(self.deviceDisconnect),
+            name: Notification.Name(disconnect),
+            object: nil)
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(self.deviceConnectFail),
+            name: Notification.Name(connectfail),
+            object: nil)
+    }
+    
+    @objc func deviceDiscover(notification:NSNotification) {
+        
+        
+        let notifyObject = notification.userInfo
+        if let serialNumber = notifyObject?["SerialNumber"] as? String, let deviceName = notifyObject?["DeviceName"] as? String{
+            
+            let data = ["deviceMacAddress": serialNumber, "deviceName": deviceName == "HS4" ? "HS4S" : deviceName]
+            self.notifyListeners("deviceDiscover", data: data)
+            self.deviceMacAddress = serialNumber
+            
+            self.connectWithMedicalDevice()
+        }else if let serialNumber = notifyObject?["ID"] as? String{
+            let data = ["deviceMacAddress": serialNumber]
+            self.notifyListeners("deviceDiscover", data: data)
+            self.deviceMacAddress = serialNumber
+            
+            self.connectWithMedicalDevice()
+        }
+        
+        
+    }
+    func connectWithMedicalDevice() {
+        if let device = self.deviceType , let serialNumber = self.deviceMacAddress {
+            ConnectDeviceController.commandGetInstance().commandContectDevice(with: device, andSerialNub: serialNumber)
+        }
+    }
+    @objc func deviceConnectFail(notification:NSNotification) {
+        
+        
+        guard let userInfo = notification.userInfo as NSDictionary? as? [String: Any] else {return}
+        
+        self.discoverDevice()
+        self.notifyListeners("deviceConnectFail", data: userInfo)
+    }
+    
+    @objc func deviceDisconnect(notification:NSNotification) {
+        let notifyObject = notification.userInfo
+        
+        
+        guard let userInfo = notification.userInfo as NSDictionary? as? [String: Any] else {return}
+        self.notifyListeners("deviceDisconnect", data: userInfo)
+        //self.notifyListeners("deviceDisconnect", data: notifyObject)
+    }
+    
+    @objc func deviceConnect(notification:NSNotification) {
+        if let device = deviceType {
+            ScanDeviceController.commandGetInstance().commandStopScanDeviceType(device)
+            
+        }
+        let notifyObject = notification.userInfo
+ 
+        guard let userInfo = notification.userInfo as NSDictionary? as? [String: Any] else {return}
+        self.notifyListeners("deviceConnect", data: userInfo)
+   
+    }
+    
+    //device connected methods
+    
+    
+    @objc func getConnectedDeviceInstance(_ call: CAPPluginCall) {
+        guard let options = call.options as NSDictionary? as? [String: Any] else { return }
+        let deviceModel = options["deviceModel"]  as? String ?? ""
+        deviceMacAddress = options["deviceMacAddress"] as? String ?? ""
+        switch deviceModel {
+        case "KN-550BT":
+            self.deviceType = HealthDeviceType._KN550BT
+            getBPDeviceInstances()
+            break
+        case "BP5S":
+            self.deviceType = HealthDeviceType._BP5S
+            getBP5SDeviceInstances()
+            break
+        case "BG5S":
+            self.deviceType = HealthDeviceType._BG5S
+            getBG5SInstances()
+            break
+        case "PO3":
+            self.deviceType = HealthDeviceType._PO3
+            getPO3Instances()
+            break
+        case "PT3SBT":
+            self.deviceType = HealthDeviceType._PT3SBT
+            getPT3SBTInstances()
+            break
+        case "HS4S":
+            self.deviceType = HealthDeviceType._HS4
+            getHS4SInstances()
+            break
+        case "HS2S":
+            deviceType = HealthDeviceType._HS2S
+            getHS2SInstances()
+            break
+        default:
+            break
+        }
+    }
+    @objc func getDeviceOfflineData(_ call: CAPPluginCall) {
+        
+        
+//        self.hs2sDataArray = [
+//                              ["HS2SMeasureTS":Date(),"HS2SWeigthResult":"68","HS2SDataID":"123dcf456"],
+//                              ["HS2SMeasureTS":Date(),"HS2SWeigthResult":"69","HS2SDataID":"123dcf456"],
+//                              ["HS2SMeasureTS":Date(),"HS2SWeigthResult":"64","HS2SDataID":"123dcf456"],
+//                              ["HS2SMeasureTS":Date(),"HS2SWeigthResult":"56","HS2SDataID":"123dcf456"]]
+//        DispatchQueue.main.asyncAfter(deadline: .now() + 3.0) {
+//            let userData = ["result": self.hs2sDataArray, "deviceModel": "HS2S", "deviceMacAddress": self.deviceMacAddress] as [String : Any]
+//
+//            self.notifyListeners("deviceDatafound", data: userData)
+//        }
+        switch deviceType {
+        case ._KN550BT:
+            self.getBPOfflineData()
+            break
+        case ._BP5S:
+            self.getBP5SOfflineData()
+            break
+        case ._BG5S:
+            self.getBG5SOfflineData()
+            break
+        case ._PO3:
+            self.getPO3OfflineData()
+            break
+        case ._PT3SBT:
+            self.getPT3SBSOfflineData()
+            break
+        case ._HS4:
+            self.getHS4SOfflineData()
+            break
+        case ._HS2S:
+            self.getHS2SOfflineData()
+            break
+        default:
+            break
+        }
+    }
+    @objc func disconnectDevice(_ call: CAPPluginCall) {
+        switch deviceType {
+        case ._KN550BT:
+            disconnectBPTrack()
+            break
+        case ._BP5S:
+            disconnectBP5S()
+            break
+        case ._BG5S:
+            disconnectBG5S()
+            break
+        case ._PO3:
+            disconnectPO3()
+            break
+        case ._PT3SBT:
+            disconnectPT3SBT()
+            break
+        case ._HS4:
+            disconnectHS4S()
+            break
+        case ._HS2S:
+            disconnectHS2S()
+            break
+        default:
+            break
+        }
+    }
+    func deleteDeviceData(_ call: CAPPluginCall){
+        switch deviceType {
+        case ._KN550BT:
+            deleteDataFromBPTrack()
+            break
+        case ._BP5S:
+            deleteDataFromBP5S()
+            break
+        case ._BG5S:
+            deleteDataFromBG5S()
+            break
+        case ._PO3:
+            deleteDataFromPO3()
+            break
+        case ._PT3SBT:
+            deleteDataFromPT3SBT()
+            break
+        case ._HS4:
+            deleteDataFromHS4S()
+            break
+        case ._HS2S:
+            deleteDataFromHS2S()
+            break
+        default:
+            break
+        }
+    }
+    // MARK: Disconnect Device Methods
+    func disconnectBG5S() {
+        
+        myBBG5SDevice?.disconnectDevice()
+    }
+    
+    func disconnectBPTrack() {
+        
+
+        myBpDevice?.commandDisconnectDevice()
+    }
+    func disconnectBP5S() {
+       
+        myBP5SDevice?.commandDisconnectDevice()
+    }
+    func disconnectPO3() {
+        
+        myPO3Device?.commandDisconnect({ isPO3Disconnected in
+            
+        }, withErrorBlock: { error in
+            
+        })
+    }
+    
+    func disconnectPT3SBT() {
+       
+        myPT3SBTDevice?.commandDisconnectDevice()
+    }
+    
+    func disconnectHS4S() {
+        myHS4SDevice?.commandDisconnectDevice()
+    }
+    func disconnectHS2S() {
+        
+        myHS2SDevice?.commandDisconnectDevice()
+    }
+    // MARK: Delete Offline Data Methods
+    func deleteDataFromBPTrack(){
+        self.myBpDevice?.commandDeleteDataSuccessBlock({
+           
+        }, errorBlock: { err in
+            
+        })
+    }
+    func deleteDataFromBP5S(){
+        self.myBP5SDevice?.commandDeleteDataSuccessBlock({
+            
+        }, errorBlock: { err in
+            
+        })
+    }
+    func deleteDataFromBG5S(){
+        self.myBBG5SDevice?.deleteRecord(successBlock: {
+            
+        }, errorBlock: { err, str in
+            
+        })
+    }
+    func deleteDataFromPO3(){
+        
+    }
+    func deleteDataFromPT3SBT(){
+        self.myPT3SBTDevice?.commandDeleteMemorryData({ isSuccess in
+            
+        }, disposeErrorBlock: { err in
+            
+        })
+    }
+    func deleteDataFromHS4S(){
+        
+    }
+    func deleteDataFromHS2S(){
+        //self.myHS2SDevice.dele
+    }
+    
+    // MARK: Get Instances Methods
+    func getBPDeviceInstances() {
+        
+        if let devices = KN550BTController.share().getAllCurrentKN550BTInstace() as? [KN550BT] {
+            for device in devices {
+                if(deviceMacAddress == device.serialNumber) {
+                    myBpDevice = device
+                }
+            }
+        }
+        myBpDevice?.commandFunction({ data in
+            
+        }, errorBlock: { error in
+            
+        })
+    }
+    func getBP5SDeviceInstances() {
+        
+        if let devices = BP5SController.shared().getAllCurrentInstance() as? [BP5S]{
+            for device in devices {
+                if(deviceMacAddress == device.serialNumber) {
+                    
+                    myBP5SDevice = device
+                }
+            }
+        }
+        self.myBP5SDevice?.commandFunction({ data in
+            
+        }, errorBlock: { err in
+            
+        })
+        DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
+            self.startBP5SMeasurement()
+        }
+    }
+    func getBG5SInstances() {
+        
+        if let devices = BG5SController.shared().getAllCurrentInstace() as? [BG5S] {
+            for device in devices {
+                if(deviceMacAddress == device.serialNumber) {
+                    myBBG5SDevice = device
+                    self.myBBG5SDevice?.delegate = self;
+                }
+            }
+        }
+        let timezone = Double(NSTimeZone.system.secondsFromGMT()) / 3600.0
+        
+        myBBG5SDevice?.setTimeWith(Date(), timezone: Float(timezone), successBlock: {
+            print(" succesfully set date ")
+        }, errorBlock: { error, msg in
+            
+        })
+        DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
+            self.startBG5SMeasurement()
+        }
+    }
+    
+    func getPO3Instances() {
+        
+        
+        if let devices = PO3Controller.shareIHPO().getAllCurrentPO3Instace() as? [PO3] {
+            for device in devices {
+                if(deviceMacAddress == device.serialNumber) {
+                    
+                    myPO3Device = device
+                }
+            }
+        }
+        myPO3Device?.commandSyncTime({ istimesynced in
+            
+        }, withErrorBlock: { error in
+            
+        })
+        DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
+            self.startPO3Measurement()
+        }
+        
+    }
+    
+    func getPT3SBTInstances() {
+        
+        if let devices = PT3SBTController.shareIHPT().getAllCurrentPT3SBTInstace() as? [PT3SBT] {
+            for device in devices {
+                
+                if let macAddress = deviceMacAddress{
+                    if(macAddress == device.serialNumber) {
+                        myPT3SBTDevice = device
+                        
+                    }
+                }
+                
+            }
+        }
+        myPT3SBTDevice?.commandFunction({ data in
+        }, disposeErrorBlock: { error in
+        })
+        DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
+            self.startPT3SBTMeasurement()
+        }
+        
+    }
+    
+    func getHS4SInstances() {
+        
+        if let devices =  HS4Controller.shareIHHs4().getAllCurrentHS4Instace() as? [HS4]{
+            for device in devices {
+                if(deviceMacAddress == device.deviceID) {
+                    myHS4SDevice = device
+                }
+            }
+        }
+        DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
+            self.startHS4SMeasurement()
+        }
+    }
+    func getHS2SInstances() {
+        
+        
+        if let devices =  HS2SController.shareIHHS().getAllCurrentHS2SInstace() as? [HS2S]{
+            for device in devices {
+                if(deviceMacAddress == device.serialNumber) {
+                
+                    myHS2SDevice = device
+                }
+            }
+        }
+        self.myHS2SDevice?.commandGetDeviceInfo({ data in
+            
+        }, diaposeErrorBlock: { err in
+            
+        })
+        
+        self.myHS2SDevice?.commandGetUserInfo({ userinfo in
+            self.healthUser = HealthUser()
+            if let userInfoArr = userinfo?["UserInfo"] as? [[String:Any]] {
+                if(userInfoArr.count == 0){
+                    let userId = "iHealth123456786"
+                    self.healthUser?.hs2SUserID = userId.data(using: .utf8)
+                    self.healthUser?.createTS = Date().currentTimeMillis()
+                    
+                    self.healthUser?.weight = 85;
+                    
+                    self.healthUser?.age = 20;
+                    
+                    self.healthUser?.height = 100;
+                    
+                    self.healthUser?.sex = UserSex_Male;
+                    
+                    self.healthUser?.impedanceMark = HS2SImpedanceMark_YES;
+                    
+                    self.healthUser?.fitnessMark = HS2SFitnessMark_YES;
+                    if let user = self.healthUser{
+                        self.myHS2SDevice?.commandUpdateUserInfo(with: user, result: { isSuccess in
+                            
+                        }, diaposeErrorBlock: { err in
+                            
+                        })
+                    }
+                   
+                }else{
+                    for (index,item) in userInfoArr.enumerated() {
+                        if let userID = item["UserInfo_ID"] as? Data{
+                            self.healthUser?.hs2SUserID = userID
+                        }
+                        
+                        if let createTime = item["create_time"] as? Int,let weight = item["weight"] as? NSNumber,let gender = item["gender"] as? Int,let age = item["age"] as? NSNumber,let height = item["height"] as? NSNumber,let impedance = item["impedance"] as? Int{
+                            
+                            self.healthUser?.createTS = createTime
+                            
+                            self.healthUser?.weight = weight;
+                            
+                            self.healthUser?.age = age;
+                            
+                            self.healthUser?.height = height;
+                            
+                            self.healthUser?.sex = gender == 1 ? UserSex_Male : UserSex_Female
+                            
+                            self.healthUser?.impedanceMark = impedance == 1 ? HS2SImpedanceMark_YES : HS2SImpedanceMark_NO
+                            
+                            self.healthUser?.fitnessMark = HS2SFitnessMark_YES
+                        }
+                    }
+                }
+                DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
+                    self.startHS2SMeasurement()
+                }
+            }
+            
+        }, diaposeErrorBlock: { error in
+            
+        })
+        
+    }
+   // MARK: Get Offline Data Methods
+    func getBG5SOfflineData() {
+        
+        
+        
+        myBBG5SDevice?.queryRecord(successBlock: { data in
+            guard let deviceDataArr = data else{
+                let userData = ["count": 0] as [String : Any]
+                self.notifyListeners("dataNotFound", data: userData)
+                return
+            }
+            
+            var userdata:[Any] = []
+            for item in deviceDataArr {
+                if let deviceData = item as? BG5SRecordModel {
+                    userdata.append(["date": deviceData.measureDate, "value": deviceData.value, "dataID": deviceData.dataID])
+                    
+                }
+            }
+            
+            
+            
+            let userData = ["result": userdata, "deviceModel": "BG5S", "deviceMacAddress": self.deviceMacAddress,"isFromLive":false] as [String : Any]
+            self.notifyListeners("deviceDatafound", data: userData)
+            
+        }, errorBlock: { error, msg in
+            
+        })
+    }
+    
+    func getBPOfflineData() {
+        myBpDevice?.commandTransferMemoryData(totalCount: { count in
+            
+            if(count == 0) {
+                let userData = ["count": count] as [String : Any]
+                self.notifyListeners("dataNotFound", data: userData)
+            }
+        }, progress: { progress in
+            
+            let userData = ["progress": progress] as [String : Any]
+            self.notifyListeners("progress", data: userData)
+        }, dataArray: { data in
+            
+            guard let deviceDataArr = data else {
+                return
+            }
+            
+            
+            let userData = ["result": deviceDataArr, "deviceModel": "KN-550BT", "deviceMacAddress": self.deviceMacAddress,"isFromLive":false] as [String : Any]
+            self.notifyListeners("deviceDatafound", data: userData)
+            
+        }, errorBlock: { error in
+            
+            self.BP550Error(errorID: error)
+        })
+    }
+    func getBP5SOfflineData() {
+        
+        
+        var bp5sData: [Any] = []
+        var isDataProgress = 0
+        //self.myBP5SDevice.comm
+       
+        self.myBP5SDevice?.commandTransferMemoryTotalCount({ totalCount in
+            
+            if(totalCount == 0){
+                let userData = ["count": totalCount] as [String : Any]
+                self.notifyListeners("dataNotFound", data: userData)
+            }else{
+                
+                
+                self.myBP5SDevice?.commandTransferMemoryData(totalCount: { count in
+                    
+                
+                    if(count == 0) {
+                        let userData = ["count": count] as [String : Any]
+                        self.notifyListeners("dataNotFound", data: userData)
+                    }
+                }, progress: { progress in
+                    
+                    
+                    if let progressStat = progress{
+                        isDataProgress = Int(progressStat)
+                        
+                        if(isDataProgress == 1 || isDataProgress == 100){
+                            
+                            let userData = ["result": bp5sData, "deviceModel": "BP5S", "deviceMacAddress": self.deviceMacAddress,"isFromLive":false] as [String : Any]
+                            self.notifyListeners("deviceDatafound", data: userData)
+                            
+                        }
+                    }
+                    
+                }, dataArray: { data in
+                    
+                    
+                    if let deviceDataArr = data{
+//                        for deviceData in deviceDataArr{
+//                            bp5sData.append(deviceData)
+//                        }
+                        bp5sData.append(contentsOf: deviceDataArr)
+                    }
+                    
+                    
+                    
+                }, errorBlock: { error in
+                    self.BP550Error(errorID: error)
+                })
+            }
+        }, errorBlock: { err in
+            self.BP550Error(errorID: err)
+        })
+        
+        
+    }
+    func getPO3OfflineData() {
+        var PO3DeviceData: [Any] = []
+        myPO3Device?.commandOfflineDataCount({ count in
+            
+            
+            if(count == 0) {
+                
+                let userData = ["count": count] as [String : Any]
+                self.notifyListeners("dataNotFound", data: userData)
+            }
+        }, withOfflineData: { data in
+            
+            guard let deviceDataArr = data else {
+                return
+            }
+            PO3DeviceData.append(deviceDataArr)
+        }, withOfflineWaveData: { data in
+            
+        }, withFinishMeasure: { isMesureFinish in
+            print(" isMesureFinish: \(isMesureFinish)")
+            
+            let userData = ["result": PO3DeviceData, "deviceModel": "PO3", "deviceMacAddress": self.deviceMacAddress,"isFromLive":false] as [String : Any]
+            
+            self.notifyListeners("deviceDatafound", data: userData)
+        }, withErrorBlock: { error in
+            self.PO3Error(errorID: error)
+        })
+    }
+    
+    func getPT3SBSOfflineData() {
+        
+            self.myPT3SBTDevice?.commandGetMemoryCount({ count in
+                
+                if(count == 0) {
+                    let userData = ["count": count] as [String : Any]
+                    
+                    self.notifyListeners("dataNotFound", data: userData)
+                } else {
+                    self.myPT3SBTDevice?.commandGetMemorryData({ data in
+                        
+                        guard let deviceDataArr = data else {
+                            return
+                        }
+                        let userData = ["result": deviceDataArr, "deviceModel": "PT3SBT", "deviceMacAddress": self.deviceMacAddress,"isFromLive":false] as [String : Any]
+                        self.notifyListeners("deviceDatafound", data: userData)
+                        //self.deleteDataFromPT3SBT()
+                    }, disposeErrorBlock: { error in
+                        
+                        let userData = ["error": error] as [String : Any]
+                        self.notifyListeners("error", data: userData)
+                    })
+                }
+            }, disposeErrorBlock: { error in
+                
+                let userData = ["error": error] as [String : Any]
+                self.notifyListeners("error", data: userData)
+            })
+        
+        
+        
+    }
+    
+    func getHS4SOfflineData() {
+        print(" getHS4SOfflineData()")
+        
+        myHS4SDevice?.commandTransferMemorryData({ dict in
+            
+            print(" dict : \(dict)")
+        }, disposeProgress: { count in
+            print(" count : \(count)")
+        }, memorryData: { data in
+            print(" data : \(data)")
+            guard let deviceDataArr = data else{
+                return
+            }
+            
+            let userData = ["result": deviceDataArr, "deviceModel": "HS4S", "deviceMacAddress": self.deviceMacAddress,"isFromLive":false] as [String : Any]
+            print(" deviceDatafound >> \(userData)")
+            self.notifyListeners("deviceDatafound", data: userData)
+            
+        }, finishTransmission: {
+            print(" finished")
+        }, disposeErrorBlock: { error in
+            print(" disposeErrorBlock >> \(error)")
+            self.HS4SError(errorID: error)
+        })
+    }
+    
+    func getHS2SAnonymousData(){
+        
+        self.myHS2SDevice?.commandGetAnonymousMemoryDataCount({ count in
+            if(count == 0){
+                if(self.hs2sDataArray?.count == 0){
+                    let userData = ["count": 0] as [String : Any]
+                    self.notifyListeners("dataNotFound", data: userData)
+                }else{
+                    let userData = ["result": self.hs2sDataArray, "deviceModel": "HS2S", "deviceMacAddress": self.deviceMacAddress,"isFromLive":false] as [String : Any]
+                    
+                    self.notifyListeners("deviceDatafound", data: userData)
+                }
+            }else{
+                self.myHS2SDevice?.commandGetAnonymousMemoryData({ data in
+                    
+                    if let deviceDataArr = data {
+                    self.hs2sDataArray?.append(contentsOf: deviceDataArr)
+                    
+                    }
+                    let userData = ["result": self.hs2sDataArray, "deviceModel": "HS2S", "deviceMacAddress": self.deviceMacAddress,"isFromLive":false] as [String : Any]
+                    
+                    self.notifyListeners("deviceDatafound", data: userData)
+                    
+                }, diaposeErrorBlock: { err in
+                    
+                })
+            }
+        }, diaposeErrorBlock: { error in
+        })
+        
+    }
+    
+    func deleteHS2sMemoryDataWithUserID(_ user:Data,_ isNotify:Bool){
+        self.myHS2SDevice?.commandDeleteMemoryData(withUserID: user, result: { isDeleted in
+           
+        }, diaposeErrorBlock: { err in
+            if(isNotify){
+                
+            }
+        })
+    }
+    
+    func getHS2sMemoryDataWithUserID(_ user:Data,_ isNotify:Bool){
+        
+        self.myHS2SDevice?.commandGetMemoryDataCount(withUserID: user, memoryCount: { count in
+            
+            if(count == 0 && isNotify){
+                
+                self.getHS2SAnonymousData()
+                //                let userData = ["count": 0] as [String : Any]
+                //                self.notifyListeners("dataNotFound", data: userData)
+                //                self.disconnectHS2S()
+            }else{
+                if(count == 0){
+                    self.hs2sUserCount = self.hs2sUserCount + 1
+                    self.getHS2sMemoryDataWithUserID(self.userIdArr[self.hs2sUserCount],self.hs2sUserCount == (self.userIdArr.count - 1))
+                }else{
+                self.myHS2SDevice?.commandGetMemoryData(withUserID: user, memoryData: { data in
+                    
+                    if let deviceDataArr = data {
+                    self.hs2sDataArray?.append(contentsOf: deviceDataArr)
+                    
+                    }
+                    if(isNotify){
+                        self.getHS2SAnonymousData()
+//                        let userData = ["result": self.hs2sDataArray, "deviceModel": "HS2S", "deviceMacAddress": self.deviceMacAddress] as [String : Any]
+//                        self.filesystem.appendFile("commandGetMemoryData hs2s data found")
+//                        self.notifyListeners("deviceDatafound", data: userData)
+                        self.hs2sUserCount = 0
+                        
+                    }else{
+                        self.hs2sUserCount = self.hs2sUserCount + 1
+                        self.getHS2sMemoryDataWithUserID(self.userIdArr[self.hs2sUserCount],self.hs2sUserCount == (self.userIdArr.count - 1))
+                    }
+                    
+                    
+                }, diaposeErrorBlock: { err in
+                    //let userData = ["count": 0] as [String : Any]
+                    //self.notifyListeners("dataNotFound", data: userData)
+                    
+                    //self.disconnectHS2S()
+                })
+            }
+            }
+        }, diaposeErrorBlock: { error in
+            
+        })
+    }
+    func getHS2SOfflineData() {
+        print(" getHS4SOfflineData()")
+        
+        self.myHS2SDevice?.commandGetDeviceInfo({ data in
+            
+        }, diaposeErrorBlock: { err in
+            
+        })
+        self.myHS2SDevice?.commandGetUserInfo({ userinfo in
+            
+            if let userInfoArr = userinfo?["UserInfo"] as? [[String:Any]] {
+            
+                self.hs2sDataArray = []
+                if(userInfoArr.count == 0){
+                    
+                    
+                        self.getHS2SAnonymousData()
+                    
+                    
+                }else{
+                    self.hs2sUserCount = 0
+                    self.userIdArr = []
+                    for (index,item) in userInfoArr.enumerated() {
+                        
+                        
+                        if let userID = item["UserInfo_ID"] as? Data{
+                            self.userIdArr.append(userID)
+                        }
+                    }
+                    if(self.userIdArr.count > 0){
+                        
+                        self.getHS2sMemoryDataWithUserID(self.userIdArr[self.hs2sUserCount],self.hs2sUserCount == (self.userIdArr.count - 1))
+                    }
+                    
+                }
+            }
+            
+        }, diaposeErrorBlock: { error in
+            
+        })
+        
+        
+    }
+    // MARK: Device Measure Methods
+    
+    
+    func startTimer() {
+        timerCount = 0
+        guard timer == nil else { return }
+        timer = Timer.scheduledTimer(timeInterval: 1, target: self, selector: #selector(test), userInfo: nil, repeats: true)
+    }
+
+    func stopTimer() {
+        guard timer != nil else { return }
+        timer?.invalidate()
+        timer = nil
+    }
+
+    @objc func test() {
+        if(timerCount == 10){
+            stopTimer()
+            let hs4sData = [["weight":timerCount,"dataID":"1234567","date":Date()]]
+                        let userData = ["result": hs4sData, "deviceModel": "HS4S", "deviceMacAddress": self.deviceMacAddress,"isFromLive":true] as [String : Any]
+                        self.notifyListeners("deviceDatafound", data: userData)
+        }else{
+            let userData = ["result": timerCount, "deviceModel": "HS4S", "deviceMacAddress": self.deviceMacAddress] as [String : Any]
+
+            self.notifyListeners("OnlineDeviceData", data: userData)
+timerCount = timerCount+1
+        }
+    }
+    
+    func startBP5SMeasurement(){
+        self.myBP5SDevice?.commandFunction({ data in
+            self.myBP5SDevice?.commandStartMeasure(zeroingState: { isZeroState in
+                
+            }, pressure: { data in
+                let userData = ["result": data, "deviceModel": "BP5S", "deviceMacAddress": self.deviceMacAddress] as [String : Any]
+                
+                self.notifyListeners("OnlineDeviceData", data: userData)
+            }, waveletWithHeartbeat: { data in
+                print("waveletWithHeartbeat \(data)")
+            }, waveletWithoutHeartbeat: { data in
+                print("waveletWithoutHeartbeat \(data)")
+            }, result: { dataObj in
+                let bp5sData = [dataObj]
+                let userData = ["result": bp5sData, "deviceModel": "BP5S", "deviceMacAddress": self.deviceMacAddress,"isFromLive":true] as [String : Any]
+                self.notifyListeners("deviceDatafound", data: userData)
+            }, errorBlock: { err in
+                
+            })
+        }, errorBlock: { error in
+            
+        })
+        
+    }
+   
+    func startPT3SBTMeasurement(){
+       // self.myPT3SBTDevice.comm
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(self.onlineMeasurementForPT3SBT),
+            name: Notification.Name("PT3SBTNotificationGetResult"),
+            object: nil)
+    }
+    @objc func onlineMeasurementForPT3SBT(notification:NSNotification){
+        let notifyObject = notification.userInfo
+        guard let userInfo = notification.userInfo as NSDictionary? as? [String: Any] else {return}
+       // self.bridge?.viewController?.showToast(message: "PT3SBT \(userInfo)")
+        let userData = ["result": [userInfo], "deviceModel": "PT3SBT", "deviceMacAddress": self.deviceMacAddress,"isFromLive":true] as [String : Any]
+        self.notifyListeners("deviceDatafound", data: userData)
+    }
+    func startPO3Measurement(){
+       
+        self.myPO3Device?.commandStartMeasure({ isSuccess in
+           
+        }, withMeasureData: { dataObj in
+            if let data = dataObj as? [String:Any] , let spo2 = data["spo2"] as? Int,let bpm = data["bpm"] as? Int{
+                if(spo2 > 0 && bpm > 0){
+                    self.onlinePO3DeviceData = data
+                    let userData = ["result": self.onlinePO3DeviceData, "deviceModel": "PO3", "deviceMacAddress": self.deviceMacAddress] as [String : Any]
+                    self.notifyListeners("OnlineDeviceData", data: userData)
+                }
+            }
+        }, withFinishMeasure: { isCompleted in
+            if(isCompleted){
+                print("PO3 start withFinishMeasure:if\(isCompleted)")
+                print("PO3 start withFinishMeasure:if\(String(describing: self.onlinePO3DeviceData))")
+                let userData = ["result": [self.onlinePO3DeviceData], "deviceModel": "PO3", "deviceMacAddress": self.deviceMacAddress,"isFromLive":true] as [String : Any]
+                self.notifyListeners("deviceDatafound", data: userData)
+            }else{
+                let userData = ["error": "Error getting final value.Please take again."] as [String : Any]
+                self.notifyListeners("error", data: userData)
+            }
+            
+        }, withErrorBlock: { err in
+            self.bridge?.viewController?.showToast(message: "PO3 start error else:\(err)")
+        })
+    }
+    func startBG5SMeasurement(){
+        self.myBBG5SDevice?.startMeasure(BGMeasureMode.noBlood, withSuccessBlock: {
+            
+        }, errorBlock: { err, msg in
+            
+        })
+    }
+    func startHS2SMeasurement(){
+        if let user = self.healthUser{
+            self.myHS2SDevice?.commandStartMeasure(with: user, weight: { weight in
+                let userData = ["result": weight, "deviceModel": "HS2S", "deviceMacAddress": self.deviceMacAddress] as [String : Any]
+
+                self.notifyListeners("OnlineDeviceData", data: userData)
+            }, stableWeight: { stableWeight in
+                let hs4sData = [["weight":stableWeight,"dataID":"1234567","date":Date()]]
+                            let userData = ["result": hs4sData, "deviceModel": "HS2S", "deviceMacAddress": self.deviceMacAddress,"isFromLive":true] as [String : Any]
+                            self.notifyListeners("deviceDatafound", data: userData)
+            }, weightAndBodyInfo: { dataObj in
+
+            }, disposeHS2SMeasureFinish: {
+
+            }, diaposeErrorBlock: { err in
+
+            })
+        }
+        
+        
+    }
+    func startHS4SMeasurement(){
+       // self.bridge?.viewController?.showToast(message: "startHS4SMeasurement")
+       // self.startTimer()
+        self.myHS4SDevice?.commandMeasure(withUint: HSUnit_Kg, weight: { unstableWeight in
+            let userData = ["result": unstableWeight, "deviceModel": "HS4S", "deviceMacAddress": self.deviceMacAddress] as [String : Any]
+          //  self.bridge?.viewController?.showToast(message: "unstable weight\(unstableWeight)")
+
+            self.notifyListeners("OnlineDeviceData", data: userData)
+        }, stableWeight: { dataObj in
+            let hs4sData = [dataObj]
+            let userData = ["result": hs4sData, "deviceModel": "HS4S", "deviceMacAddress": self.deviceMacAddress,"isFromLive":true] as [String : Any]
+            self.notifyListeners("deviceDatafound", data: userData)
+            //self.bridge?.viewController?.showToast(message: "stable weight:\(hs4sData)")
+        }, disposeErrorBlock: { err in
+            self.bridge?.viewController?.showToast(message: "error in hs4s start\(err)")
+        })
+        
+    }
+    
+    // MARK: Error CallBack Methods
+    
+    func HS4SError(errorID:HS4DeviceError) {
+        var errorMsg = ""
+        
+        switch errorID {
+        case .deviceLowPower:
+            errorMsg = "Battery level is low"
+        case .dataZeor:
+            errorMsg = "No memory"
+            let userData = ["count": 0] as [String : Any]
+            self.notifyListeners("dataNotFound", data: userData)
+        case .deviceEr0:
+            errorMsg = "The Scale failed to initialize"
+        case .deviceEr1:
+            errorMsg = "Maximum weight has been exceeded"
+        case .deviceEr2:
+            errorMsg = "The Scale can't capture a steady reading"
+        case .deviceEr4:
+            errorMsg = "Bluetooth connection error"
+        case .deviceEr7:
+            errorMsg = "Movement while measuring"
+        case .deviceEr8:
+            errorMsg = "Invalidate"
+        case .deviceEr9:
+            errorMsg = "Scale memory access error"
+        case .deviceDisconnect:
+            errorMsg = "Device disconnect"
+        case .deviceSendTimeout:
+            errorMsg = "Communication error"
+        case .deviceRecWeightError:
+            errorMsg = "DeviceRecWeightError"
+        }
+        
+        print(" HS4SError() >> \(errorMsg)")
+        if(errorMsg != "No memory"){
+            let userData = ["error": errorMsg] as [String : Any]
+            self.notifyListeners("error", data: userData)
+        }
+       
+    }
+    
+    func BP550Error(errorID:BPDeviceError){
+        var errorMsg = ""
+        switch (errorID) {
+        case .error0:
+            errorMsg = "Unable to take measurements due to arm/wrist movements."
+            break
+        case .error1:
+            errorMsg = "Failed to detect systolic pressure."
+            break
+        case .error2:
+            errorMsg = "Failed to detect diastolic pressure."
+            break
+        case .error3:
+            errorMsg = "Pneumatic system blocked or cuff is too tight during inflation."
+            break
+        case .error4:
+            errorMsg = "Pneumatic system leakage or cuff is too loose during inflation"
+            break
+        case .error5:
+            errorMsg = "Cuff pressure reached over 300mmHg."
+            break
+        case .error6:
+            errorMsg = "Cuff pressure reached over 15 mmHg for more than 160 seconds."
+            break
+        case .error7: fallthrough
+        case .error8: fallthrough
+        case .error9: fallthrough
+        case .error10:
+            errorMsg = "Data retrieving error."
+            break
+        case .error11: fallthrough
+        case .error12:
+            errorMsg = "Communication Error."
+            break
+        case .error13:
+            errorMsg = "Low battery."
+            break
+        case .error14:
+            errorMsg = "Device bluetooth set failed."
+            break
+        case .error15:
+            errorMsg = " Systolic exceeds 260mmHg or diastolic exceeds 199mmHg"
+            break
+        case .error16:
+            errorMsg = "Systolic below 60mmHg or diastolic below 40mmHg"
+            break
+        case .error17:
+            errorMsg = "Arm/wrist movement beyond range."
+            break
+        case .error18: fallthrough
+        case .error19:
+            errorMsg = "Heart rate in measure result exceeds max limit."
+            break
+        case .error20:
+            errorMsg = "PP(Average BP) exceeds limit"
+            break
+        case .errorUserStopMeasure:
+            errorMsg = "User stop measure(for ABPM history measurement only)"
+            break
+        case .normalError:
+            errorMsg = "device error, error message displayed automatically."
+            break
+        case .overTimeError: fallthrough
+        case .noRespondError:
+            errorMsg = "Abnormal communication."
+            break
+        case .beyondRangeError:
+            errorMsg = "device is out of communication range."
+            break
+        case .didDisconnect:
+            errorMsg = "Device Disconnect."
+            break
+        case .askToStopMeasure:
+            errorMsg = "measurement has been stopped."
+            break
+        case .deviceBusy:
+            errorMsg = "device is busy doing other things."
+            break
+        case .inputParameterError: fallthrough
+        case .invalidOperation:
+            errorMsg = "Parameter input error."
+            break
+        default:
+            break
+        }
+        
+        print(" HS4SError() >> \(errorMsg)")
+        
+        let userData = ["error": errorMsg] as [String : Any]
+        self.notifyListeners("error", data: userData)
+    }
+    
+    func PO3Error(errorID:PO3ErrorID){
+        var errorMsg = ""
+        
+        switch (errorID) {
+        case .overTime:
+            errorMsg = "PO3Error_OverTime."
+            break
+        case .resetDeviceFaild:
+            errorMsg = "PO3Error_ResetDeviceFaild"
+            break
+        case .disconnect:
+            errorMsg = "PO3Error_Disconnect"
+            break
+        case .parameterError:
+            errorMsg = "PO3Error_ParameterError"
+            break
+        case .firmwareVersionIsNotSupported:
+            errorMsg = "PO3Error_FirmwareVersionIsNotSupported"
+            break
+        default:
+            break
+        }
+        
+        print(" PO3Error() >> \(errorMsg)")
+        
+        let userData = ["error": errorMsg] as [String : Any]
+        self.notifyListeners("error", data: userData)
+    }
+    
+    // MARK: BG5S Delegate Methods
+    
+    public func device(_ device: BG5S!, occurError error: BG5SError, errorDescription: String!) {
+        print(" BG5S >> occurError")
+    }
+    
+    public func device(_ device: BG5S!, stripStateDidUpdate state: BG5SStripState) {
+        print(" BG5S >> stripStateDidUpdate")
+    }
+    
+    public  func deviceDropBlood(_ device: BG5S!) {
+        print(" BG5S >> deviceDropBlood")
+    }
+    
+    public func device(_ device: BG5S!, dataID: String!, measureReult result: Int) {
+        print(" BG5S >> measureReult : \(result)")
+        
+        let userData = ["result": [["date": Date(), "value": result, "dataID":dataID]], "deviceModel": "BG5S", "deviceMacAddress": self.deviceMacAddress,"isFromLive":true] as [String : Any]
+        self.notifyListeners("deviceDatafound", data: userData)
+    }
+    
+    public func device(_ device: BG5S!, chargeStateDidUpdate state: BG5SChargeState) {
+        print(" BG5S >> chargeStateDidUpdate()")
+    }
+}
+
+extension Date {
+    func currentTimeMillis() -> Int {
+        return Int(self.timeIntervalSince1970 * 1000)
+    }
+}
+extension UIViewController {
+
+func showToast(message : String) {
+    DispatchQueue.main.async {
+        let toastLabel = UILabel(frame: CGRect(x: 0, y: self.view.frame.size.height-200, width: self.view.frame.size.width, height: 200))
+        toastLabel.backgroundColor = UIColor.black.withAlphaComponent(0.6)
+        toastLabel.textColor = UIColor.white
+        toastLabel.font = .systemFont(ofSize: 12.0)
+        toastLabel.textAlignment = .center;
+        toastLabel.text = message
+        toastLabel.alpha = 1.0
+        toastLabel.layer.cornerRadius = 10;
+        toastLabel.clipsToBounds  =  true
+        self.view.addSubview(toastLabel)
+        UIView.animate(withDuration: 4.0, delay: 0.1, options: .curveEaseOut, animations: {
+            toastLabel.alpha = 0.0
+        }, completion: {(isCompleted) in
+            toastLabel.removeFromSuperview()
+        })
+    }
+}
+    
+}