@rentlydev/rently-tuya 0.1.0

package/ios/tuya/SettingsManager.swift

@@ -0,0 +1,475 @@
+import ThingSmartCameraKit
+
+class SettingsManager: NSObject, ThingSmartCameraDPObserver {
+    
+    static let shared = SettingsManager()
+    
+    private override init() {}
+    
+    private func withDPManager<T>(execute: (ThingSmartCameraDPManager) -> T?) -> T? {
+        guard let dpManager = Tuya.shared.dpManager else {
+            print("Tuya: Settings, DP Manager is not initialized")
+            return nil
+        }
+        return execute(dpManager)
+        
+    }
+    
+    func is8s() -> Bool {
+        return !(isSupportedDP(dpKey: ThingSmartCameraDPKey.wirelessElectricityDPName) ||
+                 isSupportedDP(dpKey: ThingSmartCameraDPKey.wirelessPowerModeDPName))
+    }
+
+    func isAosu() -> Bool {
+        return isSupportedDP(dpKey: ThingSmartCameraDPKey.init(rawValue: "231"))
+    }
+    
+    func cameraDPDidUpdate(_ manager: ThingSmartCameraDPManager, dps: [AnyHashable: Any]) {
+        for (dpName, dpValue) in dps {
+            if let dpKey = dpName as? String {
+                switch dpKey {
+                case ThingSmartCameraDPKey.basicOSDDPName.rawValue:
+                    if let value = dpValue as? Bool {
+                        Tuya.shared.isWaterMarkEnabled = value
+                        print("Tuya: DP Update - Watermark updated to \(value)")
+                    }
+                    
+                case ThingSmartCameraDPKey.basicFlipDPName.rawValue:
+                    if let value = dpValue as? Bool {
+                        Tuya.shared.isFlipEnabled = value
+                        print("Tuya: DP Update - Flip Mode updated to \(value)")
+                    }
+                    
+                case ThingSmartCameraDPKey.basicNightvisionDPName.rawValue:
+                    if let value = dpValue as? String {
+                        Tuya.shared.nightVisionLevel = value
+                        print("Tuya: DP Update - Night Vision Level updated to \(value)")
+                    }
+
+                case ThingSmartCameraDPKey.init(rawValue: "231").rawValue:
+                    if let value = dpValue as? Bool {
+                        Tuya.shared.isAntiDismantlingAlarmEnabled = value
+                        print("Tuya: DP Update - Anti Dismantling Alarm updated to \(value)")
+                    }
+
+                case ThingSmartCameraDPKey.motionDetectDPName.rawValue:
+                    if let value = dpValue as? Bool {
+                        Tuya.shared.isMotionDetectionEnabled = value
+                        print("Tuya: DP Update - Motion Detection updated to \(value)")
+                    }
+                    
+                case ThingSmartCameraDPKey.motionSensitivityDPName.rawValue:
+                    if let value = dpValue as? String {
+                        Tuya.shared.motionSensitivityLevel = value
+                        print("Tuya: DP Update - Motion Sensitivity updated to \(value)")
+                    }
+                
+                case ThingSmartCameraDPKey.basicPIRDPName.rawValue:
+                    if let value = dpValue as? String {
+                        Tuya.shared.basicPIRSensitivityLevel = value
+                        print("Tuya: DP Update - Motion Sensitivity for Aosu updated to \(value)")
+                    }
+                    
+                case ThingSmartCameraDPKey.init(rawValue: "240").rawValue:
+                    if let value = dpValue as? Bool {
+                        Tuya.shared.isPIRDetectionEnabled = value
+                        print("Tuya: DP Update - PIR Detection updated to \(value)")
+                    }
+                    
+                case ThingSmartCameraDPKey.init(rawValue: "241").rawValue:
+                    if let value = dpValue as? Int {
+                        Tuya.shared.pirSensitivityLevel = value
+                        print("Tuya: DP Update - PIR Sensitivity updated to \(value)")
+                    }
+                    
+                case ThingSmartCameraDPKey.sdCardStatusDPName.rawValue:
+                    if let value = dpValue as? Int {
+                        Tuya.shared.sdCardStatus = value
+                        print("Tuya: DP Update - SD Card Status updated to \(value)")
+                    }
+                    
+                case ThingSmartCameraDPKey.sdCardRecordDPName.rawValue:
+                    if let value = dpValue as? Bool {
+                        Tuya.shared.isSDCardStorageEnabled = value
+                        print("Tuya: DP Update - SD Card Recording updated to \(value)")
+                    }
+                    
+                case ThingSmartCameraDPKey.recordModeDPName.rawValue:
+                    if let value = dpValue as? String {
+                        Tuya.shared.sdCardRecordingType = value
+                        print("Tuya: DP Update - Recording Mode updated to \(value)")
+                    }
+                    
+                case ThingSmartCameraDPKey.init(rawValue: "165").rawValue:
+                    if let value = dpValue as? String {
+                        Tuya.shared.chimeType = value
+                        print("Tuya: DP Update - Chime Type updated to \(value)")
+                    }
+                    
+                case ThingSmartCameraDPKey.wirelessElectricityDPName.rawValue:
+                    if let value = dpValue as? Int {
+                        Tuya.shared.remainingBattery = value
+                        print("Tuya: DP Update - Battery Level updated to \(value)%")
+                    }
+                    
+                case ThingSmartCameraDPKey.wirelessPowerModeDPName.rawValue:
+                    if let value = dpValue as? String {
+                        Tuya.shared.powerMode = value
+                        print("Tuya: DP Update - Power Mode updated to \(value)")
+                    }
+                    
+                default:
+                    print("Tuya: Unknown DP Name in auto update: DP Name: \(dpKey), Value: \(dpValue)")
+                }
+            } else {
+                print("Tuya: Invalid DP Name type in auto update: \(dpName), Value: \(dpValue)")
+            }
+        }
+    }
+    
+    func removeObserver() {
+        withDPManager { dpManager in
+            dpManager.removeObserver(self)
+            print("Tuya: Settings, DP Observer removed")
+        }
+    }
+    
+    // Check if DP is supported
+    func isSupportedDP(dpKey: ThingSmartCameraDPKey) -> Bool {
+        return withDPManager { dpManager in
+            let isSupported = dpManager.isSupportDP(dpKey)
+            
+            return isSupported
+        } ?? false
+    }
+    
+    // Set DP value for a specific key
+    func setDPValue(
+        dpKey: ThingSmartCameraDPKey,
+        value: Any,
+        onSuccess: (() -> Void)? = nil,
+        onFailure: (() -> Void)? = nil
+    ) {
+        withDPManager { dpManager in
+            guard self.isSupportedDP(dpKey: dpKey) else {
+                return
+            }
+            
+            Tuya.shared.settingsLoader = true
+            dpManager.setValue(
+                value,
+                forDP: dpKey,
+                success: { result in
+                    Tuya.shared.settingsLoader = false
+                    onSuccess?()
+                    print("Tuya: Settings, DP settings Success for \(dpKey), Result: \(String(describing: result))")
+                },
+                failure: { error in
+                    Tuya.shared.settingsLoader = false
+                    onFailure?()
+                    Airbrake.logMessage(
+                        title: "DP setting failed",
+                        message: "\(error?.localizedDescription ?? "nil")",
+                        additionalInfo: ["dpKey" : "\(dpKey)"]
+                    )
+                }
+            )
+        }
+    }
+    
+    // Format SD Card
+    func formatSDCard() {
+        withDPManager { dpManager in
+            guard self.isSupportedDP(dpKey: ThingSmartCameraDPKey.sdCardFormatDPName) else {
+                return
+            }
+            
+            Tuya.shared.settingsLoader = true
+            dpManager.setValue(
+                true,
+                forDP: ThingSmartCameraDPKey.sdCardFormatDPName,
+                success: { result in
+                    print("Tuya: Formatting started")
+                    Tuya.shared.settingsLoader = false
+                },
+                failure: { error in
+                    print("Tuya: Format failed")
+                    Tuya.shared.settingsLoader = false
+                }
+            )
+        }
+    }
+    
+    // Get Memory card Capaciry
+    func getMemoryCardCapacity() {
+        guard self.isSupportedDP(dpKey: ThingSmartCameraDPKey.sdCardStorageDPName) else {
+            print("Tuya: Get SD card capacity is not supported.")
+            return
+        }
+        
+        Tuya.shared.settingsLoader = true
+        
+        if let result = getDPValue(dpKey: .sdCardStorageDPName) as? String {
+            print("Tuya: Retrieve memory card status successfully. Result: \(result)")
+            let components = result.split(separator: "|")
+            
+            guard components.count == 3 else {
+                Tuya.shared.settingsLoader = false
+                return
+            }
+            
+            if let totalBytes = Double(components[0]) {
+                Tuya.shared.totalCapacity = totalBytes / 1024 / 1024
+            }
+            
+            if let usedBytes = Double(components[1]) {
+                Tuya.shared.used = usedBytes / 1024 / 1024
+            }
+            
+            if let remainingBytes = Double(components[2]) {
+                Tuya.shared.remainingCapacity = remainingBytes / 1024 / 1024
+            }
+            
+            Tuya.shared.settingsLoader = false
+        } else {
+            print("Tuya: No details available for the SD card.")
+            Tuya.shared.settingsLoader = false
+        }
+    }
+    
+    func getFirmwareVersion() {
+        guard Tuya.shared.device.isSupportCheckFirmware() else {
+            print("Tuya: Firmware upgrade check is not supported for this device.")
+            return
+        }
+        
+        Tuya.shared.settingsLoader = true
+        Tuya.shared.device.checkFirmwareUpgrade { firmwares in
+            if firmwares.isEmpty {
+                print("Tuya: No firmware information available.")
+                Tuya.shared.settingsLoader = false
+                return
+            }
+            
+            for model in firmwares {
+                if model.upgradeStatus.rawValue == 0 && model.type == 0 {
+                    // No upgrade available
+                    print("Tuya: Firmware is up to date. Current version: v\(model.currentVersion ?? "unknown").")
+                    Tuya.shared.firwareVersion = model.currentVersion != nil ? "v\(model.currentVersion!)" : nil
+                    break
+                } else if model.upgradeStatus.rawValue == 1 && model.type == 0 {
+                    // Upgrade available
+                    print("Tuya: Firmware upgrade available. New version: v\(model.version ?? "unknown").")
+                    break
+                }
+            }
+            Tuya.shared.settingsLoader = false
+        } failure: { error in
+            Tuya.shared.settingsLoader = false
+            let errorMessage = error?.localizedDescription ?? "Unknown error"
+            Airbrake.logMessage(
+                title: "Failed to retrieve firmware information",
+                message: errorMessage
+            )
+        }
+    }
+    
+    // Get DP value if supported
+    func getDPValue(dpKey: ThingSmartCameraDPKey) -> Any? {
+        return withDPManager { dpManager in
+            guard isSupportedDP(dpKey: dpKey) else {
+                return nil
+            }
+            
+            return dpManager.value(forDP: dpKey)
+        }
+    }
+}
+
+class DefaultSettings: NSObject {
+    
+    static let shared = DefaultSettings()
+    
+    private override init() {}
+    
+    private var isMotionSensitivityUpdated = false
+    private var isMotionDetectionUpdated = false
+    private var isRecordingModeUpdated = false
+    
+    @MainActor
+  func updateDoorbellSettings() async {
+      var retryCount = 0
+      let maxRetries = 3
+      
+      func attemptUpdate() {
+          print("Tuya: Attempting to update doorbell settings - Attempt \(retryCount + 1)")
+
+          enableDefaultSettings(onSuccess: { [weak self] in
+              guard let self = self else { return }
+              print("Tuya: Default settings applied successfully after \(retryCount) retries.")
+              self.resetDefaultSettingsValue()
+          }, onFailure: { [weak self] in
+              guard let self = self else { return }
+              retryCount += 1
+              print("Tuya: Failed to apply default settings, retrying... \(retryCount) of \(maxRetries)")
+
+              if retryCount < maxRetries {
+                  DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {
+                      attemptUpdate()
+                  }
+              } else {
+                  print("Tuya: Maximum retries (\(maxRetries)) reached. Default settings could not be applied.")
+                  Airbrake.logMessage(
+                      title: "Default Settings Failed",
+                      message: "Failed to apply default settings after \(maxRetries) attempts."
+                  )
+              }
+          })
+      }
+      
+      attemptUpdate()
+  }
+
+    private func resetDefaultSettingsValue() {
+        if let id = Tuya.shared.id {
+            KeylessListener.emitter.resetDefaultSettings(
+                withID: id) { success, message in
+                    if success {
+                        print("Tuya: Reset Default Settings successful.")
+                    } else {
+                        print("Tuya: Reset Default Settings failed with message: \(message)")
+                    }
+                }
+        } else {
+            print("Tuya: ID is nil, cannot reset default settings.")
+        }
+    }
+    
+    private func enableDefaultSettings(onSuccess: @escaping () -> Void, onFailure: @escaping () -> Void) {
+
+      if Tuya.shared.isAosu {
+            handleMotionDetection(
+                switchKey: ThingSmartCameraDPKey.motionDetectDPName,
+                sensitivityKey: ThingSmartCameraDPKey.basicPIRDPName,
+                sensitivityValue: "1",
+                onSuccess: {
+                    self.isRecordingModeUpdated = true
+                    onSuccess()
+                },
+                onFailure: {
+                    onFailure()
+                }
+            )
+        } else if !Tuya.shared.is8s {
+            handleMotionDetection(
+                switchKey: ThingSmartCameraDPKey.init(rawValue: "240"),
+                sensitivityKey: ThingSmartCameraDPKey.init(rawValue: "241"),
+                sensitivityValue: 1,
+                onSuccess: {
+                    self.isRecordingModeUpdated = true
+                    onSuccess()
+                },
+                onFailure: {
+                    onFailure()
+                }
+            )
+        } else {
+            handleMotionDetection(
+                switchKey: ThingSmartCameraDPKey.motionDetectDPName,
+                sensitivityKey: ThingSmartCameraDPKey.motionSensitivityDPName,
+                sensitivityValue: "0",
+                onSuccess: {
+                    self.handleRecordingMode(onSuccess: onSuccess, onFailure: onFailure)
+                },
+                onFailure: {
+                    onFailure()
+                }
+            )
+        }
+    }
+    
+    private func handleMotionDetection(
+        switchKey: ThingSmartCameraDPKey,
+        sensitivityKey: ThingSmartCameraDPKey,
+        sensitivityValue: Any,
+        onSuccess: @escaping () -> Void,
+        onFailure: @escaping () -> Void
+    ) {
+        SettingsManager.shared.setDPValue(
+            dpKey: switchKey,
+            value: Tuya.shared.motionDetection,
+            onSuccess: {
+                self.isMotionDetectionUpdated = true
+                onSuccess()
+            },
+            onFailure: {
+                onFailure()
+            }
+        )
+        
+        if Tuya.shared.setSensitivityLow && !isMotionSensitivityUpdated {
+            SettingsManager.shared.setDPValue(
+                dpKey: sensitivityKey,
+                value: sensitivityValue,
+                onSuccess: { [weak self] in
+                    DispatchQueue.main.async {
+                        guard let self = self else { return }
+                        if Tuya.shared.isAosu {
+                            Tuya.shared.basicPIRSensitivityLevel = "1"
+                        } else if !Tuya.shared.is8s {
+                            Tuya.shared.pirSensitivityLevel = 1
+                        } else {
+                            Tuya.shared.motionSensitivityLevel = "0"
+                        }
+                        self.isMotionSensitivityUpdated = true
+                    }
+                },
+                onFailure: {
+                    onFailure()
+                }
+            )
+        } else {
+            isMotionSensitivityUpdated = true
+        }
+    }
+
+    private func handleRecordingMode(onSuccess: @escaping () -> Void, onFailure: @escaping () -> Void) {
+        if Tuya.shared.continuousRecording || Tuya.shared.eventRecording {
+
+            SettingsManager.shared.setDPValue(
+                dpKey: ThingSmartCameraDPKey.sdCardRecordDPName,
+                value: true,
+                onSuccess: { [weak self] in
+                    guard let self = self else { return }
+                    let mode = Tuya.shared.continuousRecording ? "2" : Tuya.shared.eventRecording ? "1" : nil
+                    
+                    if let mode = mode {
+                        SettingsManager.shared.setDPValue(
+                            dpKey: ThingSmartCameraDPKey.recordModeDPName,
+                            value: mode,
+                            onSuccess: {
+                                DispatchQueue.main.async {
+                                    Tuya.shared.sdCardRecordingType = mode
+                                    self.isRecordingModeUpdated = true
+                                    onSuccess()
+                                }
+                            },
+                            onFailure: {
+                                onFailure()
+                            }
+                        )
+                    } else {
+                        self.isRecordingModeUpdated = true
+                        onSuccess()
+                    }
+                },
+                onFailure: {
+                    onFailure()
+                }
+            )
+        } else {
+            self.isRecordingModeUpdated = true
+            onSuccess()
+        }
+    }
+}