New forward menu (#294)

Author: gdlbo

app/src/main/java/org/monogram/app/components/MobileLayout.kt

@@ -1,6 +1,7 @@
 package org.monogram.app.components
 
 import androidx.compose.animation.core.animate
+import androidx.compose.animation.core.animateFloatAsState
 import androidx.compose.animation.core.spring
 import androidx.compose.animation.core.tween
 import androidx.compose.foundation.background
@@ -28,14 +29,13 @@ import androidx.compose.ui.input.pointer.pointerInput
 import androidx.compose.ui.input.pointer.util.VelocityTracker
 import androidx.compose.ui.layout.onSizeChanged
 import androidx.compose.ui.util.fastFirstOrNull
+import androidx.compose.ui.zIndex
+import com.arkivanov.decompose.Child
 import com.arkivanov.decompose.ExperimentalDecomposeApi
 import com.arkivanov.decompose.extensions.compose.stack.Children
-import com.arkivanov.decompose.extensions.compose.stack.animation.fade
-import com.arkivanov.decompose.extensions.compose.stack.animation.plus
-import com.arkivanov.decompose.extensions.compose.stack.animation.predictiveback.predictiveBackAnimation
-import com.arkivanov.decompose.extensions.compose.stack.animation.slide
-import com.arkivanov.decompose.extensions.compose.stack.animation.stackAnimation
+import com.arkivanov.decompose.extensions.compose.stack.animation.StackAnimation
 import com.arkivanov.decompose.extensions.compose.subscribeAsState
+import com.arkivanov.decompose.router.stack.ChildStack
 import kotlinx.coroutines.launch
 import org.monogram.presentation.root.RootComponent
 import kotlin.math.abs
@@ -46,23 +46,42 @@ fun MobileLayout(root: RootComponent) {
     val stack by root.childStack.subscribeAsState()
     val isDragToBackEnabled by root.appPreferences.isDragToBackEnabled.collectAsState()
     val coroutineScope = rememberCoroutineScope()
-    val previous = stack.items.dropLast(1).lastOrNull()?.instance
+    val activeEntry = stack.active
+    val previousEntry = stack.items.dropLast(1).lastOrNull()
+    val stackKeysAreUnique = stack.items.map { it.key }.toSet().size == stack.items.size
+    val canRenderSwipePreview =
+        stackKeysAreUnique &&
+                previousEntry != null &&
+                previousEntry.key != activeEntry.key &&
+                previousEntry.instance !== activeEntry.instance
     var dragOffsetX by remember { mutableFloatStateOf(0f) }
     var isCompletingSwipeBack by remember { mutableStateOf(false) }
     var widthPx by remember { mutableFloatStateOf(0f) }
     var isSwipeBackBlocked by remember { mutableStateOf(false) }
     val canUseDragToBack =
-        isDragToBackEnabled && isSwipeBackSupported(stack.active.instance) && !isSwipeBackBlocked
+        isDragToBackEnabled &&
+                previousEntry != null &&
+                stackKeysAreUnique &&
+                isSwipeBackSupported(activeEntry.instance) &&
+                !isSwipeBackBlocked
     val dragProgress = if (widthPx > 0f) (dragOffsetX / widthPx).coerceIn(0f, 1f) else 0f
 
+    LaunchedEffect(activeEntry.key, stackKeysAreUnique) {
+        isSwipeBackBlocked = false
+        if (!stackKeysAreUnique) {
+            dragOffsetX = 0f
+            isCompletingSwipeBack = false
+        }
+    }
+
     LaunchedEffect(canUseDragToBack) {
         if (!canUseDragToBack && dragOffsetX > 0f) {
             dragOffsetX = 0f
             isCompletingSwipeBack = false
         }
     }
 
-    if (dragOffsetX > 0f && previous != null) {
+    if (dragOffsetX > 0f && canRenderSwipePreview) {
         Box(modifier = Modifier.fillMaxSize()) {
             Box(
                 modifier = Modifier
@@ -71,7 +90,12 @@ fun MobileLayout(root: RootComponent) {
                         translationX = ((dragProgress - 1f) * widthPx * 0.08f)
                     },
             ) {
-                RenderChild(previous)
+                key("swipe-preview:${previousEntry.key}") {
+                    RenderChild(
+                        child = previousEntry.instance,
+                        isOverlay = true,
+                    )
+                }
             }
             Box(
                 modifier = Modifier
@@ -93,7 +117,7 @@ fun MobileLayout(root: RootComponent) {
             }
             .then(
                 if (canUseDragToBack) {
-                    Modifier.pointerInput(canUseDragToBack) {
+                    Modifier.pointerInput(canUseDragToBack, activeEntry.key) {
                         awaitEachGesture {
                             if (size.width == 0) return@awaitEachGesture
 
@@ -170,6 +194,11 @@ fun MobileLayout(root: RootComponent) {
                                         continue
                                     }
 
+                                    if (!canRenderSwipePreview) {
+                                        dragOffsetX = 0f
+                                        break
+                                    }
+
                                     isDragging = true
                                 }
 
@@ -203,11 +232,9 @@ fun MobileLayout(root: RootComponent) {
             },
     ) {
         Children(
-            stack = root.childStack,
-            animation = predictiveBackAnimation(
-                backHandler = root.backHandler,
-                onBack = root::onBack,
-                fallbackAnimation = if (!isCompletingSwipeBack) stackAnimation(slide() + fade()) else null,
+            stack = stack,
+            animation = safeStackAnimation(
+                enabled = dragOffsetX == 0f && !isCompletingSwipeBack,
             ),
         ) { child ->
             key(child.key) {
@@ -254,4 +281,119 @@ private fun isSwipeBackSupported(child: RootComponent.Child): Boolean =
         is RootComponent.Child.DebugChild -> true
 
         else -> false
-    }
+    }
+
+private fun <C : Any, T : Any> activeOnlyStackAnimation(): StackAnimation<C, T> =
+    StackAnimation { stack, modifier, content ->
+        Box(modifier = modifier) {
+            content(stack.active)
+        }
+    }
+
+@Composable
+private fun <C : Any, T : Any> safeStackAnimation(enabled: Boolean): StackAnimation<C, T> {
+    if (!enabled) {
+        return activeOnlyStackAnimation()
+    }
+
+    return StackAnimation { stack, modifier, content ->
+        var previousStack by remember { mutableStateOf<ChildStack<C, T>?>(null) }
+        var transition by remember { mutableStateOf<StackTransition<C, T>?>(null) }
+        val oldStack = previousStack
+
+        if (oldStack == null) {
+            previousStack = stack
+        } else if (oldStack.active.key != stack.active.key) {
+            val oldActive = oldStack.active
+            val newActive = stack.active
+            transition =
+                if (oldActive.key != newActive.key) {
+                    StackTransition(
+                        oldActive = oldActive,
+                        newActive = newActive,
+                        isPop = stack.items.size < oldStack.items.size,
+                    )
+                } else {
+                    null
+                }
+            previousStack = stack
+        }
+
+        val currentTransition = transition
+        val animationProgress by animateFloatAsState(
+            targetValue = if (currentTransition == null) 1f else 0f,
+            animationSpec = tween(durationMillis = 220),
+            label = "MobileStackAnimation",
+            finishedListener = {
+                transition = null
+            },
+        )
+
+        Box(modifier = modifier) {
+            if (
+                currentTransition != null &&
+                currentTransition.oldActive.key != currentTransition.newActive.key
+            ) {
+                StackAnimatedChild(
+                    child = currentTransition.oldActive,
+                    progress = animationProgress,
+                    isPop = currentTransition.isPop,
+                    isOutgoing = true,
+                    content = content,
+                )
+                StackAnimatedChild(
+                    child = currentTransition.newActive,
+                    progress = animationProgress,
+                    isPop = currentTransition.isPop,
+                    isOutgoing = false,
+                    content = content,
+                )
+            } else {
+                content(stack.active)
+            }
+        }
+    }
+}
+
+@Composable
+private fun <C : Any, T : Any> StackAnimatedChild(
+    child: Child.Created<C, T>,
+    progress: Float,
+    isPop: Boolean,
+    isOutgoing: Boolean,
+    content: @Composable (child: Child.Created<C, T>) -> Unit,
+) {
+    val direction = if (isPop) -1f else 1f
+    val translationFactor =
+        if (isOutgoing) {
+            -direction * 0.08f * (1f - progress)
+        } else {
+            direction * progress
+        }
+    val alpha =
+        if (isOutgoing) {
+            1f - 0.18f * (1f - progress)
+        } else {
+            1f
+        }
+
+    key("stack-animation:${child.key}:${if (isOutgoing) "out" else "in"}") {
+        Box(
+            modifier = Modifier
+                .fillMaxSize()
+                .zIndex(if (isOutgoing) 0f else 1f)
+                .graphicsLayer {
+                    translationX = size.width * translationFactor
+                    this.alpha = alpha
+                },
+        ) {
+            content(child)
+        }
+    }
+}
+
+private data class StackTransition<C : Any, T : Any>(
+    val oldActive: Child.Created<C, T>,
+    val newActive: Child.Created<C, T>,
+    val isPop: Boolean,
+)

data/src/main/java/org/monogram/data/datasource/cache/ChatLocalDataSource.kt

@@ -20,7 +20,6 @@ interface ChatLocalDataSource {
     fun getMessagesForChat(chatId: Long): Flow<List<MessageEntity>>
     suspend fun getMessagesOlder(chatId: Long, fromMessageId: Long, limit: Int): List<MessageEntity>
     suspend fun getMessagesNewer(chatId: Long, fromMessageId: Long, limit: Int): List<MessageEntity>
-    suspend fun getMessage(chatId: Long, messageId: Long): MessageEntity?
     suspend fun getLatestMessages(chatId: Long, limit: Int): List<MessageEntity>
     suspend fun getMessagesByIds(chatId: Long, messageIds: List<Long>): List<MessageEntity>
     suspend fun insertMessage(message: MessageEntity)

data/src/main/java/org/monogram/data/datasource/cache/InMemoryChatLocalDataSource.kt

@@ -88,10 +88,6 @@ class InMemoryChatLocalDataSource : ChatLocalDataSource {
             .take(limit)
     }
 
-    override suspend fun getMessage(chatId: Long, messageId: Long): MessageEntity? {
-        return messages[chatId]?.value?.get(messageId)
-    }
-
     override suspend fun getLatestMessages(chatId: Long, limit: Int): List<MessageEntity> {
         val chatMessages = messages[chatId]?.value?.values ?: return emptyList()
         return chatMessages.sortedByDescending { it.date }.take(limit)

data/src/main/java/org/monogram/data/datasource/cache/RoomChatLocalDataSource.kt

@@ -51,9 +51,6 @@ class RoomChatLocalDataSource(
 
     override suspend fun getMessagesNewer(chatId: Long, fromMessageId: Long, limit: Int) = messageDao.getMessagesNewer(chatId, fromMessageId, limit)
 
-    override suspend fun getMessage(chatId: Long, messageId: Long) =
-        messageDao.getMessage(chatId, messageId)
-
     override suspend fun getLatestMessages(chatId: Long, limit: Int) = messageDao.getLatestMessages(chatId, limit)
 
     override suspend fun getMessagesByIds(chatId: Long, messageIds: List<Long>) =

data/src/main/java/org/monogram/data/datasource/remote/MessageRemoteDataSource.kt

@@ -133,9 +133,31 @@ interface MessageRemoteDataSource {
         threadId: Long?,
         sendOptions: MessageSendOptions
     ): TdApi.Messages?
-    suspend fun sendVideoNote(chatId: Long, videoPath: String, duration: Int, length: Int): TdApi.Message?
-    suspend fun sendVoiceNote(chatId: Long, voicePath: String, duration: Int, waveform: ByteArray): TdApi.Message?
-    suspend fun forwardMessages(toChatId: Long, fromChatId: Long, messageIds: LongArray, removeCaption: Boolean, sendCopy: Boolean): TdApi.Messages?
+    suspend fun sendVideoNote(
+        chatId: Long,
+        videoPath: String,
+        duration: Int,
+        length: Int,
+        replyToMsgId: Long?,
+        threadId: Long?
+    ): TdApi.Message?
+
+    suspend fun sendVoiceNote(
+        chatId: Long,
+        voicePath: String,
+        duration: Int,
+        waveform: ByteArray,
+        replyToMsgId: Long?,
+        threadId: Long?
+    ): TdApi.Message?
+    suspend fun forwardMessages(
+        toChatId: Long,
+        fromChatId: Long,
+        messageIds: LongArray,
+        forumTopicId: Int? = null,
+        removeCaption: Boolean,
+        sendCopy: Boolean
+    ): TdApi.Messages?
     suspend fun deleteMessages(chatId: Long, messageIds: LongArray, revoke: Boolean): TdApi.Ok?
     suspend fun editMessageText(chatId: Long, messageId: Long, text: String, entities: List<MessageEntity>): TdApi.Message?
     suspend fun editMessageCaption(chatId: Long, messageId: Long, caption: String, entities: List<MessageEntity>): TdApi.Message?

data/src/main/java/org/monogram/data/datasource/remote/TdMessageRemoteDataSource.kt

@@ -864,14 +864,25 @@ class TdMessageRemoteDataSource(
         return result
     }
 
-    override suspend fun sendVideoNote(chatId: Long, videoPath: String, duration: Int, length: Int): TdApi.Message? {
+    override suspend fun sendVideoNote(
+        chatId: Long,
+        videoPath: String,
+        duration: Int,
+        length: Int,
+        replyToMsgId: Long?,
+        threadId: Long?
+    ): TdApi.Message? {
         val content = TdApi.InputMessageVideoNote().apply {
             this.videoNote = TdApi.InputFileLocal(videoPath)
             this.duration = duration
             this.length = length
         }
+        val replyTo = if (replyToMsgId != null && replyToMsgId != 0L) TdApi.InputMessageReplyToMessage(replyToMsgId, null, 0, "") else null
+        val topicId = resolveTopicId(chatId, threadId)
         val req = TdApi.SendMessage().apply {
             this.chatId = chatId
+            this.topicId = topicId
+            this.replyTo = replyTo
             this.inputMessageContent = content
         }
         val response = safeExecute(req)
@@ -883,31 +894,45 @@ class TdMessageRemoteDataSource(
         chatId: Long,
         voicePath: String,
         duration: Int,
-        waveform: ByteArray
+        waveform: ByteArray,
+        replyToMsgId: Long?,
+        threadId: Long?
     ): TdApi.Message? {
         val content = TdApi.InputMessageVoiceNote().apply {
             this.voiceNote = TdApi.InputFileLocal(voicePath)
             this.duration = duration
             this.waveform = waveform
         }
+        val replyTo = if (replyToMsgId != null && replyToMsgId != 0L) TdApi.InputMessageReplyToMessage(replyToMsgId, null, 0, "") else null
+        val topicId = resolveTopicId(chatId, threadId)
         val req = TdApi.SendMessage().apply {
             this.chatId = chatId
+            this.topicId = topicId
+            this.replyTo = replyTo
             this.inputMessageContent = content
         }
         val response = safeExecute(req)
         if (response?.content is TdApi.MessageVoiceNote) waitForUpload((response.content as TdApi.MessageVoiceNote).voiceNote.voice.id).await()
         return response
     }
 
-    override suspend fun forwardMessages(toChatId: Long, fromChatId: Long, messageIds: LongArray, removeCaption: Boolean, sendCopy: Boolean): TdApi.Messages? {
+    override suspend fun forwardMessages(
+        toChatId: Long,
+        fromChatId: Long,
+        messageIds: LongArray,
+        forumTopicId: Int?,
+        removeCaption: Boolean,
+        sendCopy: Boolean
+    ): TdApi.Messages? {
         val options = TdApi.MessageSendOptions().apply {
             this.disableNotification = false
             this.fromBackground = false
         }
         val req = TdApi.ForwardMessages().apply {
             this.chatId = toChatId
+            this.topicId = forumTopicId?.let { TdApi.MessageTopicForum(it) }
             this.fromChatId = fromChatId
-            this.messageIds = messageIds
+            this.messageIds = messageIds.sortedArray()
             this.options = options
             this.removeCaption = removeCaption
             this.sendCopy = sendCopy

data/src/main/java/org/monogram/data/db/dao/MessageDao.kt

@@ -18,9 +18,6 @@ interface MessageDao {
     @Query("SELECT * FROM messages WHERE chatId = :chatId AND id > :fromMessageId ORDER BY date ASC LIMIT :limit")
     suspend fun getMessagesNewer(chatId: Long, fromMessageId: Long, limit: Int): List<MessageEntity>
 
-    @Query("SELECT * FROM messages WHERE chatId = :chatId AND id = :messageId")
-    suspend fun getMessage(chatId: Long, messageId: Long): MessageEntity?
-
     @Query("SELECT * FROM messages WHERE chatId = :chatId ORDER BY date DESC LIMIT :limit")
     suspend fun getLatestMessages(chatId: Long, limit: Int): List<MessageEntity>