Provide serverNames when available and fix issue around analytics

appnav/src/main/kotlin/io/element/android/appnav/LoggedInFlowNode.kt

@@ -37,6 +37,7 @@ import com.bumble.appyx.navmodel.backstack.operation.push
 import com.bumble.appyx.navmodel.backstack.operation.replace
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedInject
+import im.vector.app.features.analytics.plan.JoinedRoom
 import io.element.android.anvilannotations.ContributesNode
 import io.element.android.appnav.loggedin.LoggedInNode
 import io.element.android.appnav.room.RoomFlowNode
@@ -197,6 +198,8 @@ class LoggedInFlowNode @AssistedInject constructor(
         @Parcelize
         data class Room(
             val roomIdOrAlias: RoomIdOrAlias,
+            val serverNames: List<String> = emptyList(),
+            val trigger: JoinedRoom.Trigger? = null,
             val roomDescription: RoomDescription? = null,
             val initialElement: RoomNavigationTarget = RoomNavigationTarget.Messages()
         ) : NavTarget
@@ -292,8 +295,9 @@ class LoggedInFlowNode @AssistedInject constructor(
                                 backstack.push(
                                     NavTarget.Room(
                                         roomIdOrAlias = data.roomIdOrAlias,
+                                        serverNames = data.viaParameters,
+                                        trigger = JoinedRoom.Trigger.Timeline,
                                         initialElement = RoomNavigationTarget.Messages(data.eventId),
-                                        // TODO Use the viaParameters
                                     )
                                 )
                             }
@@ -311,6 +315,8 @@ class LoggedInFlowNode @AssistedInject constructor(
                 val inputs = RoomFlowNode.Inputs(
                     roomIdOrAlias = navTarget.roomIdOrAlias,
                     roomDescription = Optional.ofNullable(navTarget.roomDescription),
+                    serverNames = navTarget.serverNames,
+                    trigger = Optional.ofNullable(navTarget.trigger),
                     initialElement = navTarget.initialElement
                 )
                 createNode<RoomFlowNode>(buildContext, plugins = listOf(inputs, callback))
@@ -371,22 +377,35 @@ class LoggedInFlowNode @AssistedInject constructor(
                 roomDirectoryEntryPoint.nodeBuilder(this, buildContext)
                     .callback(object : RoomDirectoryEntryPoint.Callback {
                         override fun onResultClicked(roomDescription: RoomDescription) {
-                            backstack.push(NavTarget.Room(roomDescription.roomId.toRoomIdOrAlias(), roomDescription))
+                            backstack.push(
+                                NavTarget.Room(
+                                    roomIdOrAlias = roomDescription.roomId.toRoomIdOrAlias(),
+                                    roomDescription = roomDescription,
+                                    trigger = JoinedRoom.Trigger.RoomDirectory,
+                                )
+                            )
                         }
                     })
                     .build()
             }
         }
     }
 
-    suspend fun attachRoom(roomIdOrAlias: RoomIdOrAlias, eventId: EventId? = null) {
+    suspend fun attachRoom(
+        roomIdOrAlias: RoomIdOrAlias,
+        serverNames: List<String> = emptyList(),
+        trigger: JoinedRoom.Trigger? = null,
+        eventId: EventId? = null,
+    ) {
         waitForNavTargetAttached { navTarget ->
             navTarget is NavTarget.RoomList
         }
         attachChild<RoomFlowNode> {
             backstack.push(
                 NavTarget.Room(
                     roomIdOrAlias = roomIdOrAlias,
+                    serverNames = serverNames,
+                    trigger = trigger,
                     initialElement = RoomNavigationTarget.Messages(
                         focusedEventId = eventId
                     )

appnav/src/main/kotlin/io/element/android/appnav/RootFlowNode.kt

@@ -34,6 +34,7 @@ import com.bumble.appyx.navmodel.backstack.operation.pop
 import com.bumble.appyx.navmodel.backstack.operation.push
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedInject
+import im.vector.app.features.analytics.plan.JoinedRoom
 import io.element.android.anvilannotations.ContributesNode
 import io.element.android.appnav.di.MatrixClientsHolder
 import io.element.android.appnav.intent.IntentResolver
@@ -295,6 +296,8 @@ class RootFlowNode @AssistedInject constructor(
                     is PermalinkData.RoomLink -> {
                         attachRoom(
                             roomIdOrAlias = permalinkData.roomIdOrAlias,
+                            trigger = JoinedRoom.Trigger.MobilePermalink,
+                            serverNames = permalinkData.viaParameters,
                             eventId = permalinkData.eventId,
                         )
                     }

appnav/src/main/kotlin/io/element/android/appnav/room/RoomFlowNode.kt

@@ -32,6 +32,7 @@ import com.bumble.appyx.navmodel.backstack.BackStack
 import com.bumble.appyx.navmodel.backstack.operation.newRoot
 import dagger.assisted.Assisted
 import dagger.assisted.AssistedInject
+import im.vector.app.features.analytics.plan.JoinedRoom
 import io.element.android.anvilannotations.ContributesNode
 import io.element.android.appnav.room.joined.JoinedRoomFlowNode
 import io.element.android.appnav.room.joined.JoinedRoomLoadedFlowNode
@@ -54,6 +55,7 @@ import io.element.android.libraries.matrix.api.core.RoomAlias
 import io.element.android.libraries.matrix.api.core.RoomId
 import io.element.android.libraries.matrix.api.core.RoomIdOrAlias
 import io.element.android.libraries.matrix.api.room.CurrentUserMembership
+import io.element.android.libraries.matrix.api.room.alias.ResolvedRoomAlias
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.launchIn
@@ -83,6 +85,8 @@ class RoomFlowNode @AssistedInject constructor(
     data class Inputs(
         val roomIdOrAlias: RoomIdOrAlias,
         val roomDescription: Optional<RoomDescription>,
+        val serverNames: List<String>,
+        val trigger: Optional<JoinedRoom.Trigger>,
         val initialElement: RoomNavigationTarget,
     ) : NodeInputs
 
@@ -96,7 +100,11 @@ class RoomFlowNode @AssistedInject constructor(
         data class Resolving(val roomAlias: RoomAlias) : NavTarget
 
         @Parcelize
-        data class JoinRoom(val roomId: RoomId) : NavTarget
+        data class JoinRoom(
+            val roomId: RoomId,
+            val serverNames: List<String>,
+            val trigger: im.vector.app.features.analytics.plan.JoinedRoom.Trigger,
+        ) : NavTarget
 
         @Parcelize
         data class JoinedRoom(val roomId: RoomId) : NavTarget
@@ -114,13 +122,13 @@ class RoomFlowNode @AssistedInject constructor(
                     backstack.newRoot(NavTarget.Resolving(i.roomAlias))
                 }
                 is RoomIdOrAlias.Id -> {
-                    subscribeToRoomInfoFlow(i.roomId)
+                    subscribeToRoomInfoFlow(i.roomId, inputs.serverNames)
                 }
             }
         }
     }
 
-    private fun subscribeToRoomInfoFlow(roomId: RoomId) {
+    private fun subscribeToRoomInfoFlow(roomId: RoomId, serverNames: List<String>) {
         val roomInfoFlow = client.getRoomInfoFlow(
             roomId = roomId
         ).map { it.getOrNull() }
@@ -136,7 +144,13 @@ class RoomFlowNode @AssistedInject constructor(
                         // we can have a space here in case the space has just been joined.
                         // So navigate to the JoinRoom target for now, which will
                         // handle the space not supported screen
-                        backstack.newRoot(NavTarget.JoinRoom(roomId))
+                        backstack.newRoot(
+                            NavTarget.JoinRoom(
+                                roomId = roomId,
+                                serverNames = serverNames,
+                                trigger = inputs.trigger.getOrNull() ?: JoinedRoom.Trigger.Invite,
+                            )
+                        )
                     } else {
                         backstack.newRoot(NavTarget.JoinedRoom(roomId))
                     }
@@ -147,7 +161,13 @@ class RoomFlowNode @AssistedInject constructor(
                 }
                 else -> {
                     // Was invited or the room is not known, display the join room screen
-                    backstack.newRoot(NavTarget.JoinRoom(roomId))
+                    backstack.newRoot(
+                        NavTarget.JoinRoom(
+                            roomId = roomId,
+                            serverNames = serverNames,
+                            trigger = inputs.trigger.getOrNull() ?: JoinedRoom.Trigger.Invite,
+                        )
+                    )
                 }
             }
         }.launchIn(lifecycleScope)
@@ -158,8 +178,11 @@ class RoomFlowNode @AssistedInject constructor(
             is NavTarget.Loading -> loadingNode(buildContext)
             is NavTarget.Resolving -> {
                 val callback = object : RoomAliasResolverEntryPoint.Callback {
-                    override fun onAliasResolved(roomId: RoomId) {
-                        subscribeToRoomInfoFlow(roomId)
+                    override fun onAliasResolved(data: ResolvedRoomAlias) {
+                        subscribeToRoomInfoFlow(
+                            roomId = data.roomId,
+                            serverNames = data.servers,
+                        )
                     }
                 }
                 val params = RoomAliasResolverEntryPoint.Params(navTarget.roomAlias)
@@ -173,6 +196,8 @@ class RoomFlowNode @AssistedInject constructor(
                     roomId = navTarget.roomId,
                     roomIdOrAlias = inputs.roomIdOrAlias,
                     roomDescription = inputs.roomDescription,
+                    serverNames = navTarget.serverNames,
+                    trigger = navTarget.trigger,
                 )
                 joinRoomEntryPoint.createNode(this, buildContext, inputs)
             }

changelog.d/2843.misc

@@ -0,0 +1 @@
+Use via parameters when joining a room from permalink.

features/invite/api/build.gradle.kts

@@ -25,4 +25,5 @@ android {
 dependencies {
     implementation(projects.libraries.architecture)
     implementation(projects.libraries.matrix.api)
+    implementation(projects.services.analytics.api)
 }

features/invite/impl/src/main/kotlin/io/element/android/features/invite/impl/response/AcceptDeclineInvitePresenter.kt

@@ -33,9 +33,8 @@ import io.element.android.libraries.architecture.runCatchingUpdatingState
 import io.element.android.libraries.architecture.runUpdatingState
 import io.element.android.libraries.matrix.api.MatrixClient
 import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.api.room.join.JoinRoom
 import io.element.android.libraries.push.api.notifications.NotificationDrawerManager
-import io.element.android.services.analytics.api.AnalyticsService
-import io.element.android.services.analytics.api.extensions.toAnalyticsJoinedRoom
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
 import java.util.Optional
@@ -44,7 +43,7 @@ import kotlin.jvm.optionals.getOrNull
 
 class AcceptDeclineInvitePresenter @Inject constructor(
     private val client: MatrixClient,
-    private val analyticsService: AnalyticsService,
+    private val joinRoom: JoinRoom,
     private val notificationDrawerManager: NotificationDrawerManager,
 ) : Presenter<AcceptDeclineInviteState> {
     @Composable
@@ -59,9 +58,11 @@ class AcceptDeclineInvitePresenter @Inject constructor(
         fun handleEvents(event: AcceptDeclineInviteEvents) {
             when (event) {
                 is AcceptDeclineInviteEvents.AcceptInvite -> {
-                    currentInvite = Optional.of(event.invite)
-                    localCoroutineScope.acceptInvite(event.invite.roomId, acceptedAction)
+                    // currentInvite is used to render the decline confirmation dialog
+                    // and to reuse the roomId when the user confirm the rejection of the invitation.
+                    // Just set it to empty here.
                     currentInvite = Optional.empty()
+                    localCoroutineScope.acceptInvite(event.invite.roomId, acceptedAction)
                 }
 
                 is AcceptDeclineInviteEvents.DeclineInvite -> {
@@ -100,14 +101,18 @@ class AcceptDeclineInvitePresenter @Inject constructor(
         )
     }
 
-    private fun CoroutineScope.acceptInvite(roomId: RoomId, acceptedAction: MutableState<AsyncAction<RoomId>>) = launch {
+    private fun CoroutineScope.acceptInvite(
+        roomId: RoomId,
+        acceptedAction: MutableState<AsyncAction<RoomId>>,
+    ) = launch {
         acceptedAction.runUpdatingState {
-            client.joinRoom(roomId)
+            joinRoom(
+                roomId = roomId,
+                serverNames = emptyList(),
+                trigger = JoinedRoom.Trigger.Invite,
+            )
                 .onSuccess {
                     notificationDrawerManager.clearMembershipNotificationForRoom(client.sessionId, roomId, doRender = true)
-                    client.getRoom(roomId)?.use { room ->
-                        analyticsService.capture(room.toAnalyticsJoinedRoom(JoinedRoom.Trigger.Invite))
-                    }
                 }
                 .map { roomId }
         }

features/invite/impl/src/test/kotlin/io/element/android/features/invite/impl/response/AcceptDeclineInvitePresenterTest.kt

@@ -17,6 +17,7 @@
 package io.element.android.features.invite.impl.response
 
 import com.google.common.truth.Truth.assertThat
+import im.vector.app.features.analytics.plan.JoinedRoom
 import io.element.android.features.invite.api.response.AcceptDeclineInviteEvents
 import io.element.android.features.invite.api.response.InviteData
 import io.element.android.libraries.architecture.AsyncAction
@@ -26,13 +27,13 @@ import io.element.android.libraries.matrix.test.A_ROOM_ID
 import io.element.android.libraries.matrix.test.A_ROOM_NAME
 import io.element.android.libraries.matrix.test.FakeMatrixClient
 import io.element.android.libraries.matrix.test.room.FakeMatrixRoom
+import io.element.android.libraries.matrix.test.room.join.FakeJoinRoom
 import io.element.android.libraries.push.api.notifications.NotificationDrawerManager
 import io.element.android.libraries.push.test.notifications.FakeNotificationDrawerManager
-import io.element.android.services.analytics.api.AnalyticsService
-import io.element.android.services.analytics.test.FakeAnalyticsService
 import io.element.android.tests.testutils.WarmUpRule
 import io.element.android.tests.testutils.lambda.assert
 import io.element.android.tests.testutils.lambda.lambdaRecorder
+import io.element.android.tests.testutils.lambda.value
 import io.element.android.tests.testutils.test
 import kotlinx.coroutines.test.runTest
 import org.junit.Rule
@@ -163,62 +164,67 @@ class AcceptDeclineInvitePresenterTest {
 
     @Test
     fun `present - accepting invite error flow`() = runTest {
-        val joinRoomFailure = lambdaRecorder { roomId: RoomId ->
+        val joinRoomFailure = lambdaRecorder { roomId: RoomId, _: List<String>, _: JoinedRoom.Trigger ->
             Result.failure<Unit>(RuntimeException("Failed to join room $roomId"))
         }
-        val client = FakeMatrixClient().apply {
-            joinRoomLambda = joinRoomFailure
-        }
-        val presenter = createAcceptDeclineInvitePresenter(client = client)
+        val presenter = createAcceptDeclineInvitePresenter(joinRoomLambda = joinRoomFailure)
         presenter.test {
             val inviteData = anInviteData()
             awaitItem().also { state ->
                 state.eventSink(
                     AcceptDeclineInviteEvents.AcceptInvite(inviteData)
                 )
             }
-            skipItems(1)
             awaitItem().also { state ->
-                assertThat(state.invite).isEqualTo(Optional.of(inviteData))
+                assertThat(state.invite).isEqualTo(Optional.empty<InviteData>())
+                assertThat(state.acceptAction).isEqualTo(AsyncAction.Loading)
+            }
+            awaitItem().also { state ->
                 assertThat(state.acceptAction).isInstanceOf(AsyncAction.Failure::class.java)
                 state.eventSink(
                     InternalAcceptDeclineInviteEvents.DismissAcceptError
                 )
             }
-            skipItems(1)
             awaitItem().also { state ->
                 assertThat(state.invite).isEqualTo(Optional.empty<InviteData>())
                 assertThat(state.acceptAction).isInstanceOf(AsyncAction.Uninitialized::class.java)
             }
             cancelAndConsumeRemainingEvents()
         }
-        assert(joinRoomFailure).isCalledOnce()
+        assert(joinRoomFailure)
+            .isCalledExactly(1)
+            .withSequence(
+                listOf(value(A_ROOM_ID), value(emptyList<String>()), value(JoinedRoom.Trigger.Invite))
+            )
     }
 
     @Test
     fun `present - accepting invite success flow`() = runTest {
-        val joinRoomSuccess = lambdaRecorder { _: RoomId ->
+        val joinRoomSuccess = lambdaRecorder { _: RoomId, _: List<String>, _: JoinedRoom.Trigger ->
             Result.success(Unit)
         }
-        val client = FakeMatrixClient().apply {
-            joinRoomLambda = joinRoomSuccess
-        }
-        val presenter = createAcceptDeclineInvitePresenter(client = client)
+        val presenter = createAcceptDeclineInvitePresenter(joinRoomLambda = joinRoomSuccess)
         presenter.test {
             val inviteData = anInviteData()
             awaitItem().also { state ->
                 state.eventSink(
                     AcceptDeclineInviteEvents.AcceptInvite(inviteData)
                 )
             }
-            skipItems(1)
             awaitItem().also { state ->
-                assertThat(state.invite).isEqualTo(Optional.of(inviteData))
+                assertThat(state.invite).isEqualTo(Optional.empty<InviteData>())
+                assertThat(state.acceptAction).isEqualTo(AsyncAction.Loading)
+            }
+            awaitItem().also { state ->
                 assertThat(state.acceptAction).isInstanceOf(AsyncAction.Success::class.java)
             }
             cancelAndConsumeRemainingEvents()
         }
-        assert(joinRoomSuccess).isCalledOnce()
+        assert(joinRoomSuccess)
+            .isCalledExactly(1)
+            .withSequence(
+                listOf(value(A_ROOM_ID), value(emptyList<String>()), value(JoinedRoom.Trigger.Invite))
+            )
     }
 
     private fun anInviteData(
@@ -235,12 +241,14 @@ class AcceptDeclineInvitePresenterTest {
 
     private fun createAcceptDeclineInvitePresenter(
         client: MatrixClient = FakeMatrixClient(),
-        analyticsService: AnalyticsService = FakeAnalyticsService(),
+        joinRoomLambda: (RoomId, List<String>, JoinedRoom.Trigger) -> Result<Unit> = { _, _, _ ->
+            Result.success(Unit)
+        },
         notificationDrawerManager: NotificationDrawerManager = FakeNotificationDrawerManager(),
     ): AcceptDeclineInvitePresenter {
         return AcceptDeclineInvitePresenter(
             client = client,
-            analyticsService = analyticsService,
+            joinRoom = FakeJoinRoom(joinRoomLambda),
             notificationDrawerManager = notificationDrawerManager,
         )
     }

features/joinroom/api/build.gradle.kts

@@ -26,4 +26,5 @@ dependencies {
     implementation(projects.libraries.architecture)
     implementation(projects.libraries.matrix.api)
     implementation(projects.features.roomdirectory.api)
+    implementation(projects.services.analytics.api)
 }