@rentlydev/rently-tuya 0.1.0

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

@@ -0,0 +1,551 @@
+package com.rentlytuya.dashboard
+
+import android.Manifest
+import android.app.Activity
+import android.util.Log
+import androidx.activity.compose.BackHandler
+import androidx.compose.animation.AnimatedVisibility
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.foundation.Image
+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.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.shape.RoundedCornerShape
+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.mutableIntStateOf
+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.clip
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.unit.dp
+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.PermissionAlert
+import com.rentlytuya.alerts.SuccessAlert
+import com.rentlytuya.components.Button
+import com.rentlytuya.components.Label
+import com.rentlytuya.components.LoadingIndicator
+import com.rentlytuya.components.VideoView
+import com.rentlytuya.tuya.ScreenCapture
+import com.rentlytuya.tuya.Settings
+import com.rentlytuya.tuya.Tuya
+import com.rentlytuya.tuya.Tuya.TAG
+import com.rentlytuya.ui.theme.LocalColor
+import com.rentlytuya.util.Heap
+import com.rentlytuya.util.PermissionHandler
+import com.rentlytuya.util.Util.isLandscape
+import com.rentlytuya.util.Util.strings
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+
+@Composable
+fun Dashboard(
+  modifier: Modifier,
+  navController: NavController,
+  isMuted: MutableState<Boolean>,
+  isOnline: MutableState<Boolean>,
+  isRecording: MutableState<Boolean>,
+  powerSource: MutableState<String>,
+  batteryPercentage: MutableIntState
+) {
+  Box(
+    modifier = Modifier
+      .fillMaxSize()
+      .background(LocalColor.Monochrome.Black)
+      .then(modifier)
+  ) {
+    val context = LocalContext.current
+    val activity = LocalContext.current as Activity
+    val configuration = LocalConfiguration.current
+    val scope = rememberCoroutineScope()
+    val lifecycleOwner = LocalLifecycleOwner.current
+
+    val isMicOn = remember { mutableStateOf(false) }
+    val previewLoader = remember { mutableStateOf(false) }
+    val isLoading = remember { mutableStateOf(false) }
+    val videoType = remember { mutableIntStateOf(4) }
+    val isPermissionDisclaimerAlertVisible = remember { mutableStateOf(false) }
+    val isScreenShotSuccess = remember { mutableStateOf(false) }
+    val isRecordingSuccess = remember { mutableStateOf(false) }
+    val isRecordingFailure = remember { mutableStateOf(false) }
+    val isDoorbellControlVisible = remember { mutableStateOf(true) }
+
+    val permissions = arrayOf(
+      Manifest.permission.RECORD_AUDIO,
+    )
+
+    LaunchedEffect(configuration.orientation, isDoorbellControlVisible.value) {
+      if (isLandscape(configuration) && isDoorbellControlVisible.value) {
+        delay(3000)
+        isDoorbellControlVisible.value = false
+      }
+
+      if (!isLandscape(configuration)) {
+        isDoorbellControlVisible.value = true
+      }
+    }
+
+    PermissionAlert(
+      context = context,
+      permissions = permissions,
+      isPermissionDisclaimerAlertVisible = isPermissionDisclaimerAlertVisible.value
+    ) {
+      isPermissionDisclaimerAlertVisible.value = 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
+    }
+
+    BackHandler {
+      scope.launch {
+        val success = Tuya.disconnect { value -> isLoading.value = value }
+        if (!success) {
+          Log.i(TAG, "Not Disconnected but still navigating the user to React Native")
+        }
+        activity.finish()
+      }
+    }
+
+    DisposableEffect(lifecycleOwner) {
+      val observer = LifecycleEventObserver { _, event ->
+        if (event == Lifecycle.Event.ON_RESUME) {
+          scope.launch {
+            Tuya.connectAndStartPreview(
+              // TODO:: Check for an alternative to identify whether it is connected or not
+              setOnline = { value ->
+                isOnline.value = value
+              },
+              setMute = { value ->
+                isMuted.value = value
+              },
+              setLoading = { value ->
+                previewLoader.value = value
+              }
+            )
+          }
+        }
+      }
+      lifecycleOwner.lifecycle.addObserver(observer)
+      onDispose {
+        lifecycleOwner.lifecycle.removeObserver(observer)
+      }
+    }
+
+    Column(
+      modifier = Modifier
+        .fillMaxSize()
+    ) {
+      Preview(
+        previewLoader = previewLoader,
+        isOnline = isOnline,
+        isMuted = isMuted,
+        isDoorbellControlVisible = isDoorbellControlVisible
+      )
+    }
+
+    if (isOnline.value) {
+      DoorbellControls(
+        permissions = permissions,
+        isDoorbellControlVisible = isDoorbellControlVisible.value,
+        videoType = videoType,
+        isMicOn = isMicOn,
+        isMuted = isMuted,
+        isLoading = isLoading,
+        isPermissionDisclaimerAlertVisible = isPermissionDisclaimerAlertVisible,
+        powerSource = powerSource,
+        batteryPercentage = batteryPercentage
+      )
+    }
+
+    if (!isLandscape(configuration)) {
+      BottomNavigationBar(
+        navController = navController,
+        isMuted = isMuted,
+        isOnline = isOnline,
+        isRecording = isRecording,
+        isRecordingSuccess = isRecordingSuccess,
+        isRecordingFailure = isRecordingFailure,
+        isScreenShotSuccess = isScreenShotSuccess
+      )
+    }
+  }
+}
+
+@Composable
+fun Preview(
+  previewLoader: MutableState<Boolean>,
+  isOnline: MutableState<Boolean>,
+  isMuted: MutableState<Boolean>,
+  isDoorbellControlVisible: MutableState<Boolean>
+) {
+  val scope = rememberCoroutineScope()
+
+  fun reConnect() {
+    scope.launch {
+      Tuya.connectAndStartPreview(
+        // TODO:: Check for an alternative to identify whether it is connected or not
+        setOnline = { value ->
+          isOnline.value = value
+        },
+        setMute = { value ->
+          isMuted.value = value
+        },
+        setLoading = { value ->
+          previewLoader.value = value
+        }
+      )
+    }
+  }
+
+  Row(
+    modifier = Modifier
+      .fillMaxWidth()
+      .fillMaxHeight(0.9f)
+      .background(LocalColor.Monochrome.Black),
+    horizontalArrangement = Arrangement.Center,
+    verticalAlignment = Alignment.CenterVertically
+  ) {
+    when {
+      previewLoader.value -> LoadingIndicator()
+      !isOnline.value -> OfflineScreen(onReConnect = { reConnect() })
+      else -> Box(
+        modifier = Modifier
+          .fillMaxWidth()
+      ) {
+        VideoView(modifier = Modifier.fillMaxSize()) {
+          isDoorbellControlVisible.value = true
+        }
+      }
+    }
+  }
+}
+
+@Composable
+fun BoxScope.DoorbellControls(
+  isDoorbellControlVisible: Boolean,
+  permissions: Array<String>,
+  videoType: MutableState<Int>,
+  isMicOn: MutableState<Boolean>,
+  isMuted: MutableState<Boolean>,
+  isLoading: MutableState<Boolean>,
+  isPermissionDisclaimerAlertVisible: MutableState<Boolean>,
+  powerSource: MutableState<String>,
+  batteryPercentage: MutableIntState
+) {
+
+  val context = LocalContext.current
+  val configuration = LocalConfiguration.current
+
+  AnimatedVisibility(
+    visible = !isLandscape(configuration) || isDoorbellControlVisible,
+    enter = fadeIn(),
+    exit = fadeOut(),
+    modifier = Modifier
+      .fillMaxWidth()
+      .align(Alignment.BottomCenter)
+  ) {
+
+    if (!Settings.is8s()) {
+      Row(
+        modifier = Modifier
+          .fillMaxWidth()
+          .padding(horizontal = 30.dp, vertical = 4.dp),
+        verticalAlignment = Alignment.CenterVertically,
+      ) {
+        val batteryIcon = when {
+          powerSource.value == "0" -> {
+            when {
+              batteryPercentage.intValue > 90 -> R.drawable.ic_battery_full
+              batteryPercentage.intValue >= 75 -> R.drawable.ic_battery_good
+              batteryPercentage.intValue >= 40 -> R.drawable.ic_battery_average
+              else -> R.drawable.ic_battery_low
+            }
+          }
+
+          else -> R.drawable.ic_battery_charging
+        }
+
+        Image(
+          painter = painterResource(id = batteryIcon),
+          contentDescription = "Battery Icon",
+          modifier = Modifier.size(24.dp)
+        )
+
+        Label(
+          modifier = Modifier
+            .padding(start = 4.dp),
+          title = if (powerSource.value == "0") {
+            "${batteryPercentage.intValue}%"
+          } else {
+            strings(id = R.string.charging)
+          },
+          white = true,
+          s = true
+        )
+      }
+    }
+
+    Box(
+      modifier = Modifier
+        .padding(top = 30.dp, bottom = if (isLandscape(configuration)) 24.dp else 96.dp)
+    ) {
+
+      Box(
+        modifier = Modifier
+          .align(Alignment.CenterStart)
+          .padding(start = 25.dp)
+      ) {
+        Button(
+          modifier = Modifier
+            .width(60.dp)
+            .height(30.dp),
+          id = "Toggle to ${if (videoType.value == 2) "SD" else "HD"}",
+          title = if (videoType.value == 2) strings(id = R.string.sd) else strings(id = R.string.hd),
+          s = true,
+          semiBold = true,
+          grey = true,
+          disabled = isLoading.value,
+          textColor = LocalColor.Monochrome.White,
+          cornerRadius = 20.dp,
+          onClick = {
+            Tuya.changeResolution(
+              videoId = if (videoType.value == 2) 4 else 2,
+              setVideoType = { value -> videoType.value = value },
+              setLoading = { value -> isLoading.value = value },
+            )
+          }
+        )
+      }
+
+      val mainButtonModifier = Modifier
+        .width(160.dp)
+        .height(50.dp)
+        .align(Alignment.Center)
+
+      Button(
+        modifier = mainButtonModifier,
+        id = "Toggle to ${if (isMicOn.value) "Tap to mute" else "Tap to speak"}",
+        title = if (isMicOn.value) strings(id = R.string.tapToMute) else strings(id = R.string.tapToSpeak),
+        grey = !isMicOn.value,
+        medium = isMicOn.value,
+        semiBold = true,
+        disabled = isLoading.value,
+        textColor = LocalColor.Monochrome.White,
+        cornerRadius = 40.dp,
+        onClick = {
+          if (PermissionHandler.arePermissionsGranted(context, permissions)) {
+            if (isMicOn.value) {
+              Tuya.stopVoiceTalk(
+                setMic = { value -> isMicOn.value = value },
+                setLoading = { value -> isLoading.value = value },
+              )
+            } else {
+              // The speaker needs to be un muted when the mic is turned on.
+              if (isMuted.value) {
+                Tuya.setMute(
+                  mute = 0,
+                  setMute = { value ->
+                    isMuted.value = value
+                  }
+                )
+              }
+              Tuya.startVoiceTalk(
+                context = context,
+                setMic = { value -> isMicOn.value = value },
+                setLoading = { value -> isLoading.value = value },
+              )
+            }
+          } else {
+            isPermissionDisclaimerAlertVisible.value = true
+          }
+        }
+      )
+    }
+  }
+}
+
+@Composable
+fun BoxScope.BottomNavigationBar(
+  navController: NavController,
+  isMuted: MutableState<Boolean>,
+  isOnline: MutableState<Boolean>,
+  isRecording: MutableState<Boolean>,
+  isScreenShotSuccess: MutableState<Boolean>,
+  isRecordingSuccess: MutableState<Boolean>,
+  isRecordingFailure: MutableState<Boolean>
+) {
+
+  val context = LocalContext.current
+  val scope = rememberCoroutineScope()
+
+  Row(
+    modifier = Modifier
+      .fillMaxWidth()
+      .background(LocalColor.Monochrome.Grey)
+      .align(Alignment.BottomCenter),
+    verticalAlignment = Alignment.CenterVertically,
+    horizontalArrangement = Arrangement.SpaceEvenly
+  ) {
+    SettingsButton(
+      modifier = if (!isMuted.value) {
+        Modifier.background(LocalColor.Primary.Dark)
+      } else {
+        Modifier
+      },
+      imageId = if (isMuted.value) {
+        R.drawable.ic_sound_off
+      } else {
+        R.drawable.ic_sound_on
+      },
+      event = if (!isMuted.value) "Dashboard_SpeakerOff" else "Dashboard_SpeakerOn"
+    ) {
+      if (isOnline.value) {
+        Tuya.setMute(
+          if (isMuted.value) {
+            0
+          } else {
+            1
+          }, setMute = { value ->
+            isMuted.value = value
+          }
+        )
+      }
+    }
+
+    SettingsButton(
+      imageId = R.drawable.ic_camera,
+      event = "Dashboard_Screenshot"
+    ) {
+      scope.launch {
+        val status = ScreenCapture.screenShot(
+          context = context
+        )
+        if (status) {
+          isScreenShotSuccess.value = true
+        }
+      }
+    }
+
+    SettingsButton(
+      modifier = if (isRecording.value) {
+        Modifier.background(LocalColor.Danger.Primary)
+      } else {
+        Modifier
+      },
+      imageId = R.drawable.ic_record,
+      event = if (!isRecording.value) "Dashboard_StartRecording" else "Dashboard_StopRecording"
+    ) {
+      if (!isRecording.value) {
+        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 = R.drawable.ic_play_back, event = "Playback") {
+      if (isRecording.value) {
+        scope.launch {
+          val status = ScreenCapture.stopRecording(
+            context = context
+          ) { value ->
+            isRecording.value = value
+          }
+          if (status) {
+            isRecordingSuccess.value = true
+          } else {
+            isRecordingFailure.value = true
+          }
+        }
+      } else {
+        navController.navigate("Playback")
+      }
+    }
+
+    SettingsButton(imageId = R.drawable.ic_message, event = "Messages") {
+      navController.navigate("Messages")
+    }
+  }
+}
+
+@Composable
+fun SettingsButton(
+  modifier: Modifier = Modifier,
+  imageId: Int,
+  event: String,
+  onClick: () -> Unit
+) {
+  Image(
+    modifier = Modifier
+      .padding(vertical = 5.dp)
+      .clip(RoundedCornerShape(70.dp))
+      .size(50.dp)
+      .then(modifier)
+      .clickable {
+        Heap.trackEvent(eventName = event)
+        onClick()
+      }
+      .padding(10.dp),
+    painter = painterResource(id = imageId),
+    contentDescription = "settingsIcon"
+  )
+}