read : use the new apis

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/MessagesPresenter.kt

@@ -159,10 +159,10 @@ class MessagesPresenter @AssistedInject constructor(
         }
 
         LaunchedEffect(Unit) {
-            // Mark the room as read on entering but don't send read receipts
+            // Remove the unread flag on entering but don't send read receipts
             // as those will be handled by the timeline.
             withContext(dispatchers.io) {
-                room.markAsRead(null)
+                room.setUnreadFlag(isUnread = false)
             }
         }
 

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/TimelinePresenter.kt

@@ -232,12 +232,17 @@ class TimelinePresenter @AssistedInject constructor(
         lastReadReceiptId: MutableState<EventId?>,
         readReceiptType: ReceiptType,
     ) = launch(dispatchers.computation) {
-        // Get last valid EventId seen by the user, as the first index might refer to a Virtual item
+        // If we are at the bottom of timeline, we mark the room as read.
-        val eventId = getLastEventIdBeforeOrAt(firstVisibleIndex, timelineItems)
+        if (firstVisibleIndex == 0) {
-        if (eventId != null && firstVisibleIndex <= lastReadReceiptIndex.value && eventId != lastReadReceiptId.value) {
+            room.markAsRead(receiptType = readReceiptType)
-            lastReadReceiptIndex.value = firstVisibleIndex
+        } else {
-            lastReadReceiptId.value = eventId
+            // Get last valid EventId seen by the user, as the first index might refer to a Virtual item
-            timeline.sendReadReceipt(eventId = eventId, receiptType = readReceiptType)
+            val eventId = getLastEventIdBeforeOrAt(firstVisibleIndex, timelineItems)
+            if (eventId != null && firstVisibleIndex <= lastReadReceiptIndex.value && eventId != lastReadReceiptId.value) {
+                lastReadReceiptIndex.value = firstVisibleIndex
+                lastReadReceiptId.value = eventId
+                timeline.sendReadReceipt(eventId = eventId, receiptType = readReceiptType)
+            }
         }
     }
 

features/roomlist/impl/src/main/kotlin/io/element/android/features/roomlist/impl/RoomListPresenter.kt

@@ -145,15 +145,20 @@ class RoomListPresenter @Inject constructor(
                 is RoomListEvents.HideContextMenu -> contextMenu = RoomListState.ContextMenu.Hidden
                 is RoomListEvents.LeaveRoom -> leaveRoomState.eventSink(LeaveRoomEvent.ShowConfirmation(event.roomId))
                 is RoomListEvents.MarkAsRead -> coroutineScope.launch {
-                    val receiptType = if (sessionPreferencesStore.isSendPublicReadReceiptsEnabled().first()) {
+                    client.getRoom(event.roomId)?.use { room ->
-                        ReceiptType.READ
+                        room.setUnreadFlag(isUnread = false)
-                    } else {
+                        val receiptType = if (sessionPreferencesStore.isSendPublicReadReceiptsEnabled().first()) {
-                        ReceiptType.READ_PRIVATE
+                            ReceiptType.READ
+                        } else {
+                            ReceiptType.READ_PRIVATE
+                        }
+                        room.markAsRead(receiptType)
                     }
-                    client.getRoom(event.roomId)?.markAsRead(receiptType)
                 }
                 is RoomListEvents.MarkAsUnread -> coroutineScope.launch {
-                    client.getRoom(event.roomId)?.markAsUnread()
+                    client.getRoom(event.roomId)?.use { room ->
+                        room.setUnreadFlag(isUnread = true)
+                    }
                 }
             }
         }

features/roomlist/impl/src/test/kotlin/io/element/android/features/roomlist/impl/RoomListPresenterTests.kt

@@ -487,18 +487,18 @@ class RoomListPresenterTests {
         }.test {
             val initialState = awaitItem()
             assertThat(room.markAsReadCalls).isEmpty()
-            assertThat(room.markAsUnreadReadCallCount).isEqualTo(0)
+            assertThat(room.setUnreadFlagCalls).isEmpty()
             initialState.eventSink.invoke(RoomListEvents.MarkAsRead(A_ROOM_ID))
             assertThat(room.markAsReadCalls).isEqualTo(listOf(ReceiptType.READ))
-            assertThat(room.markAsUnreadReadCallCount).isEqualTo(0)
+            assertThat(room.setUnreadFlagCalls).isEqualTo(listOf(false))
             initialState.eventSink.invoke(RoomListEvents.MarkAsUnread(A_ROOM_ID))
             assertThat(room.markAsReadCalls).isEqualTo(listOf(ReceiptType.READ))
-            assertThat(room.markAsUnreadReadCallCount).isEqualTo(1)
+            assertThat(room.setUnreadFlagCalls).isEqualTo(listOf(false, true))
             // Test again with private read receipts
             sessionPreferencesStore.setSendPublicReadReceipts(false)
             initialState.eventSink.invoke(RoomListEvents.MarkAsRead(A_ROOM_ID))
             assertThat(room.markAsReadCalls).isEqualTo(listOf(ReceiptType.READ, ReceiptType.READ_PRIVATE))
-            assertThat(room.markAsUnreadReadCallCount).isEqualTo(1)
+            assertThat(room.setUnreadFlagCalls).isEqualTo(listOf(false, true, false))
             cancelAndIgnoreRemainingEvents()
             scope.cancel()
         }

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

@@ -153,15 +153,17 @@ interface MatrixRoom : Closeable {
     suspend fun reportContent(eventId: EventId, reason: String, blockUserId: UserId?): Result<Unit>
 
     /**
-     * Reverts a previously set unread flag, and eventually send a Read Receipt.
+     * Mark the room as read by trying to attach an unthreaded read receipt to the latest room event.
-     * @param receiptType The type of receipt to send. If null, no Read Receipt will be sent.
+     * @param receiptType The type of receipt to send.
      */
-    suspend fun markAsRead(receiptType: ReceiptType?): Result<Unit>
+    suspend fun markAsRead(receiptType: ReceiptType): Result<Unit>
 
     /**
-     * Sets a flag on the room to indicate that the user has explicitly marked it as unread.
+     * Sets a flag on the room to indicate that the user has explicitly marked it as unread, or reverts the flag.
+     * @param isUnread true to mark the room as unread, false to remove the flag.
+     *
      */
-    suspend fun markAsUnread(): Result<Unit>
+    suspend fun setUnreadFlag(isUnread: Boolean): Result<Unit>
 
     /**
      * Share a location message in the room.

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

@@ -442,19 +442,15 @@ class RustMatrixRoom(
         }
     }
 
-    override suspend fun markAsRead(receiptType: ReceiptType?): Result<Unit> = withContext(roomDispatcher) {
+    override suspend fun markAsRead(receiptType: ReceiptType): Result<Unit> = withContext(roomDispatcher) {
         runCatching {
-            if (receiptType != null) {
+            innerRoom.markAsRead(receiptType.toRustReceiptType())
-                innerRoom.markAsReadAndSendReadReceipt(receiptType.toRustReceiptType())
-            } else {
-                innerRoom.markAsRead()
-            }
         }
     }
 
-    override suspend fun markAsUnread(): Result<Unit> = withContext(roomDispatcher) {
+    override suspend fun setUnreadFlag(isUnread: Boolean): Result<Unit> = withContext(roomDispatcher) {
         runCatching {
-            innerRoom.markAsUnread()
+            innerRoom.setUnreadFlag(isUnread)
         }
     }
 

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

@@ -378,17 +378,18 @@ class FakeMatrixRoom(
         return reportContentResult
     }
 
-    val markAsReadCalls = mutableListOf<ReceiptType?>()
+    val markAsReadCalls = mutableListOf<ReceiptType>()
-    override suspend fun markAsRead(receiptType: ReceiptType?): Result<Unit> {
+
+    override suspend fun markAsRead(receiptType: ReceiptType): Result<Unit> {
         markAsReadCalls.add(receiptType)
         return Result.success(Unit)
     }
 
-    var markAsUnreadReadCallCount = 0
+    var setUnreadFlagCalls = mutableListOf<Boolean>()
         private set
 
-    override suspend fun markAsUnread(): Result<Unit> {
+    override suspend fun setUnreadFlag(isUnread: Boolean): Result<Unit> {
-        markAsUnreadReadCallCount++
+        setUnreadFlagCalls.add(isUnread)
         return Result.success(Unit)
     }