[MatrixSDK] finish mapping timeline and makes it compile

app/build.gradle.kts

@@ -219,6 +219,7 @@ dependencies {
     implementation(libs.androidx.activity.compose)
     implementation(libs.androidx.startup)
     implementation(libs.coil)
+    implementation(libs.matrix.sdk)
 
     implementation(libs.dagger)
     kapt(libs.dagger.compiler)

appnav/src/main/kotlin/io/element/android/appnav/RootFlowNode.kt

@@ -119,14 +119,15 @@ class RootFlowNode @AssistedInject constructor(
             onSuccess(latestKnownUserId)
             return
         }
-        val matrixClient = authenticationService.restoreSession(UserId(latestKnownUserId.value))
+        authenticationService.restoreSession(UserId(latestKnownUserId.value))
-        if (matrixClient == null) {
+            .onSuccess { matrixClient ->
-            Timber.v("Failed to restore session...")
+                matrixClientsHolder.add(matrixClient)
-            onFailure()
+                onSuccess(matrixClient.sessionId)
-        } else {
+            }
-            matrixClientsHolder.add(matrixClient)
+            .onFailure {
-            onSuccess(matrixClient.sessionId)
+                Timber.v("Failed to restore session...")
-        }
+                onFailure()
+            }
     }
 
     private fun onOpenBugReport() {

appnav/src/main/kotlin/io/element/android/appnav/di/MatrixClientsHolder.kt

@@ -64,10 +64,13 @@ class MatrixClientsHolder @Inject constructor(private val authenticationService:
         runBlocking {
             userIds.forEach { userId ->
                 Timber.v("Restore matrix session: $userId")
-                val matrixClient = authenticationService.restoreSession(userId)
+                authenticationService.restoreSession(userId)
-                if (matrixClient != null) {
+                    .onSuccess { matrixClient ->
-                    add(matrixClient)
+                        add(matrixClient)
-                }
+                    }
+                    .onFailure {
+                        Timber.e("Fail to restore session")
+                    }
             }
         }
     }

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/changeserver/ChangeServerView.kt

@@ -80,9 +80,9 @@ import io.element.android.libraries.designsystem.theme.components.Text
 import io.element.android.libraries.designsystem.theme.components.TextField
 import io.element.android.libraries.designsystem.theme.components.TopAppBar
 import io.element.android.libraries.designsystem.theme.components.onTabOrEnterKeyFocusNext
+import io.element.android.libraries.matrix.api.auth.AuthenticationException
 import io.element.android.libraries.testtags.TestTags
 import io.element.android.libraries.testtags.testTag
-import org.matrix.rustcomponents.sdk.AuthenticationException
 import io.element.android.libraries.ui.strings.R as StringR
 
 @OptIn(ExperimentalMaterial3Api::class, ExperimentalTextApi::class)

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/error/ErrorFormatter.kt

@@ -17,8 +17,8 @@
 package io.element.android.features.login.impl.error
 
 import io.element.android.libraries.matrix.api.auth.AuthErrorCode
+import io.element.android.libraries.matrix.api.auth.AuthenticationException
 import io.element.android.libraries.matrix.api.auth.errorCode
-import org.matrix.rustcomponents.sdk.AuthenticationException
 import io.element.android.libraries.ui.strings.R.string as StringR
 
 fun loginError(

features/login/impl/src/main/kotlin/io/element/android/features/login/impl/root/LoginRootPresenter.kt

@@ -25,7 +25,6 @@ import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.saveable.rememberSaveable
 import io.element.android.features.login.impl.util.LoginConstants
 import io.element.android.libraries.architecture.Presenter
-import io.element.android.libraries.core.data.tryOrNull
 import io.element.android.libraries.matrix.api.auth.MatrixAuthenticationService
 import io.element.android.libraries.matrix.api.auth.MatrixHomeServerDetails
 import kotlinx.coroutines.CoroutineScope
@@ -71,15 +70,14 @@ class LoginRootPresenter @Inject constructor(private val authenticationService:
     private fun CoroutineScope.submit(homeserver: String, formState: LoginFormState, loggedInState: MutableState<LoggedInState>) = launch {
         loggedInState.value = LoggedInState.LoggingIn
         //TODO rework the setHomeserver flow
-        tryOrNull {
+        authenticationService.setHomeserver(homeserver)
-            authenticationService.setHomeserver(homeserver)
+        authenticationService.login(formState.login.trim(), formState.password.trim())
-        }
+            .onSuccess { sessionId ->
-        try {
+                loggedInState.value = LoggedInState.LoggedIn(sessionId)
-            val sessionId = authenticationService.login(formState.login.trim(), formState.password.trim())
+            }
-            loggedInState.value = LoggedInState.LoggedIn(sessionId)
+            .onFailure { failure ->
-        } catch (failure: Throwable) {
+                loggedInState.value = LoggedInState.ErrorLoggingIn(failure)
-            loggedInState.value = LoggedInState.ErrorLoggingIn(failure)
+            }
-        }
     }
 
     private fun updateFormState(formState: MutableState<LoginFormState>, updateLambda: LoginFormState.() -> LoginFormState) {

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

@@ -24,6 +24,7 @@ import io.element.android.features.messages.impl.timeline.model.event.TimelineIt
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemTextContent
 import io.element.android.libraries.designsystem.components.avatar.AvatarData
 import io.element.android.libraries.matrix.api.core.EventId
+import io.element.android.libraries.matrix.api.core.UserId
 import io.element.android.libraries.matrix.api.timeline.MatrixTimeline
 import kotlinx.collections.immutable.ImmutableList
 import kotlinx.collections.immutable.persistentListOf
@@ -81,7 +82,7 @@ internal fun aTimelineItemEvent(
     return TimelineItem.Event(
         id = randomId,
         eventId = EventId(randomId),
-        senderId = "@senderId",
+        senderId = UserId("@senderId"),
         senderAvatar = AvatarData("@senderId", "sender"),
         content = content,
         reactionsState = TimelineItemReactions(

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/components/event/TimelineItemEncryptedView.kt

@@ -24,7 +24,7 @@ import androidx.compose.ui.tooling.preview.Preview
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemEncryptedContent
 import io.element.android.libraries.designsystem.preview.ElementPreviewDark
 import io.element.android.libraries.designsystem.preview.ElementPreviewLight
-import org.matrix.rustcomponents.sdk.EncryptedMessage
+import io.element.android.libraries.matrix.api.timeline.item.event.UnableToDecryptContent
 
 @Composable
 fun TimelineItemEncryptedView(
@@ -53,7 +53,7 @@ internal fun TimelineItemEncryptedViewDarkPreview() =
 private fun ContentToPreview() {
     TimelineItemEncryptedView(
         content = TimelineItemEncryptedContent(
-            encryptedMessage = EncryptedMessage.Unknown,
+            data = UnableToDecryptContent.Data.Unknown
         )
     )
 }

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/factories/event/TimelineItemContentFactory.kt

@@ -17,11 +17,20 @@
 package io.element.android.features.messages.impl.timeline.factories.event
 
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemEventContent
-import org.matrix.rustcomponents.sdk.TimelineItemContentKind
+import io.element.android.features.messages.impl.timeline.model.event.TimelineItemUnknownContent
+import io.element.android.libraries.matrix.api.timeline.item.event.FailedToParseMessageLikeContent
+import io.element.android.libraries.matrix.api.timeline.item.event.FailedToParseStateContent
+import io.element.android.libraries.matrix.api.timeline.item.event.MessageContent
+import io.element.android.libraries.matrix.api.timeline.item.event.ProfileChangeContent
+import io.element.android.libraries.matrix.api.timeline.item.event.RedactedContent
+import io.element.android.libraries.matrix.api.timeline.item.event.RoomMembershipContent
+import io.element.android.libraries.matrix.api.timeline.item.event.StateContent
+import io.element.android.libraries.matrix.api.timeline.item.event.StickerContent
+import io.element.android.libraries.matrix.api.timeline.item.event.TimelineEventContent
+import io.element.android.libraries.matrix.api.timeline.item.event.UnableToDecryptContent
+import io.element.android.libraries.matrix.api.timeline.item.event.UnknownContent
 import javax.inject.Inject
 
-typealias RustTimelineItemContent = org.matrix.rustcomponents.sdk.TimelineItemContent
-
 class TimelineItemContentFactory @Inject constructor(
     private val messageFactory: TimelineItemContentMessageFactory,
     private val redactedMessageFactory: TimelineItemContentRedactedFactory,
@@ -34,17 +43,18 @@ class TimelineItemContentFactory @Inject constructor(
     private val failedToParseStateFactory: TimelineItemContentFailedToParseStateFactory
 ) {
 
-    fun create(itemContent: RustTimelineItemContent): TimelineItemEventContent {
+    fun create(itemContent: TimelineEventContent): TimelineItemEventContent {
-        return when (val kind = itemContent.kind()) {
+        return when (itemContent) {
-            is TimelineItemContentKind.Message -> messageFactory.create(itemContent.asMessage())
+            is FailedToParseMessageLikeContent -> failedToParseMessageFactory.create(itemContent)
-            is TimelineItemContentKind.RedactedMessage -> redactedMessageFactory.create(kind)
+            is FailedToParseStateContent -> failedToParseStateFactory.create(itemContent)
-            is TimelineItemContentKind.Sticker -> stickerFactory.create(kind)
+            is MessageContent -> messageFactory.create(itemContent)
-            is TimelineItemContentKind.UnableToDecrypt -> utdFactory.create(kind)
+            is ProfileChangeContent -> profileChangeFactory.create(itemContent)
-            is TimelineItemContentKind.RoomMembership -> roomMembershipFactory.create(kind)
+            is RedactedContent -> redactedMessageFactory.create(itemContent)
-            is TimelineItemContentKind.ProfileChange -> profileChangeFactory.create(kind)
+            is RoomMembershipContent -> roomMembershipFactory.create(itemContent)
-            is TimelineItemContentKind.State -> stateFactory.create(kind)
+            is StateContent -> stateFactory.create(itemContent)
-            is TimelineItemContentKind.FailedToParseMessageLike -> failedToParseMessageFactory.create(kind)
+            is StickerContent -> stickerFactory.create(itemContent)
-            is TimelineItemContentKind.FailedToParseState -> failedToParseStateFactory.create(kind)
+            is UnableToDecryptContent -> utdFactory.create(itemContent)
+            is UnknownContent -> TimelineItemUnknownContent
         }
     }
 }

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/factories/event/TimelineItemContentFailedToParseMessageFactory.kt

@@ -18,12 +18,12 @@ package io.element.android.features.messages.impl.timeline.factories.event
 
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemEventContent
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemUnknownContent
-import org.matrix.rustcomponents.sdk.TimelineItemContentKind
+import io.element.android.libraries.matrix.api.timeline.item.event.FailedToParseMessageLikeContent
 import javax.inject.Inject
 
 class TimelineItemContentFailedToParseMessageFactory @Inject constructor() {
 
-    fun create(kind: TimelineItemContentKind.FailedToParseMessageLike): TimelineItemEventContent {
+    fun create(failedToParseMessageLike: FailedToParseMessageLikeContent): TimelineItemEventContent {
         return TimelineItemUnknownContent
     }
 }

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/factories/event/TimelineItemContentFailedToParseStateFactory.kt

@@ -18,12 +18,12 @@ package io.element.android.features.messages.impl.timeline.factories.event
 
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemEventContent
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemUnknownContent
-import org.matrix.rustcomponents.sdk.TimelineItemContentKind
+import io.element.android.libraries.matrix.api.timeline.item.event.FailedToParseStateContent
 import javax.inject.Inject
 
 class TimelineItemContentFailedToParseStateFactory @Inject constructor() {
 
-    fun create(kind: TimelineItemContentKind.FailedToParseState): TimelineItemEventContent {
+    fun create(failedToParseState: FailedToParseStateContent): TimelineItemEventContent {
         return TimelineItemUnknownContent
     }
 }

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/factories/event/TimelineItemContentMessageFactory.kt

@@ -24,43 +24,46 @@ import io.element.android.features.messages.impl.timeline.model.event.TimelineIt
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemUnknownContent
 import io.element.android.features.messages.impl.timeline.util.toHtmlDocument
 import io.element.android.libraries.matrix.api.media.MediaResolver
-import org.matrix.rustcomponents.sdk.Message
+import io.element.android.libraries.matrix.api.timeline.item.event.EmoteMessageType
-import org.matrix.rustcomponents.sdk.MessageType
+import io.element.android.libraries.matrix.api.timeline.item.event.ImageMessageType
+import io.element.android.libraries.matrix.api.timeline.item.event.MessageContent
+import io.element.android.libraries.matrix.api.timeline.item.event.NoticeMessageType
+import io.element.android.libraries.matrix.api.timeline.item.event.TextMessageType
 import javax.inject.Inject
 
 class TimelineItemContentMessageFactory @Inject constructor() {
 
-    fun create(contentAsMessage: Message?): TimelineItemEventContent {
+    fun create(content: MessageContent): TimelineItemEventContent {
-        return when (val messageType = contentAsMessage?.msgtype()) {
+        return when (val messageType = content.type) {
-            is MessageType.Emote -> TimelineItemEmoteContent(
+            is EmoteMessageType -> TimelineItemEmoteContent(
-                body = messageType.content.body,
+                body = messageType.body,
-                htmlDocument = messageType.content.formatted?.toHtmlDocument()
+                htmlDocument = messageType.formatted?.toHtmlDocument()
             )
-            is MessageType.Image -> {
+            is ImageMessageType -> {
-                val height = messageType.content.info?.height?.toFloat()
+                val height = messageType.info?.height?.toFloat()
-                val width = messageType.content.info?.width?.toFloat()
+                val width = messageType.info?.width?.toFloat()
                 val aspectRatio = if (height != null && width != null) {
                     width / height
                 } else {
                     0.7f
                 }
                 TimelineItemImageContent(
-                    body = messageType.content.body,
+                    body = messageType.body,
                     imageMeta = MediaResolver.Meta(
-                        url = messageType.content.source,
+                        url = messageType.url,
                         kind = MediaResolver.Kind.Content
                     ),
-                    blurhash = messageType.content.info?.blurhash,
+                    blurhash = messageType.info?.blurhash,
                     aspectRatio = aspectRatio
                 )
             }
-            is MessageType.Notice -> TimelineItemNoticeContent(
+            is NoticeMessageType -> TimelineItemNoticeContent(
-                body = messageType.content.body,
+                body = messageType.body,
-                htmlDocument = messageType.content.formatted?.toHtmlDocument()
+                htmlDocument = messageType.formatted?.toHtmlDocument()
             )
-            is MessageType.Text -> TimelineItemTextContent(
+            is TextMessageType -> TimelineItemTextContent(
-                body = messageType.content.body,
+                body = messageType.body,
-                htmlDocument = messageType.content.formatted?.toHtmlDocument()
+                htmlDocument = messageType.formatted?.toHtmlDocument()
             )
             else -> TimelineItemUnknownContent
         }

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/factories/event/TimelineItemContentProfileChangeFactory.kt

@@ -18,12 +18,12 @@ package io.element.android.features.messages.impl.timeline.factories.event
 
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemEventContent
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemUnknownContent
-import org.matrix.rustcomponents.sdk.TimelineItemContentKind
+import io.element.android.libraries.matrix.api.timeline.item.event.ProfileChangeContent
 import javax.inject.Inject
 
 class TimelineItemContentProfileChangeFactory @Inject constructor() {
 
-    fun create(kind: TimelineItemContentKind.ProfileChange): TimelineItemEventContent {
+    fun create(content: ProfileChangeContent): TimelineItemEventContent {
         return TimelineItemUnknownContent
     }
 }

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/factories/event/TimelineItemContentRedactedFactory.kt

@@ -18,12 +18,12 @@ package io.element.android.features.messages.impl.timeline.factories.event
 
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemEventContent
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemRedactedContent
-import org.matrix.rustcomponents.sdk.TimelineItemContentKind
+import io.element.android.libraries.matrix.api.timeline.item.event.RedactedContent
 import javax.inject.Inject
 
 class TimelineItemContentRedactedFactory @Inject constructor() {
 
-    fun create(kind: TimelineItemContentKind.RedactedMessage): TimelineItemEventContent {
+    fun create(content: RedactedContent): TimelineItemEventContent {
         return TimelineItemRedactedContent
     }
 }

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/factories/event/TimelineItemContentRoomMembershipFactory.kt

@@ -18,12 +18,12 @@ package io.element.android.features.messages.impl.timeline.factories.event
 
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemEventContent
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemUnknownContent
-import org.matrix.rustcomponents.sdk.TimelineItemContentKind
+import io.element.android.libraries.matrix.api.timeline.item.event.RoomMembershipContent
 import javax.inject.Inject
 
 class TimelineItemContentRoomMembershipFactory @Inject constructor() {
 
-    fun create(kind: TimelineItemContentKind.RoomMembership): TimelineItemEventContent {
+    fun create(content: RoomMembershipContent): TimelineItemEventContent {
         return TimelineItemUnknownContent
     }
 }

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/factories/event/TimelineItemContentStateFactory.kt

@@ -18,12 +18,12 @@ package io.element.android.features.messages.impl.timeline.factories.event
 
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemEventContent
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemUnknownContent
-import org.matrix.rustcomponents.sdk.TimelineItemContentKind
+import io.element.android.libraries.matrix.api.timeline.item.event.StateContent
 import javax.inject.Inject
 
 class TimelineItemContentStateFactory @Inject constructor() {
 
-    fun create(kind: TimelineItemContentKind.State): TimelineItemEventContent {
+    fun create(content: StateContent): TimelineItemEventContent {
         return TimelineItemUnknownContent
     }
 }

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/factories/event/TimelineItemContentStickerFactory.kt

@@ -18,12 +18,12 @@ package io.element.android.features.messages.impl.timeline.factories.event
 
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemEventContent
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemUnknownContent
-import org.matrix.rustcomponents.sdk.TimelineItemContentKind
+import io.element.android.libraries.matrix.api.timeline.item.event.StickerContent
 import javax.inject.Inject
 
 class TimelineItemContentStickerFactory @Inject constructor() {
 
-    fun create(kind: TimelineItemContentKind.Sticker): TimelineItemEventContent {
+    fun create(content: StickerContent): TimelineItemEventContent {
         return TimelineItemUnknownContent
     }
 }

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/factories/event/TimelineItemContentUTDFactory.kt

@@ -16,14 +16,14 @@
 
 package io.element.android.features.messages.impl.timeline.factories.event
 
-import io.element.android.features.messages.impl.timeline.model.event.TimelineItemEventContent
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemEncryptedContent
-import org.matrix.rustcomponents.sdk.TimelineItemContentKind
+import io.element.android.features.messages.impl.timeline.model.event.TimelineItemEventContent
+import io.element.android.libraries.matrix.api.timeline.item.event.UnableToDecryptContent
 import javax.inject.Inject
 
 class TimelineItemContentUTDFactory @Inject constructor() {
 
-    fun create(kind: TimelineItemContentKind.UnableToDecrypt): TimelineItemEventContent {
+    fun create(content: UnableToDecryptContent): TimelineItemEventContent {
-        return TimelineItemEncryptedContent(kind.msg)
+        return TimelineItemEncryptedContent(content.data)
     }
 }

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/factories/event/TimelineItemEventFactory.kt

@@ -23,8 +23,8 @@ import io.element.android.features.messages.impl.timeline.model.TimelineItemReac
 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.timeline.MatrixTimelineItem
+import io.element.android.libraries.matrix.api.timeline.item.event.ProfileTimelineDetails
 import kotlinx.collections.immutable.toImmutableList
-import org.matrix.rustcomponents.sdk.ProfileTimelineDetails
 import javax.inject.Inject
 
 class TimelineItemEventFactory @Inject constructor(
@@ -36,13 +36,13 @@ class TimelineItemEventFactory @Inject constructor(
         index: Int,
         timelineItems: List<MatrixTimelineItem>,
     ): TimelineItem.Event {
-        val currentSender = currentTimelineItem.event.sender()
+        val currentSender = currentTimelineItem.event.sender
         val groupPosition =
             computeGroupPosition(currentTimelineItem, timelineItems, index)
         val senderDisplayName: String?
         val senderAvatarUrl: String?
 
-        when (val senderProfile = currentTimelineItem.event.senderProfile()) {
+        when (val senderProfile = currentTimelineItem.event.senderProfile) {
             ProfileTimelineDetails.Unavailable,
             ProfileTimelineDetails.Pending,
             is ProfileTimelineDetails.Error -> {
@@ -56,8 +56,8 @@ class TimelineItemEventFactory @Inject constructor(
         }
 
         val senderAvatarData = AvatarData(
-            id = currentSender,
+            id = currentSender.value,
-            name = senderDisplayName ?: currentSender,
+            name = senderDisplayName ?: currentSender.value,
             url = senderAvatarUrl,
             size = AvatarSize.SMALL
         )
@@ -67,15 +67,15 @@ class TimelineItemEventFactory @Inject constructor(
             senderId = currentSender,
             senderDisplayName = senderDisplayName,
             senderAvatar = senderAvatarData,
-            content = contentFactory.create(currentTimelineItem.event.content()),
+            content = contentFactory.create(currentTimelineItem.event.content),
-            isMine = currentTimelineItem.event.isOwn(),
+            isMine = currentTimelineItem.event.isOwn,
             groupPosition = groupPosition,
             reactionsState = currentTimelineItem.computeReactionsState()
         )
     }
 
     private fun MatrixTimelineItem.Event.computeReactionsState(): TimelineItemReactions {
-        val aggregatedReactions = event.reactions().orEmpty().map {
+        val aggregatedReactions = event.reactions.map {
             AggregatedReaction(key = it.key, count = it.count.toString(), isHighlighted = false)
         }
         return TimelineItemReactions(aggregatedReactions.toImmutableList())
@@ -90,9 +90,9 @@ class TimelineItemEventFactory @Inject constructor(
             timelineItems.getOrNull(index - 1) as? MatrixTimelineItem.Event
         val nextTimelineItem =
             timelineItems.getOrNull(index + 1) as? MatrixTimelineItem.Event
-        val currentSender = currentTimelineItem.event.sender()
+        val currentSender = currentTimelineItem.event.sender
-        val previousSender = prevTimelineItem?.event?.sender()
+        val previousSender = prevTimelineItem?.event?.sender
-        val nextSender = nextTimelineItem?.event?.sender()
+        val nextSender = nextTimelineItem?.event?.sender
 
         return when {
             previousSender != currentSender && nextSender == currentSender -> TimelineItemGroupPosition.First

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/factories/virtual/TimelineItemVirtualFactory.kt

@@ -23,7 +23,6 @@ import io.element.android.features.messages.impl.timeline.model.virtual.Timeline
 import io.element.android.features.messages.impl.timeline.model.virtual.TimelineItemVirtualModel
 import io.element.android.libraries.matrix.api.timeline.MatrixTimelineItem
 import io.element.android.libraries.matrix.api.timeline.item.virtual.VirtualTimelineItem
-import org.matrix.rustcomponents.sdk.VirtualTimelineItem
 import javax.inject.Inject
 
 class TimelineItemVirtualFactory @Inject constructor(
@@ -43,10 +42,10 @@ class TimelineItemVirtualFactory @Inject constructor(
 
     private fun MatrixTimelineItem.Virtual.computeModel(index: Int): TimelineItemVirtualModel {
         return when (val inner = virtual) {
-            is io.element.android.libraries.matrix.api.timeline.item.virtual.TimelineItemVirtual.VirtualTimelineItem.DayDivider -> daySeparatorFactory.create(inner)
+            is VirtualTimelineItem.DayDivider -> daySeparatorFactory.create(inner)
-            is io.element.android.libraries.matrix.api.timeline.item.virtual.TimelineItemVirtual.VirtualTimelineItem.ReadMarker -> TimelineItemReadMarkerModel
+            is VirtualTimelineItem.ReadMarker -> TimelineItemReadMarkerModel
-            is io.element.android.libraries.matrix.api.timeline.item.virtual.TimelineItemVirtual.VirtualTimelineItem.LoadingIndicator -> TimelineItemLoadingModel
+            is VirtualTimelineItem.LoadingIndicator -> TimelineItemLoadingModel
-            is io.element.android.libraries.matrix.api.timeline.item.virtual.TimelineItemVirtual.VirtualTimelineItem.TimelineStart -> TimelineItemReadMarkerModel
+            is VirtualTimelineItem.TimelineStart -> TimelineItemReadMarkerModel
             else -> TimelineItemUnknownVirtualModel
         }
     }

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

@@ -21,11 +21,12 @@ import io.element.android.features.messages.impl.timeline.model.event.TimelineIt
 import io.element.android.features.messages.impl.timeline.model.virtual.TimelineItemVirtualModel
 import io.element.android.libraries.designsystem.components.avatar.AvatarData
 import io.element.android.libraries.matrix.api.core.EventId
+import io.element.android.libraries.matrix.api.core.UserId
 
 @Immutable
 sealed interface TimelineItem {
 
-    fun identifier(): String = when(this){
+    fun identifier(): String = when (this) {
         is Event -> id
         is Virtual -> id
     }
@@ -40,7 +41,7 @@ sealed interface TimelineItem {
     data class Event(
         val id: String,
         val eventId: EventId? = null,
-        val senderId: String,
+        val senderId: UserId,
         val senderDisplayName: String?,
         val senderAvatar: AvatarData,
         val content: TimelineItemEventContent,
@@ -52,6 +53,6 @@ sealed interface TimelineItem {
 
         val showSenderInformation = groupPosition.isNew() && !isMine
 
-        val safeSenderName: String = senderDisplayName ?: senderId
+        val safeSenderName: String = senderDisplayName ?: senderId.value
     }
 }

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/model/event/TimelineItemEncryptedContent.kt

@@ -16,8 +16,8 @@
 
 package io.element.android.features.messages.impl.timeline.model.event
 
-import org.matrix.rustcomponents.sdk.EncryptedMessage
+import io.element.android.libraries.matrix.api.timeline.item.event.UnableToDecryptContent
 
 data class TimelineItemEncryptedContent(
-    val encryptedMessage: EncryptedMessage
+    val data: UnableToDecryptContent.Data
 ) : TimelineItemEventContent

features/messages/impl/src/main/kotlin/io/element/android/features/messages/impl/timeline/model/event/TimelineItemEventContentProvider.kt

@@ -17,8 +17,8 @@
 package io.element.android.features.messages.impl.timeline.model.event
 
 import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+import io.element.android.libraries.matrix.api.timeline.item.event.UnableToDecryptContent
 import org.jsoup.Jsoup
-import org.matrix.rustcomponents.sdk.EncryptedMessage
 
 class TimelineItemEventContentProvider : PreviewParameterProvider<TimelineItemEventContent> {
     override val values = sequenceOf(
@@ -49,7 +49,7 @@ fun aTimelineItemEmoteContent() = TimelineItemEmoteContent(
 )
 
 fun aTimelineItemEncryptedContent() = TimelineItemEncryptedContent(
-    encryptedMessage = EncryptedMessage.Unknown
+    data = UnableToDecryptContent.Data.Unknown
 )
 
 fun aTimelineItemNoticeContent() = TimelineItemNoticeContent(

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

@@ -16,10 +16,10 @@
 
 package io.element.android.features.messages.impl.timeline.util
 
+import io.element.android.libraries.matrix.api.timeline.item.event.FormattedBody
+import io.element.android.libraries.matrix.api.timeline.item.event.MessageFormat
 import org.jsoup.Jsoup
 import org.jsoup.nodes.Document
-import org.matrix.rustcomponents.sdk.FormattedBody
-import org.matrix.rustcomponents.sdk.MessageFormat
 
 fun FormattedBody.toHtmlDocument(): Document? {
     return takeIf { it.format == MessageFormat.HTML }?.body?.let { formattedBody ->

libraries/core/src/main/kotlin/io/element/android/libraries/core/extensions/Result.kt

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.libraries.core.extensions
+
+/**
+ * Can be used to transform some Throwable into some other
+ */
+inline fun <R, T : R> Result<T>.mapFailure(transform: (exception: Throwable) -> Throwable): Result<R> {
+    return when (val exception = exceptionOrNull()) {
+        null -> this
+        else -> Result.failure(transform(exception))
+    }
+}

libraries/matrix/api/build.gradle.kts

@@ -32,8 +32,6 @@ anvil {
 }
 
 dependencies {
-    // api(projects.libraries.rustsdk)
-    api(libs.matrix.sdk)
     implementation(projects.libraries.di)
     implementation(libs.dagger)
     implementation(projects.libraries.core)

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

@@ -21,8 +21,6 @@ import io.element.android.libraries.matrix.api.core.SessionId
 import io.element.android.libraries.matrix.api.media.MediaResolver
 import io.element.android.libraries.matrix.api.room.MatrixRoom
 import io.element.android.libraries.matrix.api.room.RoomSummaryDataSource
-import org.matrix.rustcomponents.sdk.MediaSource
-import java.io.Closeable
 
 interface MatrixClient {
     val sessionId: SessionId
@@ -34,9 +32,9 @@ interface MatrixClient {
     suspend fun logout()
     suspend fun loadUserDisplayName(): Result<String>
     suspend fun loadUserAvatarURLString(): Result<String>
-    suspend fun loadMediaContentForSource(source: MediaSource): Result<ByteArray>
+    suspend fun loadMediaContent(url: String): Result<ByteArray>
-    suspend fun loadMediaThumbnailForSource(
+    suspend fun loadMediaThumbnail(
-        source: MediaSource,
+        url: String,
         width: Long,
         height: Long
     ): Result<ByteArray>

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

@@ -16,8 +16,6 @@
 
 package io.element.android.libraries.matrix.api.auth
 
-import org.matrix.rustcomponents.sdk.AuthenticationException
-
 enum class AuthErrorCode(val value: String) {
     UNKNOWN("M_UNKNOWN"),
     USER_DEACTIVATED("M_USER_DEACTIVATED"),

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

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.libraries.matrix.api.auth
+
+sealed class AuthenticationException(message: String) : Exception(message) {
+    class ClientMissing(message: String) : AuthenticationException(message)
+    class InvalidServerName(message: String) : AuthenticationException(message)
+    class SlidingSyncNotAvailable(message: String) : AuthenticationException(message)
+    class SessionMissing(message: String) : AuthenticationException(message)
+    class Generic(message: String) : AuthenticationException(message)
+}

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

@@ -24,8 +24,8 @@ import kotlinx.coroutines.flow.StateFlow
 interface MatrixAuthenticationService {
     fun isLoggedIn(): Flow<Boolean>
     suspend fun getLatestSessionId(): SessionId?
-    suspend fun restoreSession(sessionId: SessionId): MatrixClient?
+    suspend fun restoreSession(sessionId: SessionId): Result<MatrixClient>
     fun getHomeserverDetails(): StateFlow<MatrixHomeServerDetails?>
-    suspend fun setHomeserver(homeserver: String)
+    suspend fun setHomeserver(homeserver: String): Result<Unit>
-    suspend fun login(username: String, password: String): SessionId
+    suspend fun login(username: String, password: String): Result<SessionId>
 }

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

@@ -18,17 +18,10 @@ package io.element.android.libraries.matrix.api.auth
 
 import android.os.Parcelable
 import kotlinx.parcelize.Parcelize
-import org.matrix.rustcomponents.sdk.HomeserverLoginDetails
 
 @Parcelize
 data class MatrixHomeServerDetails(
     val url: String,
     val supportsPasswordLogin: Boolean,
     val authenticationIssuer: String?
-): Parcelable {
+): Parcelable
-    constructor(homeserverLoginDetails: HomeserverLoginDetails) : this(
-        homeserverLoginDetails.url(),
-        homeserverLoginDetails.supportsPasswordLogin(),
-        homeserverLoginDetails.authenticationIssuer()
-    )
-}

libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/api/timeline/item/event/TimelineEventContent.kt

@@ -24,11 +24,11 @@ import io.element.android.libraries.matrix.api.media.VideoInfo
 
 sealed interface TimelineEventContent
 
-data class TimelineEventMessageContent(
+data class MessageContent(
     val body: String,
     val inReplyTo: UserId?,
     val isEdited: Boolean,
-    val content: MessageContent?
+    val type: MessageType?
 ) : TimelineEventContent
 
 object RedactedContent : TimelineEventContent
@@ -39,45 +39,45 @@ data class StickerContent(
     val url: String
 ) : TimelineEventContent
 
-sealed interface EncryptedMessage {
+data class UnableToDecryptContent(
-    data class OlmV1Curve25519AesSha2(
+    val data: Data
-        val senderKey: String
+) : TimelineEventContent {
-    ) : EncryptedMessage
+    sealed interface Data {
+        data class OlmV1Curve25519AesSha2(
+            val senderKey: String
+        ) : Data
 
-    data class MegolmV1AesSha2(
+        data class MegolmV1AesSha2(
-        val sessionId: String
+            val sessionId: String
-    ) : EncryptedMessage
+        ) : Data
 
-    object Unknown : EncryptedMessage
+        object Unknown : Data
+    }
 }
 
-data class UnableToDecryptContent(
+data class RoomMembershipContent(
-    val message: EncryptedMessage
-) : TimelineEventContent
-
-data class RoomMembership(
     val userId: UserId,
     val change: MembershipChange?
 ) : TimelineEventContent
 
-data class ProfileChange(
+data class ProfileChangeContent(
     val displayName: String?,
     val prevDisplayName: String?,
     val avatarUrl: String?,
     val prevAvatarUrl: String?
 ) : TimelineEventContent
 
-data class State(
+data class StateContent(
     val stateKey: String,
     val content: OtherState
 ) : TimelineEventContent
 
-data class FailedToParseMessageLike(
+data class FailedToParseMessageLikeContent(
     val eventType: String,
     val error: String
 ) : TimelineEventContent
 
-data class FailedToParseState(
+data class FailedToParseStateContent(
     val eventType: String,
     val stateKey: String,
     val error: String
@@ -85,9 +85,9 @@ data class FailedToParseState(
 
 object UnknownContent : TimelineEventContent
 
-sealed interface MessageContent
+sealed interface MessageType
 
-object UnknownMessageContent : MessageContent
+object UnknownMessageType : MessageType
 
 enum class MessageFormat {
     HTML, UNKNOWN
@@ -98,44 +98,44 @@ data class FormattedBody(
     val body: String
 )
 
-data class EmoteMessageContent(
+data class EmoteMessageType(
     val body: String,
     val formatted: FormattedBody?
-) : MessageContent
+) : MessageType
 
-data class ImageMessageContent(
+data class ImageMessageType(
     val body: String,
     val url: String,
     val info: ImageInfo?
-) : MessageContent
+) : MessageType
 
-data class AudioMessageContent(
+data class AudioMessageType(
     var body: String,
     var url: String,
     var info: AudioInfo?
-) : MessageContent
+) : MessageType
 
-data class VideoMessageContent(
+data class VideoMessageType(
     val body: String,
     val url: String,
     val info: VideoInfo?
-) : MessageContent
+) : MessageType
 
-data class FileMessageContent(
+data class FileMessageType(
     val body: String,
     val url: String,
     val info: FileInfo?
-) : MessageContent
+) : MessageType
 
-data class NoticeMessageContent(
+data class NoticeMessageType(
     val body: String,
     val formatted: FormattedBody?
-) : MessageContent
+) : MessageType
 
-data class TextMessageContent(
+data class TextMessageType(
     val body: String,
     val formatted: FormattedBody?
-) : MessageContent
+) : MessageType
 
 enum class MembershipChange {
     NONE,

libraries/matrix/impl/build.gradle.kts

@@ -32,7 +32,7 @@ anvil {
 
 dependencies {
     // api(projects.libraries.rustsdk)
-    api(libs.matrix.sdk)
+    implementation(libs.matrix.sdk)
     implementation(projects.libraries.di)
     implementation(projects.libraries.matrix.api)
     implementation(libs.dagger)

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

@@ -32,12 +32,12 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.withContext
 import org.matrix.rustcomponents.sdk.Client
 import org.matrix.rustcomponents.sdk.ClientDelegate
-import org.matrix.rustcomponents.sdk.MediaSource
 import org.matrix.rustcomponents.sdk.RequiredState
 import org.matrix.rustcomponents.sdk.SlidingSyncMode
 import org.matrix.rustcomponents.sdk.SlidingSyncRequestListFilters
 import org.matrix.rustcomponents.sdk.SlidingSyncViewBuilder
 import org.matrix.rustcomponents.sdk.TaskHandle
+import org.matrix.rustcomponents.sdk.mediaSourceFromUrl
 import org.matrix.rustcomponents.sdk.use
 import timber.log.Timber
 import java.io.File
@@ -181,9 +181,9 @@ class RustMatrixClient constructor(
         } catch (failure: Throwable) {
             Timber.e(failure, "Fail to call logout on HS. Still delete local files.")
         }
-        client.destroy()
         baseDirectory.deleteSessionDirectory(userID = client.userId())
         sessionStore.removeSession(client.userId())
+        client.destroy()
     }
 
     override suspend fun loadUserDisplayName(): Result<String> = withContext(dispatchers.io) {
@@ -199,23 +199,30 @@ class RustMatrixClient constructor(
     }
 
     @OptIn(ExperimentalUnsignedTypes::class)
-    override suspend fun loadMediaContentForSource(source: MediaSource): Result<ByteArray> =
+    override suspend fun loadMediaContent(url: String): Result<ByteArray> =
         withContext(dispatchers.io) {
             runCatching {
-                client.getMediaContent(source).toUByteArray().toByteArray()
+                mediaSourceFromUrl(url).use { source ->
+                    client.getMediaContent(source).toUByteArray().toByteArray()
+                }
             }
         }
 
     @OptIn(ExperimentalUnsignedTypes::class)
-    override suspend fun loadMediaThumbnailForSource(
+    override suspend fun loadMediaThumbnail(
-        source: MediaSource,
+        url: String,
         width: Long,
         height: Long
     ): Result<ByteArray> =
         withContext(dispatchers.io) {
             runCatching {
-                client.getMediaThumbnail(source, width.toULong(), height.toULong()).toUByteArray()
+                mediaSourceFromUrl(url).use { source ->
-                    .toByteArray()
+                    client.getMediaThumbnail(
+                        source = source,
+                        width = width.toULong(),
+                        height = height.toULong()
+                    ).toUByteArray().toByteArray()
+                }
             }
         }
 

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

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.libraries.matrix.impl.auth
+
+import io.element.android.libraries.matrix.api.auth.AuthenticationException
+import org.matrix.rustcomponents.sdk.AuthenticationException as RustAuthenticationException
+
+fun Throwable.mapAuthenticationException(): Throwable {
+    return when (this) {
+        is RustAuthenticationException.ClientMissing -> AuthenticationException.ClientMissing(this.message!!)
+        is RustAuthenticationException.Generic -> AuthenticationException.Generic(this.message!!)
+        is RustAuthenticationException.InvalidServerName -> AuthenticationException.InvalidServerName(this.message!!)
+        is RustAuthenticationException.SessionMissing -> AuthenticationException.SessionMissing(this.message!!)
+        is RustAuthenticationException.SlidingSyncNotAvailable -> AuthenticationException.SlidingSyncNotAvailable(this.message!!)
+        else -> this
+    }
+}

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

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.libraries.matrix.impl.auth
+
+import io.element.android.libraries.matrix.api.auth.MatrixHomeServerDetails
+import org.matrix.rustcomponents.sdk.HomeserverLoginDetails
+
+fun HomeserverLoginDetails.map(): MatrixHomeServerDetails = use {
+    MatrixHomeServerDetails(
+        url = url(),
+        supportsPasswordLogin = supportsPasswordLogin(),
+        authenticationIssuer = authenticationIssuer()
+    )
+}

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

@@ -18,6 +18,7 @@ package io.element.android.libraries.matrix.impl.auth
 
 import com.squareup.anvil.annotations.ContributesBinding
 import io.element.android.libraries.core.coroutine.CoroutineDispatchers
+import io.element.android.libraries.core.extensions.mapFailure
 import io.element.android.libraries.di.AppScope
 import io.element.android.libraries.di.SingleIn
 import io.element.android.libraries.matrix.api.MatrixClient
@@ -26,7 +27,6 @@ import io.element.android.libraries.matrix.api.auth.MatrixHomeServerDetails
 import io.element.android.libraries.matrix.api.core.SessionId
 import io.element.android.libraries.matrix.api.core.UserId
 import io.element.android.libraries.matrix.impl.RustMatrixClient
-import io.element.android.libraries.matrix.impl.util.logError
 import io.element.android.libraries.sessionstorage.api.SessionData
 import io.element.android.libraries.sessionstorage.api.SessionStore
 import kotlinx.coroutines.CoroutineScope
@@ -39,7 +39,6 @@ import org.matrix.rustcomponents.sdk.Client
 import org.matrix.rustcomponents.sdk.ClientBuilder
 import org.matrix.rustcomponents.sdk.Session
 import org.matrix.rustcomponents.sdk.use
-import timber.log.Timber
 import java.io.File
 import javax.inject.Inject
 
@@ -63,10 +62,10 @@ class RustMatrixAuthenticationService @Inject constructor(
         sessionStore.getLatestSession()?.userId?.let { UserId(it) }
     }
 
-    override suspend fun restoreSession(sessionId: SessionId) = withContext(coroutineDispatchers.io) {
+    override suspend fun restoreSession(sessionId: SessionId): Result<MatrixClient> = withContext(coroutineDispatchers.io) {
-        val sessionData = sessionStore.getSession(sessionId.value)
+        runCatching {
-        if (sessionData != null) {
+            val sessionData = sessionStore.getSession(sessionId.value)
-            try {
+            if (sessionData != null) {
                 val client = ClientBuilder()
                     .basePath(baseDirectory.absolutePath)
                     .homeserverUrl(sessionData.homeserverUrl)
@@ -74,36 +73,39 @@ class RustMatrixAuthenticationService @Inject constructor(
                     .use { it.build() }
                 client.restoreSession(sessionData.toSession())
                 createMatrixClient(client)
-            } catch (throwable: Throwable) {
+            } else {
-                logError(throwable)
+                throw IllegalStateException("No session to restore with id $sessionId")
-                null
             }
-        } else null
+        }.mapFailure { failure ->
+            failure.mapAuthenticationException()
+        }
     }
 
     override fun getHomeserverDetails(): StateFlow<MatrixHomeServerDetails?> = currentHomeserver
 
-    override suspend fun setHomeserver(homeserver: String) {
+    override suspend fun setHomeserver(homeserver: String): Result<Unit> =
         withContext(coroutineDispatchers.io) {
-            authService.configureHomeserver(homeserver)
+            runCatching {
-            val homeServerDetails = authService.homeserverDetails()?.use { MatrixHomeServerDetails(it) }
+                authService.configureHomeserver(homeserver)
-            if (homeServerDetails != null) {
+                val homeServerDetails = authService.homeserverDetails()?.map()
-                currentHomeserver.value = homeServerDetails.copy(url = homeserver)
+                if (homeServerDetails != null) {
+                    currentHomeserver.value = homeServerDetails.copy(url = homeserver)
+                }
             }
+        }.mapFailure { failure ->
+            failure.mapAuthenticationException()
         }
-    }
 
-    override suspend fun login(username: String, password: String): SessionId =
+    override suspend fun login(username: String, password: String): Result<SessionId> =
         withContext(coroutineDispatchers.io) {
-            val client = try {
+            runCatching {
-                authService.login(username, password, "ElementX Android", null)
+                val client = authService.login(username, password, "ElementX Android", null)
-            } catch (failure: Throwable) {
+                val sessionData = client.use { it.session().toSessionData() }
-                Timber.e(failure, "Fail login")
+                sessionStore.storeData(sessionData)
-                throw failure
+                SessionId(sessionData.userId)
             }
-            val sessionData = client.use { it.session().toSessionData() }
+        }.mapFailure { failure ->
-            sessionStore.storeData(sessionData)
+            failure.mapAuthenticationException()
-            SessionId(sessionData.userId)
         }
 
     private fun createMatrixClient(client: Client): MatrixClient {

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

@@ -18,23 +18,15 @@ package io.element.android.libraries.matrix.impl.media
 
 import io.element.android.libraries.matrix.api.MatrixClient
 import io.element.android.libraries.matrix.api.media.MediaResolver
-import org.matrix.rustcomponents.sdk.MediaSource
-import org.matrix.rustcomponents.sdk.mediaSourceFromUrl
 
 internal class RustMediaResolver(private val client: MatrixClient) : MediaResolver {
 
     override suspend fun resolve(url: String?, kind: MediaResolver.Kind): ByteArray? {
         if (url.isNullOrEmpty()) return null
-        return mediaSourceFromUrl(url).use { mediaSource ->
-            resolve(mediaSource, kind)
-        }
-    }
-
-    private suspend fun resolve(mediaSource: MediaSource, kind: MediaResolver.Kind): ByteArray? {
         return when (kind) {
-            is MediaResolver.Kind.Content -> client.loadMediaContentForSource(mediaSource)
+            is MediaResolver.Kind.Content -> client.loadMediaContent(url)
-            is MediaResolver.Kind.Thumbnail -> client.loadMediaThumbnailForSource(
+            is MediaResolver.Kind.Thumbnail -> client.loadMediaThumbnail(
-                mediaSource,
+                url,
                 kind.width.toLong(),
                 kind.height.toLong()
             )

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/timeline/item/event/EventMessageMapper.kt

@@ -17,17 +17,17 @@
 package io.element.android.libraries.matrix.impl.timeline.item.event
 
 import io.element.android.libraries.matrix.api.core.UserId
-import io.element.android.libraries.matrix.api.timeline.item.event.AudioMessageContent
+import io.element.android.libraries.matrix.api.timeline.item.event.AudioMessageType
-import io.element.android.libraries.matrix.api.timeline.item.event.EmoteMessageContent
+import io.element.android.libraries.matrix.api.timeline.item.event.EmoteMessageType
-import io.element.android.libraries.matrix.api.timeline.item.event.FileMessageContent
+import io.element.android.libraries.matrix.api.timeline.item.event.FileMessageType
 import io.element.android.libraries.matrix.api.timeline.item.event.FormattedBody
-import io.element.android.libraries.matrix.api.timeline.item.event.ImageMessageContent
+import io.element.android.libraries.matrix.api.timeline.item.event.ImageMessageType
 import io.element.android.libraries.matrix.api.timeline.item.event.MessageFormat
-import io.element.android.libraries.matrix.api.timeline.item.event.NoticeMessageContent
+import io.element.android.libraries.matrix.api.timeline.item.event.NoticeMessageType
-import io.element.android.libraries.matrix.api.timeline.item.event.TextMessageContent
+import io.element.android.libraries.matrix.api.timeline.item.event.TextMessageType
-import io.element.android.libraries.matrix.api.timeline.item.event.TimelineEventMessageContent
+import io.element.android.libraries.matrix.api.timeline.item.event.MessageContent
-import io.element.android.libraries.matrix.api.timeline.item.event.UnknownMessageContent
+import io.element.android.libraries.matrix.api.timeline.item.event.UnknownMessageType
-import io.element.android.libraries.matrix.api.timeline.item.event.VideoMessageContent
+import io.element.android.libraries.matrix.api.timeline.item.event.VideoMessageType
 import io.element.android.libraries.matrix.impl.media.map
 import io.element.android.libraries.matrix.impl.media.useUrl
 import org.matrix.rustcomponents.sdk.Message
@@ -38,40 +38,40 @@ import org.matrix.rustcomponents.sdk.MessageFormat as RustMessageFormat
 
 class EventMessageMapper {
 
-    fun map(message: Message): TimelineEventMessageContent = message.use {
+    fun map(message: Message): MessageContent = message.use {
         val content = message.msgtype().use { type ->
             when (type) {
                 is MessageType.Audio -> {
-                    AudioMessageContent(type.content.body, type.content.source.useUrl(), type.content.info?.map())
+                    AudioMessageType(type.content.body, type.content.source.useUrl(), type.content.info?.map())
                 }
                 is MessageType.File -> {
-                    FileMessageContent(type.content.body, type.content.source.useUrl(), type.content.info?.map())
+                    FileMessageType(type.content.body, type.content.source.useUrl(), type.content.info?.map())
                 }
                 is MessageType.Image -> {
-                    ImageMessageContent(type.content.body, type.content.source.useUrl(), type.content.info?.map())
+                    ImageMessageType(type.content.body, type.content.source.useUrl(), type.content.info?.map())
                 }
                 is MessageType.Notice -> {
-                    NoticeMessageContent(type.content.body, type.content.formatted?.map())
+                    NoticeMessageType(type.content.body, type.content.formatted?.map())
                 }
                 is MessageType.Text -> {
-                    TextMessageContent(type.content.body, type.content.formatted?.map())
+                    TextMessageType(type.content.body, type.content.formatted?.map())
                 }
                 is MessageType.Emote -> {
-                    EmoteMessageContent(type.content.body, type.content.formatted?.map())
+                    EmoteMessageType(type.content.body, type.content.formatted?.map())
                 }
                 is MessageType.Video -> {
-                    VideoMessageContent(type.content.body, type.content.source.useUrl(), type.content.info?.map())
+                    VideoMessageType(type.content.body, type.content.source.useUrl(), type.content.info?.map())
                 }
                 null -> {
-                    UnknownMessageContent
+                    UnknownMessageType
                 }
             }
         }
-        TimelineEventMessageContent(
+        MessageContent(
             body = message.body(),
             inReplyTo = message.inReplyTo()?.let { UserId(it) },
             isEdited = message.isEdited(),
-            content = content
+            type = content
         )
     }
 }

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/timeline/item/event/TimelineEventContentMapper.kt

@@ -17,31 +17,33 @@
 package io.element.android.libraries.matrix.impl.timeline.item.event
 
 import io.element.android.libraries.matrix.api.core.UserId
-import io.element.android.libraries.matrix.api.timeline.item.event.FailedToParseMessageLike
+import io.element.android.libraries.matrix.api.timeline.item.event.FailedToParseMessageLikeContent
-import io.element.android.libraries.matrix.api.timeline.item.event.FailedToParseState
+import io.element.android.libraries.matrix.api.timeline.item.event.FailedToParseStateContent
 import io.element.android.libraries.matrix.api.timeline.item.event.MembershipChange
-import io.element.android.libraries.matrix.api.timeline.item.event.ProfileChange
+import io.element.android.libraries.matrix.api.timeline.item.event.ProfileChangeContent
 import io.element.android.libraries.matrix.api.timeline.item.event.RedactedContent
-import io.element.android.libraries.matrix.api.timeline.item.event.RoomMembership
+import io.element.android.libraries.matrix.api.timeline.item.event.RoomMembershipContent
 import io.element.android.libraries.matrix.api.timeline.item.event.StickerContent
 import io.element.android.libraries.matrix.api.timeline.item.event.TimelineEventContent
+import io.element.android.libraries.matrix.api.timeline.item.event.UnableToDecryptContent
 import io.element.android.libraries.matrix.api.timeline.item.event.UnknownContent
 import io.element.android.libraries.matrix.impl.media.map
 import org.matrix.rustcomponents.sdk.TimelineItemContent
 import org.matrix.rustcomponents.sdk.TimelineItemContentKind
+import org.matrix.rustcomponents.sdk.EncryptedMessage as RustEncryptedMessage
 
 class TimelineEventContentMapper(private val eventMessageMapper: EventMessageMapper = EventMessageMapper()) {
 
     fun map(content: TimelineItemContent): TimelineEventContent = content.use {
         when (val kind = content.kind()) {
             is TimelineItemContentKind.FailedToParseMessageLike -> {
-                FailedToParseMessageLike(
+                FailedToParseMessageLikeContent(
                     eventType = kind.eventType,
                     error = kind.error
                 )
             }
             is TimelineItemContentKind.FailedToParseState -> {
-                FailedToParseState(
+                FailedToParseStateContent(
                     eventType = kind.eventType,
                     stateKey = kind.stateKey,
                     error = kind.error
@@ -56,7 +58,7 @@ class TimelineEventContentMapper(private val eventMessageMapper: EventMessageMap
                 }
             }
             is TimelineItemContentKind.ProfileChange -> {
-                ProfileChange(
+                ProfileChangeContent(
                     displayName = kind.displayName,
                     prevDisplayName = kind.prevDisplayName,
                     avatarUrl = kind.avatarUrl,
@@ -67,7 +69,7 @@ class TimelineEventContentMapper(private val eventMessageMapper: EventMessageMap
                 RedactedContent
             }
             is TimelineItemContentKind.RoomMembership -> {
-                RoomMembership(
+                RoomMembershipContent(
                     UserId(kind.userId),
                     MembershipChange.JOINED
                 )
@@ -83,8 +85,18 @@ class TimelineEventContentMapper(private val eventMessageMapper: EventMessageMap
                 )
             }
             is TimelineItemContentKind.UnableToDecrypt -> {
-                UnknownContent
+                UnableToDecryptContent(
+                    data = kind.msg.map()
+                )
             }
         }
     }
 }
+
+private fun RustEncryptedMessage.map(): UnableToDecryptContent.Data {
+    return when (this) {
+        is RustEncryptedMessage.MegolmV1AesSha2 -> UnableToDecryptContent.Data.MegolmV1AesSha2(sessionId)
+        is RustEncryptedMessage.OlmV1Curve25519AesSha2 -> UnableToDecryptContent.Data.OlmV1Curve25519AesSha2(senderKey)
+        RustEncryptedMessage.Unknown -> UnableToDecryptContent.Data.Unknown
+    }
+}

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

@@ -26,7 +26,6 @@ import io.element.android.libraries.matrix.test.media.FakeMediaResolver
 import io.element.android.libraries.matrix.test.room.FakeMatrixRoom
 import io.element.android.libraries.matrix.test.room.FakeRoomSummaryDataSource
 import kotlinx.coroutines.delay
-import org.matrix.rustcomponents.sdk.MediaSource
 
 class FakeMatrixClient(
     override val sessionId: SessionId = A_SESSION_ID,
@@ -66,11 +65,11 @@ class FakeMatrixClient(
         return userAvatarURLString
     }
 
-    override suspend fun loadMediaContentForSource(source: MediaSource): Result<ByteArray> {
+    override suspend fun loadMediaContent(url: String): Result<ByteArray> {
         return Result.success(ByteArray(0))
     }
 
-    override suspend fun loadMediaThumbnailForSource(source: MediaSource, width: Long, height: Long): Result<ByteArray> {
+    override suspend fun loadMediaThumbnail(url: String, width: Long, height: Long): Result<ByteArray> {
         return Result.success(ByteArray(0))
     }
 }

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

@@ -20,7 +20,6 @@ import io.element.android.libraries.matrix.api.MatrixClient
 import io.element.android.libraries.matrix.api.auth.MatrixAuthenticationService
 import io.element.android.libraries.matrix.api.auth.MatrixHomeServerDetails
 import io.element.android.libraries.matrix.api.core.SessionId
-import io.element.android.libraries.matrix.test.A_HOMESERVER
 import io.element.android.libraries.matrix.test.A_USER_ID
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.Flow
@@ -41,8 +40,8 @@ class FakeAuthenticationService : MatrixAuthenticationService {
         return null
     }
 
-    override suspend fun restoreSession(sessionId: SessionId): MatrixClient? {
+    override suspend fun restoreSession(sessionId: SessionId): Result<MatrixClient> {
-        return null
+        return Result.failure(IllegalStateException())
     }
 
     override fun getHomeserverDetails(): StateFlow<MatrixHomeServerDetails?> {
@@ -53,15 +52,16 @@ class FakeAuthenticationService : MatrixAuthenticationService {
         this.homeserver.value = homeserver
     }
 
-    override suspend fun setHomeserver(homeserver: String) {
+    override suspend fun setHomeserver(homeserver: String): Result<Unit> {
         changeServerError?.let { throw it }
         delay(100)
+        return Result.success(Unit)
     }
 
-    override suspend fun login(username: String, password: String): SessionId {
+    override suspend fun login(username: String, password: String): Result<SessionId> {
         delay(100)
         loginError?.let { throw it }
-        return A_USER_ID
+        return Result.success(A_USER_ID)
     }
 
     fun givenLoginError(throwable: Throwable?) {

samples/minimal/build.gradle.kts

@@ -57,5 +57,6 @@ dependencies {
     implementation(projects.features.roomlist.impl)
     implementation(projects.features.login.impl)
     implementation(libs.coroutines.core)
+    implementation(libs.matrix.sdk)
     coreLibraryDesugaring("com.android.tools:desugar_jdk_libs:2.0.2")
 }

samples/minimal/src/main/kotlin/io/element/android/samples/minimal/MainActivity.kt

@@ -72,7 +72,7 @@ class MainActivity : ComponentActivity() {
         } else {
             val matrixClient = runBlocking {
                 val sessionId = matrixAuthenticationService.getLatestSessionId()!!
-                matrixAuthenticationService.restoreSession(sessionId)
+                matrixAuthenticationService.restoreSession(sessionId).getOrNull()
             }
             RoomListScreen(matrixClient = matrixClient!!).Content(modifier)
         }