@rentlydev/rently-tuya 0.1.0

package/android/src/main/java/com/rentlytuya/RentlyTuyaModule.kt

@@ -0,0 +1,503 @@
+package com.rentlytuya
+
+import android.content.Intent
+import android.util.Log
+import com.alibaba.fastjson.JSON
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import com.rentlytuya.tuya.Settings
+import com.rentlytuya.tuya.Settings.createJsonPayload
+import com.rentlytuya.tuya.Tuya
+import com.rentlytuya.tuya.Tuya.iTuyaDevice
+import com.rentlytuya.ui.theme.LocalColor
+import com.rentlytuya.util.Airbrake
+import com.rentlytuya.util.DPConstants
+import com.rentlytuya.util.DateUtil.isNull
+import com.rentlytuya.util.ReactUtils
+import com.rentlytuya.util.checkParams
+import com.thingclips.smart.android.common.utils.WiFiUtil
+import com.thingclips.smart.android.user.api.ILogoutCallback
+import com.thingclips.smart.home.sdk.ThingHomeSdk
+import com.thingclips.smart.home.sdk.bean.HomeBean
+import com.thingclips.smart.home.sdk.builder.ThingCameraActivatorBuilder
+import com.thingclips.smart.home.sdk.callback.IThingHomeResultCallback
+import com.thingclips.smart.sdk.api.IResultCallback
+import com.thingclips.smart.sdk.api.IThingActivatorGetToken
+import com.thingclips.smart.sdk.api.IThingSmartCameraActivatorListener
+import com.thingclips.smart.sdk.bean.DeviceBean
+import kotlinx.coroutines.CoroutineExceptionHandler
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withTimeoutOrNull
+
+class RentlyTuyaModule(private val reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext) {
+
+  override fun getName(): String {
+    return NAME
+  }
+
+  private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+
+  @ReactMethod
+  fun initAirbrake(params: ReadableMap, promise: Promise) {
+    if (!params.checkParams("key", "id")) {
+      promise.reject("false", "invalid_params")
+      return
+    }
+
+    val airbrakeKey = params.getString("key")!!
+    val airbrakeID = params.getString("id")!!
+
+    Airbrake.initialize(
+      airbrakeKey = airbrakeKey,
+      airbrakeID = airbrakeID,
+      context = reactApplicationContext
+    )
+  }
+
+  @ReactMethod
+  fun openCameraLivePreview(params: ReadableMap, promise: Promise) {
+    if (!params.checkParams("uid", "passwd", "countryCode", "devId", "homeId", "id", "flavour")) {
+      promise.reject("false", "invalid_params")
+      return
+    }
+
+    val exceptionHandler =
+      CoroutineExceptionHandler { _, e ->
+        Log.i(TAG, "Error in openCameraLivePreview: ${e.message}")
+        promise.reject("false", e)
+      }
+
+    scope.launch(exceptionHandler) {
+      Tuya.lastMoveOutDate =
+        if (params.hasKey("last_moveout_at")) params.getString("last_moveout_at") else null
+      Tuya.resetRequired =
+        if (params.hasKey("resetRequired")) params.getBoolean("resetRequired") else null
+      Tuya.isResident = if (params.hasKey("isResident")) params.getBoolean("isResident") else true
+      Tuya.displayRemoveDoorbellButton =
+        if (params.hasKey("display_remove_doorbell_button")) params.getBoolean("display_remove_doorbell_button") else null
+      Tuya.tuyaProductName =
+        if (params.hasKey("tuya_product_name")) params.getString("tuya_product_name") else null
+      Tuya.tuyaProductID =
+        if (params.hasKey("product_id")) params.getString("product_id") else null
+      Tuya.uuid = if (params.hasKey("device_uuid")) params.getString("device_uuid") else null
+      Tuya.serialNumber = if (params.hasKey("serial_no")) params.getString("serial_no") else null
+      Tuya.id = if (params.hasKey("id")) params.getString("id") else null
+      Tuya.isDefaultSettingsUpdated =
+        if (params.hasKey("doorbell_default_settings_updated")) params.getBoolean("doorbell_default_settings_updated") else false
+      Tuya.motionDetection =
+        if (params.hasKey("motion_detection")) params.getBoolean("motion_detection") else false
+      Tuya.continuousRecording =
+        if (params.hasKey("continuous_recording")) params.getBoolean("continuous_recording") else false
+      Tuya.eventRecording =
+        if (params.hasKey("event_recording")) params.getBoolean("event_recording") else false
+      Tuya.setSensitivityLow =
+        if (params.hasKey("set_sensitivity_low")) params.getBoolean("set_sensitivity_low") else false
+
+      // If both event and continuous recording are false, set event recording to true - NB: Only for 8s Doorbell
+      if (!Tuya.eventRecording && !Tuya.continuousRecording) {
+        Tuya.eventRecording = true
+      }
+
+      val username = params.getString("propertyCredentialUsername") ?: params.getString("uid")!!
+      val password = params.getString("propertyCredentialPassword") ?: params.getString("passwd")!!
+
+      val deviceId = params.getString("devId")!!
+      val homeId = params.getString("homeId")!!.toLong()
+      val countryCode = params.getString("countryCode")!!
+      val flavour = params.getString("flavour")!!
+
+      val success = Tuya.loginAndSetDevice(
+        deviceId = deviceId,
+        homeId = homeId,
+        password = password,
+        username = username,
+        countryCode = countryCode
+      )
+
+      if (success) {
+        LocalColor.setTheme(flavour)
+        val intent = Intent(reactContext, TuyaActivity::class.java)
+
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+        reactContext.startActivity(intent)
+        promise.resolve(true)
+      } else {
+        promise.resolve(false)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun loginWithUid(params: ReadableMap, promise: Promise) {
+    if (!params.checkParams("uid", "password", "countryCode")) {
+      promise.reject("false", "Invalid params")
+      return
+    }
+
+    val exceptionHandler =
+      CoroutineExceptionHandler { _, e ->
+        Log.i(TAG, "Error in loginWithUid: ${e.message}")
+        promise.reject("false", e)
+      }
+
+    scope.launch(exceptionHandler) {
+      val uid = params.getString("uid")!!
+      val password = params.getString("password")!!
+      val countryCode = params.getString("countryCode")!!
+
+      val success = Tuya.login(
+        uid = uid,
+        password = password,
+        countryCode = countryCode
+      )
+      promise.resolve(success)
+    }
+  }
+
+  @ReactMethod
+  fun getTokenForQRCode(params: ReadableMap, promise: Promise) {
+    if (!params.checkParams("homeId")) {
+      promise.reject("false", "Invalid params")
+      return
+    }
+
+    val exceptionHandler =
+      CoroutineExceptionHandler { _, e ->
+        Log.i(TAG, "Get Token Failure: ${e.message}")
+        promise.reject("false", e.message)
+      }
+
+    scope.launch(exceptionHandler) {
+      val homeId = params.getString("homeId")!!.toLong()
+
+      ThingHomeSdk.getActivatorInstance().getActivatorToken(
+        homeId,
+        object : IThingActivatorGetToken {
+          override fun onSuccess(s: String) {
+            Log.i(TAG, "Get Token success: $s")
+            promise.resolve(s)
+          }
+
+          override fun onFailure(code: String, message: String) {
+            Log.i(TAG, "Get Token Failure: $code $message")
+            promise.reject(code, message)
+          }
+        }
+      )
+    }
+  }
+
+  @ReactMethod
+  fun getCurrentWifi(promise: Promise) {
+    try {
+      val ssid = WiFiUtil.getCurrentSSID(reactApplicationContext.applicationContext).orEmpty()
+      Log.i(TAG, "Current SSID: $ssid")
+      promise.resolve(if (ssid == "<unknown ssid>" || ssid.isEmpty()) "" else ssid)
+    } catch (e: Exception) {
+      promise.resolve("")
+    }
+  }
+
+  @ReactMethod
+  fun logout(promise: Promise) {
+    val exceptionHandler =
+      CoroutineExceptionHandler { _, e ->
+        Log.i(TAG, "Logout Failure: ${e.message}")
+        promise.reject("false", e.message)
+      }
+
+    scope.launch(exceptionHandler) {
+      ThingHomeSdk.getUserInstance().logout(object : ILogoutCallback {
+        override fun onSuccess() {
+          Log.i(TAG, "Logout Success")
+          promise.resolve(true)
+        }
+
+        override fun onError(code: String?, error: String?) {
+          Log.i(TAG, "Logout Failure: Code $code, Error: $error")
+          promise.reject(code, error)
+        }
+      })
+    }
+  }
+
+  @ReactMethod
+  fun registerForPushNotification(params: ReadableMap, promise: Promise) {
+    if (!params.checkParams("token")) {
+      promise.reject("false", "Invalid params")
+      return
+    }
+
+    val exceptionHandler =
+      CoroutineExceptionHandler { _, e ->
+        Log.i(TAG, "Error registering push notification: ${e.message}")
+        promise.reject("false", e.message)
+      }
+
+    scope.launch(exceptionHandler) {
+      val token = params.getString("token")
+
+      ThingHomeSdk.getPushInstance()
+        .registerDevice(token, "FCM", object : IResultCallback {
+          override fun onSuccess() {
+            Log.i(TAG, "Push notification: registration success")
+            promise.resolve(true)
+          }
+
+          override fun onError(code: String, message: String) {
+            Log.i(TAG, "Error registering push notification: Code: $code, Error: $message")
+            promise.resolve(false)
+          }
+        })
+    }
+  }
+
+  @ReactMethod
+  fun renameDevice(params: ReadableMap, promise: Promise) {
+    if (!params.checkParams("devId", "name")) {
+      promise.reject("false", "Invalid params")
+      return
+    }
+
+    val exceptionHandler =
+      CoroutineExceptionHandler { _, e ->
+        Log.i(TAG, "Error renaming device: ${e.message}")
+        promise.reject("false", e.message)
+      }
+
+    scope.launch(exceptionHandler) {
+      ThingHomeSdk.newDeviceInstance(params.getString("devId"))
+        .renameDevice(params.getString("name"), object : IResultCallback {
+          override fun onSuccess() {
+            Log.i(TAG, "Rename Success")
+            promise.resolve("success")
+          }
+
+          override fun onError(code: String?, message: String?) {
+            Log.i(TAG, "Error renaming device: Code: $code, Error: $message")
+            promise.reject(code, message)
+          }
+        })
+    }
+  }
+
+  @ReactMethod
+  fun resetDevice(params: ReadableMap, promise: Promise) {
+    if (!params.checkParams("devId", "homeId", "username", "password", "countryCode")) {
+      promise.resolve(Arguments.createMap().apply { putString("success", "false") })
+      return
+    }
+
+    val exceptionHandler =
+      CoroutineExceptionHandler { _, e ->
+        Log.i(TAG, "Error in Reset Device: ${e.message}")
+        promise.resolve(Arguments.createMap().apply { putString("success", "false") })
+      }
+
+    scope.launch(exceptionHandler) {
+      val deviceId = params.getString("devId")
+      val homeId = params.getString("homeId")!!
+      val username = params.getString("username")!!
+      val password = params.getString("password")!!
+      val countryCode = params.getString("countryCode")!!
+
+      val success = Tuya.loginAndSetDevice(
+        deviceId = deviceId!!,
+        homeId = homeId.toLong(),
+        username = username,
+        password = password,
+        countryCode = countryCode
+      )
+
+      if (!success) {
+        promise.resolve(Arguments.createMap().apply { putString("success", "false") })
+        return@launch
+      }
+
+      if (iTuyaDevice.isNull()) {
+        // TODO:: Need to refactor (Change this to reject and handle in react native)
+        promise.resolve(Arguments.createMap().apply { putString("success", "false") })
+        return@launch
+      }
+
+      val result = withTimeoutOrNull(10000) {
+        // Step 1: Set Chime type to Mechanical
+        iTuyaDevice!!.publishDps(
+          createJsonPayload(DPConstants.CHIME_TYPE, "1"),
+          object : IResultCallback {
+            override fun onError(code: String, error: String?) {
+              Log.i(TAG, "Error in 'chime': Code=$code, Error=$error")
+            }
+
+            override fun onSuccess() {
+              Log.i(TAG, "Step 'chime' reset successfully")
+            }
+          })
+
+        // Step 2: Set SD Card Mode to Event Recording
+        val isSDCardModeSupported =
+          Settings.isDPSupported(deviceId = deviceId, dpId = DPConstants.SD_RECORD_MODE)
+        val isSDStatusSupported =
+          Settings.isDPSupported(deviceId = deviceId, dpId = DPConstants.SD_STATUS)
+
+        if (isSDStatusSupported) {
+          if (isSDCardModeSupported) {
+            iTuyaDevice!!.publishDps(
+              createJsonPayload(DPConstants.SD_RECORD_MODE, "1"),
+              object : IResultCallback {
+                override fun onError(code: String, error: String?) {
+                  Log.i(
+                    TAG,
+                    "Error in 'SD Card Record Mode': Code=$code, Error=$error"
+                  )
+                }
+
+                override fun onSuccess() {
+                  Log.i(TAG, "Step 'SD Card Record Mode' reset successfully")
+                }
+              })
+          } else {
+            Log.i(TAG, "Reset Failed due to SD Card Mode not supported")
+          }
+
+          // Step 3: Format SD Card
+          val sdCardStatus =
+            Settings.queryValueByDPID(deviceId = deviceId, dpId = DPConstants.SD_STATUS)
+          if (sdCardStatus != null && sdCardStatus != 5) {
+            iTuyaDevice!!.publishDps(
+              createJsonPayload(DPConstants.SD_FORMAT, true),
+              object : IResultCallback {
+                override fun onError(code: String, error: String?) {
+                  Log.i(
+                    TAG,
+                    "Error in 'SD Card Format': Code=$code, Error=$error"
+                  )
+                }
+
+                override fun onSuccess() {
+                  Log.i(TAG, "Step 'SD Card Format' successful")
+                }
+              })
+          } else {
+            promise.resolve(Arguments.createMap().apply { putString("success", "false") })
+          }
+        } else {
+          Log.i(TAG, "Reset Failed due to SD Card status not supported")
+          promise.resolve(Arguments.createMap().apply { putString("success", "false") })
+        }
+      }
+
+      if (result == null) {
+        Log.i(TAG, "Timeout occurred while resetting the device")
+        promise.resolve(Arguments.createMap().apply { putString("success", "false") })
+      } else {
+        promise.resolve(Arguments.createMap().apply { putString("success", "true") })
+      }
+    }
+  }
+
+  @ReactMethod
+  fun initActivatorForQRCode(params: ReadableMap, promise: Promise) {
+    if (!params.checkParams("ssid", "password", "time", "token")) {
+      promise.reject("false", "Invalid params")
+      return
+    }
+
+    val cameraActivator = ThingHomeSdk.getActivatorInstance().newCameraDevActivator(
+      ThingCameraActivatorBuilder()
+        .setSsid(params.getString("ssid"))
+        .setContext(reactApplicationContext.applicationContext)
+        .setPassword(params.getString("password"))
+        .setTimeOut(params.getInt("time").toLong())
+        .setToken(params.getString("token"))
+        .setListener(object : IThingSmartCameraActivatorListener {
+          override fun onQRCodeSuccess(qrCodeUrl: String?) {
+            Log.i(TAG, "QR Code Success: $qrCodeUrl")
+          }
+
+          override fun onError(errorCode: String?, errorMsg: String?) {
+            Log.i(TAG, "Error in QR Code Activation: Code: $errorCode, Message: $errorMsg")
+            if (errorCode == "1006" && errorMsg.equals("time out", true)) {
+              promise.resolve(Arguments.createMap().apply { putString("is_timeout", "true") })
+            } else {
+              promise.reject(errorCode, errorMsg)
+            }
+          }
+
+          override fun onActiveSuccess(device: DeviceBean?) {
+            Log.i(TAG, "Activation Success: $device")
+            promise.resolve(ReactUtils.parseToWritableMap(device))
+          }
+        })
+    )
+    cameraActivator?.start() ?: Log.i(TAG, "Camera Activator is null")
+  }
+
+  @ReactMethod
+  fun setTuyaHome(params: ReadableMap, promise: Promise) {
+    if (!params.checkParams("homeId")) {
+      promise.resolve(Arguments.createMap().apply { putString("success", "false") })
+      return
+    }
+
+    val exceptionHandler =
+      CoroutineExceptionHandler { _, e ->
+        Log.i(TAG, "Error in setTuyaHome: ${e.message}")
+        promise.resolve(Arguments.createMap().apply { putString("success", "false") })
+      }
+
+    scope.launch(exceptionHandler) {
+      ThingHomeSdk.newHomeInstance(params.getString("homeId")!!.toLong())
+        .getHomeDetail(object : IThingHomeResultCallback {
+          override fun onSuccess(bean: HomeBean?) {
+            Log.i(TAG, "setTuyaHome success: $bean")
+            promise.resolve(Arguments.createMap().apply { putString("success", "true") })
+          }
+
+          override fun onError(errorCode: String?, errorMsg: String?) {
+            Log.e(TAG, "Error in setTuyaHome: Code: $errorCode, Message: $errorMsg")
+            promise.resolve(Arguments.createMap().apply { putString("success", "false") })
+          }
+        })
+    }
+  }
+
+  @ReactMethod
+  fun getDeviceData(params: ReadableMap, promise: Promise) {
+    if (!params.checkParams("devId")) {
+      promise.reject("false", "Invalid params")
+      return
+    }
+
+    val exceptionHandler =
+      CoroutineExceptionHandler { _, e ->
+        Log.i(TAG, "Error in getDeviceData: ${e.message}")
+        promise.reject("false", e.message)
+      }
+
+    scope.launch(exceptionHandler) {
+      val deviceId = params.getString("devId")
+      val deviceData = ThingHomeSdk.getDataInstance().getDeviceBean(deviceId)
+
+      if (deviceData != null) {
+        val json = JSON.toJSONString(deviceData)
+        promise.resolve(json)
+      } else {
+        promise.reject("device_not_found", "Device not found for devId: $deviceId")
+      }
+    }
+  }
+
+  companion object {
+    const val NAME = "RentlyTuya"
+    const val TAG = "RentlyTuya"
+  }
+}

package/android/src/main/java/com/rentlytuya/RentlyTuyaPackage.kt

@@ -0,0 +1,18 @@
+package com.rentlytuya
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+import com.rentlytuya.util.KeylessModule
+
+
+class RentlyTuyaPackage : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    return listOf(RentlyTuyaModule(reactContext), KeylessModule(reactContext))
+  }
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    return emptyList()
+  }
+}

package/android/src/main/java/com/rentlytuya/TuyaActivity.kt

@@ -0,0 +1,45 @@
+package com.rentlytuya
+
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.lifecycle.lifecycleScope
+import androidx.navigation.NavHostController
+import androidx.navigation.compose.rememberNavController
+import com.rentlytuya.dashboard.NavController
+import com.rentlytuya.tuya.Tuya
+import com.rentlytuya.ui.theme.TuyaTheme
+import kotlinx.coroutines.launch
+
+class TuyaActivity : ComponentActivity() {
+
+  private var navController: NavHostController? = null
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+
+    setContent {
+      navController = rememberNavController()
+
+      TuyaTheme {
+        navController?.let { NavController(navController = it) }
+      }
+    }
+  }
+
+  override fun onStop() {
+    super.onStop()
+    if (navController?.currentDestination?.route != "Playback") {
+      lifecycleScope.launch {
+        Tuya.disconnect()
+      }
+    }
+  }
+
+  override fun onDestroy() {
+    super.onDestroy()
+    lifecycleScope.launch {
+      Tuya.disconnect()
+    }
+  }
+}

package/android/src/main/java/com/rentlytuya/alerts/FormatSDCardAlert.kt

@@ -0,0 +1,83 @@
+package com.rentlytuya.alerts
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import com.rentlytuya.R
+import com.rentlytuya.components.Alert
+import com.rentlytuya.components.AnchorButton
+import com.rentlytuya.components.Label
+import com.rentlytuya.util.Util.strings
+
+@Composable
+fun FormatSDCardAlert(
+  isFormatSDCardVisible: Boolean,
+  onDismiss: () -> Unit,
+  onFormat: () -> Unit
+) {
+
+  Alert(
+    modifier = Modifier
+      .padding(top = 20.dp, start = 20.dp, end = 15.dp),
+    isVisible = isFormatSDCardVisible,
+    onDismiss = onDismiss
+  ) {
+
+    Label(
+      modifier = Modifier
+        .padding(bottom = 5.dp),
+      title = strings(id = R.string.formatSDCard),
+      bold = true,
+      xl20 = true,
+      black = true
+    )
+
+    Label(
+      modifier = Modifier
+        .padding(vertical = 5.dp),
+      title = strings(id = R.string.formatSDCardDescription),
+      medium = true,
+      l = true,
+      black = true,
+      maxLines = 6,
+      lineHeight = 18.sp
+    )
+
+    Row(
+      modifier = Modifier
+        .fillMaxWidth()
+        .padding(bottom = 5.dp),
+      horizontalArrangement = Arrangement.End
+    ) {
+      AnchorButton(
+        modifier = Modifier,
+        id = "FormatSDCard_No",
+        title = strings(id = R.string.no),
+        semiBold = true,
+        black = true,
+        m = true,
+        onClick = {
+          onDismiss()
+        }
+      )
+
+      AnchorButton(
+        modifier = Modifier,
+        id = "FormatSDCard_Yes",
+        title = strings(id = R.string.yes),
+        semiBold = true,
+        black = true,
+        m = true,
+        onClick = {
+          onFormat()
+        }
+      )
+    }
+  }
+}
+