@rentlydev/rently-tuya 0.1.0

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

@@ -0,0 +1,685 @@
+package com.rentlytuya.dashboard
+
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import androidx.activity.compose.BackHandler
+import androidx.annotation.RequiresApi
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.BoxScope
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.MutableIntState
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableLongStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.shadow
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleEventObserver
+import androidx.lifecycle.compose.LocalLifecycleOwner
+import androidx.navigation.NavController
+import com.rentlytuya.R
+import com.rentlytuya.alerts.SuccessAlert
+import com.rentlytuya.components.DatePicker
+import com.rentlytuya.components.Label
+import com.rentlytuya.components.LoadingIndicator
+import com.rentlytuya.components.Slider
+import com.rentlytuya.components.VideoView
+import com.rentlytuya.tuya.Playback
+import com.rentlytuya.tuya.ScreenCapture
+import com.rentlytuya.tuya.Tuya
+import com.rentlytuya.tuya.Tuya.TAG
+import com.rentlytuya.ui.theme.LocalColor
+import com.rentlytuya.util.DateUtil
+import com.rentlytuya.util.DateUtil.isNotNull
+import com.rentlytuya.util.Util
+import com.rentlytuya.util.Util.isLandscape
+import com.rentlytuya.util.Util.strings
+import com.thingclips.smart.ipc.camera.autotesting.excute.bean.TimePieceBean
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import java.time.Instant
+import java.time.LocalDate
+import java.time.ZoneId
+import java.time.format.DateTimeFormatter
+import java.util.Date
+
+@RequiresApi(Build.VERSION_CODES.O)
+@Composable
+fun Playback(
+  isMuted: MutableState<Boolean>,
+  isSettings: MutableState<Boolean>,
+  isDatePickerVisible: MutableState<Boolean>,
+  navController: NavController
+) {
+
+  val coroutineScope = rememberCoroutineScope()
+  val configuration = LocalConfiguration.current
+  val lifecycleOwner = LocalLifecycleOwner.current
+
+  val datePickerLoader = remember { mutableStateOf(false) }
+  val availableDates = remember { mutableStateOf(emptyArray<Int>()) }
+  val selectedDate = remember { mutableLongStateOf(Date().time) }
+  val isLoading = remember { mutableStateOf(false) }
+  val videos = remember { mutableStateOf(emptyList<TimePieceBean>()) }
+  val selectedItem = remember { mutableStateOf<TimePieceBean?>(null) }
+
+  val isPlaying = remember { mutableStateOf(false) }
+  val isPaused = remember { mutableStateOf(false) }
+  val isScreenShotSuccess = remember { mutableStateOf(false) }
+  val isRecordingSuccess = remember { mutableStateOf(false) }
+  val isRecordingFailure = remember { mutableStateOf(false) }
+
+  val sliderVisible = remember { mutableStateOf(false) }
+  val sliderAlpha = remember { mutableFloatStateOf(0f) }
+
+  val timerHandler = remember { Handler(Looper.getMainLooper()) }
+
+  val currentPosition = remember { mutableIntStateOf(0) }
+  val isSeeking = remember { mutableStateOf(false) }
+
+  BackHandler {
+    isSettings.value = false
+    navController.navigate("Dashboard")
+  }
+
+  DisposableEffect(lifecycleOwner) {
+    val observer = LifecycleEventObserver { _, event ->
+      if (event == Lifecycle.Event.ON_PAUSE) {
+        Playback.pauseSDCardPlayback(isPaused = isPaused)
+      }
+    }
+    lifecycleOwner.lifecycle.addObserver(observer)
+    onDispose {
+      lifecycleOwner.lifecycle.removeObserver(observer)
+    }
+  }
+
+  fun updateSliderValue() {
+    val startTime = selectedItem.value?.startTime
+    val endTime = selectedItem.value?.endTime
+
+    if (isPlaying.value && !isPaused.value && !isLoading.value && !isSeeking.value && startTime != null && endTime != null) {
+      if (currentPosition.intValue < (endTime - startTime)) {
+        currentPosition.intValue += 1
+      } else {
+        Playback.pauseSDCardPlayback(isPaused = isPaused)
+      }
+    }
+  }
+
+  val timerRunnable: Runnable = remember {
+    object : Runnable {
+      override fun run() {
+        updateSliderValue()
+        timerHandler.postDelayed(this, 1000)
+      }
+    }
+  }
+
+  fun setupTimer() {
+    timerHandler.post(timerRunnable)
+  }
+
+  fun stopTimer() {
+    timerHandler.removeCallbacks(timerRunnable)
+  }
+
+  fun showSlider() {
+    coroutineScope.launch {
+      sliderVisible.value = true
+      sliderAlpha.floatValue = 1f
+      delay(8000)
+      sliderAlpha.floatValue = 0f
+      delay(500)
+      sliderVisible.value = false
+    }
+  }
+
+  LaunchedEffect(Unit) {
+    Tuya.stopPreview()
+    setupTimer()
+    Playback.getAvailableDates(
+      year = LocalDate.now().year,
+      month = LocalDate.now().monthValue,
+      availableDates = availableDates,
+      isLoading = datePickerLoader
+    )
+    showSlider()
+  }
+
+  LaunchedEffect(selectedDate.longValue) {
+    val (year, month, day) = DateUtil.getDateComponents(selectedDate.longValue)
+
+    if (isPlaying.value) {
+      Playback.stopSDCardPlayback(
+        isPlaying = isPlaying
+      )
+    }
+
+    Playback.getAllTheClipsOfTheDay(
+      year = year,
+      month = month,
+      day = day,
+      isPaused = isPaused,
+      isPlaying = isPlaying,
+      isLoading = isLoading,
+      videos = videos,
+      selectedItem = selectedItem
+    )
+  }
+
+  LaunchedEffect(selectedItem.value) {
+    selectedItem.value?.let {
+      currentPosition.intValue = 0
+    }
+  }
+
+  LaunchedEffect(isPlaying.value) {
+    if (!isPlaying.value) {
+      Tuya.setMute(1,
+        setMute = { value ->
+          isMuted.value = value
+        }
+      )
+    }
+  }
+
+  LaunchedEffect(configuration.orientation) {
+    if (isLandscape(configuration) && isDatePickerVisible.value) {
+      isDatePickerVisible.value = false
+    }
+  }
+
+  DisposableEffect(Unit) {
+    onDispose { stopTimer() }
+  }
+
+  Column(
+    modifier = Modifier
+      .fillMaxSize(),
+    horizontalAlignment = Alignment.CenterHorizontally,
+    verticalArrangement = Arrangement.Center
+  ) {
+    if (isLoading.value) {
+      LoadingIndicator()
+    }
+
+    Column(
+      modifier = Modifier
+        .fillMaxSize()
+    ) {
+      Box(
+        modifier = Modifier
+          .fillMaxWidth()
+          .fillMaxHeight(if (Util.isLandscape(configuration)) 1f else 0.3f)
+      ) {
+        if (!isPlaying.value) {
+          Box(
+            modifier = Modifier
+              .fillMaxSize()
+              .background(LocalColor.Monochrome.Black)
+          )
+        } else {
+          Box(
+            modifier = Modifier
+              .fillMaxSize()
+              .background(LocalColor.Monochrome.Black)
+          ) {
+            VideoView(
+              onClick = {
+                showSlider()
+              }
+            )
+
+            SliderView(
+              isPaused = isPaused,
+              isPlaying = isPlaying,
+              isLoading = isLoading,
+              isSeeking = isSeeking,
+              currentPosition = currentPosition,
+              sliderVisible = sliderVisible,
+              selectedItem = selectedItem,
+              videoList = videos.value
+            )
+          }
+        }
+      }
+
+      if (!Util.isLandscape(configuration)) {
+        Column(
+          modifier = Modifier
+            .fillMaxWidth()
+            .fillMaxHeight(0.85f)
+            .background(LocalColor.Monochrome.White)
+        ) {
+          if (videos.value.isEmpty()) {
+            Column(
+              modifier = Modifier
+                .fillMaxSize()
+                .background(LocalColor.Main.Light),
+              horizontalAlignment = Alignment.CenterHorizontally,
+              verticalArrangement = Arrangement.Center
+            ) {
+              Label(
+                modifier = Modifier.padding(horizontal = 30.dp),
+                id = "noPlaybackVideos",
+                title = strings(id = R.string.noPlaybackVideos),
+                l = true,
+                center = true,
+                black = true,
+                medium = true,
+                maxLines = 3
+              )
+            }
+          } else {
+            LazyColumn(
+              modifier = Modifier
+                .fillMaxSize()
+                .background(LocalColor.Main.Light),
+              horizontalAlignment = Alignment.CenterHorizontally
+            ) {
+              items(videos.value) { video ->
+                VideoItem(
+                  video = video,
+                  videoList = videos.value,
+                  isPaused = isPaused,
+                  isPlaying = isPlaying,
+                  isLoading = isLoading,
+                  selectedItem = selectedItem,
+                  currentSliderValue = currentPosition
+                )
+              }
+            }
+          }
+        }
+
+        BottomBar(
+          isMuted = isMuted,
+          isPaused = isPaused,
+          isPlaying = isPlaying,
+          isLoading = isLoading,
+          videoList = videos.value,
+          selectedItem = selectedItem,
+          currentSliderValue = currentPosition,
+          isRecordingSuccess = isRecordingSuccess,
+          isRecordingFailure = isRecordingFailure,
+          isScreenShotSuccess = isScreenShotSuccess,
+        )
+      }
+
+      DatePicker(
+        isVisible = isDatePickerVisible,
+        availableDates = availableDates.value,
+        minDate = if (Tuya.lastMoveOutDate.isNotNull()) LocalDate.parse(
+          Tuya.lastMoveOutDate,
+          DateTimeFormatter.ISO_DATE_TIME
+        ) else null,
+        isLoading = datePickerLoader.value,
+        onDateSelected = {
+
+        },
+        onMonthChanged = { newMonth ->
+          coroutineScope.launch {
+            Playback.getAvailableDates(
+              year = newMonth.year,
+              month = newMonth.monthValue,
+              availableDates = availableDates,
+              isLoading = datePickerLoader
+            )
+          }
+        },
+        onCancel = {
+          isDatePickerVisible.value = false
+        },
+        onOk = { date ->
+          selectedDate.longValue = date
+          isDatePickerVisible.value = false
+        },
+        onAppear = {
+          val localDate = Instant.ofEpochMilli(selectedDate.longValue)
+            .atZone(ZoneId.systemDefault())
+            .toLocalDate()
+
+          coroutineScope.launch {
+            Playback.getAvailableDates(
+              year = localDate.year,
+              month = localDate.monthValue,
+              availableDates = availableDates,
+              isLoading = datePickerLoader
+            )
+          }
+        }
+      )
+    }
+  }
+}
+
+@Composable
+fun BoxScope.SliderView(
+  videoList: List<TimePieceBean>,
+  isPaused: MutableState<Boolean>,
+  isPlaying: MutableState<Boolean>,
+  isLoading: MutableState<Boolean>,
+  currentPosition: MutableIntState,
+  sliderVisible: MutableState<Boolean>,
+  isSeeking: MutableState<Boolean>,
+  selectedItem: MutableState<TimePieceBean?>
+) {
+  if (selectedItem.value.isNotNull()) {
+    Column(
+      modifier = Modifier
+        .fillMaxWidth()
+        .align(Alignment.BottomCenter)
+    ) {
+      AnimatedVisibility(
+        visible = sliderVisible.value && selectedItem.value != null,
+        enter = fadeIn(),
+        exit = fadeOut(),
+      ) {
+        Column(
+          modifier = Modifier
+            .padding(horizontal = 18.dp)
+        ) {
+
+          Label(
+            modifier = Modifier
+              .align(Alignment.Start)
+              .width(300.dp),
+            id = "duration",
+            title = "${DateUtil.formatSecondsToHHMMSS(currentPosition.intValue)} / ${
+              DateUtil.calculateDuration(
+                startTime = selectedItem.value!!.startTime,
+                endTime = selectedItem.value!!.endTime
+              )
+            }",
+            s = true,
+            white = true,
+            bold = true,
+            lineHeight = 12.sp
+          )
+
+          Slider(
+            id = "playbackSlider",
+            sliderValue = currentPosition.intValue.toFloat(),
+            onValueChange = { value ->
+              isSeeking.value = true
+              currentPosition.intValue = value.toInt()
+            },
+            onSlidingComplete = {
+              isSeeking.value = false
+              val playTime = DateUtil.incrementTimestampBySeconds(
+                timestamp = selectedItem.value!!.startTime,
+                secondsToAdd = currentPosition.intValue
+              )
+              Log.i(
+                TAG,
+                "PlayTime: $playTime, Start Time: ${selectedItem.value!!.startTime}, End Time: ${selectedItem.value!!.endTime}"
+              )
+              Playback.startSDCardPlayback(
+                videoList = videoList,
+                video = selectedItem.value!!,
+                playTime = playTime,
+                isPaused = isPaused,
+                isPlaying = isPlaying,
+                isLoading = isLoading,
+                selectedItem = selectedItem
+              )
+            },
+            minimumValue = 0f,
+            maximumValue = DateUtil.calculateSecondsBetweenTimestamps(
+              startTime = selectedItem.value!!.startTime,
+              endTime = selectedItem.value!!.endTime
+            ).toFloat(),
+            modifier = Modifier
+              .fillMaxWidth()
+          )
+        }
+      }
+    }
+  }
+}
+
+@Composable
+fun VideoItem(
+  video: TimePieceBean,
+  videoList: List<TimePieceBean>,
+  isPaused: MutableState<Boolean>,
+  isLoading: MutableState<Boolean>,
+  isPlaying: MutableState<Boolean>,
+  currentSliderValue: MutableIntState,
+  selectedItem: MutableState<TimePieceBean?>
+) {
+
+  Row(
+    modifier = Modifier
+      .fillMaxWidth(0.93f)
+      .height(78.dp)
+      .padding(top = 10.dp)
+      .shadow(1.dp)
+      .background(if (selectedItem.value == video) LocalColor.Secondary.Light else LocalColor.Monochrome.White)
+      .clickable {
+          if (selectedItem.value == video) {
+            currentSliderValue.intValue = 0
+          }
+          Playback.startSDCardPlayback(
+            videoList = videoList,
+            video = video,
+            isPaused = isPaused,
+            isPlaying = isPlaying,
+            isLoading = isLoading,
+            selectedItem = selectedItem
+          )
+      },
+    horizontalArrangement = Arrangement.SpaceBetween,
+    verticalAlignment = Alignment.CenterVertically
+  ) {
+    Column(
+      modifier = Modifier
+        .padding(horizontal = 15.dp, vertical = 10.dp)
+    ) {
+      Label(
+        title = DateUtil.convertTimestampToTime(video.startTime).uppercase(),
+        primary = true,
+        l = true,
+        center = true,
+        semiBold = true
+      )
+      Label(
+        title = "Duration: ${
+          DateUtil.calculateDuration(
+            startTime = video.startTime,
+            endTime = video.endTime
+          )
+        }",
+        secondary = true,
+        semiBold = true,
+        center = true,
+        s = true,
+      )
+    }
+  }
+}
+
+@Composable
+fun BottomBar(
+  isMuted: MutableState<Boolean>,
+  isPaused: MutableState<Boolean>,
+  isPlaying: MutableState<Boolean>,
+  isLoading: MutableState<Boolean>,
+  videoList: List<TimePieceBean>,
+  currentSliderValue: MutableIntState,
+  isScreenShotSuccess: MutableState<Boolean>,
+  isRecordingSuccess: MutableState<Boolean>,
+  isRecordingFailure: MutableState<Boolean>,
+  selectedItem: MutableState<TimePieceBean?>
+) {
+  val context = LocalContext.current
+  val scope = rememberCoroutineScope()
+
+  val isRecording = remember {
+    mutableStateOf(false)
+  }
+
+  SuccessAlert(
+    title = strings(id = R.string.success),
+    description = strings(id = R.string.videoSuccess),
+    isVisible = isRecordingSuccess.value
+  ) {
+    isRecordingSuccess.value = false
+  }
+
+  SuccessAlert(
+    title = strings(id = R.string.failure),
+    description = strings(id = R.string.videoFailure),
+    isVisible = isRecordingFailure.value
+  ) {
+    isRecordingFailure.value = false
+  }
+
+  SuccessAlert(
+    title = strings(id = R.string.success),
+    description = strings(id = R.string.screenshotSuccess),
+    isVisible = isScreenShotSuccess.value
+  ) {
+    isScreenShotSuccess.value = false
+  }
+
+  Row(
+    modifier = Modifier
+      .fillMaxSize()
+      .background(LocalColor.Monochrome.Grey),
+    verticalAlignment = Alignment.CenterVertically,
+    horizontalArrangement = Arrangement.SpaceEvenly
+  ) {
+    SettingsButton(
+      modifier = if (!isMuted.value) {
+        Modifier.background(LocalColor.Primary.Dark)
+      } else {
+        Modifier
+      },
+      imageId = when {
+        isPlaying.value && !isMuted.value -> R.drawable.ic_sound_on
+        else -> R.drawable.ic_sound_off
+      },
+      event = if (!isMuted.value) "Playback_SpeakerOff" else "Playback_SpeakerOn"
+    ) {
+      if (isPlaying.value) {
+        Tuya.setMute(
+          mute = if (isMuted.value) 0 else 1,
+          setMute = { value ->
+            isMuted.value = value
+          }
+        )
+      }
+    }
+
+    SettingsButton(
+      if (isRecording.value) {
+        Modifier.background(LocalColor.Danger.Primary)
+      } else {
+        Modifier
+      },
+      imageId = R.drawable.ic_record,
+      event = if (isRecording.value) "Playback_StopRecording" else "Playback_StartRecording"
+    )
+    {
+      if (!isRecording.value) {
+        val status = ScreenCapture.startRecording(
+          context = context
+        ) { value ->
+          isRecording.value = value
+        }
+      } else {
+        scope.launch {
+          val status = ScreenCapture.stopRecording(
+            context = context
+          ) { value ->
+            isRecording.value = value
+          }
+          if (status) {
+            isRecordingSuccess.value = true
+          } else {
+            isRecordingFailure.value = true
+          }
+        }
+      }
+    }
+    SettingsButton(
+      imageId = if (isPaused.value) {
+        R.drawable.ic_play
+      } else {
+        R.drawable.ic_pause
+      },
+      event = if (isPaused.value) "Playback_Play" else "Playback_Pause"
+    ) {
+      if (isPaused.value) {
+        scope.launch {
+          selectedItem.value?.let {
+            val startTime = it.startTime
+            val endTime = it.endTime
+            val videoDuration = (endTime - startTime).toDouble()
+
+            if (currentSliderValue.intValue >= videoDuration) {
+              currentSliderValue.intValue = 0
+
+              // Restart playback from the beginning if it is completed
+              Playback.startSDCardPlayback(
+                videoList = videoList,
+                video = selectedItem.value!!,
+                isPaused = isPaused,
+                isPlaying = isPlaying,
+                isLoading = isLoading,
+                selectedItem = selectedItem
+              )
+            } else {
+              Playback.resumeSDCardPlayback(isPaused)
+            }
+          } ?: Playback.resumeSDCardPlayback(isPaused)
+        }
+      } else {
+        Playback.pauseSDCardPlayback(isPaused = isPaused)
+      }
+    }
+    SettingsButton(imageId = R.drawable.ic_camera, event = "Playback_Screenshot") {
+      scope.launch {
+        if (isPlaying.value) {
+          val status = ScreenCapture.screenShot(
+            context = context
+          )
+          if (status) {
+            isScreenShotSuccess.value = true
+          }
+        }
+      }
+    }
+  }
+}