Split module matrix to matrix.api with interfaces and data classes and matrix.impl with Rust implementation.

libraries/matrix/api/src/main/AndroidManifest.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (c) 2022 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.
+  -->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <uses-permission android:name="android.permission.INTERNET" />
+
+</manifest>

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

@@ -0,0 +1,43 @@
+/*
+ * 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
+
+import io.element.android.libraries.matrix.core.RoomId
+import io.element.android.libraries.matrix.core.SessionId
+import io.element.android.libraries.matrix.media.MediaResolver
+import io.element.android.libraries.matrix.room.MatrixRoom
+import io.element.android.libraries.matrix.room.RoomSummaryDataSource
+import org.matrix.rustcomponents.sdk.MediaSource
+import java.io.Closeable
+
+interface MatrixClient : Closeable {
+    val sessionId: SessionId
+    fun getRoom(roomId: RoomId): MatrixRoom?
+    fun startSync()
+    fun stopSync()
+    fun roomSummaryDataSource(): RoomSummaryDataSource
+    fun mediaResolver(): MediaResolver
+    suspend fun logout()
+    suspend fun loadUserDisplayName(): Result<String>
+    suspend fun loadUserAvatarURLString(): Result<String>
+    suspend fun loadMediaContentForSource(source: MediaSource): Result<ByteArray>
+    suspend fun loadMediaThumbnailForSource(
+        source: MediaSource,
+        width: Long,
+        height: Long
+    ): Result<ByteArray>
+}

libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/auth/MatrixAuthenticationService.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.auth
+
+import io.element.android.libraries.matrix.MatrixClient
+import io.element.android.libraries.matrix.core.SessionId
+import kotlinx.coroutines.flow.Flow
+
+interface MatrixAuthenticationService {
+    fun isLoggedIn(): Flow<Boolean>
+    suspend fun getLatestSessionId(): SessionId?
+    suspend fun restoreSession(sessionId: SessionId): MatrixClient?
+    fun getHomeserver(): String?
+    fun getHomeserverOrDefault(): String
+    suspend fun setHomeserver(homeserver: String)
+    suspend fun login(username: String, password: String): SessionId
+}

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

@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2022 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.core
+
+import java.io.Serializable
+
+@JvmInline
+value class EventId(val value: String) : Serializable

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

@@ -0,0 +1,201 @@
+/*
+ * 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.core
+
+import io.element.android.libraries.matrix.api.BuildConfig
+import timber.log.Timber
+
+/**
+ * This class contains pattern to match the different Matrix ids
+ * Ref: https://matrix.org/docs/spec/appendices#identifier-grammar
+ */
+object MatrixPatterns {
+
+    // Note: TLD is not mandatory (localhost, IP address...)
+    private const val DOMAIN_REGEX = ":[A-Z0-9.-]+(:[0-9]{2,5})?"
+
+    // regex pattern to find matrix user ids in a string.
+    // See https://matrix.org/docs/spec/appendices#historical-user-ids
+    private const val MATRIX_USER_IDENTIFIER_REGEX = "@[A-Z0-9\\x21-\\x39\\x3B-\\x7F]+$DOMAIN_REGEX"
+    val PATTERN_CONTAIN_MATRIX_USER_IDENTIFIER = MATRIX_USER_IDENTIFIER_REGEX.toRegex(RegexOption.IGNORE_CASE)
+
+    // regex pattern to find room ids in a string.
+    private const val MATRIX_ROOM_IDENTIFIER_REGEX = "![A-Z0-9]+$DOMAIN_REGEX"
+    private val PATTERN_CONTAIN_MATRIX_ROOM_IDENTIFIER = MATRIX_ROOM_IDENTIFIER_REGEX.toRegex(RegexOption.IGNORE_CASE)
+
+    // regex pattern to find room aliases in a string.
+    private const val MATRIX_ROOM_ALIAS_REGEX = "#[A-Z0-9._%#@=+-]+$DOMAIN_REGEX"
+    private val PATTERN_CONTAIN_MATRIX_ALIAS = MATRIX_ROOM_ALIAS_REGEX.toRegex(RegexOption.IGNORE_CASE)
+
+    // regex pattern to find message ids in a string.
+    private const val MATRIX_EVENT_IDENTIFIER_REGEX = "\\$[A-Z0-9]+$DOMAIN_REGEX"
+    private val PATTERN_CONTAIN_MATRIX_EVENT_IDENTIFIER = MATRIX_EVENT_IDENTIFIER_REGEX.toRegex(RegexOption.IGNORE_CASE)
+
+    // regex pattern to find message ids in a string.
+    private const val MATRIX_EVENT_IDENTIFIER_V3_REGEX = "\\$[A-Z0-9/+]+"
+    private val PATTERN_CONTAIN_MATRIX_EVENT_IDENTIFIER_V3 = MATRIX_EVENT_IDENTIFIER_V3_REGEX.toRegex(RegexOption.IGNORE_CASE)
+
+    // Ref: https://matrix.org/docs/spec/rooms/v4#event-ids
+    private const val MATRIX_EVENT_IDENTIFIER_V4_REGEX = "\\$[A-Z0-9\\-_]+"
+    private val PATTERN_CONTAIN_MATRIX_EVENT_IDENTIFIER_V4 = MATRIX_EVENT_IDENTIFIER_V4_REGEX.toRegex(RegexOption.IGNORE_CASE)
+
+    // regex pattern to find group ids in a string.
+    private const val MATRIX_GROUP_IDENTIFIER_REGEX = "\\+[A-Z0-9=_\\-./]+$DOMAIN_REGEX"
+    private val PATTERN_CONTAIN_MATRIX_GROUP_IDENTIFIER = MATRIX_GROUP_IDENTIFIER_REGEX.toRegex(RegexOption.IGNORE_CASE)
+
+    // regex pattern to find permalink with message id.
+    // Android does not support in URL so extract it.
+    private const val PERMALINK_BASE_REGEX = "https://matrix\\.to/#/"
+    private const val APP_BASE_REGEX = "https://[A-Z0-9.-]+\\.[A-Z]{2,}/[A-Z]{3,}/#/room/"
+    const val SEP_REGEX = "/"
+
+    private const val LINK_TO_ROOM_ID_REGEXP = PERMALINK_BASE_REGEX + MATRIX_ROOM_IDENTIFIER_REGEX + SEP_REGEX + MATRIX_EVENT_IDENTIFIER_REGEX
+    private val PATTERN_CONTAIN_MATRIX_TO_PERMALINK_ROOM_ID = LINK_TO_ROOM_ID_REGEXP.toRegex(RegexOption.IGNORE_CASE)
+
+    private const val LINK_TO_ROOM_ALIAS_REGEXP = PERMALINK_BASE_REGEX + MATRIX_ROOM_ALIAS_REGEX + SEP_REGEX + MATRIX_EVENT_IDENTIFIER_REGEX
+    private val PATTERN_CONTAIN_MATRIX_TO_PERMALINK_ROOM_ALIAS = LINK_TO_ROOM_ALIAS_REGEXP.toRegex(RegexOption.IGNORE_CASE)
+
+    private const val LINK_TO_APP_ROOM_ID_REGEXP = APP_BASE_REGEX + MATRIX_ROOM_IDENTIFIER_REGEX + SEP_REGEX + MATRIX_EVENT_IDENTIFIER_REGEX
+    private val PATTERN_CONTAIN_APP_LINK_PERMALINK_ROOM_ID = LINK_TO_APP_ROOM_ID_REGEXP.toRegex(RegexOption.IGNORE_CASE)
+
+    private const val LINK_TO_APP_ROOM_ALIAS_REGEXP = APP_BASE_REGEX + MATRIX_ROOM_ALIAS_REGEX + SEP_REGEX + MATRIX_EVENT_IDENTIFIER_REGEX
+    private val PATTERN_CONTAIN_APP_LINK_PERMALINK_ROOM_ALIAS = LINK_TO_APP_ROOM_ALIAS_REGEXP.toRegex(RegexOption.IGNORE_CASE)
+
+    // ascii characters in the range \x20 (space) to \x7E (~)
+    val ORDER_STRING_REGEX = "[ -~]+".toRegex()
+
+    // list of patterns to find some matrix item.
+    val MATRIX_PATTERNS = listOf(
+        PATTERN_CONTAIN_MATRIX_TO_PERMALINK_ROOM_ID,
+        PATTERN_CONTAIN_MATRIX_TO_PERMALINK_ROOM_ALIAS,
+        PATTERN_CONTAIN_APP_LINK_PERMALINK_ROOM_ID,
+        PATTERN_CONTAIN_APP_LINK_PERMALINK_ROOM_ALIAS,
+        PATTERN_CONTAIN_MATRIX_USER_IDENTIFIER,
+        PATTERN_CONTAIN_MATRIX_ALIAS,
+        PATTERN_CONTAIN_MATRIX_ROOM_IDENTIFIER,
+        PATTERN_CONTAIN_MATRIX_EVENT_IDENTIFIER,
+        PATTERN_CONTAIN_MATRIX_GROUP_IDENTIFIER
+    )
+
+    /**
+     * Tells if a string is a valid user Id.
+     *
+     * @param str the string to test
+     * @return true if the string is a valid user id
+     */
+    fun isUserId(str: String?): Boolean {
+        return str != null && str matches PATTERN_CONTAIN_MATRIX_USER_IDENTIFIER
+    }
+
+    /**
+     * Tells if a string is a valid room id.
+     *
+     * @param str the string to test
+     * @return true if the string is a valid room Id
+     */
+    fun isRoomId(str: String?): Boolean {
+        return str != null && str matches PATTERN_CONTAIN_MATRIX_ROOM_IDENTIFIER
+    }
+
+    /**
+     * Tells if a string is a valid room alias.
+     *
+     * @param str the string to test
+     * @return true if the string is a valid room alias.
+     */
+    fun isRoomAlias(str: String?): Boolean {
+        return str != null && str matches PATTERN_CONTAIN_MATRIX_ALIAS
+    }
+
+    /**
+     * Tells if a string is a valid event id.
+     *
+     * @param str the string to test
+     * @return true if the string is a valid event id.
+     */
+    fun isEventId(str: String?): Boolean {
+        return str != null &&
+            (str matches PATTERN_CONTAIN_MATRIX_EVENT_IDENTIFIER ||
+                str matches PATTERN_CONTAIN_MATRIX_EVENT_IDENTIFIER_V3 ||
+                str matches PATTERN_CONTAIN_MATRIX_EVENT_IDENTIFIER_V4)
+    }
+
+    /**
+     * Tells if a string is a valid group id.
+     *
+     * @param str the string to test
+     * @return true if the string is a valid group id.
+     */
+    fun isGroupId(str: String?): Boolean {
+        return str != null && str matches PATTERN_CONTAIN_MATRIX_GROUP_IDENTIFIER
+    }
+
+    /**
+     * Extract server name from a matrix id.
+     *
+     * @param matrixId
+     * @return null if not found or if matrixId is null
+     */
+    fun extractServerNameFromId(matrixId: String?): String? {
+        return matrixId?.substringAfter(":", missingDelimiterValue = "")?.takeIf { it.isNotEmpty() }
+    }
+
+    /**
+     * Extract user name from a matrix id.
+     *
+     * @param matrixId
+     * @return null if the input is not a valid matrixId
+     */
+    fun extractUserNameFromId(matrixId: String): String? {
+        return if (isUserId(matrixId)) {
+            matrixId.removePrefix("@").substringBefore(":", missingDelimiterValue = "")
+        } else {
+            null
+        }
+    }
+
+    /**
+     * Orders which are not strings, or do not consist solely of ascii characters in the range \x20 (space) to \x7E (~),
+     * or consist of more than 50 characters, are forbidden and the field should be ignored if received.
+     */
+    fun isValidOrderString(order: String?): Boolean {
+        return order != null && order.length < 50 && order matches ORDER_STRING_REGEX
+    }
+
+    /*
+    fun candidateAliasFromRoomName(roomName: String, domain: String): String {
+        return roomName.lowercase()
+                .replaceSpaceChars(replacement = "_")
+                .removeInvalidRoomNameChars()
+                .take(MatrixConstants.maxAliasLocalPartLength(domain))
+    }
+     */
+
+    /**
+     * Return the domain form a userId.
+     * Examples:
+     * - "@alice:domain.org".getDomain() will return "domain.org"
+     * - "@bob:domain.org:3455".getDomain() will return "domain.org:3455"
+     */
+    fun String.getServerName(): String {
+        if (BuildConfig.DEBUG && !isUserId(this)) {
+            // They are some invalid userId localpart in the wild, but the domain part should be there anyway
+            Timber.w("Not a valid user ID: $this")
+        }
+        return substringAfter(":")
+    }
+}

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

@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2022 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.core
+
+import java.io.Serializable
+
+@JvmInline
+value class RoomId(val value: String) : Serializable

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

@@ -0,0 +1,19 @@
+/*
+ * 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.core
+
+typealias SessionId = UserId

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

@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2022 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.core
+
+import java.io.Serializable
+
+@JvmInline
+value class UserId(val value: String) : Serializable

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

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2022 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.media
+
+import org.matrix.rustcomponents.sdk.MediaSource
+
+interface MediaResolver {
+
+    sealed interface Kind {
+        data class Thumbnail(val width: Int, val height: Int) : Kind {
+            constructor(size: Int) : this(size, size)
+        }
+
+        object Content : Kind
+    }
+
+    data class Meta(
+        val source: MediaSource?,
+        val kind: Kind
+    )
+
+    suspend fun resolve(url: String?, kind: Kind): ByteArray?
+
+    suspend fun resolve(meta: Meta): ByteArray?
+}

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

@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2022 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.permalink
+
+import android.net.Uri
+
+/**
+ * Mapping of an input URI to a matrix.to compliant URI.
+ */
+object MatrixToConverter {
+
+    const val MATRIX_TO_URL_BASE = "https://matrix.to/#/"
+
+    /**
+     * Try to convert a URL from an element web instance or from a client permalink to a matrix.to url.
+     * To be successfully converted, URL path should contain one of the [SUPPORTED_PATHS].
+     * Examples:
+     * - https://riot.im/develop/#/room/#element-android:matrix.org  ->  https://matrix.to/#/#element-android:matrix.org
+     * - https://app.element.io/#/room/#element-android:matrix.org   ->  https://matrix.to/#/#element-android:matrix.org
+     * - https://www.example.org/#/room/#element-android:matrix.org  ->  https://matrix.to/#/#element-android:matrix.org
+     */
+    fun convert(uri: Uri): Uri? {
+        val uriString = uri.toString()
+
+        return when {
+            // URL is already a matrix.to
+            uriString.startsWith(MATRIX_TO_URL_BASE) -> uri
+            // Web or client url
+            SUPPORTED_PATHS.any { it in uriString } -> {
+                val path = SUPPORTED_PATHS.first { it in uriString }
+                Uri.parse(MATRIX_TO_URL_BASE + uriString.substringAfter(path))
+            }
+            // URL is not supported
+            else -> null
+        }
+    }
+
+    private val SUPPORTED_PATHS = listOf(
+        "/#/room/",
+        "/#/user/",
+        "/#/group/"
+    )
+}

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

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2022 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.permalink
+
+import android.net.Uri
+
+/**
+ * This sealed class represents all the permalink cases.
+ * You don't have to instantiate yourself but should use [PermalinkParser] instead.
+ */
+sealed class PermalinkData {
+
+    data class RoomLink(
+        val roomIdOrAlias: String,
+        val isRoomAlias: Boolean,
+        val eventId: String?,
+        val viaParameters: List<String>
+    ) : PermalinkData()
+
+    /*
+     * &room_name=Team2
+     * &room_avatar_url=mxc:
+     * &inviter_name=bob
+     */
+    data class RoomEmailInviteLink(
+        val roomId: String,
+        val email: String,
+        val signUrl: String,
+        val roomName: String?,
+        val roomAvatarUrl: String?,
+        val inviterName: String?,
+        val identityServer: String,
+        val token: String,
+        val privateKey: String,
+        val roomType: String?
+    ) : PermalinkData()
+
+    data class UserLink(val userId: String) : PermalinkData()
+
+    data class FallbackLink(val uri: Uri, val isLegacyGroupLink: Boolean = false) : PermalinkData()
+}

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

@@ -0,0 +1,144 @@
+/*
+ * 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.permalink
+
+import android.net.Uri
+import android.net.UrlQuerySanitizer
+import io.element.android.libraries.matrix.core.MatrixPatterns
+import timber.log.Timber
+import java.net.URLDecoder
+
+/**
+ * This class turns a uri to a [PermalinkData].
+ * element-based domains (e.g. https://app.element.io/#/user/@chagai95:matrix.org) permalinks
+ * or matrix.to permalinks (e.g. https://matrix.to/#/@chagai95:matrix.org)
+ * or client permalinks (e.g. <clientPermalinkBaseUrl>user/@chagai95:matrix.org)
+ */
+object PermalinkParser {
+
+    /**
+     * Turns a uri string to a [PermalinkData].
+     */
+    fun parse(uriString: String): PermalinkData {
+        val uri = Uri.parse(uriString)
+        return parse(uri)
+    }
+
+    /**
+     * Turns a uri to a [PermalinkData].
+     * https://github.com/matrix-org/matrix-doc/blob/master/proposals/1704-matrix.to-permalinks.md
+     */
+    fun parse(uri: Uri): PermalinkData {
+        // the client or element-based domain permalinks (e.g. https://app.element.io/#/user/@chagai95:matrix.org) don't have the
+        // mxid in the first param (like matrix.to does - https://matrix.to/#/@chagai95:matrix.org) but rather in the second after /user/ so /user/mxid
+        // so convert URI to matrix.to to simplify parsing process
+        val matrixToUri = MatrixToConverter.convert(uri) ?: return PermalinkData.FallbackLink(uri)
+
+        // We can't use uri.fragment as it is decoding to early and it will break the parsing
+        // of parameters that represents url (like signurl)
+        val fragment = matrixToUri.toString().substringAfter("#") // uri.fragment
+        if (fragment.isEmpty()) {
+            return PermalinkData.FallbackLink(uri)
+        }
+        val safeFragment = fragment.substringBefore('?')
+        val viaQueryParameters = fragment.getViaParameters()
+
+        // we are limiting to 2 params
+        val params = safeFragment
+            .split(MatrixPatterns.SEP_REGEX)
+            .filter { it.isNotEmpty() }
+            .take(2)
+
+        val decodedParams = params
+            .map { URLDecoder.decode(it, "UTF-8") }
+
+        val identifier = params.getOrNull(0)
+        val decodedIdentifier = decodedParams.getOrNull(0)
+        val extraParameter = decodedParams.getOrNull(1)
+        return when {
+            identifier.isNullOrEmpty() || decodedIdentifier.isNullOrEmpty() -> PermalinkData.FallbackLink(uri)
+            MatrixPatterns.isUserId(decodedIdentifier) -> PermalinkData.UserLink(userId = decodedIdentifier)
+            MatrixPatterns.isRoomId(decodedIdentifier) -> {
+                handleRoomIdCase(fragment, decodedIdentifier, matrixToUri, extraParameter, viaQueryParameters)
+            }
+            MatrixPatterns.isRoomAlias(decodedIdentifier) -> {
+                PermalinkData.RoomLink(
+                    roomIdOrAlias = decodedIdentifier,
+                    isRoomAlias = true,
+                    eventId = extraParameter.takeIf { !it.isNullOrEmpty() && MatrixPatterns.isEventId(it) },
+                    viaParameters = viaQueryParameters
+                )
+            }
+            else -> PermalinkData.FallbackLink(uri, MatrixPatterns.isGroupId(identifier))
+        }
+    }
+
+    private fun handleRoomIdCase(fragment: String, identifier: String, uri: Uri, extraParameter: String?, viaQueryParameters: List<String>): PermalinkData {
+        // Can't rely on built in parsing because it's messing around the signurl
+        val paramList = safeExtractParams(fragment)
+        val signUrl = paramList.firstOrNull { it.first == "signurl" }?.second
+        val email = paramList.firstOrNull { it.first == "email" }?.second
+        return if (signUrl.isNullOrEmpty().not() && email.isNullOrEmpty().not()) {
+            try {
+                val signValidUri = Uri.parse(signUrl)
+                val identityServerHost = signValidUri.authority ?: throw IllegalArgumentException()
+                val token = signValidUri.getQueryParameter("token") ?: throw IllegalArgumentException()
+                val privateKey = signValidUri.getQueryParameter("private_key") ?: throw IllegalArgumentException()
+                PermalinkData.RoomEmailInviteLink(
+                    roomId = identifier,
+                    email = email!!,
+                    signUrl = signUrl!!,
+                    roomName = paramList.firstOrNull { it.first == "room_name" }?.second,
+                    inviterName = paramList.firstOrNull { it.first == "inviter_name" }?.second,
+                    roomAvatarUrl = paramList.firstOrNull { it.first == "room_avatar_url" }?.second,
+                    roomType = paramList.firstOrNull { it.first == "room_type" }?.second,
+                    identityServer = identityServerHost,
+                    token = token,
+                    privateKey = privateKey
+                )
+            } catch (failure: Throwable) {
+                Timber.i("## Permalink: Failed to parse permalink $signUrl")
+                PermalinkData.FallbackLink(uri)
+            }
+        } else {
+            PermalinkData.RoomLink(
+                roomIdOrAlias = identifier,
+                isRoomAlias = false,
+                eventId = extraParameter.takeIf { !it.isNullOrEmpty() && MatrixPatterns.isEventId(it) },
+                viaParameters = viaQueryParameters
+            )
+        }
+    }
+
+    private fun safeExtractParams(fragment: String) =
+        fragment.substringAfter("?").split('&').mapNotNull {
+            val splitNameValue = it.split("=")
+            if (splitNameValue.size == 2) {
+                Pair(splitNameValue[0], URLDecoder.decode(splitNameValue[1], "UTF-8"))
+            } else null
+        }
+
+    private fun String.getViaParameters(): List<String> {
+        return UrlQuerySanitizer(this)
+            .parameterList
+            .filter {
+                it.mParameter == "via"
+            }.map {
+                URLDecoder.decode(it.mValue, "UTF-8")
+            }
+    }
+}

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

@@ -0,0 +1,49 @@
+/*
+ * 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.room
+
+import io.element.android.libraries.matrix.core.EventId
+import io.element.android.libraries.matrix.core.RoomId
+import io.element.android.libraries.matrix.timeline.MatrixTimeline
+import kotlinx.coroutines.flow.Flow
+
+interface MatrixRoom {
+    val roomId: RoomId
+    val name: String?
+    val bestName: String
+    val displayName: String
+    val topic: String?
+    val avatarUrl: String?
+
+    fun syncUpdateFlow(): Flow<Long>
+
+    fun timeline(): MatrixTimeline
+
+    suspend fun fetchMembers(): Result<Unit>
+
+    suspend fun userDisplayName(userId: String): Result<String?>
+
+    suspend fun userAvatarUrl(userId: String): Result<String?>
+
+    suspend fun sendMessage(message: String): Result<Unit>
+
+    suspend fun editMessage(originalEventId: EventId, message: String): Result<Unit>
+
+    suspend fun replyMessage(eventId: EventId, message: String): Result<Unit>
+
+    suspend fun redactEvent(eventId: EventId, reason: String? = null): Result<Unit>
+}

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

@@ -0,0 +1,41 @@
+/*
+ * 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.room
+
+import io.element.android.libraries.matrix.core.RoomId
+
+sealed interface RoomSummary {
+    data class Empty(val identifier: String) : RoomSummary
+    data class Filled(val details: RoomSummaryDetails) : RoomSummary
+
+    fun identifier(): String {
+        return when (this) {
+            is Empty -> identifier
+            is Filled -> details.roomId.value
+        }
+    }
+}
+
+data class RoomSummaryDetails(
+    val roomId: RoomId,
+    val name: String,
+    val isDirect: Boolean,
+    val avatarURLString: String?,
+    val lastMessage: CharSequence?,
+    val lastMessageTimestamp: Long?,
+    val unreadNotificationCount: Int,
+)

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

@@ -0,0 +1,24 @@
+/*
+ * 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.room
+
+import kotlinx.coroutines.flow.StateFlow
+
+interface RoomSummaryDataSource {
+    fun roomSummaries(): StateFlow<List<RoomSummary>>
+    fun setSlidingSyncRange(range: IntRange)
+}

libraries/matrix/api/src/main/kotlin/io/element/android/libraries/matrix/room/message/RoomMessage.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.matrix.room.message
+
+import io.element.android.libraries.matrix.core.EventId
+import io.element.android.libraries.matrix.core.UserId
+
+data class RoomMessage(
+    val eventId: EventId,
+    val body: String,
+    val sender: UserId,
+    val originServerTs: Long,
+)

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

@@ -0,0 +1,45 @@
+/*
+ * 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.timeline
+
+import io.element.android.libraries.matrix.core.EventId
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.StateFlow
+
+interface MatrixTimeline {
+
+    data class PaginationState(
+        val isBackPaginating: Boolean,
+        val canBackPaginate: Boolean
+    )
+
+    fun paginationState(): StateFlow<PaginationState>
+
+    fun timelineItems(): Flow<List<MatrixTimelineItem>>
+    suspend fun paginateBackwards(requestSize: Int, untilNumberOfItems: Int): Result<Unit>
+    fun initialize()
+    fun dispose()
+
+    /**
+     * @param message markdown message
+     */
+    suspend fun sendMessage(message: String): Result<Unit>
+
+    suspend fun editMessage(originalEventId: EventId, message: String): Result<Unit>
+
+    suspend fun replyMessage(inReplyToEventId: EventId, message: String): Result<Unit>
+}

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

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2022 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.timeline
+
+import io.element.android.libraries.matrix.core.EventId
+import org.matrix.rustcomponents.sdk.EventTimelineItem
+import org.matrix.rustcomponents.sdk.VirtualTimelineItem
+
+sealed interface MatrixTimelineItem {
+    data class Event(val event: EventTimelineItem) : MatrixTimelineItem {
+        val uniqueId: String = event.uniqueIdentifier()
+        val eventId: EventId? = event.eventId()?.let { EventId(it) }
+    }
+
+    data class Virtual(val virtual: VirtualTimelineItem) : MatrixTimelineItem
+    object Other : MatrixTimelineItem
+}
+

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

@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2022 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.tracing
+
+import timber.log.Timber
+
+data class TracingConfiguration(
+    val overrides: Map<Target, LogLevel> = emptyMap()
+) {
+
+    // Order should matters
+    private val targets: MutableMap<Target, LogLevel> = mutableMapOf(
+        Target.Common to LogLevel.Warn,
+        Target.Hyper to LogLevel.Warn,
+        Target.Sled to LogLevel.Warn,
+        Target.MatrixSdk.Root to LogLevel.Warn,
+        Target.MatrixSdk.Sled to LogLevel.Warn,
+        Target.MatrixSdk.Crypto to LogLevel.Debug,
+        Target.MatrixSdk.HttpClient to LogLevel.Debug,
+        Target.MatrixSdk.SlidingSync to LogLevel.Trace,
+        Target.MatrixSdk.BaseSlidingSync to LogLevel.Trace,
+    )
+
+    val filter: String
+        get() {
+            overrides.forEach { (target, logLevel) ->
+                targets[target] = logLevel
+            }
+            return targets.map {
+                if (it.key.filter.isEmpty()) {
+                    it.value.filter
+                } else {
+                    "${it.key.filter}=${it.value.filter}"
+                }
+            }.joinToString(separator = ",")
+        }
+}
+
+sealed class Target(open val filter: String) {
+    object Common : Target("")
+    object Hyper : Target("hyper")
+    object Sled : Target("sled")
+    sealed class MatrixSdk(override val filter: String) : Target(filter) {
+        object Root : MatrixSdk("matrix_sdk")
+        object Sled : MatrixSdk("matrix_sdk_sled")
+        object Crypto: MatrixSdk("matrix_sdk_crypto")
+        object FFI : MatrixSdk("matrix_sdk_ffi")
+        object HttpClient : MatrixSdk("matrix_sdk::http_client")
+        object UniffiAPI : MatrixSdk("matrix_sdk_ffi::uniffi_api")
+        object SlidingSync : MatrixSdk("matrix_sdk::sliding_sync")
+        object BaseSlidingSync : MatrixSdk("matrix_sdk_base::sliding_sync")
+    }
+}
+
+sealed class LogLevel(val filter: String) {
+    object Warn : LogLevel("warn")
+    object Trace : LogLevel("trace")
+    object Info : LogLevel("info")
+    object Debug : LogLevel("debug")
+    object Error : LogLevel("error")
+}
+
+object TracingConfigurations {
+    val release = TracingConfiguration(overrides = mapOf(Target.Common to LogLevel.Info))
+    val debug = TracingConfiguration(overrides = mapOf(Target.Common to LogLevel.Info))
+
+    fun custom(overrides: Map<Target, LogLevel>) = TracingConfiguration(overrides)
+}