feat: implement group members caching and enhance emoji picker functionality in GroupSetupScreen

app/src/main/java/com/rosetta/messenger/ui/chats/GroupInfoScreen.kt

@@ -149,6 +149,40 @@ private data class GroupSharedStats(
     val linksCount: Int = 0
 )
 
+private data class GroupMembersCacheEntry(
+    val members: List<String>,
+    val memberInfoByKey: Map<String, SearchUser>,
+    val updatedAtMs: Long
+)
+
+private object GroupMembersMemoryCache {
+    private const val TTL_MS = 90_000L
+    private val cache = mutableMapOf<String, GroupMembersCacheEntry>()
+
+    fun getAny(key: String): GroupMembersCacheEntry? = synchronized(cache) { cache[key] }
+
+    fun getFresh(key: String): GroupMembersCacheEntry? = synchronized(cache) {
+        val entry = cache[key] ?: return@synchronized null
+        if (System.currentTimeMillis() - entry.updatedAtMs <= TTL_MS) entry else null
+    }
+
+    fun put(key: String, members: List<String>, memberInfoByKey: Map<String, SearchUser>) {
+        if (key.isBlank()) return
+        synchronized(cache) {
+            cache[key] =
+                GroupMembersCacheEntry(
+                    members = members,
+                    memberInfoByKey = memberInfoByKey,
+                    updatedAtMs = System.currentTimeMillis()
+                )
+        }
+    }
+
+    fun remove(key: String) {
+        synchronized(cache) { cache.remove(key) }
+    }
+}
+
 private data class GroupMediaItem(
     val key: String,
     val attachment: MessageAttachment,
@@ -249,9 +283,13 @@ fun GroupInfoScreen(
     var isMuted by remember { mutableStateOf(false) }
     var showAddMembersPicker by rememberSaveable(dialogPublicKey) { mutableStateOf(false) }
     var pendingInviteText by rememberSaveable(dialogPublicKey) { mutableStateOf("") }
+    var isRefreshingMembers by remember(dialogPublicKey) { mutableStateOf(false) }
 
     var members by remember(dialogPublicKey) { mutableStateOf<List<String>>(emptyList()) }
     val memberInfoByKey = remember(dialogPublicKey) { mutableStateMapOf<String, SearchUser>() }
+    val membersCacheKey = remember(currentUserPublicKey, normalizedGroupId) {
+        "${currentUserPublicKey.trim().lowercase()}|${normalizedGroupId.trim().lowercase()}"
+    }
 
     val groupEntity by produceState<com.rosetta.messenger.database.GroupEntity?>(
         initialValue = null,
@@ -341,16 +379,32 @@ fun GroupInfoScreen(
         }
     }
 
-    fun refreshMembers() {
+    fun refreshMembers(force: Boolean = false, showLoader: Boolean = true) {
         if (normalizedGroupId.isBlank()) return
+        if (isRefreshingMembers && !force) return
 
         scope.launch {
-            membersLoading = true
+            if (!force) {
+                GroupMembersMemoryCache.getFresh(membersCacheKey)?.let { cached ->
+                    members = cached.members
+                    memberInfoByKey.clear()
+                    memberInfoByKey.putAll(cached.memberInfoByKey)
+                    return@launch
+                }
+            }
+
+            val hasAnyCache = GroupMembersMemoryCache.getAny(membersCacheKey) != null
+            val shouldShowLoader = showLoader && members.isEmpty() && !hasAnyCache
+            if (shouldShowLoader) membersLoading = true
+            isRefreshingMembers = true
+            try {
                 val fetchedMembers = withContext(Dispatchers.IO) {
                     groupRepository.requestGroupMembers(normalizedGroupId).orEmpty()
                 }
-            members = fetchedMembers.distinct()
+                val distinctMembers = fetchedMembers.distinct()
-            membersLoading = false
+                if (distinctMembers.isNotEmpty() || members.isEmpty()) {
+                    members = distinctMembers
+                }
 
                 if (members.isEmpty()) return@launch
 
@@ -371,11 +425,30 @@ fun GroupInfoScreen(
                 if (resolvedUsers.isNotEmpty()) {
                     memberInfoByKey.putAll(resolvedUsers)
                 }
+
+                GroupMembersMemoryCache.put(
+                    key = membersCacheKey,
+                    members = members,
+                    memberInfoByKey = memberInfoByKey.toMap()
+                )
+            } finally {
+                if (shouldShowLoader) membersLoading = false
+                isRefreshingMembers = false
+            }
         }
     }
 
-    LaunchedEffect(normalizedGroupId) {
+    LaunchedEffect(membersCacheKey) {
-        refreshMembers()
+        val cachedEntry = GroupMembersMemoryCache.getAny(membersCacheKey)
+        cachedEntry?.let { cached ->
+            members = cached.members
+            memberInfoByKey.clear()
+            memberInfoByKey.putAll(cached.memberInfoByKey)
+        }
+
+        if (GroupMembersMemoryCache.getFresh(membersCacheKey) == null) {
+            refreshMembers(force = true, showLoader = cachedEntry == null)
+        }
     }
 
     val onlineCount by remember(members, memberInfoByKey) {
@@ -541,6 +614,7 @@ fun GroupInfoScreen(
             }
             isLeaving = false
             if (left) {
+                GroupMembersMemoryCache.remove(membersCacheKey)
                 onGroupLeft()
             } else {
                 Toast.makeText(context, "Failed to leave group", Toast.LENGTH_SHORT).show()
@@ -580,7 +654,12 @@ fun GroupInfoScreen(
             if (removed) {
                 members = members.filterNot { it.trim().equals(memberKey, ignoreCase = true) }
                 memberInfoByKey.remove(member.publicKey)
-                refreshMembers()
+                GroupMembersMemoryCache.put(
+                    key = membersCacheKey,
+                    members = members,
+                    memberInfoByKey = memberInfoByKey.toMap()
+                )
+                refreshMembers(force = true, showLoader = false)
                 Toast.makeText(context, "Member removed", Toast.LENGTH_SHORT).show()
             } else {
                 Toast.makeText(context, "Failed to remove member", Toast.LENGTH_SHORT).show()
@@ -1117,43 +1196,86 @@ fun GroupInfoScreen(
 
     if (showEncryptionDialog) {
         val displayLines = remember(encryptionKey) { encodeGroupKeyForDisplay(encryptionKey) }
+        val keyImagePalette = if (isDarkTheme) {
+            listOf(
+                Color(0xFF2B4F78),
+                Color(0xFF2F5F90),
+                Color(0xFF3D74A8),
+                Color(0xFF4E89BE),
+                Color(0xFF64A0D6)
+            )
+        } else {
+            listOf(
+                Color(0xFFD5E8FF),
+                Color(0xFFBBD9FF),
+                Color(0xFFA1CAFF),
+                Color(0xFF87BAFF),
+                Color(0xFF6EA9F4)
+            )
+        }
+        val keyCardColor = if (isDarkTheme) Color(0xFF1F1F22) else Color(0xFFF7F9FC)
+        val keyCodeColor = if (isDarkTheme) Color(0xFFC7D6EA) else Color(0xFF34495E)
+
         AlertDialog(
             onDismissRequest = { showEncryptionDialog = false },
-            title = { Text("Encryption key") },
+            containerColor = cardColor,
+            shape = RoundedCornerShape(20.dp),
+            title = {
+                Text(
+                    text = "Encryption key",
+                    color = primaryText,
+                    fontWeight = FontWeight.SemiBold
+                )
+            },
             text = {
                 Column {
-                    Box(
+                    Surface(
                         modifier = Modifier.fillMaxWidth(),
+                        color = keyCardColor,
+                        shape = RoundedCornerShape(16.dp)
+                    ) {
+                        Box(
+                            modifier = Modifier
+                                .fillMaxWidth()
+                                .padding(vertical = 14.dp),
                             contentAlignment = Alignment.Center
                         ) {
                             DesktopStyleKeyImage(
                                 keyRender = encryptionKey,
                                 size = 180.dp,
-                            radius = 14.dp
+                                radius = 14.dp,
+                                palette = keyImagePalette
                             )
                         }
-                    Spacer(modifier = Modifier.height(12.dp))
+                    }
+                    Spacer(modifier = Modifier.height(10.dp))
                     SelectionContainer {
-                        Column {
+                        Surface(
+                            modifier = Modifier.fillMaxWidth(),
+                            color = sectionColor,
+                            shape = RoundedCornerShape(12.dp)
+                        ) {
+                            Column(modifier = Modifier.padding(horizontal = 12.dp, vertical = 10.dp)) {
                                 if (displayLines.isNotEmpty()) {
                                     displayLines.forEach { line ->
                                         Text(
                                             text = line,
-                                        color = secondaryText,
+                                            color = keyCodeColor,
                                             fontSize = 12.sp,
                                             fontFamily = FontFamily.Monospace
                                         )
                                     }
-                                Spacer(modifier = Modifier.height(10.dp))
                                 }
+                            }
+                        }
+                    }
+                    Spacer(modifier = Modifier.height(10.dp))
                     Text(
                         text = "This key encrypts and decrypts group messages.",
                         color = secondaryText,
                         fontSize = 12.sp
                     )
                 }
-                    }
-                }
             },
             confirmButton = {
                 TextButton(
@@ -1167,7 +1289,7 @@ fun GroupInfoScreen(
             },
             dismissButton = {
                 TextButton(onClick = { showEncryptionDialog = false }) {
-                    Text("Close", color = secondaryText)
+                    Text("Close", color = primaryText)
                 }
             }
         )
@@ -1244,15 +1366,17 @@ fun GroupInfoScreen(
 private fun DesktopStyleKeyImage(
     keyRender: String,
     size: androidx.compose.ui.unit.Dp,
-    radius: androidx.compose.ui.unit.Dp = 0.dp
+    radius: androidx.compose.ui.unit.Dp = 0.dp,
+    palette: List<Color> = KEY_IMAGE_COLORS
 ) {
-    val composition = remember(keyRender) {
+    val colors = if (palette.isNotEmpty()) palette else KEY_IMAGE_COLORS
+    val composition = remember(keyRender, colors) {
         buildList(64) {
             val source = if (keyRender.isBlank()) "rosetta" else keyRender
             for (i in 0 until 64) {
                 val code = source[i % source.length].code
-                val colorIndex = code % KEY_IMAGE_COLORS.size
+                val colorIndex = code % colors.size
-                add(KEY_IMAGE_COLORS[colorIndex])
+                add(colors[colorIndex])
             }
         }
     }
@@ -1261,7 +1385,7 @@ private fun DesktopStyleKeyImage(
         modifier = Modifier
             .size(size)
             .clip(RoundedCornerShape(radius))
-            .background(KEY_IMAGE_COLORS.first())
+            .background(colors.first())
     ) {
         val cells = 8
         val cellSize = this.size.minDimension / cells.toFloat()

app/src/main/java/com/rosetta/messenger/ui/chats/GroupSetupScreen.kt

@@ -1,7 +1,9 @@
 package com.rosetta.messenger.ui.chats
 
+import android.content.Context
 import android.net.Uri
 import android.app.Activity
+import android.view.inputmethod.InputMethodManager
 import androidx.activity.compose.BackHandler
 import androidx.activity.compose.rememberLauncherForActivityResult
 import androidx.activity.result.contract.ActivityResultContracts
@@ -17,7 +19,6 @@ import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.ime
-import androidx.compose.foundation.layout.navigationBars
 import androidx.compose.foundation.layout.navigationBarsPadding
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
@@ -39,6 +40,7 @@ import androidx.compose.material3.TopAppBarDefaults
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableLongStateOf
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
@@ -75,12 +77,15 @@ import com.rosetta.messenger.data.GroupRepository
 import com.rosetta.messenger.network.GroupStatus
 import com.rosetta.messenger.network.SearchUser
 import com.rosetta.messenger.repository.AvatarRepository
+import com.rosetta.messenger.ui.components.KeyboardHeightProvider
 import com.rosetta.messenger.ui.components.OptimizedEmojiPicker
 import com.rosetta.messenger.ui.components.AvatarImage
 import com.rosetta.messenger.ui.icons.TelegramIcons
 import com.rosetta.messenger.utils.AvatarFileManager
 import com.rosetta.messenger.utils.ImageCropHelper
 import com.rosetta.messenger.ui.settings.ProfilePhotoPicker
+import app.rosette.android.ui.keyboard.AnimatedKeyboardTransition
+import app.rosette.android.ui.keyboard.rememberKeyboardTransitionCoordinator
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
@@ -118,6 +123,9 @@ fun GroupSetupScreen(
     var errorText by rememberSaveable { mutableStateOf<String?>(null) }
     var showEmojiKeyboard by rememberSaveable { mutableStateOf(false) }
     var showPhotoPicker by rememberSaveable { mutableStateOf(false) }
+    val coordinator = rememberKeyboardTransitionCoordinator()
+    var lastToggleTime by remember { mutableLongStateOf(0L) }
+    val toggleCooldownMs = 500L
 
     val cropLauncher =
         rememberLauncherForActivityResult(
@@ -217,20 +225,90 @@ fun GroupSetupScreen(
     val actionEnabled = if (step == GroupSetupStep.DETAILS) canGoNext else canCreate
     val density = LocalDensity.current
     val imeBottomPx = WindowInsets.ime.getBottom(density)
-    val navBottomPx = WindowInsets.navigationBars.getBottom(density)
+    val imeBottomDp = with(density) { imeBottomPx.toDp() }
-    val keyboardHeightPx = (imeBottomPx - navBottomPx).coerceAtLeast(0)
+    val keyboardOrEmojiHeight =
+        if (coordinator.isEmojiBoxVisible) coordinator.emojiHeight else imeBottomDp
     val fabBottomPadding =
-        if (keyboardHeightPx > 0) {
+        if (keyboardOrEmojiHeight > 0.dp) {
-            with(density) { keyboardHeightPx.toDp() } + 14.dp
+            keyboardOrEmojiHeight + 14.dp
         } else {
             18.dp
         }
 
     LaunchedEffect(step) {
         if (step != GroupSetupStep.DETAILS) {
-            showEmojiKeyboard = false
+            if (showEmojiKeyboard || coordinator.isEmojiVisible || coordinator.isEmojiBoxVisible) {
+                coordinator.closeEmoji(hideEmoji = { showEmojiKeyboard = false })
             }
         }
+    }
+
+    LaunchedEffect(Unit) {
+        val savedPx = KeyboardHeightProvider.getSavedKeyboardHeight(context)
+        if (savedPx > 0) {
+            coordinator.initializeEmojiHeight(with(density) { savedPx.toDp() })
+        }
+    }
+
+    var lastStableKeyboardHeight by remember { mutableStateOf(0.dp) }
+    LaunchedEffect(imeBottomPx) {
+        val currentImeHeight = with(density) { imeBottomPx.toDp() }
+        coordinator.updateKeyboardHeight(currentImeHeight)
+        if (currentImeHeight > 100.dp) {
+            coordinator.syncHeights()
+            lastStableKeyboardHeight = currentImeHeight
+        }
+    }
+
+    fun toggleEmojiPicker() {
+        val now = System.currentTimeMillis()
+        if (now - lastToggleTime < toggleCooldownMs || step != GroupSetupStep.DETAILS || isLoading) return
+        lastToggleTime = now
+
+        val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager
+        if (coordinator.isEmojiVisible) {
+            coordinator.requestShowKeyboard(
+                showKeyboard = {
+                    nameFocusRequester.requestFocus()
+                    keyboardController?.show()
+                    @Suppress("DEPRECATION")
+                    imm.showSoftInput(view, InputMethodManager.SHOW_IMPLICIT)
+                },
+                hideEmoji = { showEmojiKeyboard = false }
+            )
+            return
+        }
+
+        if (imeBottomPx > 0) {
+            coordinator.requestShowEmoji(
+                hideKeyboard = {
+                    imm.hideSoftInputFromWindow(view.windowToken, 0)
+                    keyboardController?.hide()
+                },
+                showEmoji = {
+                    focusManager.clearFocus(force = true)
+                    showEmojiKeyboard = true
+                }
+            )
+            return
+        }
+
+        if (coordinator.emojiHeight == 0.dp) {
+            val fallbackHeight = if (lastStableKeyboardHeight > 0.dp) {
+                lastStableKeyboardHeight
+            } else {
+                with(density) { KeyboardHeightProvider.getSavedKeyboardHeight(context).toDp() }
+            }
+            coordinator.initializeEmojiHeight(fallbackHeight)
+        }
+
+        coordinator.openEmojiOnly(
+            showEmoji = {
+                focusManager.clearFocus(force = true)
+                showEmojiKeyboard = true
+            }
+        )
+    }
 
     LaunchedEffect(Unit) {
         if (step == GroupSetupStep.DETAILS) {
@@ -270,7 +348,11 @@ fun GroupSetupScreen(
             )
         },
         bottomBar = {
-            if (step == GroupSetupStep.DETAILS && showEmojiKeyboard) {
+            if (step == GroupSetupStep.DETAILS) {
+                AnimatedKeyboardTransition(
+                    coordinator = coordinator,
+                    showEmojiPicker = showEmojiKeyboard
+                ) {
                     OptimizedEmojiPicker(
                         isVisible = true,
                         isDarkTheme = isDarkTheme,
@@ -278,10 +360,12 @@ fun GroupSetupScreen(
                             val emoji = decodeEmojiCodeToUnicode(emojiCode)
                             title = (title + emoji).take(80)
                         },
-                    modifier = Modifier.fillMaxWidth().navigationBarsPadding()
+                        onClose = { toggleEmojiPicker() },
+                        modifier = Modifier.fillMaxWidth()
                     )
                 }
             }
+        }
     ) { paddingValues ->
         Box(
             modifier =
@@ -366,8 +450,11 @@ fun GroupSetupScreen(
                                             .fillMaxWidth()
                                             .focusRequester(nameFocusRequester)
                                             .onFocusChanged { focusState ->
-                                                if (focusState.isFocused) {
+                                                if (focusState.isFocused &&
-                                                    showEmojiKeyboard = false
+                                                    showEmojiKeyboard &&
+                                                    !coordinator.isTransitioning
+                                                ) {
+                                                    coordinator.closeEmoji(hideEmoji = { showEmojiKeyboard = false })
                                                 }
                                             }
                                             .padding(vertical = 2.dp),
@@ -391,21 +478,15 @@ fun GroupSetupScreen(
                             }
 
                             IconButton(
-                                onClick = {
+                                onClick = { toggleEmojiPicker() },
-                                    if (showEmojiKeyboard) {
-                                        showEmojiKeyboard = false
-                                        nameFocusRequester.requestFocus()
-                                        keyboardController?.show()
-                                    } else {
-                                        showEmojiKeyboard = true
-                                        focusManager.clearFocus(force = true)
-                                        keyboardController?.hide()
-                                    }
-                                },
                                 enabled = !isLoading
                             ) {
                                 Icon(
-                                    painter = TelegramIcons.Smile,
+                                    painter = if (showEmojiKeyboard || coordinator.isEmojiBoxVisible) {
+                                        TelegramIcons.Keyboard
+                                    } else {
+                                        TelegramIcons.Smile
+                                    },
                                     contentDescription = "Emoji",
                                     tint = secondaryTextColor,
                                     modifier = Modifier.size(22.dp)