@rentlydev/rently-tuya 0.1.0

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

@@ -0,0 +1,463 @@
+package com.rentlytuya.dashboard
+
+import android.os.Build
+import android.util.Log
+import androidx.activity.compose.BackHandler
+import androidx.annotation.RequiresApi
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.gestures.rememberTransformableState
+import androidx.compose.foundation.gestures.transformable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.BoxWithConstraints
+import androidx.compose.foundation.layout.Column
+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.lazy.LazyColumn
+import androidx.compose.foundation.lazy.LazyListState
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.lazy.rememberLazyListState
+import androidx.compose.material3.IconButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.MutableLongState
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.derivedStateOf
+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.geometry.Offset
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.platform.LocalConfiguration
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.unit.dp
+import androidx.navigation.NavController
+import com.rentlytuya.R
+import com.rentlytuya.components.DatePicker
+import com.rentlytuya.components.Divider
+import com.rentlytuya.components.EncryptedImageView
+import com.rentlytuya.components.Label
+import com.rentlytuya.components.LoadingIndicator
+import com.rentlytuya.tuya.Messages
+import com.rentlytuya.tuya.Tuya
+import com.rentlytuya.tuya.Tuya.TAG
+import com.rentlytuya.ui.theme.LocalColor
+import com.rentlytuya.util.DateUtil.isNotNull
+import com.rentlytuya.util.Heap
+import com.rentlytuya.util.Util
+import com.rentlytuya.util.Util.isLandscape
+import com.rentlytuya.util.Util.strings
+import com.thingclips.smart.ipc.messagecenter.bean.CameraMessageBean
+import kotlinx.coroutines.launch
+import java.time.Instant
+import java.time.LocalDate
+import java.time.ZoneId
+import java.time.format.DateTimeFormatter
+import java.util.Calendar
+import java.util.Date
+
+@RequiresApi(Build.VERSION_CODES.O)
+@Composable
+fun Messages(
+  isSettings: MutableState<Boolean>,
+  isDatePickerVisible: MutableState<Boolean>,
+  navController: NavController
+) {
+
+  val coroutineScope = rememberCoroutineScope()
+  val configuration = LocalConfiguration.current
+  val datePickerLoader = remember { mutableStateOf(false) }
+  val availableDates = remember { mutableStateOf(emptyArray<Int>()) }
+
+  val listState = rememberLazyListState()
+  val isLoading = remember { mutableStateOf(false) }
+  val messages = remember { mutableStateOf<List<CameraMessageBean?>?>(emptyList()) }
+  val offset = remember { mutableIntStateOf(0) }
+  val noMoreMessages = remember { mutableStateOf(false) }
+  val selectedMessage = remember { mutableStateOf<CameraMessageBean?>(null) }
+  val selectedDate = remember { mutableLongStateOf(Date().time) }
+
+  val scrollEndReached = remember {
+    derivedStateOf {
+      !noMoreMessages.value &&
+        (listState.layoutInfo.visibleItemsInfo.lastOrNull()?.index
+          ?: 0) >= listState.layoutInfo.totalItemsCount - 1
+    }
+  }
+
+  BackHandler {
+    isSettings.value = false
+    navController.navigate("Dashboard")
+  }
+
+  Column(
+    modifier = Modifier
+      .fillMaxSize()
+      .background(LocalColor.Main.Light),
+    horizontalAlignment = Alignment.CenterHorizontally
+  ) {
+    LaunchedEffect(Unit) {
+      Tuya.deviceId?.let {
+        Messages.initializeAndFetchMessages(
+          offset = offset,
+          messages = messages,
+          isLoading = isLoading,
+          selectedDate = selectedDate,
+          noMoreMessages = noMoreMessages
+        )
+      }
+
+      val calendar = Calendar.getInstance()
+      val currentYear = calendar.get(Calendar.YEAR)
+      val currentMonth = calendar.get(Calendar.MONTH) + 1
+
+      Messages.getAvailableMessageDates(
+        year = currentYear,
+        month = currentMonth,
+        availableDates = availableDates,
+        isLoading = datePickerLoader
+      )
+    }
+
+    LaunchedEffect(scrollEndReached.value) {
+      if (scrollEndReached.value) {
+        fetchMoreMessages(
+          offset = offset,
+          messages = messages,
+          isLoading = isLoading,
+          selectedDate = selectedDate,
+          noMoreMessages = noMoreMessages
+        )
+      }
+    }
+
+    LaunchedEffect(selectedDate.longValue) {
+      offset.intValue = 0
+      noMoreMessages.value = false
+      messages.value = emptyList()
+      listState.scrollToItem(0)
+      fetchMoreMessages(
+        offset = offset,
+        messages = messages,
+        isLoading = isLoading,
+        selectedDate = selectedDate,
+        noMoreMessages = noMoreMessages
+      )
+    }
+
+    LaunchedEffect(configuration.orientation) {
+      if (isLandscape(configuration) && isDatePickerVisible.value) {
+        isDatePickerVisible.value = false
+      }
+    }
+
+    DisposableEffect(Unit) {
+      onDispose { Messages.destroy() }
+    }
+
+    Box(
+      modifier = Modifier
+        .fillMaxSize()
+    ) {
+      when {
+        isLoading.value && messages.value.isNullOrEmpty() -> {
+          LoadingIndicator()
+        }
+
+        messages.value.isNullOrEmpty() -> {
+          NoMessage()
+        }
+
+        else -> {
+          MessageList(
+            messages = messages.value,
+            listState = listState,
+            isLoading = isLoading,
+            noMoreMessages = noMoreMessages,
+            onImageClick = { message ->
+              selectedMessage.value = message
+            }
+          )
+        }
+      }
+
+      if (selectedMessage.value.isNotNull()) {
+        MessageOverlay(
+          message = selectedMessage.value,
+          onClose = { selectedMessage.value = null }
+        )
+      }
+    }
+
+    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 {
+          Messages.getAvailableMessageDates(
+            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 {
+          Messages.getAvailableMessageDates(
+            year = localDate.year,
+            month = localDate.monthValue,
+            availableDates = availableDates,
+            isLoading = datePickerLoader
+          )
+        }
+      }
+    )
+  }
+}
+
+@Composable
+private fun NoMessage() {
+  Column(
+    modifier = Modifier
+      .fillMaxSize(),
+    horizontalAlignment = Alignment.CenterHorizontally,
+    verticalArrangement = Arrangement.Center
+  ) {
+    Label(
+      modifier = Modifier
+        .padding(horizontal = 20.dp),
+      title = strings(id = R.string.noMessages),
+      bold = true,
+      xl18 = true,
+      black = true,
+      center = true,
+      maxLines = 2
+    )
+  }
+}
+
+@Composable
+private fun MessageList(
+  messages: List<CameraMessageBean?>?,
+  listState: LazyListState,
+  isLoading: MutableState<Boolean>,
+  noMoreMessages: MutableState<Boolean>,
+  onImageClick: (CameraMessageBean) -> Unit
+) {
+  LazyColumn(state = listState) {
+    items(messages.orEmpty()) { message ->
+      MessageItem(message = message, onImageClick = onImageClick)
+    }
+
+    if (isLoading.value && !noMoreMessages.value) {
+      item {
+        LoadingIndicator()
+      }
+    }
+//    else if (noMoreMessages.value) {
+//      item {
+//        Label(
+//          title = "To view more messages, adjust filters above.",
+//          modifier = Modifier.padding(16.dp)
+//        )
+//      }
+//    }
+  }
+}
+
+@Composable
+fun MessageItem(
+  message: CameraMessageBean?,
+  onImageClick: (CameraMessageBean) -> Unit
+) {
+  if (message.isNotNull()) {
+    Column(
+      modifier = Modifier
+        .padding(horizontal = 5.dp)
+    ) {
+      Column(
+        modifier = Modifier
+          .fillMaxWidth()
+          .padding(top = 8.dp, bottom = 20.dp, start = 35.dp, end = 35.dp),
+        horizontalAlignment = Alignment.CenterHorizontally
+      ) {
+        Column(
+          modifier = Modifier
+            .fillMaxWidth(),
+          horizontalAlignment = Alignment.Start
+        ) {
+          Label(
+            id = message.dateTime,
+            title = message.dateTime,
+            bold = true,
+            m = true,
+            black = true,
+            medium = true
+          )
+
+          Label(
+            modifier = Modifier
+              .padding(bottom = if (message.attachPics.isNotNull()) 12.dp else 0.dp),
+            id = message.msgContent,
+            title = if (message.attachPics.isNotNull()) {
+              message.msgContent
+            } else {
+              strings(id = R.string.unableToCaptureDetectedEvents)
+            },
+            l = true,
+            primary = true,
+            semiBold = true,
+            maxLines = 6
+          )
+        }
+
+        if (message.attachPics.isNotNull()) {
+          EncryptedImageView(
+            imageUrl = message.attachPics,
+            modifier = Modifier
+              .fillMaxWidth()
+              .height(180.dp)
+              .clickable { onImageClick(message) }
+          )
+        }
+      }
+
+      Divider(thickness = 1.dp)
+    }
+  }
+}
+
+@Composable
+fun MessageOverlay(message: CameraMessageBean?, onClose: () -> Unit) {
+
+  val configuration = LocalConfiguration.current
+
+  if (message.isNotNull()) {
+    val scale = remember { mutableFloatStateOf(1f) }
+    val offset = remember { mutableStateOf(Offset.Zero) }
+
+    LaunchedEffect(configuration.orientation) {
+      scale.floatValue = 1f
+      offset.value = Offset.Zero
+    }
+
+    Box(
+      modifier = Modifier
+        .fillMaxSize()
+        .background(color = LocalColor.Monochrome.Black.copy(alpha = 0.9f))
+        .clickable(enabled = false, onClick = {})
+    ) {
+      Column(
+        modifier = Modifier
+          .align(Alignment.Center)
+      ) {
+        BoxWithConstraints(
+          modifier = Modifier
+            .fillMaxWidth(if (Util.isLandscape(configuration)) 0.7f else 1f)
+            .fillMaxHeight(if (Util.isLandscape(configuration)) 0.9f else 0.3f)
+        ) {
+          val state = rememberTransformableState { zoomChange, panChange, _ ->
+            scale.floatValue = (scale.floatValue * zoomChange).coerceIn(1f, 5f)
+
+            val extraWidth = (scale.floatValue - 1) * constraints.maxWidth
+            val extraHeight = (scale.floatValue - 1) * constraints.maxHeight
+
+            val maxX = extraWidth / 2
+            val maxY = extraHeight / 2
+
+            offset.value = Offset(
+              x = (offset.value.x + scale.floatValue * panChange.x).coerceIn(-maxX, maxX),
+              y = (offset.value.y + scale.floatValue * panChange.y).coerceIn(-maxY, maxY)
+            )
+          }
+
+          EncryptedImageView(
+            imageUrl = message.attachPics,
+            modifier = Modifier
+              .fillMaxWidth()
+              .fillMaxHeight()
+              .graphicsLayer {
+                scaleX = scale.floatValue
+                scaleY = scale.floatValue
+                translationX = offset.value.x
+                translationY = offset.value.y
+              }
+              .transformable(state)
+          )
+        }
+      }
+
+      IconButton(
+        modifier = Modifier
+          .align(Alignment.TopEnd)
+          .padding(16.dp),
+        onClick = {
+          Heap.trackEvent(eventName = "Messages_Overlay_Close")
+          onClose()
+        }
+      ) {
+        Image(
+          modifier = Modifier.size(30.dp),
+          painter = painterResource(R.drawable.ic_close),
+          contentDescription = "Close"
+        )
+      }
+    }
+  }
+}
+
+@RequiresApi(Build.VERSION_CODES.O)
+private suspend fun fetchMoreMessages(
+  offset: MutableState<Int>,
+  messages: MutableState<List<CameraMessageBean?>?>,
+  isLoading: MutableState<Boolean>,
+  selectedDate: MutableLongState,
+  noMoreMessages: MutableState<Boolean>
+) {
+  if (noMoreMessages.value || isLoading.value) return
+
+  Log.i(
+    TAG,
+    "Fetching messages ${offset.value} ${noMoreMessages.value} ${isLoading.value} ${messages.value}"
+  )
+
+  Messages.getMessageList(
+    offset = offset,
+    messages = messages,
+    isLoading = isLoading,
+    selectedDate = selectedDate,
+    noMoreMessages = noMoreMessages
+  )
+}