Merge branch 'develop' into feature/valere/support_verification_violation_banner

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

@@ -13,6 +13,7 @@ import io.element.android.libraries.core.bool.orFalse
 import io.element.android.libraries.core.coroutine.CoroutineDispatchers
 import io.element.android.libraries.core.coroutine.childScope
 import io.element.android.libraries.core.data.tryOrNull
+import io.element.android.libraries.core.extensions.mapFailure
 import io.element.android.libraries.featureflag.api.FeatureFlagService
 import io.element.android.libraries.matrix.api.MatrixClient
 import io.element.android.libraries.matrix.api.core.DeviceId
@@ -32,12 +33,11 @@ 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.CurrentUserMembership
 import io.element.android.libraries.matrix.api.room.MatrixRoom
-import io.element.android.libraries.matrix.api.room.PendingRoom
 import io.element.android.libraries.matrix.api.room.RoomMember
 import io.element.android.libraries.matrix.api.room.RoomMembershipObserver
+import io.element.android.libraries.matrix.api.room.RoomPreview
 import io.element.android.libraries.matrix.api.room.alias.ResolvedRoomAlias
 import io.element.android.libraries.matrix.api.room.join.JoinRule
-import io.element.android.libraries.matrix.api.room.preview.RoomPreviewInfo
 import io.element.android.libraries.matrix.api.roomdirectory.RoomDirectoryService
 import io.element.android.libraries.matrix.api.roomdirectory.RoomVisibility
 import io.element.android.libraries.matrix.api.roomlist.RoomListService
@@ -50,6 +50,7 @@ import io.element.android.libraries.matrix.api.user.MatrixUser
 import io.element.android.libraries.matrix.api.verification.SessionVerificationService
 import io.element.android.libraries.matrix.impl.core.toProgressWatcher
 import io.element.android.libraries.matrix.impl.encryption.RustEncryptionService
+import io.element.android.libraries.matrix.impl.exception.mapClientException
 import io.element.android.libraries.matrix.impl.media.RustMediaLoader
 import io.element.android.libraries.matrix.impl.notification.RustNotificationService
 import io.element.android.libraries.matrix.impl.notificationsettings.RustNotificationSettingsService
@@ -58,9 +59,9 @@ import io.element.android.libraries.matrix.impl.pushers.RustPushersService
 import io.element.android.libraries.matrix.impl.room.RoomContentForwarder
 import io.element.android.libraries.matrix.impl.room.RoomSyncSubscriber
 import io.element.android.libraries.matrix.impl.room.RustRoomFactory
+import io.element.android.libraries.matrix.impl.room.RustRoomPreview
 import io.element.android.libraries.matrix.impl.room.TimelineEventTypeFilterFactory
 import io.element.android.libraries.matrix.impl.room.join.map
-import io.element.android.libraries.matrix.impl.room.preview.RoomPreviewInfoMapper
 import io.element.android.libraries.matrix.impl.roomdirectory.RustRoomDirectoryService
 import io.element.android.libraries.matrix.impl.roomdirectory.map
 import io.element.android.libraries.matrix.impl.roomlist.RoomListFactory
@@ -261,8 +262,8 @@ class RustMatrixClient(
         return roomFactory.create(roomId)
     }
 
-    override suspend fun getPendingRoom(roomId: RoomId): PendingRoom? {
-        return roomFactory.createPendingRoom(roomId)
+    override suspend fun getPendingRoom(roomId: RoomId): RoomPreview? {
+        return roomFactory.createRoomPreview(roomId)
     }
 
     /**
@@ -393,7 +394,7 @@ class RustMatrixClient(
                 null
             }
         }
-    }
+    }.mapFailure { it.mapClientException() }
 
     override suspend fun joinRoomByIdOrAlias(roomIdOrAlias: RoomIdOrAlias, serverNames: List<String>): Result<RoomSummary?> = withContext(sessionDispatcher) {
         runCatching {
@@ -407,7 +408,7 @@ class RustMatrixClient(
                 Timber.e(e, "Timeout waiting for the room to be available in the room list")
                 null
             }
-        }
+        }.mapFailure { it.mapClientException() }
     }
 
     override suspend fun knockRoom(roomIdOrAlias: RoomIdOrAlias, message: String, serverNames: List<String>): Result<RoomSummary?> = withContext(
@@ -421,7 +422,7 @@ class RustMatrixClient(
                 Timber.e(e, "Timeout waiting for the room to be available in the room list")
                 null
             }
-        }
+        }.mapFailure { it.mapClientException() }
     }
 
     override suspend fun trackRecentlyVisitedRoom(roomId: RoomId): Result<Unit> = withContext(sessionDispatcher) {
@@ -448,15 +449,14 @@ class RustMatrixClient(
         }
     }
 
-    override suspend fun getRoomPreviewInfo(roomIdOrAlias: RoomIdOrAlias, serverNames: List<String>): Result<RoomPreviewInfo> = withContext(sessionDispatcher) {
+    override suspend fun getRoomPreview(roomIdOrAlias: RoomIdOrAlias, serverNames: List<String>): Result<RoomPreview> = withContext(sessionDispatcher) {
         runCatching {
-            when (roomIdOrAlias) {
+            val roomPreview = when (roomIdOrAlias) {
                 is RoomIdOrAlias.Alias -> innerClient.getRoomPreviewFromRoomAlias(roomIdOrAlias.roomAlias.value)
                 is RoomIdOrAlias.Id -> innerClient.getRoomPreviewFromRoomId(roomIdOrAlias.roomId.value, serverNames)
-            }.use { roomPreview ->
-                RoomPreviewInfoMapper.map(roomPreview.info())
             }
-        }
+            RustRoomPreview(sessionId, roomPreview, roomMembershipObserver)
+        }.mapFailure { it.mapClientException() }
     }
 
     override fun syncService(): SyncService = rustSyncService
@@ -495,6 +495,7 @@ class RustMatrixClient(
 
     override suspend fun logout(userInitiated: Boolean, ignoreSdkError: Boolean): String? {
         var result: String? = null
+        sessionCoroutineScope.cancel()
         // Remove current delegate so we don't receive an auth error
         clientDelegateTaskHandle?.cancelAndDestroy()
         clientDelegateTaskHandle = null

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

@@ -15,6 +15,11 @@ fun Throwable.mapClientException(): ClientException {
         is RustClientException -> {
             when (this) {
                 is RustClientException.Generic -> ClientException.Generic(msg)
+                is RustClientException.MatrixApi -> ClientException.MatrixApi(
+                    kind = kind.map(),
+                    code = code,
+                    message = msg
+                )
             }
         }
         else -> ClientException.Other(message ?: "Unknown error")

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

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.matrix.impl.exception
+import io.element.android.libraries.matrix.api.exception.ErrorKind
+import org.matrix.rustcomponents.sdk.ErrorKind as RustErrorKind
+
+fun RustErrorKind.map(): ErrorKind {
+    return when (this) {
+        RustErrorKind.BadAlias -> ErrorKind.BadAlias
+        RustErrorKind.BadJson -> ErrorKind.BadJson
+        RustErrorKind.BadState -> ErrorKind.BadState
+        is RustErrorKind.BadStatus -> ErrorKind.BadStatus(status?.toInt(), body)
+        RustErrorKind.CannotLeaveServerNoticeRoom -> ErrorKind.CannotLeaveServerNoticeRoom
+        RustErrorKind.CannotOverwriteMedia -> ErrorKind.CannotOverwriteMedia
+        RustErrorKind.CaptchaInvalid -> ErrorKind.CaptchaInvalid
+        RustErrorKind.CaptchaNeeded -> ErrorKind.CaptchaNeeded
+        RustErrorKind.ConnectionFailed -> ErrorKind.ConnectionFailed
+        RustErrorKind.ConnectionTimeout -> ErrorKind.ConnectionTimeout
+        is RustErrorKind.Custom -> ErrorKind.Custom(errcode)
+        RustErrorKind.DuplicateAnnotation -> ErrorKind.DuplicateAnnotation
+        RustErrorKind.Exclusive -> ErrorKind.Exclusive
+        RustErrorKind.Forbidden -> ErrorKind.Forbidden
+        RustErrorKind.GuestAccessForbidden -> ErrorKind.GuestAccessForbidden
+        is RustErrorKind.IncompatibleRoomVersion -> ErrorKind.IncompatibleRoomVersion(roomVersion)
+        RustErrorKind.InvalidParam -> ErrorKind.InvalidParam
+        RustErrorKind.InvalidRoomState -> ErrorKind.InvalidRoomState
+        RustErrorKind.InvalidUsername -> ErrorKind.InvalidUsername
+        is RustErrorKind.LimitExceeded -> ErrorKind.LimitExceeded(retryAfterMs?.toLong())
+        RustErrorKind.MissingParam -> ErrorKind.MissingParam
+        RustErrorKind.MissingToken -> ErrorKind.MissingToken
+        RustErrorKind.NotFound -> ErrorKind.NotFound
+        RustErrorKind.NotJson -> ErrorKind.NotJson
+        RustErrorKind.NotYetUploaded -> ErrorKind.NotYetUploaded
+        is RustErrorKind.ResourceLimitExceeded -> ErrorKind.ResourceLimitExceeded(adminContact)
+        RustErrorKind.RoomInUse -> ErrorKind.RoomInUse
+        RustErrorKind.ServerNotTrusted -> ErrorKind.ServerNotTrusted
+        RustErrorKind.ThreepidAuthFailed -> ErrorKind.ThreepidAuthFailed
+        RustErrorKind.ThreepidDenied -> ErrorKind.ThreepidDenied
+        RustErrorKind.ThreepidInUse -> ErrorKind.ThreepidInUse
+        RustErrorKind.ThreepidMediumNotSupported -> ErrorKind.ThreepidMediumNotSupported
+        RustErrorKind.ThreepidNotFound -> ErrorKind.ThreepidNotFound
+        RustErrorKind.TooLarge -> ErrorKind.TooLarge
+        RustErrorKind.UnableToAuthorizeJoin -> ErrorKind.UnableToAuthorizeJoin
+        RustErrorKind.UnableToGrantJoin -> ErrorKind.UnableToGrantJoin
+        RustErrorKind.Unauthorized -> ErrorKind.Unauthorized
+        RustErrorKind.Unknown -> ErrorKind.Unknown
+        is RustErrorKind.UnknownToken -> ErrorKind.UnknownToken(softLogout)
+        RustErrorKind.Unrecognized -> ErrorKind.Unrecognized
+        RustErrorKind.UnsupportedRoomVersion -> ErrorKind.UnsupportedRoomVersion
+        RustErrorKind.UrlNotSet -> ErrorKind.UrlNotSet
+        RustErrorKind.UserDeactivated -> ErrorKind.UserDeactivated
+        RustErrorKind.UserInUse -> ErrorKind.UserInUse
+        RustErrorKind.UserLocked -> ErrorKind.UserLocked
+        RustErrorKind.UserSuspended -> ErrorKind.UserSuspended
+        RustErrorKind.WeakPassword -> ErrorKind.WeakPassword
+        is RustErrorKind.WrongRoomKeysVersion -> ErrorKind.WrongRoomKeysVersion(currentVersion)
+    }
+}

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

@@ -37,7 +37,6 @@ class MatrixRoomInfoMapper {
             topic = it.topic,
             avatarUrl = it.avatarUrl,
             isDirect = it.isDirect,
-            isPublic = it.isPublic,
             joinRule = it.joinRule?.map(),
             isSpace = it.isSpace,
             isTombstoned = it.isTombstoned,

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

@@ -1,31 +0,0 @@
-/*
- * Copyright 2024 New Vector Ltd.
- *
- * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
- * Please see LICENSE files in the repository root for full details.
- */
-
-package io.element.android.libraries.matrix.impl.room
-
-import io.element.android.libraries.matrix.api.core.RoomId
-import io.element.android.libraries.matrix.api.core.SessionId
-import io.element.android.libraries.matrix.api.room.PendingRoom
-import io.element.android.libraries.matrix.api.room.RoomMembershipObserver
-import org.matrix.rustcomponents.sdk.RoomPreview
-
-class RustPendingRoom(
-    override val sessionId: SessionId,
-    override val roomId: RoomId,
-    private val inner: RoomPreview,
-    private val roomMembershipObserver: RoomMembershipObserver,
-) : PendingRoom {
-    override suspend fun leave(): Result<Unit> = runCatching {
-        inner.leave()
-    }.onSuccess {
-        roomMembershipObserver.notifyUserLeftRoom(roomId)
-    }
-
-    override fun close() {
-        inner.destroy()
-    }
-}

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

@@ -16,8 +16,8 @@ import io.element.android.libraries.matrix.api.core.RoomId
 import io.element.android.libraries.matrix.api.core.SessionId
 import io.element.android.libraries.matrix.api.notificationsettings.NotificationSettingsService
 import io.element.android.libraries.matrix.api.room.MatrixRoom
-import io.element.android.libraries.matrix.api.room.PendingRoom
 import io.element.android.libraries.matrix.api.room.RoomMembershipObserver
+import io.element.android.libraries.matrix.api.room.RoomPreview
 import io.element.android.libraries.matrix.api.roomlist.RoomListService
 import io.element.android.libraries.matrix.api.roomlist.awaitLoaded
 import io.element.android.libraries.matrix.impl.roomlist.fullRoomWithTimeline
@@ -28,7 +28,6 @@ import kotlinx.coroutines.NonCancellable
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withContext
-import org.matrix.rustcomponents.sdk.Membership
 import org.matrix.rustcomponents.sdk.Room
 import org.matrix.rustcomponents.sdk.RoomListException
 import org.matrix.rustcomponents.sdk.RoomListItem
@@ -36,7 +35,6 @@ import timber.log.Timber
 import org.matrix.rustcomponents.sdk.RoomListService as InnerRoomListService
 
 private const val CACHE_SIZE = 16
-private val PENDING_MEMBERSHIPS = setOf(Membership.INVITED, Membership.KNOCKED)
 
 class RustRoomFactory(
     private val sessionId: SessionId,
@@ -125,7 +123,7 @@ class RustRoomFactory(
         }
     }
 
-    suspend fun createPendingRoom(roomId: RoomId): PendingRoom? = withContext(dispatcher) {
+    suspend fun createRoomPreview(roomId: RoomId): RoomPreview? = withContext(dispatcher) {
         if (isDestroyed) {
             Timber.d("Room factory is destroyed, returning null for $roomId")
             return@withContext null
@@ -135,19 +133,18 @@ class RustRoomFactory(
             Timber.d("Room not found for $roomId")
             return@withContext null
         }
-        if (roomListItem.membership() !in PENDING_MEMBERSHIPS) {
-            Timber.d("Room $roomId is not in pending state")
+        if (roomListItem.membership() !in RustRoomPreview.ALLOWED_MEMBERSHIPS) {
+            Timber.d("Room $roomId is not in allowed membership")
             return@withContext null
         }
         val innerRoom = try {
             roomListItem.previewRoom(via = emptyList())
         } catch (e: Exception) {
-            Timber.e(e, "Failed to get pending room for $roomId")
+            Timber.e(e, "Failed to get room preview for $roomId")
             return@withContext null
         }
-        RustPendingRoom(
+        RustRoomPreview(
             sessionId = sessionId,
-            roomId = roomId,
             inner = innerRoom,
             roomMembershipObserver = roomMembershipObserver,
         )

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

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2024 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.matrix.impl.room
+
+import androidx.compose.runtime.Immutable
+import io.element.android.libraries.matrix.api.core.SessionId
+import io.element.android.libraries.matrix.api.room.RoomMembershipDetails
+import io.element.android.libraries.matrix.api.room.RoomMembershipObserver
+import io.element.android.libraries.matrix.api.room.RoomPreview
+import io.element.android.libraries.matrix.api.room.preview.RoomPreviewInfo
+import io.element.android.libraries.matrix.impl.room.member.RoomMemberMapper
+import io.element.android.libraries.matrix.impl.room.preview.RoomPreviewInfoMapper
+import org.matrix.rustcomponents.sdk.Membership
+import org.matrix.rustcomponents.sdk.RoomPreview as InnerRoomPreview
+
+@Immutable
+class RustRoomPreview(
+    override val sessionId: SessionId,
+    private val inner: InnerRoomPreview,
+    private val roomMembershipObserver: RoomMembershipObserver?,
+) : RoomPreview {
+    companion object {
+        val ALLOWED_MEMBERSHIPS = setOf(Membership.INVITED, Membership.KNOCKED, Membership.BANNED)
+    }
+
+    override val info: RoomPreviewInfo = RoomPreviewInfoMapper.map(inner.info())
+
+    override suspend fun leave(): Result<Unit> = runCatching {
+        inner.leave()
+    }.onSuccess {
+        roomMembershipObserver?.notifyUserLeftRoom(info.roomId)
+    }
+
+    override suspend fun forget(): Result<Unit> = runCatching {
+        inner.forget()
+    }
+
+    override suspend fun membershipDetails(): Result<RoomMembershipDetails?> = runCatching {
+        val details = inner.ownMembershipDetails() ?: return@runCatching null
+        RoomMembershipDetails(
+            currentUserMember = RoomMemberMapper.map(details.ownRoomMember),
+            senderMember = details.senderRoomMember?.let { RoomMemberMapper.map(it) },
+        )
+    }
+
+    override fun close() {
+        inner.destroy()
+    }
+}

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

@@ -25,6 +25,7 @@ object RoomMemberMapper {
         normalizedPowerLevel = roomMember.normalizedPowerLevel,
         isIgnored = roomMember.isIgnored,
         role = mapRole(roomMember.suggestedRoleForPowerLevel),
+        membershipChangeReason = roomMember.membershipChangeReason
     )
 
     fun mapRole(role: RoomMemberRole): RoomMember.Role =

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

@@ -11,9 +11,8 @@ import io.element.android.libraries.core.bool.orFalse
 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.room.preview.RoomPreviewInfo
+import io.element.android.libraries.matrix.impl.room.join.map
 import io.element.android.libraries.matrix.impl.room.map
-import org.matrix.rustcomponents.sdk.JoinRule
-import org.matrix.rustcomponents.sdk.Membership
 import org.matrix.rustcomponents.sdk.RoomPreviewInfo as RustRoomPreviewInfo
 
 object RoomPreviewInfoMapper {
@@ -27,10 +26,8 @@ object RoomPreviewInfoMapper {
             numberOfJoinedMembers = info.numJoinedMembers.toLong(),
             roomType = info.roomType.map(),
             isHistoryWorldReadable = info.isHistoryWorldReadable.orFalse(),
-            isJoined = info.membership == Membership.JOINED,
-            isInvited = info.membership == Membership.INVITED,
-            isPublic = info.joinRule == JoinRule.Public,
-            canKnock = info.joinRule == JoinRule.Knock
+            membership = info.membership?.map(),
+            joinRule = info.joinRule.map(),
         )
     }
 }

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

@@ -48,6 +48,7 @@ import io.element.android.services.toolbox.api.systemclock.SystemClock
 import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.NonCancellable
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.flow.Flow
@@ -296,7 +297,7 @@ class RustTimeline(
         htmlBody: String?,
         intentionalMentions: List<IntentionalMention>,
     ): Result<Unit> = withContext(dispatcher) {
-        runCatching<Unit> {
+        runCatching {
             val editedContent = EditedContent.RoomMessage(
                 content = MessageEventContent.from(
                     body = body,
@@ -324,10 +325,12 @@ class RustTimeline(
                 },
                 mentions = null,
             )
-            inner.edit(
-                newContent = editedContent,
-                eventOrTransactionId = eventOrTransactionId.toRustEventOrTransactionId(),
-            )
+            withContext(Dispatchers.IO) {
+                inner.edit(
+                    newContent = editedContent,
+                    eventOrTransactionId = eventOrTransactionId.toRustEventOrTransactionId(),
+                )
+            }
         }
     }
 
@@ -519,7 +522,7 @@ class RustTimeline(
                 newContent = editedContent,
                 eventOrTransactionId = RustEventOrTransactionId.EventId(pollStartId.value),
             )
-        }.map { }
+        }
     }
 
     override suspend fun sendPollResponse(

libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/room/MatrixRoomInfoMapperTest.kt

@@ -85,7 +85,6 @@ class MatrixRoomInfoMapperTest {
                 topic = "topic",
                 avatarUrl = AN_AVATAR_URL,
                 isDirect = true,
-                isPublic = false,
                 isSpace = false,
                 isTombstoned = false,
                 isFavorite = false,
@@ -167,7 +166,6 @@ class MatrixRoomInfoMapperTest {
                 topic = null,
                 avatarUrl = null,
                 isDirect = false,
-                isPublic = true,
                 joinRule = null,
                 isSpace = false,
                 isTombstoned = false,

libraries/matrix/impl/src/test/kotlin/io/element/android/libraries/matrix/impl/room/preview/RoomPreviewInfoMapperTest.kt

@@ -8,14 +8,16 @@
 package io.element.android.libraries.matrix.impl.room.preview
 
 import com.google.common.truth.Truth.assertThat
+import io.element.android.libraries.matrix.api.room.CurrentUserMembership
 import io.element.android.libraries.matrix.api.room.RoomType
+import io.element.android.libraries.matrix.api.room.join.JoinRule
 import io.element.android.libraries.matrix.api.room.preview.RoomPreviewInfo
 import io.element.android.libraries.matrix.impl.fixtures.factories.aRustRoomPreviewInfo
 import io.element.android.libraries.matrix.test.A_ROOM_ALIAS
 import io.element.android.libraries.matrix.test.A_ROOM_ID
 import org.junit.Test
-import org.matrix.rustcomponents.sdk.JoinRule
 import org.matrix.rustcomponents.sdk.Membership
+import org.matrix.rustcomponents.sdk.JoinRule as RustJoinRule
 
 class RoomPreviewInfoMapperTest {
     @Test
@@ -23,7 +25,7 @@ class RoomPreviewInfoMapperTest {
         assertThat(
             RoomPreviewInfoMapper.map(
                 info = aRustRoomPreviewInfo(
-                    membership = null,
+                    membership = Membership.JOINED,
                 )
             )
         ).isEqualTo(
@@ -36,10 +38,8 @@ class RoomPreviewInfoMapperTest {
                 numberOfJoinedMembers = 1L,
                 roomType = RoomType.Room,
                 isHistoryWorldReadable = true,
-                isJoined = false,
-                isInvited = false,
-                isPublic = true,
-                canKnock = false,
+                membership = CurrentUserMembership.JOINED,
+                joinRule = JoinRule.Public,
             )
         )
     }
@@ -51,7 +51,7 @@ class RoomPreviewInfoMapperTest {
                 info = aRustRoomPreviewInfo(
                     canonicalAlias = null,
                     membership = Membership.JOINED,
-                    joinRule = JoinRule.Knock,
+                    joinRule = RustJoinRule.Knock,
                 )
             )
         ).isEqualTo(
@@ -64,10 +64,8 @@ class RoomPreviewInfoMapperTest {
                 numberOfJoinedMembers = 1L,
                 roomType = RoomType.Room,
                 isHistoryWorldReadable = true,
-                isJoined = true,
-                isInvited = false,
-                isPublic = false,
-                canKnock = true,
+                membership = CurrentUserMembership.JOINED,
+                joinRule = JoinRule.Knock,
             )
         )
     }