@rentlydev/rently-tuya 0.1.0

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

@@ -0,0 +1,234 @@
+package com.rentlytuya.tuya
+
+import android.os.Build
+import android.util.Log
+import androidx.annotation.RequiresApi
+import androidx.compose.runtime.MutableLongState
+import androidx.compose.runtime.MutableState
+import com.rentlytuya.tuya.Tuya.TAG
+import com.rentlytuya.util.Airbrake
+import com.rentlytuya.util.DateUtil
+import com.rentlytuya.util.DateUtil.isNotNull
+import com.rentlytuya.util.DateUtil.isNull
+import com.thingclips.smart.android.camera.sdk.ThingIPCSdk
+import com.thingclips.smart.android.camera.sdk.api.IThingCameraMessage
+import com.thingclips.smart.android.camera.sdk.api.IThingIPCMsg
+import com.thingclips.smart.home.sdk.callback.IThingResultCallback
+import com.thingclips.smart.ipc.messagecenter.bean.CameraMessageBean
+import com.thingclips.smart.ipc.messagecenter.bean.CameraMessageClassifyBean
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.withContext
+import kotlinx.coroutines.withTimeoutOrNull
+import java.time.ZonedDateTime
+import java.time.format.DateTimeFormatter
+import kotlin.coroutines.resume
+
+object Messages {
+
+  private var iThingCameraMessage: IThingCameraMessage? = null
+  private var alarmDetectionClassify: CameraMessageClassifyBean? = null
+
+  @RequiresApi(Build.VERSION_CODES.O)
+  suspend fun initializeAndFetchMessages(
+    offset: MutableState<Int>,
+    selectedDate: MutableLongState,
+    isLoading: MutableState<Boolean>,
+    noMoreMessages: MutableState<Boolean>,
+    messages: MutableState<List<CameraMessageBean?>?>
+  ) {
+    isLoading.value = true
+    val isInitialized = initialize()
+    if (isInitialized) {
+      getMessageList(
+        offset = offset,
+        messages = messages,
+        isLoading = isLoading,
+        selectedDate = selectedDate,
+        noMoreMessages = noMoreMessages
+      )
+    } else {
+      isLoading.value = false
+      Log.i(TAG, "Failed to initialize messages")
+    }
+  }
+
+  private suspend fun initialize(): Boolean = withTimeoutOrNull(8000) {
+    suspendCancellableCoroutine<Boolean> { continuation ->
+      val message: IThingIPCMsg? = ThingIPCSdk.getMessage()
+      if (message.isNotNull()) {
+        iThingCameraMessage = message.createCameraMessage()
+        continuation.resume(true)
+      } else {
+        Airbrake.logMessage(
+          title = "Message Initializing Failed",
+          message = "ThingIPCSdk.getMessage() returned null"
+        )
+        continuation.resume(false)
+      }
+    }
+  } ?: false
+
+  private suspend fun fetchAlarmDetectionClassify(): CameraMessageClassifyBean? {
+    if (alarmDetectionClassify.isNull()) {
+      alarmDetectionClassify = withTimeoutOrNull(8000) {
+        suspendCancellableCoroutine { continuation ->
+          iThingCameraMessage?.queryAlarmDetectionClassify(
+            Tuya.deviceId,
+            object : IThingResultCallback<List<CameraMessageClassifyBean?>?> {
+              override fun onSuccess(result: List<CameraMessageClassifyBean?>?) {
+                continuation.resume(result?.get(0))
+              }
+
+              override fun onError(errorCode: String, errorMessage: String) {
+                Airbrake.logMessage(
+                  title = "Fetch Alarm Detection Classify Failed",
+                  message = "Error Code: $errorCode",
+                  additionalInfo = mapOf("Error" to errorMessage)
+                )
+                continuation.resume(null)
+              }
+            }
+          )
+        }
+      }
+    }
+    return alarmDetectionClassify
+  }
+
+  @RequiresApi(Build.VERSION_CODES.O)
+  suspend fun getMessageList(
+    offset: MutableState<Int>,
+    selectedDate: MutableLongState,
+    isLoading: MutableState<Boolean>,
+    noMoreMessages: MutableState<Boolean>,
+    messages: MutableState<List<CameraMessageBean?>?>
+  ) {
+    if (iThingCameraMessage.isNotNull()) {
+      isLoading.value = true
+
+      val selectedDateInSeconds = maxOf(
+        DateUtil.getStartOfDay(selectedDate.longValue) / 1000,
+        Tuya.lastMoveOutDate?.let {
+          ZonedDateTime.parse(it, DateTimeFormatter.ISO_ZONED_DATE_TIME)
+            .toEpochSecond()
+        } ?: 0L
+      )
+      val endTime = selectedDateInSeconds + 86340
+
+      fetchAlarmDetectionClassify()?.let { classifyBean ->
+        Log.i(
+          TAG,
+          "Fetching messages for: $selectedDateInSeconds to $endTime, offset: ${offset.value}"
+        )
+        iThingCameraMessage?.getAlarmDetectionMessageList(
+          Tuya.deviceId,
+          selectedDateInSeconds.toInt(),
+          endTime.toInt(),
+          classifyBean.msgCode,
+          offset.value,
+          20,
+          object : IThingResultCallback<List<CameraMessageBean?>?> {
+            override fun onSuccess(result: List<CameraMessageBean?>?) {
+              if (result.isNotNull()) {
+                messages.value = messages.value?.plus(result)
+                offset.value += result.size
+                if (result.size < 20) {
+                  noMoreMessages.value = true
+                }
+                isLoading.value = false
+                Log.i(TAG, "getAlarmDetectionMessageList success $result")
+              } else {
+                noMoreMessages.value = true
+                isLoading.value = false
+                Log.i(TAG, "Messages received is null or empty")
+              }
+            }
+
+            override fun onError(errorCode: String, errorMessage: String) {
+              isLoading.value = false
+              Airbrake.logMessage(
+                title = "Get Message List Failed",
+                message = "Error Code: $errorCode",
+                additionalInfo = mapOf("Error" to errorMessage)
+              )
+            }
+          }
+        )
+      } ?: run {
+        isLoading.value = false
+        Log.i(TAG, "Failed to fetch alarm detection classify")
+      }
+    } else {
+      Log.i(TAG, "iThingCameraMessage is null")
+    }
+  }
+
+  suspend fun getAvailableMessageDates(
+    year: Int,
+    month: Int,
+    isLoading: MutableState<Boolean>,
+    availableDates: MutableState<Array<Int>>
+  ) {
+    if (iThingCameraMessage.isNotNull()) {
+      isLoading.value = true
+
+      withContext(Dispatchers.IO) {
+        val result: List<String?>? = withTimeoutOrNull(5000) {
+          suspendCancellableCoroutine { continuation ->
+            iThingCameraMessage?.queryMotionDaysByMonth(
+              Tuya.deviceId,
+              year,
+              month,
+              object : IThingResultCallback<List<String?>?> {
+                override fun onSuccess(result: List<String?>?) {
+                  Log.i(TAG, "getAvailableMessageDates success $result")
+                  continuation.resume(result)
+                }
+
+                override fun onError(errorCode: String, errorMessage: String) {
+                  Airbrake.logMessage(
+                    title = "Get Available Message Dates Failed",
+                    message = "Error Code: $errorCode",
+                    additionalInfo = mapOf("Error" to errorMessage)
+                  )
+                  continuation.resume(null)
+                }
+              })
+          }
+        }
+
+        if (result.isNullOrEmpty()) {
+          Log.i(TAG, "Fetching available dates for Messages timed out or failed")
+          availableDates.value = emptyArray()
+          isLoading.value = false
+        } else {
+          try {
+            val days = result.filterNotNull().map { it.toInt() }.toTypedArray()
+            availableDates.value = days
+            Log.i(
+              TAG,
+              "Available Message Dates received: ${availableDates.value.joinToString(", ")}"
+            )
+          } catch (e: Exception) {
+            Log.e(TAG, "Parsing available dates for Messages failed: ${e.message}")
+            availableDates.value = emptyArray()
+          } finally {
+            isLoading.value = false
+          }
+        }
+      }
+
+    } else {
+      Log.i(TAG, "iThingCameraMessage is null")
+      availableDates.value = emptyArray()
+    }
+  }
+
+  fun destroy() {
+    if (iThingCameraMessage.isNotNull()) {
+      iThingCameraMessage?.destroy()
+      iThingCameraMessage = null
+    }
+  }
+}

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

@@ -0,0 +1,385 @@
+package com.rentlytuya.tuya
+
+import android.os.Build
+import android.util.Log
+import androidx.annotation.RequiresApi
+import androidx.compose.runtime.MutableState
+import com.alibaba.fastjson.JSONObject
+import com.rentlytuya.tuya.Tuya.TAG
+import com.rentlytuya.util.Airbrake
+import com.rentlytuya.util.DateUtil
+import com.rentlytuya.util.DateUtil.isNotNull
+import com.rentlytuya.util.DateUtil.isNull
+import com.thingclips.smart.camera.camerasdk.thingplayer.callback.OperationDelegateCallBack
+import com.thingclips.smart.ipc.camera.autotesting.excute.bean.RecordInfoBean
+import com.thingclips.smart.ipc.camera.autotesting.excute.bean.TimePieceBean
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.withContext
+import kotlinx.coroutines.withTimeoutOrNull
+import kotlin.coroutines.resume
+
+object Playback {
+
+  suspend fun getAvailableDates(
+    year: Int,
+    month: Int,
+    availableDates: MutableState<Array<Int>>,
+    isLoading: MutableState<Boolean>
+  ) {
+    if (Tuya.mCameraP2P.isNotNull()) {
+      isLoading.value = true
+
+      withContext(Dispatchers.IO) {
+        val result: String? = withTimeoutOrNull(5000) {
+          suspendCancellableCoroutine { continuation ->
+            Tuya.mCameraP2P?.queryRecordDaysByMonth(
+              year,
+              month,
+              object : OperationDelegateCallBack {
+                override fun onSuccess(sessionId: Int, requestId: Int, data: String) {
+                  Log.i(TAG, "getAvailableDates Success: Data: $data")
+                  continuation.resume(data)
+                }
+
+                override fun onFailure(sessionId: Int, requestId: Int, errCode: Int) {
+                  Airbrake.logMessage(
+                    title = "Get Available dates Failed",
+                    message = "Error Code: $errCode",
+                    additionalInfo = mapOf(
+                      "sessionId" to sessionId.toString(),
+                      "requestId" to requestId.toString()
+                    )
+                  )
+                  continuation.resume(null)
+                }
+              })
+          }
+        }
+
+        if (result.isNullOrEmpty()) {
+          Log.i(TAG, "Fetching available dates timed out or failed")
+          availableDates.value = emptyArray()
+          isLoading.value = false
+        } else {
+          try {
+            val jsonObject = org.json.JSONObject(result)
+            val dataDaysArray = jsonObject.getJSONArray("DataDays")
+            val days = Array(dataDaysArray.length()) { index ->
+              dataDaysArray.getString(index).toInt()
+            }
+            availableDates.value = days
+            Log.i(TAG, "Available Dates received: ${availableDates.value.joinToString(", ")}")
+          } catch (e: Exception) {
+            Log.e(TAG, "Parsing available dates failed: ${e.message}")
+            availableDates.value = emptyArray()
+          } finally {
+            isLoading.value = false
+          }
+        }
+      }
+    } else {
+      Log.i(TAG, "mCameraP2P is null")
+      availableDates.value = emptyArray()
+    }
+  }
+
+  @RequiresApi(Build.VERSION_CODES.O)
+  suspend fun getAllTheClipsOfTheDay(
+    year: Int,
+    month: Int,
+    day: Int,
+    isPaused: MutableState<Boolean>,
+    isPlaying: MutableState<Boolean>,
+    isLoading: MutableState<Boolean>,
+    videos: MutableState<List<TimePieceBean>>,
+    selectedItem: MutableState<TimePieceBean?>
+  ) {
+    if (Tuya.mCameraP2P.isNotNull()) {
+      isLoading.value = true
+
+      withContext(Dispatchers.IO) {
+        val result: String? = withTimeoutOrNull(10000) {
+          suspendCancellableCoroutine { continuation ->
+            Tuya.mCameraP2P?.queryRecordTimeSliceByDay(
+              year,
+              month,
+              day,
+              object : OperationDelegateCallBack {
+                override fun onSuccess(sessionId: Int, requestId: Int, data: String) {
+                  Log.i(
+                    TAG,
+                    "getAllTheClipsOfTheDay Success: SessionId: $sessionId, RequestID: $requestId, Date: $data"
+                  )
+                  continuation.resume(data)
+                }
+
+                override fun onFailure(sessionId: Int, requestId: Int, errCode: Int) {
+                  isPlaying.value = false
+                  isLoading.value = false
+                  Airbrake.logMessage(
+                    title = "Get Video Clips Failed",
+                    message = "Error Code: $errCode",
+                    additionalInfo = mapOf(
+                      "sessionId" to sessionId.toString(),
+                      "requestId" to requestId.toString()
+                    )
+                  )
+                  continuation.resume(null)
+                }
+              }
+            )
+          }
+        }
+
+        if (result.isNull()) {
+          Log.i(TAG, "Video List fetching timed out after 10 seconds")
+          isPlaying.value = false
+          isLoading.value = false
+        } else {
+          parsePlaybackData(
+            data = result!!,
+            videos = videos,
+            isPaused = isPaused,
+            isLoading = isLoading,
+            isPlaying = isPlaying,
+            selectedItem = selectedItem
+          )
+        }
+      }
+    }
+  }
+
+  @RequiresApi(Build.VERSION_CODES.O)
+  private fun parsePlaybackData(
+    data: String,
+    isPaused: MutableState<Boolean>,
+    isLoading: MutableState<Boolean>,
+    isPlaying: MutableState<Boolean>,
+    videos: MutableState<List<TimePieceBean>>,
+    selectedItem: MutableState<TimePieceBean?>
+  ) {
+    val recordInfoBean: RecordInfoBean =
+      JSONObject.parseObject(data, RecordInfoBean::class.java)
+
+    if (recordInfoBean.count != 0) {
+      val timePieceBeanList: List<TimePieceBean>? = recordInfoBean.items
+      if (!timePieceBeanList.isNullOrEmpty()) {
+        videos.value = timePieceBeanList
+          .filter { video ->
+            Tuya.lastMoveOutDate?.let {
+              val epochTime = DateUtil.convertToEpoch(it)
+              val isValid = video.startTime >= epochTime
+              isValid
+            } ?: true
+          }
+          .reversed()
+
+        if (videos.value.isNotEmpty()) {
+          startSDCardPlayback(
+            isPaused = isPaused,
+            isLoading = isLoading,
+            isPlaying = isPlaying,
+            selectedItem = selectedItem,
+            video = videos.value[0],
+            videoList = videos.value
+          )
+        } else {
+          videos.value = emptyList()
+          isLoading.value = false
+          isPlaying.value = false
+          isPaused.value = true
+          Log.i(TAG, "No valid videos found before lastMoveOut")
+        }
+      }
+    } else {
+      videos.value = emptyList()
+      isLoading.value = false
+      isPlaying.value = false
+      isPaused.value = true
+      Log.i(TAG, "RecordInfoBean count is equal to 0")
+    }
+  }
+
+  fun startSDCardPlayback(
+    videoList: List<TimePieceBean>?,
+    video: TimePieceBean,
+    playTime: Int? = null,
+    isPaused: MutableState<Boolean>,
+    isLoading: MutableState<Boolean>,
+    isPlaying: MutableState<Boolean>,
+    selectedItem: MutableState<TimePieceBean?>
+  ) {
+    if (Tuya.mCameraP2P.isNotNull()) {
+
+      val isEndOfVideo = playTime.isNotNull() && playTime == video.endTime
+
+      if (isEndOfVideo) {
+        val currentIndex = videoList?.indexOf(video) ?: -1
+        val nextIndex = currentIndex + 1
+
+        if (videoList.isNotNull() && nextIndex < videoList.size) {
+          val nextVideo = videoList[nextIndex]
+          Log.i(TAG, "Switching to next video: $nextVideo")
+          startSDCardPlayback(
+            videoList = videoList,
+            video = nextVideo,
+            isPaused = isPaused,
+            isLoading = isLoading,
+            isPlaying = isPlaying,
+            selectedItem = selectedItem
+          )
+          return
+        } else {
+          Log.i(TAG, "No more videos available.")
+          isPlaying.value = false
+          return
+        }
+      }
+
+      isLoading.value = true
+      Tuya.mCameraP2P?.startPlayBack(
+        video.startTime,
+        video.endTime,
+        playTime ?: video.startTime, object : OperationDelegateCallBack {
+          override fun onSuccess(sessionId: Int, requestId: Int, data: String) {
+            Log.i(
+              TAG,
+              "startSDCardPlayback success: SessionId: $sessionId, RequestId: $requestId, Data: $data"
+            )
+            isLoading.value = false
+            isPlaying.value = true
+            isPaused.value = false
+            selectedItem.value = video
+          }
+
+          override fun onFailure(sessionId: Int, requestId: Int, errCode: Int) {
+            isLoading.value = false
+            isPlaying.value = false
+            Airbrake.logMessage(
+              title = "Start SD Card Playback Failed",
+              message = "Error Code: $errCode",
+              additionalInfo = mapOf(
+                "sessionId" to sessionId.toString(),
+                "requestId" to requestId.toString()
+              )
+            )
+          }
+        }, object : OperationDelegateCallBack {
+          override fun onSuccess(sessionId: Int, requestId: Int, data: String) {
+            Log.i(
+              TAG,
+              "Finished playback: Session Id: $sessionId, requestId: $requestId, Data: $data"
+            )
+            isLoading.value = false
+            isPlaying.value = false
+          }
+
+          override fun onFailure(sessionId: Int, requestId: Int, errCode: Int) {
+            isLoading.value = false
+            isPlaying.value = false
+            Airbrake.logMessage(
+              title = "Finish Playback Failed",
+              message = "Error Code: $errCode",
+              additionalInfo = mapOf(
+                "sessionId" to sessionId.toString(),
+                "requestId" to requestId.toString()
+              )
+            )
+          }
+        })
+    }
+  }
+
+  fun pauseSDCardPlayback(
+    isPaused: MutableState<Boolean>
+  ) {
+    if (Tuya.mCameraP2P.isNotNull()) {
+      Tuya.mCameraP2P?.pausePlayBack(object : OperationDelegateCallBack {
+        override fun onSuccess(sessionId: Int, requestId: Int, data: String) {
+          Log.i(
+            TAG,
+            "pauseSDCardPlayback success: SessionId: $sessionId, RequestId: $requestId, Data: $data"
+          )
+          isPaused.value = true
+        }
+
+        override fun onFailure(sessionId: Int, requestId: Int, errCode: Int) {
+          // Keep the isPaused state same
+          Airbrake.logMessage(
+            title = "Pause SD card Playback Failed",
+            message = "Error Code: $errCode",
+            additionalInfo = mapOf(
+              "sessionId" to sessionId.toString(),
+              "requestId" to requestId.toString()
+            )
+          )
+        }
+      })
+    } else {
+      Log.i(TAG, "mCameraP2P is null")
+    }
+  }
+
+  fun resumeSDCardPlayback(
+    isPaused: MutableState<Boolean>
+  ) {
+    if (Tuya.mCameraP2P.isNotNull()) {
+      Tuya.mCameraP2P?.resumePlayBack(object : OperationDelegateCallBack {
+        override fun onSuccess(sessionId: Int, requestId: Int, data: String) {
+          Log.i(
+            TAG,
+            "resumeSDCardPlayback success: SessionId: $sessionId. RequestId: $requestId, Data: $data"
+          )
+          isPaused.value = false
+        }
+
+        override fun onFailure(sessionId: Int, requestId: Int, errCode: Int) {
+          // Keep the isPaused state same
+          Airbrake.logMessage(
+            title = "Resume SD Card Playback Failed",
+            message = "Error Code: $errCode",
+            additionalInfo = mapOf(
+              "sessionId" to sessionId.toString(),
+              "requestId" to requestId.toString()
+            )
+          )
+        }
+      })
+    } else {
+      Log.i(TAG, "mCameraP2P is null")
+    }
+  }
+
+  fun stopSDCardPlayback(
+    isPlaying: MutableState<Boolean>? = null
+  ) {
+    if (Tuya.mCameraP2P.isNotNull()) {
+      Tuya.mCameraP2P?.stopPlayBack(object : OperationDelegateCallBack {
+        override fun onSuccess(sessionId: Int, requestId: Int, data: String) {
+          if (isPlaying.isNotNull()) {
+            isPlaying.value = false
+          }
+          Log.i(
+            TAG,
+            "stopSDCardPlayback success: SessionId: $sessionId. RequestId: $requestId, Data: $data"
+          )
+        }
+
+        override fun onFailure(sessionId: Int, requestId: Int, errCode: Int) {
+          // Keep the isPlaying and isPaused state same
+          Airbrake.logMessage(
+            title = "Stop SD card Playback Failed",
+            message = "Error Code: $errCode",
+            additionalInfo = mapOf(
+              "sessionId" to sessionId.toString(),
+              "requestId" to requestId.toString()
+            )
+          )
+        }
+      })
+    } else {
+      Log.i(TAG, "mCameraP2P is null")
+    }
+  }
+}