fix(messenger): hold a message-link landing until the linked group resolves

A link with a group id could open with the chat marked a tip DM before the
group loaded, so the landing read as Readable and paged a withheld group's
history. A group hydrated by id also has a null membership, which left the
landing waiting forever. Carry linkedAsGroup from the route and read a null
membership as outside, as the gate does.

Author: bmc08gt

apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/ChatFlowScreen.kt

@@ -77,7 +77,14 @@ fun ChatFlowScreen(
     // first frame already has what the open can draw from memory (a group's name and picture). The
     // steps get this instance from flowSharedViewModel: the flow's store owner is this entry's.
     val viewModel = hiltViewModel<ChatViewModel, ChatViewModel.Factory>(
-        creationCallback = { factory -> factory.create(route.identifier, route.jumpToMessageId, route.returnToTitle) },
+        creationCallback = { factory ->
+            factory.create(
+                route.identifier,
+                route.jumpToMessageId,
+                route.returnToTitle,
+                linkedAsGroup = route.jumpToMessageId != null && route.isGroupLink,
+            )
+        },
     )
 
     // A group link the server has no record of: say so and leave, rather than sit on an empty chat

apps/flipcash/features/messenger/src/main/kotlin/com/flipcash/app/messenger/internal/ChatViewModel.kt

@@ -253,6 +253,11 @@ internal class ChatViewModel @AssistedInject constructor(
      * back to it. Null for any other open.
      */
     @Assisted private val returnToTitle: String? = null,
+    /**
+     * Whether the link that opened this visit named a group (a dashed UUID id) rather than a DM.
+     * See [State.linkedAsGroup].
+     */
+    @Assisted private val linkedAsGroup: Boolean = false,
     private val chatCoordinator: ChatCoordinator,
     private val mediaUploads: ChatMediaUploads,
     private val e2eePolicy: E2eePolicy,
@@ -292,6 +297,7 @@ internal class ChatViewModel @AssistedInject constructor(
     initialState = State(
         openingAtMessage = openAtMessageId != null,
         returnToTitle = returnToTitle,
+        linkedAsGroup = linkedAsGroup,
     ),
     updateStateForEvent = updateStateForEvent,
     defaultDispatcher = dispatchers.Default,
@@ -441,6 +447,12 @@ internal class ChatViewModel @AssistedInject constructor(
          * the message away or sending.
          */
         val returnToTitle: String? = null,
+        /**
+         * Whether a message link opened this visit with a group's id. The open can mark the chat a
+         * tip DM before the group resolves, and a landing that believed it would page a withheld
+         * group's history, so [messageLinkLanding] waits on the group for such a link.
+         */
+        val linkedAsGroup: Boolean = false,
         /**
          * Where the "N Unread Messages" divider sits, read once per visit from the viewer's stored
          * READ pointer. Never re-read: the list advances that pointer as the reader scrolls, and a
@@ -641,15 +653,19 @@ internal class ChatViewModel @AssistedInject constructor(
         val messageLinkLanding: MessageLinkLanding?
             get() = when {
                 chatNotFound -> MessageLinkLanding.Withheld
+                // A null membership is a group hydrated by id, which the device holds no row for;
+                // like the gate, read it as outside (see ChatMembership.isMember).
                 subject is ChatSubject.Group -> when (subject.isMember) {
                     true -> MessageLinkLanding.Readable
-                    null -> null
-                    false -> when (groupAccess) {
+                    null, false -> when (groupAccess) {
                         null, GroupAccess.Undetermined -> null
                         else -> if (readsFromOutside) MessageLinkLanding.Readable
                         else MessageLinkLanding.Withheld
                     }
                 }
+                // The open can call a group a tip DM before the group resolves, so a link that
+                // named a group never reads as one.
+                linkedAsGroup -> null
                 chatType == ChatType.TIP_DM || chatType == ChatType.CONTACT_DM ->
                     MessageLinkLanding.Readable
                 else -> null
@@ -3478,6 +3494,7 @@ internal class ChatViewModel @AssistedInject constructor(
             identifier: ChatIdentifier?,
             openAtMessageId: Long?,
             returnToTitle: String?,
+            linkedAsGroup: Boolean,
         ): ChatViewModel
     }
 

apps/flipcash/features/messenger/src/test/kotlin/com/flipcash/app/messenger/internal/ChatViewModelStateTest.kt

@@ -663,7 +663,6 @@ class ChatViewModelStateTest {
     fun `a message link waits while the viewer's standing in a group is unknown`() {
         // A chat id alone, before the open says what it is: paging now could fetch a withheld group.
         assertNull(ChatViewModel.State(chatId = groupChatId).messageLinkLanding)
-        assertNull(ChatViewModel.State(subject = group(isMember = null)).messageLinkLanding)
         assertNull(ChatViewModel.State(subject = group(isMember = false)).messageLinkLanding)
         assertNull(
             ChatViewModel.State(
@@ -673,6 +672,38 @@ class ChatViewModelStateTest {
         )
     }
 
+    @Test
+    fun `a message link into a group hydrated by id waits on access, not membership`() {
+        // A group the device holds no row for resolves with isMember = null and keeps it, so
+        // waiting on membership would hold the landing forever; seen on device.
+        assertNull(ChatViewModel.State(subject = group(isMember = null)).messageLinkLanding)
+        assertEquals(
+            MessageLinkLanding.Withheld,
+            ChatViewModel.State(
+                subject = group(isMember = null),
+                groupAccess = GroupAccess.Blocked(unmet),
+            ).messageLinkLanding,
+        )
+    }
+
+    @Test
+    fun `a group's message link waits for the group even after the open calls it a tip DM`() {
+        // OnTipDmDetected can mark the chat a tip DM before the group resolves; seen on device as
+        // a gated group's history being paged.
+        assertNull(
+            ChatViewModel.State(linkedAsGroup = true, chatType = ChatType.TIP_DM).messageLinkLanding
+        )
+        assertEquals(
+            MessageLinkLanding.Withheld,
+            ChatViewModel.State(
+                linkedAsGroup = true,
+                chatType = ChatType.GROUP,
+                subject = group(isMember = false),
+                groupAccess = GroupAccess.Blocked(unmet),
+            ).messageLinkLanding,
+        )
+    }
+
     @Test
     fun `a message link lands where the transcript is the viewer's to read`() {
         assertEquals(