feat: Move alert showing logic into state presenter.

Author: kaylendog

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/crypto/historyvisible/HistoryVisibleState.kt

@@ -7,11 +7,7 @@
 
 package io.element.android.features.messages.impl.crypto.historyvisible
 
-import io.element.android.libraries.matrix.api.room.history.RoomHistoryVisibility
-
 data class HistoryVisibleState(
-    val roomHistoryVisibility: RoomHistoryVisibility,
-    val roomIsEncrypted: Boolean,
-    val acknowledged: Boolean,
+    val showAlert: Boolean,
     val eventSink: (HistoryVisibleEvent) -> Unit,
 )

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/crypto/historyvisible/HistoryVisibleStatePresenter.kt

@@ -38,9 +38,7 @@ class HistoryVisibleStatePresenter(
         }
 
         return HistoryVisibleState(
-            roomHistoryVisibility = roomInfo.historyVisibility,
-            roomIsEncrypted = roomInfo.isEncrypted == true,
-            acknowledged = acknowledged,
+            showAlert = roomInfo.historyVisibility != RoomHistoryVisibility.Joined && roomInfo.isEncrypted == true && !acknowledged,
             eventSink = { event ->
                 when (event) {
                     is HistoryVisibleEvent.Acknowledge ->

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/crypto/historyvisible/HistoryVisibleStateProvider.kt

@@ -13,20 +13,15 @@ import io.element.android.libraries.matrix.api.room.history.RoomHistoryVisibilit
 class HistoryVisibleStateProvider : PreviewParameterProvider<HistoryVisibleState> {
     override val values: Sequence<HistoryVisibleState>
         get() = sequenceOf(
-            aHistoryVisibleState(RoomHistoryVisibility.Joined, roomIsEncrypted = false, acknowledged = false),
-            aHistoryVisibleState(RoomHistoryVisibility.Shared, roomIsEncrypted = true, acknowledged = false),
-            aHistoryVisibleState(RoomHistoryVisibility.Shared, roomIsEncrypted = true, acknowledged = true)
+            aHistoryVisibleState(showAlert = false),
+            aHistoryVisibleState(showAlert = true),
         )
 }
 
 internal fun aHistoryVisibleState(
-    roomHistoryVisibility: RoomHistoryVisibility = RoomHistoryVisibility.Joined,
-    roomIsEncrypted: Boolean = false,
-    acknowledged: Boolean = false,
+    showAlert: Boolean = false,
     eventSink: (HistoryVisibleEvent) -> Unit = {},
 ) = HistoryVisibleState(
-    roomHistoryVisibility = roomHistoryVisibility,
-    roomIsEncrypted = roomIsEncrypted,
-    acknowledged = acknowledged,
+    showAlert,
     eventSink = eventSink,
 )

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/crypto/historyvisible/HistoryVisibleStateView.kt

@@ -23,7 +23,6 @@ import io.element.android.libraries.designsystem.atomic.molecules.ComposerAlertL
 import io.element.android.libraries.designsystem.atomic.molecules.ComposerAlertMolecule
 import io.element.android.libraries.designsystem.preview.ElementPreview
 import io.element.android.libraries.designsystem.preview.PreviewsDayNight
-import io.element.android.libraries.matrix.api.room.history.RoomHistoryVisibility
 import io.element.android.libraries.ui.strings.CommonStrings
 
 @Composable
@@ -32,18 +31,7 @@ fun HistoryVisibleStateView(
     onLinkClick: (String, Boolean) -> Unit,
     modifier: Modifier = Modifier,
 ) {
-    // Ignore non-encrypted rooms.
-    if (!state.roomIsEncrypted) {
-        return
-    }
-
-    // Ignore rooms with `history_visibility = joined`.
-    if (state.roomHistoryVisibility == RoomHistoryVisibility.Joined) {
-        return
-    }
-
-    // Ignore non-joined rooms we have acknowledged.
-    if (state.acknowledged) {
+    if (!state.showAlert) {
         return
     }
 

features/messages/impl/src/test/kotlin/io/element/android/features/messages/impl/crypto/historyvisible/FakeHistoryVisibleAcknowledgementRepository.kt

@@ -9,17 +9,34 @@ package io.element.android.features.messages.impl.crypto.historyvisible
 
 import io.element.android.libraries.matrix.api.core.RoomId
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.MutableSharedFlow
-
-class FakeHistoryVisibleAcknowledgementRepository : HistoryVisibleAcknowledgementRepository {
-    private val acknowledgements = mutableMapOf<RoomId, MutableSharedFlow<Boolean>>()
+import kotlinx.coroutines.flow.MutableStateFlow
 
+class FakeHistoryVisibleAcknowledgementRepository(
+    private val acknowledgements: MutableMap<RoomId, MutableStateFlow<Boolean>> = mutableMapOf()
+) : HistoryVisibleAcknowledgementRepository {
     override fun hasAcknowledged(roomId: RoomId): Flow<Boolean> {
-        return acknowledgements.getOrPut(roomId) { MutableSharedFlow() }
+        return acknowledgements.getOrPut(roomId) {
+            MutableStateFlow(false)
+        }
     }
 
     override suspend fun setAcknowledged(roomId: RoomId, value: Boolean) {
-        val flow = acknowledgements.getOrPut(roomId) { MutableSharedFlow() }
+        val flow = acknowledgements.getOrPut(roomId) {
+            MutableStateFlow(value)
+        }
         flow.emit(value)
     }
+
+    companion object {
+        /**
+         * Create the repository with a pre-existing entry.
+         */
+        fun withRoom(roomId: RoomId, acknowledged: Boolean = false): FakeHistoryVisibleAcknowledgementRepository {
+            return FakeHistoryVisibleAcknowledgementRepository(
+                mutableMapOf(
+                    roomId to MutableStateFlow(acknowledged)
+                )
+            )
+        }
+    }
 }

features/messages/impl/src/test/kotlin/io/element/android/features/messages/impl/crypto/historyvisible/HistoryVisibleStatePresenterTest.kt

@@ -22,35 +22,98 @@ class HistoryVisibleStatePresenterTest {
     @get:Rule
     val warmUpRule = WarmUpRule()
 
+
+@Test
+fun `present - initial with room shared, unencrypted`() = runTest {
+    val room = FakeJoinedRoom()
+    room.givenRoomInfo(aRoomInfo(historyVisibility = RoomHistoryVisibility.Shared, isEncrypted = false))
+    val presenter = createHistoryVisibleStatePresenter(room)
+    presenter.test {
+        val initialState = awaitItem()
+        assertThat(initialState.showAlert).isFalse()
+        val nextState = awaitItem()
+        assertThat(nextState.showAlert).isFalse()
+    }
+}
+
     @Test
-    fun `present - initial state`() = runTest {
-        val presenter = createHistoryVisibleStatePresenter()
+    fun `present - initial with room joined, encrypted`() = runTest {
+        val room = FakeJoinedRoom()
+        room.givenRoomInfo(aRoomInfo(historyVisibility = RoomHistoryVisibility.Joined, isEncrypted = false))
+        val presenter = createHistoryVisibleStatePresenter(room)
         presenter.test {
             val initialState = awaitItem()
-            assertThat(initialState.acknowledged).isFalse()
-            assertThat(initialState.roomHistoryVisibility).isEqualTo(RoomHistoryVisibility.Joined)
+            assertThat(initialState.showAlert).isFalse()
+            val nextState = awaitItem()
+            assertThat(nextState.showAlert).isFalse()
         }
     }
 
     @Test
-    fun `present - when the room history visibility changes, the presenter emits a new state`() = runTest {
+    fun `present - initial with room shared, encrypted, unacknowledged`() = runTest {
         val room = FakeJoinedRoom()
-        val presenter = createHistoryVisibleStatePresenter(room)
+        room.givenRoomInfo(aRoomInfo(historyVisibility = RoomHistoryVisibility.Shared, isEncrypted = true))
+        val presenter = createHistoryVisibleStatePresenter(room, acknowledged = false)
         presenter.test {
             val initialState = awaitItem()
-            assertThat(initialState.roomHistoryVisibility).isEqualTo(RoomHistoryVisibility.Joined)
-            room.givenRoomInfo(aRoomInfo(historyVisibility = RoomHistoryVisibility.Shared))
+            assertThat(initialState.showAlert).isFalse()
             val nextState = awaitItem()
-            assertThat(nextState.roomHistoryVisibility).isEqualTo(RoomHistoryVisibility.Shared)
+            assertThat(nextState.showAlert).isTrue()
+        }
+    }
+
+    @Test
+    fun `present - initial with room shared, encrypted, acknowledged`() = runTest {
+        val room = FakeJoinedRoom()
+        room.givenRoomInfo(aRoomInfo(historyVisibility = RoomHistoryVisibility.Shared, isEncrypted = true))
+        val presenter = createHistoryVisibleStatePresenter(room, acknowledged = true)
+        presenter.test {
+            val initialState = awaitItem()
+            assertThat(initialState.showAlert).isFalse()
+            // we do not expect a next state here, since the room info matches the initial state and does not get re-emitted.
+        }
+    }
+
+    @Test
+    fun `present - transition from joined + unencrypted, to shared + encrypted`() = runTest {
+        val room = FakeJoinedRoom()
+        val repository = FakeHistoryVisibleAcknowledgementRepository()
+
+        room.givenRoomInfo(aRoomInfo(historyVisibility = RoomHistoryVisibility.Joined, isEncrypted = false))
+
+        val presenter = HistoryVisibleStatePresenter(
+            repository,
+            room,
+        )
+
+        presenter.test {
+            // initial state
+            assertThat(awaitItem().showAlert).isFalse()
+
+            // emitted state from room info assignment
+            assertThat(awaitItem().showAlert).isFalse()
+
+            // room is marked as encrypted
+            room.givenRoomInfo(aRoomInfo(historyVisibility = RoomHistoryVisibility.Joined, isEncrypted = true))
+            assertThat(awaitItem().showAlert).isFalse()
+
+            // room history visibility is changed to shared
+            room.givenRoomInfo(aRoomInfo(historyVisibility = RoomHistoryVisibility.Shared, isEncrypted = true))
+            assertThat(awaitItem().showAlert).isTrue()
+
+            // alert is acknowledged
+            repository.setAcknowledged(room.roomId, true)
+            assertThat(awaitItem().showAlert).isFalse()
         }
     }
 
     private fun createHistoryVisibleStatePresenter(
         room: JoinedRoom = FakeJoinedRoom(),
+        acknowledged: Boolean = false
     ): HistoryVisibleStatePresenter {
         return HistoryVisibleStatePresenter(
             room = room,
-            repository = FakeHistoryVisibleAcknowledgementRepository()
+            repository = FakeHistoryVisibleAcknowledgementRepository.withRoom(room.roomId, acknowledged)
         )
     }
 }