pinned messages

Signed-off-by: Marcel Hibbe <dev@mhibbe.de>

Author: mahibi

app/src/main/java/com/nextcloud/talk/chat/ChatActivity.kt

@@ -61,8 +61,11 @@ import androidx.activity.viewModels
 import androidx.appcompat.app.AlertDialog
 import androidx.appcompat.view.ContextThemeWrapper
 import androidx.cardview.widget.CardView
+import androidx.compose.foundation.lazy.LazyListState
+import androidx.compose.foundation.lazy.rememberLazyListState
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.SideEffect
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.setValue
@@ -149,6 +152,7 @@ import com.nextcloud.talk.signaling.SignalingMessageReceiver
 import com.nextcloud.talk.signaling.SignalingMessageSender
 import com.nextcloud.talk.threadsoverview.ThreadsOverviewActivity
 import com.nextcloud.talk.translate.ui.TranslateActivity
+import com.nextcloud.talk.ui.PinnedMessageView
 import com.nextcloud.talk.ui.PlaybackSpeed
 import com.nextcloud.talk.ui.StatusDrawable
 import com.nextcloud.talk.ui.chat.ChatView
@@ -510,6 +514,7 @@ class ChatActivity :
         if (useJetpackCompose) {
             setChatListContent()
         }
+        setPinnedMessageContent()
 
         lifecycleScope.launch {
             currentUserProvider.getCurrentUser()
@@ -557,13 +562,50 @@ class ChatActivity :
         onBackPressedDispatcher.addCallback(this, onBackPressedCallback)
     }
 
+    private fun setPinnedMessageContent() {
+        binding.pinnedMessageComposeView.setContent {
+            val uiState by chatViewModel.uiState.collectAsStateWithLifecycle()
+            val pinnedMessage = uiState.pinnedMessage
+            binding.pinnedMessageContainer.visibility = if (pinnedMessage != null) View.VISIBLE else View.GONE
+            if (pinnedMessage != null) {
+                PinnedMessageView(
+                    message = pinnedMessage,
+                    viewThemeUtils = viewThemeUtils,
+                    currentConversation = uiState.conversation,
+                    scrollToMessageWithIdWithOffset = { messageId ->
+                        scrollToMessageById(messageId.toLong())
+                    },
+                    hidePinnedMessage = ::hidePinnedMessage,
+                    unPinMessage = ::unPinMessage
+                )
+            }
+        }
+    }
+
+    private var chatListState: LazyListState? = null
+
+    private fun scrollToMessageById(messageId: Long) {
+        val items = chatViewModel.uiState.value.items
+        val targetIndex = items.indexOfFirst { item ->
+            (item as? ChatViewModel.ChatItem.MessageItem)?.uiMessage?.id == messageId.toInt()
+        }
+        if (targetIndex >= 0) {
+            lifecycleScope.launch {
+                chatListState?.scrollToItem(targetIndex)
+            }
+        }
+    }
+
     private fun setChatListContent() {
         binding.messagesListViewCompose.setContent {
             val uiState by chatViewModel.uiState.collectAsStateWithLifecycle()
             currentConversation = uiState.conversation
 
             binding.messagesListViewCompose.visibility = View.VISIBLE
 
+            val listState = rememberLazyListState()
+            SideEffect { chatListState = listState }
+
             CompositionLocalProvider(
                 LocalViewThemeUtils provides viewThemeUtils,
                 LocalMessageUtils provides messageUtils,
@@ -588,7 +630,8 @@ class ChatActivity :
                     onReactionClick = { messageId, emoji -> handleReactionClick(messageId, emoji) },
                     onReactionLongClick = { messageId -> openReactionsDialog(messageId) },
                     onOpenThreadClick = { messageId -> openThread(messageId.toLong()) },
-                    onLoadQuotedMessageClick = { messageId -> onLoadQuotedMessage(messageId) }
+                    onLoadQuotedMessageClick = { messageId -> onLoadQuotedMessage(messageId) },
+                    listState = listState
                 )
             }
         }

app/src/main/java/com/nextcloud/talk/chat/viewmodels/ChatViewModel.kt

@@ -75,6 +75,7 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.flow.catch
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.distinctUntilChangedBy
@@ -344,7 +345,8 @@ class ChatViewModel @AssistedInject constructor(
 
         // Adding the whole conversation is just an intermediate solution as it is used in the activity.
         // For the future, only necessary vars from conversation should be in the ui state
-        val conversation: ConversationModel? = null
+        val conversation: ConversationModel? = null,
+        val pinnedMessage: ChatMessage? = null
     )
 
     private val _uiState = MutableStateFlow(ChatUiState())
@@ -435,6 +437,7 @@ class ChatViewModel @AssistedInject constructor(
         observeConversation()
         observeMessages()
         observeMediaPlayerProgressForCompose()
+        observePinnedMessage()
     }
 
     private fun observeMediaPlayerProgressForCompose() {
@@ -529,6 +532,43 @@ class ChatViewModel @AssistedInject constructor(
             .launchIn(viewModelScope)
     }
 
+    private fun observePinnedMessage() {
+        nonNullUserFlow
+            .flatMapLatest { user ->
+                conversationRepository.observeConversation(requireNotNull(user.id), chatRoomToken)
+                    .mapNotNull { result ->
+                        (result as? OfflineFirstConversationsRepository.ConversationResult.Found)?.conversation
+                    }
+                    .distinctUntilChangedBy { it.lastPinnedId to it.hiddenPinnedId }
+                    .flatMapLatest { conversation ->
+                        val pinnedId = conversation.lastPinnedId
+                        if (pinnedId != null && pinnedId != 0L && pinnedId != conversation.hiddenPinnedId) {
+                            val bundle = Bundle().apply {
+                                putString(
+                                    BundleKeys.KEY_CHAT_URL,
+                                    ApiUtils.getUrlForChat(1, user.baseUrl, chatRoomToken)
+                                )
+                                putString(
+                                    BundleKeys.KEY_CREDENTIALS,
+                                    ApiUtils.getCredentials(user.username, user.token)
+                                )
+                                putString(BundleKeys.KEY_ROOM_TOKEN, chatRoomToken)
+                            }
+                            chatRepository.getMessage(pinnedId, bundle)
+                                .map { it as ChatMessage? }
+                                .catch { emit(null) }
+                        } else {
+                            flowOf(null)
+                        }
+                    }
+            }
+            .onEach { pinnedMessage ->
+                _uiState.update { it.copy(pinnedMessage = pinnedMessage) }
+            }
+            .catch { Log.e(TAG, "Error observing pinned message", it) }
+            .launchIn(viewModelScope)
+    }
+
     // val lastCommonReadMessageId = getLastCommonReadFlow.first()
 
     // ------------------------------