@rentlydev/rently-tuya 0.1.0

package/android/src/main/java/com/rentlytuya/util/Airbrake.kt

@@ -0,0 +1,40 @@
+package com.rentlytuya.util
+
+import android.content.Context
+import android.util.Log
+import com.loopj.android.airbrake.AirbrakeNotifier
+import com.rentlytuya.tuya.Tuya.TAG
+
+object Airbrake {
+
+  private var isInitialized = false
+
+  fun initialize(
+    airbrakeKey: String,
+    airbrakeID: String,
+    context: Context
+  ) {
+    if (isInitialized) return
+    runCatching {
+      AirbrakeNotifier.register(context, airbrakeKey)
+      isInitialized = true
+      Log.i(TAG, "Successfully Initialized Airbrake")
+    }.onFailure {
+      Log.i(TAG, "Error in Airbrake Initialization")
+      it.printStackTrace()
+    }
+  }
+
+  fun logMessage(title: String, message: String, additionalInfo: Map<String, String>? = null) {
+    Log.i(TAG, "$title, $message, $additionalInfo")
+    if (!isInitialized) return
+    runCatching {
+      val logData = additionalInfo.orEmpty()
+      val throwable = Throwable("$title: $message")
+      AirbrakeNotifier.notify(throwable, logData)
+    }.onFailure {
+      Log.i(TAG, "Error in Airbrake log message")
+      it.printStackTrace()
+    }
+  }
+}

package/android/src/main/java/com/rentlytuya/util/DpConstants.kt

@@ -0,0 +1,53 @@
+package com.rentlytuya.util
+
+object DPConstants {
+
+  const val PTZ_CONTROL: String = "119"
+  const val PTZ_STOP: String = "116"
+
+  const val BASIC_FLIP: String = "103"
+  const val WATERMARK: String = "104"
+  const val ANTI_DISMANTLING_ALARM: String = "231"
+
+  // 0-Auto, 1-Off, 2-On
+  const val BASIC_NIGHT_VISION: String = "108"
+
+  // 0-None, 1-Mechanical, 2-Digital, 3-No bells
+  const val CHIME_TYPE: String = "165"
+
+  // Motion Detection for 8s and AOSU Doorbell
+  const val MOTION_SWITCH: String = "134"
+  const val MOTION_SENSITIVITY: String = "106"
+
+  // Motion Sensitivity for AOSU
+  const val MOTION_SENSITIVITY_AOSU: String = "152"
+
+  // Motion Detection for 15s
+  const val PIR_SWITCH: String = "240"
+  const val PIR_SENSITIVITY: String = "241"
+
+  // 1-Normal, 2-Abnormal, 3-Insufficient Capacity, 4-Formatting.., 5-No Storage
+  const val SD_STATUS: String = "110"
+  const val SD_STORAGE: String = "109"
+  const val SD_FORMAT: String = "111"
+  const val SD_FORMAT_STATUS: String = "117"
+  const val SD_RECORD_SWITCH: String = "150"
+  const val SD_RECORD_MODE: String = "151"
+
+  const val WIRELESS_ELECTRICITY: String = "145"
+
+  // 0-Battery Powered, 1-Wire Mode
+  const val WIRELESS_POWER_MODE: String = "146"
+
+  // DP Data type
+  const val SCHEMA_TYPE_RAW: String = "raw"
+  const val SCHEMA_TYPE_BOOL: String = "bool"
+  const val SCHEMA_TYPE_ENUM: String = "enum"
+  const val SCHEMA_TYPE_VALUE: String = "value"
+  const val SCHEMA_TYPE_STRING: String = "string"
+
+  const val PTZ_UP: String = "0"
+  const val PTZ_LEFT: String = "2"
+  const val PTZ_DOWN: String = "4"
+  const val PTZ_RIGHT: String = "6"
+}

package/android/src/main/java/com/rentlytuya/util/FrescoManager.kt

@@ -0,0 +1,86 @@
+package com.rentlytuya.util
+
+import android.content.Context
+import android.os.StatFs
+import com.facebook.drawee.backends.pipeline.Fresco
+import com.facebook.imagepipeline.core.ExecutorSupplier
+import com.facebook.imagepipeline.core.ImagePipelineConfig
+import com.facebook.imagepipeline.listener.RequestListener
+import com.thingclips.imagepipeline.okhttp3.OkHttpImagePipelineConfigFactory
+import com.thingclips.smart.android.common.task.ThingExecutor
+import okhttp3.Cache
+import okhttp3.OkHttpClient
+import java.io.File
+import java.util.concurrent.Executor
+import java.util.concurrent.ScheduledExecutorService
+import java.util.concurrent.TimeUnit
+
+object FrescoManager {
+
+  @JvmStatic
+  fun initFresco(context: Context) {
+    val defaultConfig = getDefaultConfig(context)
+    initFresco(context, defaultConfig)
+  }
+
+  @JvmStatic
+  fun initFresco(context: Context, config: ImagePipelineConfig) {
+    Fresco.initialize(context, config)
+  }
+
+  private fun getDefaultConfig(context: Context): ImagePipelineConfig {
+    val requestListeners: Set<RequestListener> = emptySet()
+    val cacheDir = File(context.cacheDir, "okhttp3")
+    val size = calculateDiskCacheSize(cacheDir)
+
+    val okHttpClient = OkHttpClient.Builder()
+      .cache(Cache(cacheDir, size))
+      .connectTimeout(0, TimeUnit.MILLISECONDS)
+      .readTimeout(0, TimeUnit.MILLISECONDS)
+      .writeTimeout(0, TimeUnit.MILLISECONDS)
+      .build()
+
+    val builder = OkHttpImagePipelineConfigFactory.newBuilder(
+      context.applicationContext, okHttpClient
+    ).setRequestListeners(requestListeners)
+
+    builder.setExecutorSupplier(object : ExecutorSupplier {
+      override fun forLocalStorageRead(): Executor =
+        ThingExecutor.getInstance().thingExecutorService
+
+      override fun forLocalStorageWrite(): Executor =
+        ThingExecutor.getInstance().thingExecutorService
+
+      override fun forDecode(): Executor = ThingExecutor.getInstance().thingExecutorService
+
+      override fun forBackgroundTasks(): Executor = ThingExecutor.getInstance().thingExecutorService
+
+      override fun forLightweightBackgroundTasks(): Executor =
+        ThingExecutor.getInstance().thingExecutorService
+
+      override fun forThumbnailProducer(): Executor =
+        ThingExecutor.getInstance().thingExecutorService
+
+      override fun scheduledExecutorServiceForBackgroundTasks(): ScheduledExecutorService? = null
+    })
+
+    return builder.build()
+  }
+
+  private const val MIN_DISK_CACHE_SIZE = 5 * 1024 * 1024L // 5MB
+  private const val MAX_DISK_CACHE_SIZE = 10 * 1024 * 1024L // 50MB
+
+  private fun calculateDiskCacheSize(dir: File): Long {
+    var size = MIN_DISK_CACHE_SIZE
+
+    try {
+      val statFs = StatFs(dir.absolutePath)
+      val available = statFs.blockCountLong * statFs.blockSizeLong
+      size = available / 50 // Target 2% of the total space.
+    } catch (ignored: IllegalArgumentException) {
+    }
+
+    // Bound inside min/max size for disk cache.
+    return size.coerceIn(MIN_DISK_CACHE_SIZE, MAX_DISK_CACHE_SIZE)
+  }
+}

package/android/src/main/java/com/rentlytuya/util/HeapAnalytics.kt

@@ -0,0 +1,16 @@
+package com.rentlytuya.util
+
+import android.util.Log
+import com.heapanalytics.android.Heap
+import com.rentlytuya.tuya.Tuya.TAG
+
+object Heap {
+
+  fun trackEvent(eventName: String, properties: Map<String, String>? = null) {
+    try {
+      Heap.track(eventName, properties)
+    } catch (e: Exception) {
+      Log.e(TAG, "Error in Heap trackEvent: $eventName", e)
+    }
+  }
+}

package/android/src/main/java/com/rentlytuya/util/KeylessModule.kt

@@ -0,0 +1,81 @@
+package com.rentlytuya.util
+
+import android.util.Log
+import com.facebook.react.ReactApplication
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.WritableNativeArray
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.rentlytuya.tuya.Tuya.TAG
+
+@ReactModule(name = "KeylessListener")
+class KeylessModule(private val reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext) {
+
+  private var eventEmitter: DeviceEventManagerModule.RCTDeviceEventEmitter? = null
+  private var onSuccessListener: ((String) -> Unit)? = null
+  private var onFailureListener: ((String) -> Unit)? = null
+
+  override fun getName(): String = "KeylessListener"
+
+  override fun initialize() {
+    super.initialize()
+    eventEmitter =
+      reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+  }
+
+  fun sendDataToJS(
+    eventName: String,
+    deviceId: String,
+    onSuccess: (String) -> Unit,
+    onFailure: (String) -> Unit
+  ) {
+    try {
+      val params = WritableNativeArray()
+      params.pushString(deviceId) // For Update Default Settings value, id is passed
+
+      onSuccessListener = onSuccess
+      onFailureListener = onFailure
+      invokeJSMethod(methodName = eventName, params = params)
+    } catch (e: Exception) {
+      Log.e(TAG, "Error sending event to JS: ${e.message}", e)
+    }
+  }
+
+  private fun invokeJSMethod(methodName: String, params: WritableNativeArray) {
+    try {
+      val reactInstanceManager = (reactContext.applicationContext as ReactApplication)
+        .reactNativeHost.reactInstanceManager
+
+      val currentReactContext = reactInstanceManager.currentReactContext
+      if (currentReactContext == null || !currentReactContext.hasActiveCatalystInstance()) {
+        Log.e(TAG, "ReactContext is not active or null. Attempting to recreate")
+        reactInstanceManager.recreateReactContextInBackground()
+        Thread.sleep(2000)
+      }
+
+      if (currentReactContext != null) {
+        val catalystInstance = currentReactContext.catalystInstance
+        catalystInstance?.callFunction("RNOperation", methodName, params)
+          ?: Log.e(TAG, "Catalyst instance is null")
+      }
+
+    } catch (e: Exception) {
+      Log.e(TAG, "Error invoking JS method: ${e.message}", e)
+    }
+  }
+
+  @ReactMethod
+  fun successCallback(message: String) {
+    onSuccessListener?.invoke(message)
+    onSuccessListener = null
+  }
+
+  @ReactMethod
+  fun failureCallback(message: String) {
+    onFailureListener?.invoke(message)
+    onFailureListener = null
+  }
+}

package/android/src/main/java/com/rentlytuya/util/PermissionHandler.kt

@@ -0,0 +1,75 @@
+package com.rentlytuya.util
+
+import android.app.Activity
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.net.Uri
+import android.provider.Settings
+import androidx.core.app.ActivityCompat
+import androidx.core.content.ContextCompat
+
+object PermissionHandler {
+
+  fun isPermissionGranted(context: Context, permission: String): Boolean {
+    return ContextCompat.checkSelfPermission(
+      context,
+      permission
+    ) == PackageManager.PERMISSION_GRANTED
+  }
+
+  fun arePermissionsGranted(context: Context, permissions: Array<String>): Boolean {
+    return permissions.all { permission ->
+      ContextCompat.checkSelfPermission(context, permission) == PackageManager.PERMISSION_GRANTED
+    }
+  }
+
+  fun checkAndRequestPermissions(
+    activity: Activity,
+    permissions: Array<String>,
+    requestCode: Int
+  ): Boolean {
+    try {
+      val notGrantedPermissions = permissions.filter { permission ->
+        ContextCompat.checkSelfPermission(activity, permission) != PackageManager.PERMISSION_GRANTED
+      }
+
+      return if (notGrantedPermissions.isNotEmpty()) {
+        val shouldShowRationale = notGrantedPermissions.any { permission ->
+          ActivityCompat.shouldShowRequestPermissionRationale(activity, permission)
+        }
+
+        if (!shouldShowRationale) {
+          ActivityCompat.requestPermissions(
+            activity,
+            notGrantedPermissions.toTypedArray(),
+            requestCode
+          )
+        } else {
+          openAppSettings(activity)
+        }
+        false
+      } else {
+        true
+      }
+    } catch (e: Exception) {
+      e.printStackTrace()
+      return false
+    }
+  }
+
+  fun requestPermission(activity: Activity, permission: String, requestCode: Int) {
+    try {
+      ActivityCompat.requestPermissions(activity, arrayOf(permission), requestCode)
+    } catch (e: Exception) {
+      e.printStackTrace()
+    }
+  }
+
+  private fun openAppSettings(activity: Activity) {
+    val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS).apply {
+      data = Uri.fromParts("package", activity.packageName, null)
+    }
+    activity.startActivity(intent)
+  }
+}

package/android/src/main/java/com/rentlytuya/util/ReactParamsCheck.kt

@@ -0,0 +1,152 @@
+package com.rentlytuya.util
+
+import android.text.TextUtils
+import com.alibaba.fastjson.JSON
+import com.alibaba.fastjson.JSONArray
+import com.alibaba.fastjson.JSONObject
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.ReadableType
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import java.math.BigDecimal
+
+fun ReadableMap.checkParams(vararg keys: String): Boolean {
+  for (key in keys) {
+    if (!hasKey(key)) {
+      return false
+    }
+  }
+  return true
+}
+
+object ReactUtils {
+
+  private fun parseToMap(readableMap: ReadableMap): HashMap<String, Any?> {
+    val iterator = readableMap.keySetIterator()
+    val deconstructedMap = HashMap<String, Any?>()
+    while (iterator.hasNextKey()) {
+      val key = iterator.nextKey()
+      val type = readableMap.getType(key)
+      when (type) {
+        ReadableType.Null -> deconstructedMap[key] = null
+        ReadableType.Boolean -> deconstructedMap[key] = readableMap.getBoolean(key)
+        ReadableType.Number -> {
+          val value = readableMap.getDouble(key)
+          deconstructedMap[key] = if (value > Integer.MAX_VALUE && value % 1 == 0.0) {
+            value.toLong()
+          } else {
+            value
+          }
+        }
+
+        ReadableType.String -> deconstructedMap[key] = readableMap.getString(key)
+        ReadableType.Map -> deconstructedMap[key] = parseToMap(readableMap.getMap(key)!!)
+        ReadableType.Array -> deconstructedMap[key] = parseToList(readableMap.getArray(key)!!)
+      }
+    }
+    return deconstructedMap
+  }
+
+  fun parseToLongMap(readableMap: ReadableMap): HashMap<String, Any?> {
+    val iterator = readableMap.keySetIterator()
+    val deconstructedMap = HashMap<String, Any?>()
+    while (iterator.hasNextKey()) {
+      val key = iterator.nextKey()
+      val type = readableMap.getType(key)
+      when (type) {
+        ReadableType.Null -> deconstructedMap[key] = null
+        ReadableType.Boolean -> deconstructedMap[key] = readableMap.getBoolean(key)
+        ReadableType.Number -> {
+          val value = readableMap.getDouble(key)
+          deconstructedMap[key] = try {
+            if (value > Integer.MAX_VALUE && value % 1 == 0.0) {
+              value.toLong()
+            } else {
+              value.toLong()
+            }
+          } catch (e: Exception) {
+            value
+          }
+        }
+
+        ReadableType.String -> deconstructedMap[key] = readableMap.getString(key)
+        ReadableType.Map -> deconstructedMap[key] = parseToMap(readableMap.getMap(key)!!)
+        ReadableType.Array -> deconstructedMap[key] = parseToList(readableMap.getArray(key)!!)
+      }
+    }
+    return deconstructedMap
+  }
+
+  private fun parseToList(readableArray: ReadableArray): ArrayList<Any?> {
+    val deconstructedList = ArrayList<Any?>(readableArray.size())
+    for (i in 0 until readableArray.size()) {
+      val indexType = readableArray.getType(i)
+      when (indexType) {
+        ReadableType.Null -> deconstructedList.add(i, null)
+        ReadableType.Boolean -> deconstructedList.add(i, readableArray.getBoolean(i))
+        ReadableType.Number -> {
+          val value = readableArray.getDouble(i)
+          deconstructedList.add(
+            i,
+            if (value > Integer.MAX_VALUE && value % 1 == 0.0) value.toLong() else value
+          )
+        }
+
+        ReadableType.String -> deconstructedList.add(i, readableArray.getString(i))
+        ReadableType.Map -> deconstructedList.add(i, parseToMap(readableArray.getMap(i)))
+        ReadableType.Array -> deconstructedList.add(i, parseToList(readableArray.getArray(i)))
+      }
+    }
+    return deconstructedList
+  }
+
+  private fun parseToWritableMap(s: String): WritableMap {
+    return if (TextUtils.isEmpty(s)) Arguments.createMap() else parseToWritableMap(
+      JSON.parseObject(
+        s
+      )
+    )
+  }
+
+  fun parseToWritableMap(data: Any?): WritableMap {
+    return if (data == null) Arguments.createMap() else parseToWritableMap(JSON.toJSONString(data))
+  }
+
+  private fun parseToWritableMap(json: JSONObject): WritableMap {
+    val map = Arguments.createMap()
+    for ((key, obv) in json.entries) {
+      when (obv) {
+        is JSONObject -> map.putMap(key, parseToWritableMap(obv))
+        is JSONArray -> map.putArray(key, parseToWritableArray(obv))
+        is Int -> map.putInt(key, obv)
+        is String -> map.putString(key, obv)
+        is Boolean -> map.putBoolean(key, obv)
+        is Double -> map.putDouble(key, obv)
+        is BigDecimal -> map.putDouble(key, obv.toDouble())
+        is Long -> map.putString(key, obv.toString())
+        else -> map.putNull(key)
+      }
+    }
+    return map
+  }
+
+  private fun parseToWritableArray(jsonArray: JSONArray): WritableArray {
+    val list = Arguments.createArray()
+    for (obv in jsonArray.toTypedArray()) {
+      when (obv) {
+        is JSONObject -> list.pushMap(parseToWritableMap(obv))
+        is JSONArray -> list.pushArray(parseToWritableArray(obv))
+        is Int -> list.pushInt(obv)
+        is String -> list.pushString(obv)
+        is Boolean -> list.pushBoolean(obv)
+        is Double -> list.pushDouble(obv)
+        is BigDecimal -> list.pushDouble(obv.toDouble())
+        is Long -> list.pushString(obv.toString())
+        else -> list.pushNull()
+      }
+    }
+    return list
+  }
+}

package/android/src/main/java/com/rentlytuya/util/Util.kt

@@ -0,0 +1,128 @@
+package com.rentlytuya.util
+
+import android.content.res.Configuration
+import android.os.Build
+import androidx.annotation.RequiresApi
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.res.stringResource
+import java.text.SimpleDateFormat
+import java.time.Instant
+import java.time.LocalDateTime
+import java.time.ZoneId
+import java.time.ZoneOffset
+import java.time.format.DateTimeFormatter
+import java.util.Calendar
+import java.util.Date
+import java.util.Locale
+import java.util.concurrent.TimeUnit
+import kotlin.contracts.ExperimentalContracts
+import kotlin.contracts.contract
+
+object Util {
+  @Composable
+  fun strings(id: Int): String =
+    stringResource(id = id)
+
+  fun isLandscape(config: Configuration): Boolean =
+    config.orientation == Configuration.ORIENTATION_LANDSCAPE
+}
+
+object DateUtil {
+
+  fun getCurrentTimeInSeconds(): Long {
+    return System.currentTimeMillis() / 1000
+  }
+
+  fun getDateMinusYearsInSeconds(years: Int): Long {
+    val calendar = Calendar.getInstance()
+    calendar.add(Calendar.YEAR, -years)
+
+    return calendar.timeInMillis / 1000
+  }
+
+  fun getDateComponents(dateLong: Long): Triple<Int, Int, Int> {
+    val calendar = Calendar.getInstance().apply {
+      timeInMillis = dateLong
+    }
+
+    val year = calendar.get(Calendar.YEAR)
+    val month = calendar.get(Calendar.MONTH) + 1
+    val day = calendar.get(Calendar.DAY_OF_MONTH)
+
+    return Triple(year, month, day)
+  }
+
+  fun convertTimestampToTime(timestamp: Int, format: String = "hh:mm a"): String {
+    val date = Date(timestamp * 1000L)
+    val formatter = SimpleDateFormat(format, Locale.getDefault())
+    return formatter.format(date)
+  }
+
+  fun formatSecondsToHHMMSS(seconds: Int): String {
+    val hours = seconds / 3600
+    val minutes = (seconds % 3600) / 60
+    val secs = seconds % 60
+
+    return String.format(Locale.getDefault(), "%02d:%02d:%02d", hours, minutes, secs)
+  }
+
+  fun calculateDuration(startTime: Int, endTime: Int): String {
+    val diffInSeconds = endTime - startTime
+
+    val hours = TimeUnit.SECONDS.toHours(diffInSeconds.toLong())
+    val minutes = TimeUnit.SECONDS.toMinutes(diffInSeconds.toLong()) % 60
+    val seconds = diffInSeconds % 60
+
+    return String.format(Locale.getDefault(), "%02d:%02d:%02d", hours, minutes, seconds)
+  }
+
+  fun calculateSecondsBetweenTimestamps(startTime: Int, endTime: Int): Long {
+    return (endTime - startTime).toLong()
+  }
+
+  fun incrementTimestampBySeconds(timestamp: Int, secondsToAdd: Int): Int {
+    return timestamp + secondsToAdd
+  }
+
+  @RequiresApi(Build.VERSION_CODES.O)
+  fun getStartOfDay(epochMillis: Long): Long {
+    return Instant.ofEpochMilli(epochMillis)
+      .atZone(ZoneId.systemDefault())
+      .toLocalDate()
+      .atStartOfDay(ZoneId.systemDefault())
+      .toInstant()
+      .toEpochMilli()
+  }
+
+  @RequiresApi(Build.VERSION_CODES.O)
+  fun convertToEpoch(isoDateString: String): Long {
+    return try {
+      val instant = Instant.from(DateTimeFormatter.ISO_INSTANT.parse(isoDateString))
+      instant.epochSecond
+    } catch (e: Exception) {
+      e.printStackTrace()
+      val oneYearBack = LocalDateTime.now().minusYears(1).toEpochSecond(ZoneOffset.UTC)
+      oneYearBack
+    }
+  }
+
+  @OptIn(ExperimentalContracts::class)
+  inline fun <reified T> T?.isNull(): Boolean {
+    contract {
+      returns(true) implies (this@isNull == null)
+    }
+    return this == null
+  }
+
+  @OptIn(ExperimentalContracts::class)
+  inline fun <reified T> T?.isNotNull(): Boolean {
+    contract {
+      returns(true) implies (this@isNotNull != null)
+    }
+    return this != null
+  }
+
+  fun Boolean?.isTrue(): Boolean {
+    return this == true
+  }
+}

package/android/src/main/res/drawable/ic_close.xml

@@ -0,0 +1,12 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+  android:width="24dp"
+  android:height="24dp"
+  android:tint="#FFFFFF"
+  android:viewportWidth="24"
+  android:viewportHeight="24">
+
+  <path
+    android:fillColor="@android:color/white"
+    android:pathData="M19,6.41L17.59,5 12,10.59 6.41,5 5,6.41 10.59,12 5,17.59 6.41,19 12,13.41 17.59,19 19,17.59 13.41,12z" />
+
+</vector>