misc : rework getRoomInfoFlow (by using getRoomSummaryFlow)

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

@@ -45,6 +45,8 @@ import io.element.android.libraries.matrix.api.MatrixClient
 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.core.toRoomIdOrAlias
+import io.element.android.libraries.matrix.api.getRoomInfoFlow
 import io.element.android.libraries.matrix.api.room.CurrentUserMembership
 import io.element.android.libraries.matrix.api.room.alias.ResolvedRoomAlias
 import kotlinx.coroutines.flow.combine
@@ -120,12 +122,9 @@ class RoomFlowNode @AssistedInject constructor(
     }
 
     private fun subscribeToRoomInfoFlow(roomId: RoomId, serverNames: List<String>) {
-        val roomInfoFlow = client.getRoomInfoFlow(
+        val roomInfoFlow = client.getRoomInfoFlow(roomIdOrAlias = roomId.toRoomIdOrAlias())
-            roomId = roomId
+        val isSpaceFlow = roomInfoFlow.map { it.getOrNull()?.isSpace.orFalse() }.distinctUntilChanged()
-        ).map { it.getOrNull() }
+        val currentMembershipFlow = roomInfoFlow.map { it.getOrNull()?.currentUserMembership }.distinctUntilChanged()
-
-        val isSpaceFlow = roomInfoFlow.map { it?.isSpace.orFalse() }.distinctUntilChanged()
-        val currentMembershipFlow = roomInfoFlow.map { it?.currentUserMembership }.distinctUntilChanged()
         combine(currentMembershipFlow, isSpaceFlow) { membership, isSpace ->
             Timber.d("Room membership: $membership")
             when (membership) {

features/joinroom/impl/src/main/kotlin/io/element/android/features/joinroom/impl/JoinRoomPresenter.kt

@@ -33,6 +33,8 @@ import io.element.android.libraries.core.meta.BuildMeta
 import io.element.android.libraries.matrix.api.MatrixClient
 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.core.toRoomIdOrAlias
+import io.element.android.libraries.matrix.api.getRoomInfoFlow
 import io.element.android.libraries.matrix.api.room.CurrentUserMembership
 import io.element.android.libraries.matrix.api.room.MatrixRoomInfo
 import io.element.android.libraries.matrix.api.room.RoomType
@@ -70,7 +72,7 @@ class JoinRoomPresenter @AssistedInject constructor(
     override fun present(): JoinRoomState {
         val coroutineScope = rememberCoroutineScope()
         var retryCount by remember { mutableIntStateOf(0) }
-        val roomInfo by matrixClient.getRoomInfoFlow(roomId).collectAsState(initial = Optional.empty())
+        val roomInfo by matrixClient.getRoomInfoFlow(roomId.toRoomIdOrAlias()).collectAsState(initial = Optional.empty())
         val joinAction: MutableState<AsyncAction<Unit>> = remember { mutableStateOf(AsyncAction.Uninitialized) }
         val knockAction: MutableState<AsyncAction<Unit>> = remember { mutableStateOf(AsyncAction.Uninitialized) }
         val contentState by produceState<ContentState>(
@@ -204,7 +206,7 @@ internal fun MatrixRoomInfo.toContentState(): ContentState {
         name = name,
         topic = topic,
         alias = canonicalAlias,
-        numberOfMembers = activeMembersCount,
+        numberOfMembers = activeMembersCount.toLong(),
         isDm = isDm,
         roomType = if (isSpace) RoomType.Space else RoomType.Room,
         roomAvatarUrl = avatarUrl,

features/joinroom/impl/src/main/kotlin/io/element/android/features/joinroom/impl/JoinRoomStateProvider.kt

@@ -19,7 +19,6 @@ import io.element.android.libraries.matrix.api.core.RoomIdOrAlias
 import io.element.android.libraries.matrix.api.core.UserId
 import io.element.android.libraries.matrix.api.core.toRoomIdOrAlias
 import io.element.android.libraries.matrix.api.room.RoomType
-import io.element.android.libraries.matrix.api.room.isDm
 import io.element.android.libraries.matrix.ui.model.InviteSender
 
 open class JoinRoomStateProvider : PreviewParameterProvider<JoinRoomState> {

features/joinroom/impl/src/test/kotlin/io/element/android/features/joinroom/impl/JoinRoomPresenterTest.kt

@@ -32,8 +32,8 @@ import io.element.android.libraries.matrix.test.A_ROOM_NAME
 import io.element.android.libraries.matrix.test.A_SERVER_LIST
 import io.element.android.libraries.matrix.test.FakeMatrixClient
 import io.element.android.libraries.matrix.test.core.aBuildMeta
-import io.element.android.libraries.matrix.test.room.aRoomInfo
 import io.element.android.libraries.matrix.test.room.aRoomMember
+import io.element.android.libraries.matrix.test.room.aRoomSummary
 import io.element.android.libraries.matrix.test.room.join.FakeJoinRoom
 import io.element.android.libraries.matrix.ui.model.toInviteSender
 import io.element.android.tests.testutils.WarmUpRule
@@ -67,10 +67,10 @@ class JoinRoomPresenterTest {
 
     @Test
     fun `present - when room is joined then content state is filled with his data`() = runTest {
-        val roomInfo = aRoomInfo()
+        val roomSummary = aRoomSummary()
         val matrixClient = FakeMatrixClient().apply {
-            getRoomInfoFlowLambda = { _ ->
+            getRoomSummaryFlowLambda = { _ ->
-                flowOf(Optional.of(roomInfo))
+                flowOf(Optional.of(roomSummary))
             }
         }
         val presenter = createJoinRoomPresenter(
@@ -81,22 +81,22 @@ class JoinRoomPresenterTest {
             awaitItem().also { state ->
                 val contentState = state.contentState as ContentState.Loaded
                 assertThat(contentState.roomId).isEqualTo(A_ROOM_ID)
-                assertThat(contentState.name).isEqualTo(roomInfo.name)
+                assertThat(contentState.name).isEqualTo(roomSummary.info.name)
-                assertThat(contentState.topic).isEqualTo(roomInfo.topic)
+                assertThat(contentState.topic).isEqualTo(roomSummary.info.topic)
-                assertThat(contentState.alias).isEqualTo(roomInfo.canonicalAlias)
+                assertThat(contentState.alias).isEqualTo(roomSummary.info.canonicalAlias)
-                assertThat(contentState.numberOfMembers).isEqualTo(roomInfo.activeMembersCount)
+                assertThat(contentState.numberOfMembers).isEqualTo(roomSummary.info.activeMembersCount)
-                assertThat(contentState.isDm).isEqualTo(roomInfo.isDirect)
+                assertThat(contentState.isDm).isEqualTo(roomSummary.info.isDirect)
-                assertThat(contentState.roomAvatarUrl).isEqualTo(roomInfo.avatarUrl)
+                assertThat(contentState.roomAvatarUrl).isEqualTo(roomSummary.info.avatarUrl)
             }
         }
     }
 
     @Test
     fun `present - when room is invited then join authorization is equal to invited`() = runTest {
-        val roomInfo = aRoomInfo(currentUserMembership = CurrentUserMembership.INVITED)
+        val roomSummary = aRoomSummary(currentUserMembership = CurrentUserMembership.INVITED)
         val matrixClient = FakeMatrixClient().apply {
-            getRoomInfoFlowLambda = { _ ->
+            getRoomSummaryFlowLambda = { _ ->
-                flowOf(Optional.of(roomInfo))
+                flowOf(Optional.of(roomSummary))
             }
         }
         val presenter = createJoinRoomPresenter(
@@ -114,13 +114,13 @@ class JoinRoomPresenterTest {
     fun `present - when room is invited then join authorization is equal to invited, an inviter is provided`() = runTest {
         val inviter = aRoomMember(userId = UserId("@bob:example.com"), displayName = "Bob")
         val expectedInviteSender = inviter.toInviteSender()
-        val roomInfo = aRoomInfo(
+        val roomSummary = aRoomSummary(
             currentUserMembership = CurrentUserMembership.INVITED,
             inviter = inviter,
         )
         val matrixClient = FakeMatrixClient().apply {
-            getRoomInfoFlowLambda = { _ ->
+            getRoomSummaryFlowLambda = { _ ->
-                flowOf(Optional.of(roomInfo))
+                flowOf(Optional.of(roomSummary))
             }
         }
         val presenter = createJoinRoomPresenter(
@@ -140,10 +140,10 @@ class JoinRoomPresenterTest {
         val acceptDeclinePresenter = Presenter {
             anAcceptDeclineInviteState(eventSink = eventSinkRecorder)
         }
-        val roomInfo = aRoomInfo(currentUserMembership = CurrentUserMembership.INVITED)
+        val roomSummary = aRoomSummary(currentUserMembership = CurrentUserMembership.INVITED)
         val matrixClient = FakeMatrixClient().apply {
-            getRoomInfoFlowLambda = { _ ->
+            getRoomSummaryFlowLambda = { _ ->
-                flowOf(Optional.of(roomInfo))
+                flowOf(Optional.of(roomSummary))
             }
         }
         val presenter = createJoinRoomPresenter(
@@ -224,10 +224,10 @@ class JoinRoomPresenterTest {
 
     @Test
     fun `present - when room is left and public then join authorization is equal to canJoin`() = runTest {
-        val roomInfo = aRoomInfo(currentUserMembership = CurrentUserMembership.LEFT, isPublic = true)
+        val roomSummary = aRoomSummary(currentUserMembership = CurrentUserMembership.LEFT, isPublic = true)
         val matrixClient = FakeMatrixClient().apply {
-            getRoomInfoFlowLambda = { _ ->
+            getRoomSummaryFlowLambda = { _ ->
-                flowOf(Optional.of(roomInfo))
+                flowOf(Optional.of(roomSummary))
             }
         }
         val presenter = createJoinRoomPresenter(
@@ -243,10 +243,10 @@ class JoinRoomPresenterTest {
 
     @Test
     fun `present - when room is left and not public then join authorization is equal to unknown`() = runTest {
-        val roomInfo = aRoomInfo(currentUserMembership = CurrentUserMembership.LEFT, isPublic = false)
+        val roomSummary = aRoomSummary(currentUserMembership = CurrentUserMembership.LEFT, isPublic = false)
         val matrixClient = FakeMatrixClient().apply {
-            getRoomInfoFlowLambda = { _ ->
+            getRoomSummaryFlowLambda = { _ ->
-                flowOf(Optional.of(roomInfo))
+                flowOf(Optional.of(roomSummary))
             }
         }
         val presenter = createJoinRoomPresenter(

libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/MatrixClient.kt

@@ -38,6 +38,8 @@ import kotlinx.collections.immutable.ImmutableList
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.map
 import java.io.Closeable
 import java.util.Optional
 
@@ -94,7 +96,13 @@ interface MatrixClient : Closeable {
     suspend fun getAccountManagementUrl(action: AccountManagementAction?): Result<String?>
     suspend fun uploadMedia(mimeType: String, data: ByteArray, progressCallback: ProgressCallback?): Result<String>
     fun roomMembershipObserver(): RoomMembershipObserver
-    fun getRoomInfoFlow(roomId: RoomId): Flow<Optional<MatrixRoomInfo>>
+
+    /**
+     * Get a room summary flow for a given room ID or alias.
+     * The flow will emit a new value whenever the room summary is updated.
+     * The flow will emit Optional.empty item if the room is not found.
+     */
+    fun getRoomSummaryFlow(roomIdOrAlias: RoomIdOrAlias): Flow<Optional<RoomSummary>>
 
     fun isMe(userId: UserId?) = userId == sessionId
 
@@ -142,3 +150,14 @@ interface MatrixClient : Closeable {
     fun canDeactivateAccount(): Boolean
     suspend fun deactivateAccount(password: String, eraseData: Boolean): Result<Unit>
 }
+
+/**
+ * Get a room info flow for a given room ID or alias.
+ * The flow will emit a new value whenever the room info is updated.
+ * The flow will emit Optional.empty item if the room is not found.
+ */
+fun MatrixClient.getRoomInfoFlow(roomIdOrAlias: RoomIdOrAlias): Flow<Optional<MatrixRoomInfo>> {
+    return getRoomSummaryFlow(roomIdOrAlias)
+        .map { roomSummary -> roomSummary.map { it.info } }
+        .distinctUntilChanged()
+}

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/RustMatrixClient.kt

@@ -32,7 +32,6 @@ import io.element.android.libraries.matrix.api.pusher.PushersService
 import io.element.android.libraries.matrix.api.room.CurrentUserMembership
 import io.element.android.libraries.matrix.api.room.InvitedRoom
 import io.element.android.libraries.matrix.api.room.MatrixRoom
-import io.element.android.libraries.matrix.api.room.MatrixRoomInfo
 import io.element.android.libraries.matrix.api.room.RoomMembershipObserver
 import io.element.android.libraries.matrix.api.room.alias.ResolvedRoomAlias
 import io.element.android.libraries.matrix.api.room.preview.RoomPreview
@@ -84,8 +83,8 @@ import kotlinx.coroutines.flow.buffer
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.filter
 import kotlinx.coroutines.flow.first
-import kotlinx.coroutines.flow.flow
 import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.mapNotNull
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
@@ -105,8 +104,8 @@ import org.matrix.rustcomponents.sdk.use
 import timber.log.Timber
 import java.io.File
 import java.util.Optional
+import kotlin.jvm.optionals.getOrNull
 import kotlin.time.Duration
-import kotlin.time.Duration.Companion.INFINITE
 import kotlin.time.Duration.Companion.seconds
 import org.matrix.rustcomponents.sdk.CreateRoomParameters as RustCreateRoomParameters
 import org.matrix.rustcomponents.sdk.RoomPreset as RustRoomPreset
@@ -262,21 +261,14 @@ class RustMatrixClient(
      * @param timeout the timeout to wait for the room to be available
      * @throws TimeoutCancellationException if the room is not available after the timeout
      */
-    private suspend fun awaitJoinedRoom(roomIdOrAlias: RoomIdOrAlias, timeout: Duration): RoomSummary {
+    private suspend fun awaitJoinedRoom(
-        val predicate: (List<RoomSummary>) -> Boolean = when (roomIdOrAlias) {
+        roomIdOrAlias: RoomIdOrAlias,
-            is RoomIdOrAlias.Alias -> { roomSummaries: List<RoomSummary> ->
+        timeout: Duration
-                val found = roomSummaries.find { it.aliases.contains(roomIdOrAlias.roomAlias) }
+    ): RoomSummary {
-                found != null && found.currentUserMembership == CurrentUserMembership.JOINED
-            }
-            is RoomIdOrAlias.Id -> { roomSummaries: List<RoomSummary> ->
-                val found = roomSummaries.find { it.roomId == roomIdOrAlias.roomId }
-                found != null && found.currentUserMembership == CurrentUserMembership.JOINED
-            }
-        }
         return withTimeout(timeout) {
-            roomListService.allRooms.summaries
+            getRoomSummaryFlow(roomIdOrAlias)
-                .filter(predicate)
+                .mapNotNull { optionalRoomSummary -> optionalRoomSummary.getOrNull() }
-                .first()
+                .filter { roomSummary -> roomSummary.info.currentUserMembership == CurrentUserMembership.JOINED }
                 .first()
                 // Ensure that the room is ready
                 .also { client.awaitRoomRemoteEcho(it.roomId.value) }
@@ -568,20 +560,21 @@ class RustMatrixClient(
 
     override fun roomMembershipObserver(): RoomMembershipObserver = roomMembershipObserver
 
-    override fun getRoomInfoFlow(roomId: RoomId): Flow<Optional<MatrixRoomInfo>> {
+    override fun getRoomSummaryFlow(roomIdOrAlias: RoomIdOrAlias): Flow<Optional<RoomSummary>> {
-        return flow {
+        val predicate: (RoomSummary) -> Boolean = when (roomIdOrAlias) {
-            var room = getRoom(roomId)
+            is RoomIdOrAlias.Alias -> { roomSummary ->
-            if (room == null) {
+                roomSummary.info.aliases.contains(roomIdOrAlias.roomAlias)
-                emit(Optional.empty())
-                awaitJoinedRoom(roomId.toRoomIdOrAlias(), INFINITE)
-                room = getRoom(roomId)
             }
-            room?.use {
+            is RoomIdOrAlias.Id -> { roomSummary ->
-                room.roomInfoFlow
+                roomSummary.roomId == roomIdOrAlias.roomId
-                    .map { roomInfo -> Optional.of(roomInfo) }
-                    .collect(this)
             }
-        }.distinctUntilChanged()
+        }
+        return roomListService.allRooms.summaries
+            .map { roomSummaries ->
+                val roomSummary = roomSummaries.firstOrNull(predicate)
+                Optional.ofNullable(roomSummary)
+            }
+            .distinctUntilChanged()
     }
 
     override suspend fun setAllSendQueuesEnabled(enabled: Boolean) = withContext(sessionDispatcher) {

libraries/matrix/test/src/main/kotlin/io/element/android/libraries/matrix/test/FakeMatrixClient.kt

@@ -24,7 +24,6 @@ import io.element.android.libraries.matrix.api.oidc.AccountManagementAction
 import io.element.android.libraries.matrix.api.pusher.PushersService
 import io.element.android.libraries.matrix.api.room.InvitedRoom
 import io.element.android.libraries.matrix.api.room.MatrixRoom
-import io.element.android.libraries.matrix.api.room.MatrixRoomInfo
 import io.element.android.libraries.matrix.api.room.RoomMembershipObserver
 import io.element.android.libraries.matrix.api.room.alias.ResolvedRoomAlias
 import io.element.android.libraries.matrix.api.room.preview.RoomPreview
@@ -118,8 +117,8 @@ class FakeMatrixClient(
     var knockRoomLambda: (RoomId) -> Result<Unit> = {
         Result.success(Unit)
     }
-    var getRoomInfoFlowLambda = { _: RoomId ->
+    var getRoomSummaryFlowLambda = { _: RoomIdOrAlias ->
-        flowOf<Optional<MatrixRoomInfo>>(Optional.empty())
+        flowOf<Optional<RoomSummary>>(Optional.empty())
     }
     var logoutLambda: (Boolean, Boolean) -> String? = { _, _ ->
         null
@@ -316,7 +315,7 @@ class FakeMatrixClient(
         return Result.success(visitedRoomsId)
     }
 
-    override fun getRoomInfoFlow(roomId: RoomId) = getRoomInfoFlowLambda(roomId)
+    override fun getRoomSummaryFlow(roomIdOrAlias: RoomIdOrAlias) = getRoomSummaryFlowLambda(roomIdOrAlias)
 
     var setAllSendQueuesEnabledLambda = lambdaRecorder(ensureNeverCalled = true) { _: Boolean ->
         // no-op