@rentlydev/rently-tuya 0.1.0

package/android/src/main/java/com/rentlytuya/tuya/Settings.kt

@@ -0,0 +1,809 @@
+package com.rentlytuya.tuya
+
+import android.util.Log
+import androidx.compose.runtime.MutableState
+import com.facebook.react.bridge.ReactContext
+import com.rentlytuya.tuya.Tuya.TAG
+import com.rentlytuya.tuya.Tuya.deviceId
+import com.rentlytuya.tuya.Tuya.iTuyaDevice
+import com.rentlytuya.util.Airbrake
+import com.rentlytuya.util.DPConstants
+import com.rentlytuya.util.DateUtil.isNotNull
+import com.rentlytuya.util.KeylessModule
+import com.thingclips.smart.android.device.bean.UpgradeInfoBean
+import com.thingclips.smart.home.sdk.ThingHomeSdk
+import com.thingclips.smart.sdk.api.IDevListener
+import com.thingclips.smart.sdk.api.IGetOtaInfoCallback
+import com.thingclips.smart.sdk.api.IResultCallback
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import org.json.JSONException
+import org.json.JSONObject
+import java.util.Locale
+import kotlin.coroutines.resume
+import kotlin.coroutines.suspendCoroutine
+
+object Settings {
+
+  fun is8s(): Boolean {
+    return !(isDPSupported(dpId = DPConstants.WIRELESS_ELECTRICITY) || isDPSupported(
+      dpId = DPConstants.WIRELESS_POWER_MODE
+    ))
+  }
+
+  fun isAOSU(): Boolean {
+    return (isDPSupported(dpId = DPConstants.ANTI_DISMANTLING_ALARM))
+  }
+
+  fun publishDps(
+    dpKey: String,
+    value: Any,
+    onSuccess: () -> Unit,
+    onError: (code: String?, error: String?) -> Unit
+  ) {
+    if (iTuyaDevice.isNotNull()) {
+      iTuyaDevice?.publishDps(createJsonPayload(dpKey, value), object : IResultCallback {
+        override fun onError(code: String, error: String) {
+          Airbrake.logMessage(
+            title = "Publish DP's Failed",
+            message = "Error Code: $code",
+            additionalInfo = mapOf(
+              "Error" to error,
+              "DP-Key" to dpKey,
+              "Value" to value.toString()
+            )
+          )
+          onError(code, error)
+        }
+
+        override fun onSuccess() {
+          Log.i(TAG, "$dpKey set to $value successfully")
+          onSuccess()
+        }
+      })
+    } else {
+      Log.i(TAG, "Device is null, cannot publishDps")
+      onError(null, null)
+    }
+  }
+
+  fun createJsonPayload(dpKey: String, value: Any): String {
+    val jsonObject = JSONObject()
+    try {
+      jsonObject.put(dpKey, value)
+    } catch (e: JSONException) {
+      Airbrake.logMessage(
+        title = "Creating JSON Payload for Publish DP's Failed",
+        message = "Error: ${e.message}"
+      )
+    }
+    return jsonObject.toString()
+  }
+
+  fun initializeSettings(
+    isWaterMarkEnabled: MutableState<Boolean>,
+    isFlipEnabled: MutableState<Boolean>,
+    isAntiDismantlingAlarmEnabled: MutableState<Boolean>,
+    nightVisionLevel: MutableState<String>,
+    isMotionDetectionEnabled: MutableState<Boolean>,
+    motionSensitivityLevel: MutableState<String>,
+    aosuMotionSensitivityLevel: MutableState<String>,
+    isPIRDetectionEnabled: MutableState<Boolean>,
+    pirSensitivityLevel: MutableState<Int>,
+    storageFunctionType: MutableState<Int>,
+    isSDCardRecordingEnabled: MutableState<Boolean>,
+    sdCardRecordingType: MutableState<String>,
+    chimeType: MutableState<String>,
+    powerSource: MutableState<String>,
+    batteryPercentage: MutableState<Int>,
+    totalStorageCapacity: MutableState<String>,
+    usedStorage: MutableState<String>,
+    remainingStorageCapacity: MutableState<String>
+  ) {
+    val deviceBean = ThingHomeSdk.getDataInstance().getDeviceBean(deviceId)
+    if (deviceBean.isNotNull()) {
+      for ((key, value) in deviceBean.getDps()) {
+        if (key.isNotNull() && value.isNotNull()) {
+          when (key) {
+            DPConstants.WATERMARK -> {
+              Log.i(TAG, "Watermark: $value ${value::class}")
+              isWaterMarkEnabled.value = value as Boolean
+            }
+
+            DPConstants.BASIC_FLIP -> {
+              Log.i(TAG, "Flip: $value ${value::class}")
+              isFlipEnabled.value = value as Boolean
+            }
+
+            DPConstants.ANTI_DISMANTLING_ALARM -> {
+              Log.i(TAG, "AntiDismantlingAlarm: $value ${value::class}")
+              isAntiDismantlingAlarmEnabled.value = value as Boolean
+            }
+
+            DPConstants.BASIC_NIGHT_VISION -> {
+              Log.i(TAG, "Night Vision Mode: $value ${value::class}")
+              nightVisionLevel.value = value as String
+            }
+
+            DPConstants.MOTION_SWITCH -> {
+              Log.i(TAG, "Motion Detection: $value ${value::class}")
+              isMotionDetectionEnabled.value = value as Boolean
+            }
+
+            DPConstants.MOTION_SENSITIVITY -> {
+              Log.i(TAG, "Motion Sensitivity: $value ${value::class}")
+              motionSensitivityLevel.value = value as String
+            }
+
+            DPConstants.MOTION_SENSITIVITY_AOSU -> {
+              Log.i(TAG, "AOSU Motion Sensitivity: $value ${value::class}")
+              aosuMotionSensitivityLevel.value = value as String
+            }
+
+            DPConstants.PIR_SWITCH -> {
+              Log.i(TAG, "PIR Detection: $value ${value::class}")
+              isPIRDetectionEnabled.value = value as Boolean
+            }
+
+            DPConstants.PIR_SENSITIVITY -> {
+              Log.i(TAG, "PIR Sensitivity: $value ${value::class}")
+              pirSensitivityLevel.value = value as Int
+            }
+
+            DPConstants.SD_STATUS -> {
+              Log.i(TAG, "SD Card Status: $value ${value::class}")
+              storageFunctionType.value = value as Int
+            }
+
+            DPConstants.SD_RECORD_SWITCH -> {
+              Log.i(TAG, "SD Card Recording: $value ${value::class}")
+              isSDCardRecordingEnabled.value = value as Boolean
+            }
+
+            DPConstants.SD_RECORD_MODE -> {
+              Log.i(TAG, "SD Card Record Mode: $value ${value::class}")
+              sdCardRecordingType.value = value as String
+            }
+
+            DPConstants.CHIME_TYPE -> {
+              Log.i(TAG, "Chime Type: $value ${value::class}")
+              chimeType.value = value as String
+            }
+
+            DPConstants.WIRELESS_POWER_MODE -> {
+              Log.i(TAG, "Power Mode: $value ${value::class}")
+              powerSource.value = value as String
+            }
+
+            DPConstants.WIRELESS_ELECTRICITY -> {
+              Log.i(TAG, "Wireless Electricity: $value ${value::class}")
+              batteryPercentage.value = value as Int
+            }
+
+            DPConstants.SD_STORAGE -> {
+              Log.i(TAG, "SD Card Capacity Value: $value ${value::class}")
+              parseStorageValue(
+                value = value,
+                totalStorageCapacity = totalStorageCapacity,
+                usedStorage = usedStorage,
+                remainingStorageCapacity = remainingStorageCapacity
+              )
+            }
+          }
+        }
+      }
+    }
+
+    listenDPUpdate(
+      isWaterMarkEnabled = isWaterMarkEnabled,
+      isFlipEnabled = isFlipEnabled,
+      isAntiDismantlingAlarmEnabled = isAntiDismantlingAlarmEnabled,
+      nightVisionLevel = nightVisionLevel,
+      isMotionDetectionEnabled = isMotionDetectionEnabled,
+      motionSensitivityLevel = motionSensitivityLevel,
+      aosuMotionSensitivityLevel = aosuMotionSensitivityLevel,
+      isPIRDetectionEnabled = isPIRDetectionEnabled,
+      pirSensitivityLevel = pirSensitivityLevel,
+      storageFunctionType = storageFunctionType,
+      isSDCardRecordingEnabled = isSDCardRecordingEnabled,
+      sdCardRecordingType = sdCardRecordingType,
+      chimeType = chimeType,
+      powerSource = powerSource,
+      batteryPercentage = batteryPercentage,
+      totalStorageCapacity = totalStorageCapacity,
+      usedStorage = usedStorage,
+      remainingStorageCapacity = remainingStorageCapacity
+    )
+  }
+
+  private fun parseStorageValue(
+    value: Any,
+    totalStorageCapacity: MutableState<String>,
+    usedStorage: MutableState<String>,
+    remainingStorageCapacity: MutableState<String>
+  ) {
+    val storageValue = value.toString()
+    if (storageValue.contains("|")) {
+      val storageParts: Array<String> = storageValue.split("\\|".toRegex())
+        .dropLastWhile { it.isEmpty() }
+        .toTypedArray()
+
+      if (storageParts.size == 3) {
+        val totalStorageGB = storageParts[0].toDouble() / 1024 / 1024
+        totalStorageCapacity.value = String.format(Locale.getDefault(), "%.1fG", totalStorageGB)
+
+        val usedStorageGB = storageParts[1].toDouble() / 1024 / 1024
+        usedStorage.value = String.format(Locale.getDefault(), "%.1fG", usedStorageGB)
+
+        val remainingStorageGB = storageParts[2].toDouble() / 1024 / 1024
+        remainingStorageCapacity.value =
+          String.format(Locale.getDefault(), "%.1fG", remainingStorageGB)
+      }
+    } else {
+      totalStorageCapacity.value = String.format(Locale.getDefault(), "%.1fG", 0.0)
+      usedStorage.value = String.format(Locale.getDefault(), "%.1fG", 0.0)
+      remainingStorageCapacity.value = String.format(Locale.getDefault(), "%.1fG", 0.0)
+    }
+    Log.i(TAG, "Total Capacity: ${totalStorageCapacity.value}")
+    Log.i(TAG, "Used: ${usedStorage.value}")
+    Log.i(TAG, "Remaining Capacity: ${remainingStorageCapacity.value}")
+  }
+
+  fun setWatermark(
+    enable: Boolean,
+    isLoading: MutableState<Boolean>,
+    isWaterMarkEnabled: MutableState<Boolean>
+  ) {
+    isLoading.value = true
+    publishDps(
+      dpKey = DPConstants.WATERMARK,
+      value = enable,
+      onSuccess = {
+        isLoading.value = false
+        isWaterMarkEnabled.value = enable
+        Log.i(TAG, "Watermark value changed to $enable")
+      },
+      onError = { code, error ->
+        isLoading.value = false
+        Log.i(TAG, "Error in changing Watermark value: Error Code: $code, Error: $error")
+      }
+    )
+  }
+
+  fun setFlip(
+    enable: Boolean,
+    isLoading: MutableState<Boolean>,
+    isFlipEnabled: MutableState<Boolean>
+  ) {
+    isLoading.value = true
+    publishDps(
+      dpKey = DPConstants.BASIC_FLIP,
+      value = enable,
+      onSuccess = {
+        isLoading.value = false
+        isFlipEnabled.value = enable
+        Log.i(TAG, "Flip value changed to $enable")
+      },
+      onError = { code, error ->
+        isLoading.value = false
+        Log.i(TAG, "Error in changing Flip value: Error Code: $code, Error: $error")
+      }
+    )
+  }
+
+  fun setAntiDismantlingAlarm(
+    enable: Boolean,
+    isLoading: MutableState<Boolean>,
+    isAntiDismantlingAlarmEnabled: MutableState<Boolean>
+  ) {
+    isLoading.value = true
+    publishDps(
+      dpKey = DPConstants.ANTI_DISMANTLING_ALARM,
+      value = enable,
+      onSuccess = {
+        isLoading.value = false
+        isAntiDismantlingAlarmEnabled.value = enable
+        Log.i(TAG, "Anti-Dismantling Alarm value changed to $enable")
+      },
+      onError = { code, error ->
+        isLoading.value = false
+        Log.i(
+          TAG,
+          "Error in changing Anti-Dismantling Alarm value: Error Code: $code, Error: $error"
+        )
+      }
+    )
+  }
+
+  fun setNightVision(
+    newMode: String,
+    mode: MutableState<String>,
+    isLoading: MutableState<Boolean>
+  ) {
+    isLoading.value = true
+    publishDps(
+      dpKey = DPConstants.BASIC_NIGHT_VISION,
+      value = newMode,
+      onSuccess = {
+        isLoading.value = false
+        mode.value = newMode
+        Log.i(TAG, "Night Vision value changed to $newMode")
+      },
+      onError = { code, error ->
+        isLoading.value = false
+        Log.i(TAG, "Error in changing Night Vision value: Error Code: $code, Error: $error")
+      }
+    )
+  }
+
+  fun setMotionDetection(
+    is8s: Boolean,
+    enable: Boolean,
+    isLoading: MutableState<Boolean>,
+    isMotionDetectionEnabled: MutableState<Boolean>
+  ) {
+    isLoading.value = true
+    publishDps(
+      dpKey = if (is8s) DPConstants.MOTION_SWITCH else DPConstants.PIR_SWITCH,
+      value = enable,
+      onSuccess = {
+        isLoading.value = false
+        isMotionDetectionEnabled.value = enable
+        Log.i(TAG, "Motion/PIR Detection value changed to $enable")
+      },
+      onError = { code, error ->
+        isLoading.value = false
+        Log.i(
+          TAG,
+          "Error in changing Motion/PIR Detection value: Error Code: $code, Error: $error"
+        )
+      }
+    )
+  }
+
+  fun setMotionSensitivity(
+    newMode: String,
+    mode: MutableState<String>,
+    isLoading: MutableState<Boolean>,
+    isAOSU: Boolean = false
+  ) {
+    isLoading.value = true
+    publishDps(
+      dpKey = if (isAOSU) DPConstants.MOTION_SENSITIVITY_AOSU else DPConstants.MOTION_SENSITIVITY,
+      value = newMode,
+      onSuccess = {
+        isLoading.value = false
+        mode.value = newMode
+        Log.i(TAG, "Motion Sensitivity changed to $newMode")
+      },
+      onError = { code, error ->
+        isLoading.value = false
+        Log.i(
+          TAG,
+          "Error in changing Motion Sensitivity value: Error Code: $code, Error: $error"
+        )
+      }
+    )
+  }
+
+  fun setPIRSensitivity(
+    newMode: Int,
+    mode: MutableState<Int>,
+    isLoading: MutableState<Boolean>
+  ) {
+    isLoading.value = true
+    publishDps(
+      dpKey = DPConstants.PIR_SENSITIVITY,
+      value = newMode,
+      onSuccess = {
+        isLoading.value = false
+        mode.value = newMode
+        Log.i(TAG, "PIR Sensitivity changed to $newMode")
+      },
+      onError = { code, error ->
+        isLoading.value = false
+        Log.i(
+          TAG,
+          "Error in changing PIR Sensitivity value: Error Code: $code, Error: $error"
+        )
+      }
+    )
+  }
+
+  fun setSDCardRecording(
+    enable: Boolean,
+    isLoading: MutableState<Boolean>,
+    isSDCardRecordingEnabled: MutableState<Boolean>
+  ) {
+    isLoading.value = true
+    publishDps(
+      dpKey = DPConstants.SD_RECORD_SWITCH,
+      value = enable,
+      onSuccess = {
+        isLoading.value = false
+        isSDCardRecordingEnabled.value = enable
+        Log.i(TAG, "SD card recording enabled set to $enable")
+      },
+      onError = { code, error ->
+        isLoading.value = false
+        Log.i(
+          TAG,
+          "Error in changing SD card recording value: Error Code: $code, Error: $error"
+        )
+      }
+    )
+  }
+
+  fun setSDCardRecordingMode(
+    newMode: String,
+    mode: MutableState<String>,
+    isLoading: MutableState<Boolean>
+  ) {
+    isLoading.value = true
+    publishDps(
+      dpKey = DPConstants.SD_RECORD_MODE,
+      value = newMode,
+      onSuccess = {
+        isLoading.value = false
+        mode.value = newMode
+        Log.i(TAG, "SD Card Recording mode changed to $newMode")
+      },
+      onError = { code, error ->
+        isLoading.value = false
+        Log.i(
+          TAG,
+          "Error in changing Sd Card Recording Mode value: Error Code: $code, Error: $error"
+        )
+      }
+    )
+  }
+
+  fun setChime(
+    newMode: String,
+    mode: MutableState<String>,
+    isLoading: MutableState<Boolean>
+  ) {
+    isLoading.value = true
+    publishDps(
+      dpKey = DPConstants.CHIME_TYPE,
+      value = newMode,
+      onSuccess = {
+        isLoading.value = false
+        mode.value = newMode
+        Log.i(TAG, "Chime value changed to $newMode")
+      },
+      onError = { code, error ->
+        isLoading.value = false
+        Log.i(TAG, "Error in changing Chime value: Error Code: $code, Error: $error")
+      }
+    )
+  }
+
+  fun formatSDCard(
+    isLoading: MutableState<Boolean>? = null
+  ) {
+    isLoading?.value = true
+    publishDps(
+      dpKey = DPConstants.SD_FORMAT,
+      value = true,
+      onSuccess = {
+        isLoading?.value = false
+        Log.i(TAG, "SD Card Format started")
+      },
+      onError = { code, error ->
+        isLoading?.value = false
+        Log.i(TAG, "Error in SD Card Format: Error Code: $code, Error: $error")
+      }
+    )
+  }
+
+  fun getMemoryCardCapacity(
+    totalStorageCapacity: MutableState<String>,
+    usedStorage: MutableState<String>,
+    remainingStorageCapacity: MutableState<String>
+  ) {
+
+    val value = queryValueByDPID(deviceId = deviceId, dpId = DPConstants.SD_STORAGE)
+
+    if (value.isNotNull()) {
+      parseStorageValue(
+        value = value,
+        totalStorageCapacity = totalStorageCapacity,
+        usedStorage = usedStorage,
+        remainingStorageCapacity = remainingStorageCapacity
+      )
+    }
+  }
+
+  fun getFirmwareVersion(
+    isLoading: MutableState<Boolean>,
+    firmwareVersion: MutableState<String?>
+  ) {
+    isLoading.value = true
+    val otaService = ThingHomeSdk.newOTAServiceInstance(deviceId)
+    otaService.getFirmwareUpgradeInfo(object : IGetOtaInfoCallback {
+      override fun onSuccess(upgradeInfoBeans: List<UpgradeInfoBean>) {
+        val mainModuleBean = upgradeInfoBeans.firstOrNull {
+          it.typeDesc.equals("Main Module", ignoreCase = true)
+        }
+        firmwareVersion.value = mainModuleBean?.currentVersion?.let { "v$it" }
+        isLoading.value = false
+        Log.i(TAG, "Fetch current firmware version success: $upgradeInfoBeans")
+      }
+
+      override fun onFailure(code: String, error: String) {
+        isLoading.value = false
+        Log.e(TAG, "Failed to fetch firmware info: $code, $error")
+        Airbrake.logMessage(
+          title = "Get Firmware version Failed",
+          message = "Error Code: $code",
+          additionalInfo = mapOf("Error" to error)
+        )
+      }
+    })
+  }
+
+  fun queryValueByDPID(deviceId: String?, dpId: String): Any? {
+    val validDeviceId = deviceId ?: Tuya.deviceId
+    return if (validDeviceId.isNotNull()) {
+      ThingHomeSdk.getDataInstance().getDeviceBean(validDeviceId)?.getDps()?.get(dpId)
+    } else {
+      Log.i(TAG, "Device Id is null")
+      null
+    }
+  }
+
+  fun isDPSupported(
+    deviceId: String? = null,
+    dpId: String
+  ): Boolean {
+    val value = queryValueByDPID(deviceId, dpId)
+    return value.isNotNull()
+  }
+
+  private fun listenDPUpdate(
+    isWaterMarkEnabled: MutableState<Boolean>,
+    isFlipEnabled: MutableState<Boolean>,
+    isAntiDismantlingAlarmEnabled: MutableState<Boolean>,
+    nightVisionLevel: MutableState<String>,
+    isMotionDetectionEnabled: MutableState<Boolean>,
+    motionSensitivityLevel: MutableState<String>,
+    aosuMotionSensitivityLevel: MutableState<String>,
+    isPIRDetectionEnabled: MutableState<Boolean>,
+    pirSensitivityLevel: MutableState<Int>,
+    storageFunctionType: MutableState<Int>,
+    isSDCardRecordingEnabled: MutableState<Boolean>,
+    sdCardRecordingType: MutableState<String>,
+    chimeType: MutableState<String>,
+    powerSource: MutableState<String>,
+    batteryPercentage: MutableState<Int>,
+    totalStorageCapacity: MutableState<String>,
+    usedStorage: MutableState<String>,
+    remainingStorageCapacity: MutableState<String>
+  ) {
+    ThingHomeSdk.newDeviceInstance(deviceId).registerDevListener(object : IDevListener {
+      override fun onDpUpdate(devId: String, dpStr: String) {
+        try {
+          val obj = JSONObject(dpStr)
+          val keys = obj.keys()
+          val key = keys.next()
+          if (key.isNotNull()) {
+            Log.i(TAG, "dp listen $key ${obj.getString(key)}")
+            when (key) {
+              DPConstants.WATERMARK -> {
+                isWaterMarkEnabled.value = obj.getBoolean(key)
+              }
+
+              DPConstants.BASIC_FLIP -> {
+                isFlipEnabled.value = obj.getBoolean(key)
+              }
+
+              DPConstants.ANTI_DISMANTLING_ALARM -> {
+                isAntiDismantlingAlarmEnabled.value = obj.getBoolean(key)
+              }
+
+              DPConstants.BASIC_NIGHT_VISION -> {
+                nightVisionLevel.value = obj.getString(key)
+              }
+
+              DPConstants.MOTION_SWITCH -> {
+                isMotionDetectionEnabled.value = obj.getBoolean(key)
+              }
+
+              DPConstants.MOTION_SENSITIVITY -> {
+                motionSensitivityLevel.value = obj.getString(key)
+              }
+
+              DPConstants.MOTION_SENSITIVITY_AOSU -> {
+                aosuMotionSensitivityLevel.value = obj.getString(key)
+              }
+
+              DPConstants.PIR_SWITCH -> {
+                isPIRDetectionEnabled.value = obj.getBoolean(key)
+              }
+
+              DPConstants.PIR_SENSITIVITY -> {
+                pirSensitivityLevel.value = obj.getInt(key)
+              }
+
+              DPConstants.SD_STATUS -> {
+                storageFunctionType.value = obj.getInt(key)
+              }
+
+              DPConstants.SD_RECORD_SWITCH -> {
+                isSDCardRecordingEnabled.value = obj.getBoolean(key)
+              }
+
+              DPConstants.SD_RECORD_MODE -> {
+                sdCardRecordingType.value = obj.getString(key)
+              }
+
+              DPConstants.CHIME_TYPE -> {
+                chimeType.value = obj.getString(key)
+              }
+
+              DPConstants.WIRELESS_POWER_MODE -> {
+                powerSource.value = obj.getString(key)
+              }
+
+              DPConstants.WIRELESS_ELECTRICITY -> {
+                batteryPercentage.value = obj.getInt(key)
+              }
+
+              DPConstants.SD_STORAGE -> {
+                parseStorageValue(
+                  value = obj.getInt(key),
+                  totalStorageCapacity = totalStorageCapacity,
+                  usedStorage = usedStorage,
+                  remainingStorageCapacity = remainingStorageCapacity
+                )
+              }
+            }
+          }
+        } catch (e: Exception) {
+          Log.i(TAG, "Exception in listen onDPUpdate ${e.message}")
+          e.printStackTrace()
+        }
+      }
+
+      override fun onRemoved(devId: String) {
+        Log.i(TAG, "onRemoved $devId")
+      }
+
+      override fun onStatusChanged(devId: String, online: Boolean) {
+        Log.i(TAG, "onStatusChanged $devId $online")
+      }
+
+      override fun onNetworkStatusChanged(devId: String, status: Boolean) {
+        Log.i(TAG, "onNetworkStatusChanged $devId $status")
+      }
+
+      override fun onDevInfoUpdate(devId: String) {
+        Log.i(TAG, "onDevInfoUpdate $devId")
+      }
+    })
+  }
+}
+
+object DefaultSettings {
+
+  // For Default Settings
+  private var isMotionSensitivityUpdated = false
+  private var isMotionDetectionUpdated = false
+  private var isRecordingModeUpdated = false
+  private var isRetryRequired = true
+
+  private fun resetValues() {
+    isMotionSensitivityUpdated = false
+    isMotionDetectionUpdated = false
+    isRecordingModeUpdated = false
+    isRetryRequired = true
+  }
+
+  private suspend fun publishDps(dpKey: String, value: Any): Boolean =
+    suspendCoroutine { continuation ->
+      Settings.publishDps(
+        dpKey = dpKey,
+        value = value,
+        onSuccess = { continuation.resume(true) },
+        onError = { code, error ->
+          Log.i(TAG, "Failed to publish Dps for $dpKey, Code: $code, Error: $error")
+          continuation.resume(false)
+        }
+      )
+    }
+
+  suspend fun updateDoorbellSettings(reactContext: ReactContext) = withContext(Dispatchers.IO) {
+    while (true) {
+      try {
+        enableDefaultSettings()
+
+        if (isMotionDetectionUpdated && isMotionSensitivityUpdated && isRecordingModeUpdated) {
+          resetDefaultSettingsValue(reactContext = reactContext)
+          resetValues()
+          break
+        } else if (isRetryRequired) {
+          isRetryRequired = false
+        } else {
+          resetValues()
+          break
+        }
+      } catch (e: Exception) {
+        Airbrake.logMessage(
+          title = "Update Doorbell Default Settings Failed",
+          message = "Error: ${e.message}"
+        )
+        break
+      }
+    }
+  }
+
+  private fun resetDefaultSettingsValue(reactContext: ReactContext) {
+    reactContext.let { context ->
+      val keylessModule = context.getNativeModule(KeylessModule::class.java)
+      Tuya.id?.let {
+        keylessModule?.sendDataToJS(
+          eventName = "resetDoorbellDefaultSettingsFlag",
+          deviceId = it,
+          onSuccess = {
+            Log.i(TAG, "Reset Default Settings Success")
+          },
+          onFailure = {
+            Log.i(TAG, "Reset Default Settings Failed")
+          }
+        )
+      } ?: Log.i(TAG, "ID is null")
+    }
+  }
+
+  private suspend fun enableDefaultSettings() = withContext(Dispatchers.IO) {
+    try {
+      if (Settings.isAOSU()){
+        // AOSU Doorbell Logic
+        handleMotionDetection(DPConstants.MOTION_SWITCH, DPConstants.MOTION_SENSITIVITY_AOSU, "1")
+        isRecordingModeUpdated= true // Recording mode not supported for AOSU
+      } else if (!Settings.is8s()) {
+        // 15s Doorbell Logic
+        handleMotionDetection(DPConstants.PIR_SWITCH, DPConstants.PIR_SENSITIVITY, 1)
+        isRecordingModeUpdated = true // Recording mode not supported for 15s Doorbell
+      } else {
+        // 8s Doorbell Logic
+        handleMotionDetection(DPConstants.MOTION_SWITCH, DPConstants.MOTION_SENSITIVITY, "0")
+        isRecordingModeUpdated = handleRecordingMode()
+      }
+    } catch (e: Exception) {
+      Airbrake.logMessage(
+        title = "Enable Doorbell Default Settings Failed",
+        message = "Error: ${e.message}"
+      )
+    }
+  }
+
+  private suspend fun handleMotionDetection(
+    switchKey: String,
+    sensitivityKey: String,
+    sensitivityValue: Any
+  ) {
+    isMotionDetectionUpdated = publishDps(switchKey, Tuya.motionDetection)
+
+    isMotionSensitivityUpdated = if (Tuya.setSensitivityLow && !isMotionSensitivityUpdated) {
+      publishDps(sensitivityKey, sensitivityValue)
+    } else {
+      true
+    }
+  }
+
+  private suspend fun handleRecordingMode(): Boolean {
+    if (Tuya.continuousRecording || Tuya.eventRecording) {
+      val recordingSwitchUpdated = publishDps(DPConstants.SD_RECORD_SWITCH, true)
+      return if (recordingSwitchUpdated) {
+        when {
+          Tuya.continuousRecording -> publishDps(DPConstants.SD_RECORD_MODE, "2")
+          Tuya.eventRecording -> publishDps(DPConstants.SD_RECORD_MODE, "1")
+          else -> true
+        }
+      } else false
+    }
+    return true
+  }
+}