fix (identity change) : ensure we can configure to observe RoomMemberIdentityStateChange in non encrypted room if needed

Author: ganfra

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/crypto/identity/IdentityChangeStatePresenter.kt

@@ -15,7 +15,7 @@ import io.element.android.libraries.architecture.Presenter
 import io.element.android.libraries.matrix.api.core.UserId
 import io.element.android.libraries.matrix.api.encryption.EncryptionService
 import io.element.android.libraries.matrix.api.room.JoinedRoom
-import io.element.android.libraries.matrix.ui.room.observeRoomMemberIdentityStateChange
+import io.element.android.libraries.matrix.ui.room.roomMemberIdentityStateChange
 import kotlinx.collections.immutable.persistentListOf
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
@@ -30,7 +30,7 @@ class IdentityChangeStatePresenter @Inject constructor(
     override fun present(): IdentityChangeState {
         val coroutineScope = rememberCoroutineScope()
         val roomMemberIdentityStateChange by produceState(persistentListOf()) {
-            observeRoomMemberIdentityStateChange(room)
+            room.roomMemberIdentityStateChange(waitForEncryption = true).collect { value = it }
         }
 
         fun handleEvent(event: IdentityChangeEvent) {

features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/RoomDetailsPresenter.kt

@@ -174,7 +174,7 @@ class RoomDetailsPresenter @Inject constructor(
         }
 
         val hasMemberVerificationViolations by produceState(false) {
-            room.roomMemberIdentityStateChange()
+            room.roomMemberIdentityStateChange(waitForEncryption = true)
                 .onEach { identities -> value = identities.any { it.identityState == IdentityState.VerificationViolation } }
                 .launchIn(this)
         }

features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/members/RoomMemberListPresenter.kt

@@ -66,7 +66,7 @@ class RoomMemberListPresenter @Inject constructor(
         val roomModerationState = roomMembersModerationPresenter.present()
 
         val roomMemberIdentityStates by produceState(persistentMapOf<UserId, IdentityState>()) {
-            room.roomMemberIdentityStateChange()
+            room.roomMemberIdentityStateChange(waitForEncryption = true)
                 .onEach { identities ->
                     value = identities.associateBy({ it.identityRoomMember.userId }, { it.identityState }).toPersistentMap()
                 }

features/roomdetails/impl/src/main/kotlin/io/element/android/features/roomdetails/impl/members/details/RoomMemberDetailsPresenter.kt

@@ -9,6 +9,7 @@ package io.element.android.features.roomdetails.impl.members.details
 
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.produceState
 import androidx.compose.runtime.remember
@@ -33,9 +34,7 @@ import io.element.android.libraries.matrix.ui.room.getRoomMemberAsState
 import io.element.android.libraries.matrix.ui.room.roomMemberIdentityStateChange
 import io.element.android.libraries.ui.strings.CommonStrings
 import kotlinx.coroutines.ExperimentalCoroutinesApi
-import kotlinx.coroutines.flow.filter
 import kotlinx.coroutines.flow.filterNotNull
-import kotlinx.coroutines.flow.flatMapLatest
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.launch
 
@@ -86,31 +85,30 @@ class RoomMemberDetailsPresenter @AssistedInject constructor(
 
         val userProfileState = userProfilePresenter.present()
 
-        val identityStateChanges by produceState<IdentityStateChange?>(initialValue = null) {
-            room.roomInfoFlow.filter { it.isEncrypted == true }
-                .flatMapLatest {
-                    // Fetch the initial identity state manually
-                    val identityState = encryptionService.getUserIdentity(roomMemberId).getOrNull()
-                    value = identityState?.let { IdentityStateChange(roomMemberId, it) }
+        val identityStateChanges = produceState<IdentityStateChange?>(initialValue = null) {
+            // Fetch the initial identity state manually
+            val identityState = encryptionService.getUserIdentity(roomMemberId).getOrNull()
+            value = identityState?.let { IdentityStateChange(roomMemberId, it) }
 
-                    // Subscribe to the identity changes
-                    room.roomMemberIdentityStateChange()
-                        .map { it.find { it.identityRoomMember.userId == roomMemberId } }
-                        .map { roomMemberIdentityStateChange ->
-                            // If we didn't receive any info, manually fetch it
-                            roomMemberIdentityStateChange?.identityState ?: encryptionService.getUserIdentity(roomMemberId).getOrNull()
-                        }
-                        .filterNotNull()
+            // Subscribe to the identity changes
+            room.roomMemberIdentityStateChange(waitForEncryption = false)
+                .map { it.find { it.identityRoomMember.userId == roomMemberId } }
+                .map { roomMemberIdentityStateChange ->
+                    // If we didn't receive any info, manually fetch it
+                    roomMemberIdentityStateChange?.identityState ?: encryptionService.getUserIdentity(roomMemberId).getOrNull()
                 }
+                .filterNotNull()
                 .collect { value = IdentityStateChange(roomMemberId, it) }
         }
 
-        val verificationState = remember(identityStateChanges) {
-            when (identityStateChanges?.identityState) {
-                IdentityState.VerificationViolation -> UserProfileVerificationState.VERIFICATION_VIOLATION
-                IdentityState.Verified -> UserProfileVerificationState.VERIFIED
-                IdentityState.Pinned, IdentityState.PinViolation -> UserProfileVerificationState.UNVERIFIED
-                else -> UserProfileVerificationState.UNKNOWN
+        val verificationState by remember {
+            derivedStateOf {
+                when (identityStateChanges.value?.identityState) {
+                    IdentityState.VerificationViolation -> UserProfileVerificationState.VERIFICATION_VIOLATION
+                    IdentityState.Verified -> UserProfileVerificationState.VERIFIED
+                    IdentityState.Pinned, IdentityState.PinViolation -> UserProfileVerificationState.UNVERIFIED
+                    else -> UserProfileVerificationState.UNKNOWN
+                }
             }
         }
 

libraries/matrixui/src/main/kotlin/io/element/android/libraries/matrix/ui/room/ObserveRoomMemberIdentityStateChange.kt

@@ -7,7 +7,6 @@
 
 package io.element.android.libraries.matrix.ui.room
 
-import androidx.compose.runtime.ProduceStateScope
 import io.element.android.libraries.designsystem.components.avatar.AvatarData
 import io.element.android.libraries.designsystem.components.avatar.AvatarSize
 import io.element.android.libraries.matrix.api.core.UserId
@@ -17,25 +16,25 @@ import io.element.android.libraries.matrix.api.room.RoomMember
 import io.element.android.libraries.matrix.api.room.roomMembers
 import io.element.android.libraries.matrix.ui.model.getAvatarData
 import kotlinx.collections.immutable.ImmutableList
-import kotlinx.collections.immutable.PersistentList
 import kotlinx.collections.immutable.toPersistentList
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.distinctUntilChanged
-import kotlinx.coroutines.flow.filter
+import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.flow.flatMapLatest
-import kotlinx.coroutines.flow.launchIn
-import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.flow.flow
 
 @OptIn(ExperimentalCoroutinesApi::class)
-fun JoinedRoom.roomMemberIdentityStateChange(): Flow<ImmutableList<RoomMemberIdentityStateChange>> {
-    return roomInfoFlow
-        .filter {
-            // Room cannot become unencrypted, so we can just apply a filter here.
-            it.isEncrypted == true
+fun JoinedRoom.roomMemberIdentityStateChange(waitForEncryption: Boolean): Flow<ImmutableList<RoomMemberIdentityStateChange>> {
+    val encryptionChangeFlow = flow {
+        if (waitForEncryption) {
+            // Room cannot become unencrypted, so it's ok to use first here
+            roomInfoFlow.first { roomInfo -> roomInfo.isEncrypted == true }
         }
-        .distinctUntilChanged()
+        emit(Unit)
+    }
+    return encryptionChangeFlow
         .flatMapLatest {
             combine(identityStateChangesFlow, membersStateFlow) { identityStateChanges, membersState ->
                 identityStateChanges.map { identityStateChange ->
@@ -52,14 +51,6 @@ fun JoinedRoom.roomMemberIdentityStateChange(): Flow<ImmutableList<RoomMemberIde
         }
 }
 
-fun ProduceStateScope<PersistentList<RoomMemberIdentityStateChange>>.observeRoomMemberIdentityStateChange(room: JoinedRoom) {
-    room.roomMemberIdentityStateChange()
-        .onEach { roomMemberIdentityStateChanges ->
-            value = roomMemberIdentityStateChanges.toPersistentList()
-        }
-        .launchIn(this)
-}
-
 private fun RoomMember.toIdentityRoomMember() = IdentityRoomMember(
     userId = userId,
     displayNameOrDefault = displayNameOrDefault,