react-native-mytatva-rn-sdk 1.2.36 → 1.2.38

package/ios/ViewControllers/ConnectToSensorViewController.swift

@@ -0,0 +1,415 @@
+//
+//  ConnectToSensorViewController.swift
+//  MyTatvaCare
+//
+//  Created by Nirav Ramani on 08/05/25.
+//
+
+import UIKit
+import AVFoundation
+class ConnectToSensorViewController: UIViewController {
+    @IBOutlet weak var contactSupport: CustomOverlayButton!
+    @IBOutlet weak var customTopView: CustomTopUIView!
+    @IBOutlet weak var tableView: UITableView!
+    @IBOutlet weak var bottomButton: CustomOverlayButton!
+    
+    enum enumTableSection: Int, CaseIterable {
+        case details
+        case success
+        case error
+    }
+    
+    enum enumTableRow: Int, CaseIterable {
+        case separator
+        case verticalLabel
+        case image
+        case camera
+    }
+    
+    enum enumSuccessTableRow: Int, CaseIterable {
+        case success
+        case note
+    }
+    
+    enum enumFailureTableRow: Int, CaseIterable {
+        case failAnimation
+        case details
+        case image
+        case watchVideo
+    }
+    
+    enum enumScreenType {
+        case camera
+        case success
+        case error
+    }
+    
+    var isFromReconnect: Bool = false
+    var connectedTime: Date?
+    var connected:(()->())?
+    var screenType: enumScreenType = .camera
+    var isCodeDetected = false
+    var isPermissionGiven: Bool = false
+    let manager = KLTBluetoothManager.shared()
+    
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        // Do any additional setup after loading the view.
+        setupLayout()
+    }
+    
+    func setupLayout() {
+        manager?.addObserver(self, forKeyPath: "status", options: [.new], context: nil)
+        
+        
+        tableView.delegate = self
+        tableView.dataSource = self
+        tableView.registerNibs([VerticalLabelsTVC.self,
+                                SeparatorTVC.self,
+                                ImageTVC.self,
+                                SearchDeviceTVC.self,
+                                ConnectDeviceTVC.self,
+                                ConnectSuccessTVC.self,
+                                NoteTVC.self,
+                                PodDetailsTVC.self,
+                                WatchVideoTVC.self])
+        tableView.reloadData()
+        contactSupport.isHidden = screenType != .error
+        contactSupport.labelText = "Contact Support"
+        contactSupport.setBorderOnly()
+        contactSupport.buttonTapCallback = {
+        }
+        
+        bottomButton.labelText = screenType == .error ? "Retry" : "Proceed"
+        
+        if screenType == .error {
+            bottomButton.hideRightArrow()
+        }
+        
+        bottomButton.buttonTapCallback = {
+            let isForReconnect = UserDefaults.standard.bool(forKey: "isForReconnect")
+            if isForReconnect {
+                let vc = AttachTransmitterViewController.instantiate(fromStoryboard: Enum_stroyboard.Main.rawValue)
+                self.navigationController?.pushViewController(vc, animated: false)
+            } else {
+                let vc = PutOnTheSensorViewController.instantiate(fromStoryboard: Enum_stroyboard.Main.rawValue)
+                self.navigationController?.pushViewController(vc, animated: false)
+            }
+        }
+        
+        customTopView.onDemoTapped = {
+            let webVC = WebViewController()
+            webVC.modalPresentationStyle = .formSheet
+            webVC.videoURL = URL(string: watchCGMVideo)
+            self.present(webVC, animated: true, completion: nil)
+        }
+        customTopView.onCloseTapped = {
+            let vc = ExitJourneyViewController.instantiate(fromStoryboard: Enum_stroyboard.Main.rawValue)
+            vc.modalPresentationStyle = .overFullScreen
+            self.present(vc, animated: true, completion: nil)
+        }
+        customTopView.onWhatsAppTapped = {
+            let vc = ChatWithExpertViewController.instantiate(fromStoryboard: Enum_stroyboard.Main.rawValue)
+            self.navigationController?.pushViewController(vc, animated: false)
+        }
+        checkCameraPermission()
+        bottomButton.disable()
+    }
+    
+    func checkCameraPermission() {
+        let status = AVCaptureDevice.authorizationStatus(for: .video)
+        
+        switch status {
+        case .authorized:
+            self.isPermissionGiven = true
+            print("Camera access is authorized")
+        case .notDetermined:
+            AVCaptureDevice.requestAccess(for: .video) { granted in
+                if granted {
+                    self.isPermissionGiven = true
+                    DispatchQueue.main.async {
+                        self.tableView.reloadData()
+                    }
+                    print("Camera access granted")
+                } else {
+                    print("Camera access denied")
+                    self.showCameraAccessAlert()
+                }
+            }
+        case .denied, .restricted:
+            print("Camera access denied or restricted")
+            self.showCameraAccessAlert()
+        @unknown default:
+            self.showCameraAccessAlert()
+            print("Unknown camera authorization status")
+        }
+        DispatchQueue.main.async {
+            self.tableView.reloadData()
+        }
+        
+    }
+    
+    func showCameraAccessAlert() {
+        let alert = UIAlertController(
+            title: "Camera Access Needed",
+            message: "Please enable camera access in Settings to use this feature.",
+            preferredStyle: .alert
+        )
+        alert.addAction(UIAlertAction(title: "Cancel", style: .cancel))
+        alert.addAction(UIAlertAction(title: "Open Settings", style: .default) { _ in
+            if let settingsURL = URL(string: UIApplication.openSettingsURLString) {
+                UIApplication.shared.open(settingsURL)
+            }
+        })
+        
+        DispatchQueue.main.async {
+            self.present(alert, animated: true)
+        }
+    }
+    
+    func connectSensor(value: String, controller: ConnectToSensorViewController) {
+        UserDefaults.standard.set(value, forKey: "sensorId")
+        var isMatch = false
+        
+        var regex = #"^[A-Z0-9][0-9](0[1-9]|[1-9][0-9]|[A-Z][1-9A-Z])(00[1-9]|0[1-9][0-9]|[1-9][0-9][0-9]){2}[0-9]{4,5}[0-9A-Z]{3}$"#
+        var predicate = NSPredicate(format: "SELF MATCHES %@", regex)
+        
+        if predicate.evaluate(with: value) {
+            isMatch = true
+        } else {
+            regex = #"^[A-Z1-9][1-9][A-Z0-9][0-9](0[1-9]|[1-9][0-9]|[A-Z][1-9A-Z])(00[1-9]|0[1-9][0-9]|[1-9][0-9][0-9]){2}[0-9]{6}[0-9A-Z]{3}$"#
+            predicate = NSPredicate(format: "SELF MATCHES %@", regex)
+            if predicate.evaluate(with: value) {
+                isMatch = true
+            }
+        }
+        
+        if isMatch {
+            let data = AlgorithmTools.decodeCT(value)
+            
+            if data.k > 0 || data.r > 0 {
+                //KLTLocalSettingManager.shareInstance.deviceInfoSensor = value
+                UserDefaults.standard.set(data.k, forKey: "algo_k")
+                UserDefaults.standard.set(data.r, forKey: "algo_r")
+                UserDefaults.standard.synchronize()
+                //self.connected?()
+                //controller.navigationController?.popViewController(animated: true)
+                self.showConfirmInsulinUser()
+                //showConfirmInsulinUser()
+                return
+            }
+        }
+        
+        //controller.resumeScanning()
+    }
+    func connectThisSensor() {
+        // Connect the transmitter
+        manager?.connectPeripheral(manager?.readyToConnectedPeripheral)
+    }
+    
+    func showConfirmInsulinUser() {
+        let typeOfDiabetes = UserDefaults.standard.object(forKey: "profilePatientType") as? NSNumber
+        
+        if let diabetesType = typeOfDiabetes {
+            // LocalizedString(@"user_diabete_no") index is 0
+            if diabetesType.intValue == 0 {
+                // No
+                UserDefaults.standard.set(2, forKey: "algo_user_type")
+            } else {
+                // Yes
+                UserDefaults.standard.set(1, forKey: "algo_user_type")
+            }
+        } else {
+            // Not selected
+            UserDefaults.standard.set(0, forKey: "algo_user_type")
+        }
+        
+        UserDefaults.standard.synchronize() // Optional, rarely needed in modern iOS
+        
+        connectThisSensor()
+    }
+    override func observeValue(forKeyPath keyPath: String?,
+                               of object: Any?,
+                               change: [NSKeyValueChangeKey : Any]?,
+                               context: UnsafeMutableRawPointer?) {
+        if keyPath == "status" && context == nil {
+            if let newValue = change?[.newKey] as? Int {
+                //let btStatus = newValue
+                let btStatus: BluetoothManagerStatus = BluetoothManagerStatus(rawValue: newValue) ?? .scanStart
+                
+                if btStatus == .initialStart {
+                    self.connectedTime = Date()
+                    print("Success")
+                    screenType = .success
+                    tableView.reloadData()
+                    bottomButton.enable()
+                    if self.isFromReconnect {
+                        let _ = FinalViewModelManager.shared
+                        NotificationCenter.default.post(name: Notification.Name("cgmDeviceEvent"), object: nil, userInfo: ["a":"a"])
+                        if let rootVC = UIApplication.shared.connectedScenes
+                            .compactMap({ ($0 as? UIWindowScene)?.windows.first?.rootViewController })
+                            .first {
+                            rootVC.dismiss(animated: true, completion: nil)
+                        } else if let rootViewController = UIApplication.shared.keyWindow?.rootViewController {
+                            rootViewController.dismiss(animated: true, completion: nil)
+                        }
+                    }
+                } else if btStatus == .closed || btStatus == .modifyVoltageFailed {
+                    // Handle failed or closed status
+                    
+                    navigationController?.popToRootViewController(animated: true)
+                }
+            }
+        } else if keyPath == "status", context != nil {
+            if let playerItem = object as? AVPlayerItem {
+                if playerItem.status == .readyToPlay {
+                    if UserDefaults.standard.integer(forKey: "bgmode") == 0 {
+                        // player?.play()
+                    }
+                }
+            }
+        } else {
+            super.observeValue(forKeyPath: keyPath, of: object, change: change, context: context)
+        }
+    }
+    
+}
+
+extension ConnectToSensorViewController: UITableViewDelegate, UITableViewDataSource {
+    
+    func numberOfSections(in tableView: UITableView) -> Int {
+        return enumTableSection.allCases.count
+    }
+    
+    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
+        switch enumTableSection(rawValue: section)! {
+        case .details:
+            return (screenType == .camera) ? enumTableRow.allCases.count : 0
+        case .success:
+            return screenType == .success ? enumSuccessTableRow.allCases.count : 0
+        case .error:
+            return screenType == .error ? enumFailureTableRow.allCases.count : 0
+        }
+    }
+    
+    func tableView(_ tableView: UITableView, heightForRowAt indexPath: IndexPath) -> CGFloat {
+        switch enumTableSection(rawValue: indexPath.section)! {
+        case .details:
+            switch enumTableRow(rawValue: indexPath.row) {
+            case .image:
+                return (UIScreen.main.bounds.width * 120 / 390) + 40
+            case .camera:
+                return 220
+            default:
+                return UITableView.automaticDimension
+            }
+        case .error:
+            switch enumFailureTableRow(rawValue: indexPath.row) {
+            case .failAnimation:
+                return 120
+            case .image:
+                return (UIScreen.main.bounds.width * 120 / 390) + 20
+            default:
+                return UITableView.automaticDimension
+            }
+        default:
+            return UITableView.automaticDimension
+        }
+    }
+    
+    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
+        switch enumTableSection(rawValue: indexPath.section)! {
+        case .details:
+            switch enumTableRow(rawValue: indexPath.row)! {
+            case .separator:
+                let cell: SeparatorTVC = tableView.dequeueReusableCell(for: indexPath)
+                return cell
+            case .verticalLabel:
+                let cell: VerticalLabelsTVC = tableView.dequeueReusableCell(for: indexPath)
+                cell.label1.text = "STEP 3"
+                cell.label2.text = "Connect to your Sensor"
+                cell.label3.text = "Scan the QR on the back of the sensor to connect with the GoodFlip app"
+                return cell
+            case .image:
+                let cell: ImageTVC = tableView.dequeueReusableCell(for: indexPath)
+                cell.displayImageView.image = loadImage(named: "flip_the_reference")
+                cell.displayImageView.contentMode = .scaleAspectFill
+                cell.displayImageView.isHidden = false
+                cell.cameraView.isHidden = true
+                return cell
+            case .camera:
+                let cell: ImageTVC = tableView.dequeueReusableCell(for: indexPath)
+                cell.displayImageView.contentMode = .scaleAspectFill
+                cell.displayImageView.isHidden = true
+                cell.cameraView.isHidden = false
+                if isPermissionGiven {
+                    DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
+                        cell.setupQRView()
+                        cell.scannerView?.onCodeDetected = { data in
+                            if !self.isCodeDetected {
+                                self.isCodeDetected = true
+                                self.connectSensor(value: data, controller: self)
+                            }
+                        }
+                    }
+                }
+                return cell
+            }
+        case .success:
+            switch enumSuccessTableRow(rawValue: indexPath.row)! {
+            case .success:
+                let cell: ConnectSuccessTVC = tableView.dequeueReusableCell(for: indexPath)
+                let dateFormatter = DateFormatter()
+                dateFormatter.dateFormat = "dd-MM-yyyy hh:mm a"
+                dateFormatter.timeZone = TimeZone.current
+                if let connectedTime = connectedTime {
+                    // Convert the Date to a String
+                    let dateString = dateFormatter.string(from: connectedTime)
+                    cell.labelDate.text = "Connected on \(String(describing: dateString))"
+                } else {
+                    cell.labelDate.text = ""
+                }
+                cell.labelDesc.isHidden = true
+                cell.labelTitle.text = "Sensor Connected Successfully"
+                cell.setImageForCGM()
+                return cell
+                
+            case .note:
+                let cell: NoteTVC = tableView.dequeueReusableCell(for: indexPath)
+                cell.setImportantNote(isFromSuccessConnection: true)
+                return cell
+            }
+        case .error:
+            switch enumFailureTableRow(rawValue: indexPath.row)! {
+            case .failAnimation:
+                let cell: ImageTVC = tableView.dequeueReusableCell(for: indexPath)
+                cell.displayImageView.loadGif(named: "failure")
+                cell.bottomConstraint.constant = 11
+                return cell
+            case .details:
+                let cell: VerticalLabelsTVC = tableView.dequeueReusableCell(for: indexPath)
+                cell.topConstraint.constant = 0
+                cell.label1.isHidden = true
+                cell.label2.text = "Unable to detect sensor"
+                cell.label3.text = "Make sure there is proper lighting in the room"
+                return cell
+            case .image:
+                let cell: ImageTVC = tableView.dequeueReusableCell(for: indexPath)
+                cell.topConstraint.constant = 0
+                cell.displayImageView.image = loadImage(named: "flip_the_reference")
+                cell.displayImageView.contentMode = .scaleAspectFill
+                return cell
+            case .watchVideo:
+                let cell: WatchVideoTVC = tableView.dequeueReusableCell(for: indexPath)
+                cell.onPlayVideo = {
+                    let webVC = WebViewController()
+                    webVC.modalPresentationStyle = .formSheet
+                    webVC.videoURL = URL(string: qrScanFailed)
+                    self.present(webVC, animated: true, completion: nil)
+                }
+                return cell
+            }
+        }
+    }
+}
+

package/ios/ViewControllers/StartConnectionViewController.swift

@@ -0,0 +1,219 @@
+//
+//  ViewController.swift
+//  MyTatvaCare
+//
+//  Created by Nirav Ramani on 05/05/25.
+//
+
+import UIKit
+import WebKit
+import CoreBluetooth
+import CoreLocation
+
+class StartConnectionViewController: UIViewController {
+
+    @IBOutlet weak var customTopView: CustomTopUIView!
+    @IBOutlet weak var tableView: UITableView!
+    @IBOutlet weak var startConnectionJourneyButton: CustomOverlayButton!
+    @objc var isForReconnect: Bool = false
+    var webView: WKWebView!
+    // Declare the CBCentralManager
+    var centralManager: CBCentralManager?
+    var isBluetoothEnabled: Bool = false
+    
+    // Declare the CLLocationManager
+    var locationManager: CLLocationManager?
+    var isLocationEnabled: Bool = false
+    
+    enum enumTableRow: Int, CaseIterable {
+        case separator
+        case verticalLabel
+        case image
+        case chargingIndicator
+    }
+    
+    override func viewDidLoad() {
+        super.viewDidLoad()
+        // Do any additional setup after loading the view.
+        setupLayout()
+        //checkForDevice()
+    }
+    
+    func setupLayout() {
+        navigationController?.navigationBar.isHidden = true
+        tableView.delegate = self
+        tableView.dataSource = self
+        tableView.registerNibs([VerticalLabelsTVC.self,
+                                SeparatorTVC.self,
+                                ImageTVC.self,
+                                ChargingIndicatorTVC.self])
+        tableView.reloadData()
+        
+        UserDefaults.standard.set(isForReconnect, forKey: "isForReconnect")
+        let isForReconnect = UserDefaults.standard.bool(forKey: "isForReconnect")
+
+        if isForReconnect {
+            startConnectionJourneyButton.labelText = "Start Reconnection Journey"
+        } else {
+            startConnectionJourneyButton.labelText = "Start Connection Journey"
+        }
+        
+        checkLocationPermission()
+        centralManager = CBCentralManager(delegate: self, queue: nil)
+        checkBluetoothPermission()
+        
+        startConnectionJourneyButton.buttonTapCallback = {
+            let isForReconnect = UserDefaults.standard.bool(forKey: "isForReconnect")
+            if isForReconnect {
+                self.updateBottomButtonState()
+            } else {
+                let vc = ProvidePermissionViewController.instantiate(fromStoryboard: Enum_stroyboard.Main.rawValue)
+                self.navigationController?.pushViewController(vc, animated: false)
+            }
+        }
+
+        customTopView.onDemoTapped = {
+            let webVC = WebViewController()
+            webVC.modalPresentationStyle = .formSheet // or .pageSheet, .fullScreen
+            webVC.videoURL = URL(string: watchCGMVideo)
+            self.present(webVC, animated: true, completion: nil)
+        }
+        
+        customTopView.onCloseTapped = {
+            let vc = ExitJourneyViewController.instantiate(fromStoryboard: Enum_stroyboard.Main.rawValue)
+            vc.modalPresentationStyle = .overFullScreen
+            self.present(vc, animated: true, completion: nil)
+        }
+        
+        customTopView.onWhatsAppTapped = {
+            let vc = ChatWithExpertViewController.instantiate(fromStoryboard: Enum_stroyboard.Main.rawValue)
+            self.navigationController?.pushViewController(vc, animated: false)
+        }
+    }
+
+    func checkForDevice() {
+        let manager = KLTBluetoothManager.shared()
+        let currentDevice = manager?.currentDevice
+     
+        if (currentDevice != nil) {
+            let eDevice : EDevice = EDevice.getEnumDevice(currentDevice?.advertise?.localName ?? "")
+            let viewModel = FinalViewModel()
+            viewModel.initialPeriod = Int(eDevice.initNumber * 3 * 60)
+  
+            let vc = AttachTransmitterViewController.instantiate(fromStoryboard: Enum_stroyboard.Main.rawValue)
+            vc.viewModel = viewModel
+            self.navigationController?.pushViewController(vc, animated: false)
+        } else {
+            // 未连接任何发射器
+            // stay on this screen
+        }
+    }
+    
+    private func updateBottomButtonState() {
+        if isBluetoothEnabled && isLocationEnabled {
+            let vc = ConnectToTransmitterViewController.instantiate(fromStoryboard: Enum_stroyboard.Main.rawValue)
+            self.navigationController?.pushViewController(vc, animated: false)
+        } else {
+            let vc = ProvidePermissionViewController.instantiate(fromStoryboard: Enum_stroyboard.Main.rawValue)
+            self.navigationController?.pushViewController(vc, animated: false)
+        }
+    }
+   
+    // Function to check Location Permission and State
+    private func checkLocationPermission() {
+        // Check if location services are enabled
+        
+        let status = CLLocationManager.authorizationStatus()
+        
+        switch status {
+        case .notDetermined:
+            print("Location permission is not determined.")
+            // Request permission to use location services
+            locationManager?.requestWhenInUseAuthorization()
+        case .restricted, .denied:
+            print("Location permission is restricted or denied.")
+        case .authorizedWhenInUse, .authorizedAlways:
+            print("Location is authorized.")
+            isLocationEnabled = true
+           
+        @unknown default:
+            print("Unknown location status.")
+        }
+    }
+    
+    // Function to check Bluetooth Permission and State
+    private func checkBluetoothPermission() {
+        isBluetoothEnabled = false
+        switch centralManager?.state {
+        case .unknown:
+            print("Bluetooth state is unknown.")
+        case .resetting:
+            print("Bluetooth state is resetting.")
+        case .unsupported:
+            print("Bluetooth is unsupported on this device.")
+        case .unauthorized:
+            print("Bluetooth is unauthorized.")
+        case .poweredOff:
+            print("Bluetooth is powered off.")
+        case .poweredOn:
+            print("Bluetooth is powered on and available.")
+            isBluetoothEnabled = true
+        case .none:
+            print("Unknown Bluetooth state.")
+        @unknown default:
+            print("Unknown Bluetooth state.")
+        }
+    }
+}
+
+extension StartConnectionViewController: UITableViewDelegate, UITableViewDataSource {
+    
+    func numberOfSections(in tableView: UITableView) -> Int {
+        return 1
+    }
+    
+    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
+        return enumTableRow.allCases.count
+    }
+    
+    func tableView(_ tableView: UITableView, heightForRowAt indexPath: IndexPath) -> CGFloat {
+        switch enumTableRow(rawValue: indexPath.row) {
+        case .image:
+            return 205
+        default:
+            return UITableView.automaticDimension
+        }
+    }
+    
+    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
+        switch enumTableRow(rawValue: indexPath.row)! {
+        case .separator:
+            let cell: SeparatorTVC = tableView.dequeueReusableCell(for: indexPath)
+            return cell
+        case .verticalLabel:
+            let cell: VerticalLabelsTVC = tableView.dequeueReusableCell(for: indexPath)
+            cell.label1.text = "STEP1"
+            cell.label1.isHidden = true
+            cell.label2.text = "Before You Start"
+            cell.label3.text = "Make sure your transmitter is fully charged. Put it in the charging pod until the blinking white light turns blue. This takes about 15 minutes"
+            return cell
+        case .image:
+            let cell: ImageTVC = tableView.dequeueReusableCell(for: indexPath)
+            cell.displayImageView.image = loadImage(named: "charging_pod")
+            return cell
+        case .chargingIndicator:
+            let cell: ChargingIndicatorTVC = tableView.dequeueReusableCell(for: indexPath)
+            return cell
+        }
+    }
+}
+
+
+extension StartConnectionViewController: CBCentralManagerDelegate {
+    
+    // Delegate method called when Bluetooth state changes
+    func centralManagerDidUpdateState(_ central: CBCentralManager) {
+        checkBluetoothPermission()
+    }
+}
+