Add some refactoring and first simple test on RoomListPresenter

app/build.gradle.kts

@@ -32,6 +32,8 @@ plugins {
 android {
     namespace = "io.element.android.x"
 
+    testOptions { unitTests.isIncludeAndroidResources = true }
+
     defaultConfig {
         applicationId = "io.element.android.x"
         targetSdk = 33 // TODO Use Versions.targetSdk

app/src/main/java/io/element/android/x/ElementXApplication.kt

@@ -18,7 +18,7 @@ package io.element.android.x
 
 import android.app.Application
 import androidx.startup.AppInitializer
-import io.element.android.x.core.di.DaggerComponentOwner
+import io.element.android.x.di.DaggerComponentOwner
 import io.element.android.x.di.AppComponent
 import io.element.android.x.di.DaggerAppComponent
 import io.element.android.x.initializer.CrashInitializer

app/src/main/java/io/element/android/x/MainActivity.kt

@@ -26,7 +26,7 @@ import androidx.core.view.WindowCompat
 import com.bumble.appyx.core.integration.NodeHost
 import com.bumble.appyx.core.integrationpoint.NodeComponentActivity
 import io.element.android.x.architecture.bindings
-import io.element.android.x.core.di.DaggerComponentOwner
+import io.element.android.x.di.DaggerComponentOwner
 import io.element.android.x.designsystem.ElementXTheme
 import io.element.android.x.di.AppBindings
 import io.element.android.x.node.RootFlowNode
@@ -47,7 +47,7 @@ class MainActivity : NodeComponentActivity() {
                         RootFlowNode(
                             buildContext = it,
                             appComponentOwner = applicationContext as DaggerComponentOwner,
-                            matrix = appBindings.matrix(),
+                            authenticationService = appBindings.authenticationService(),
                             rootPresenter = appBindings.rootPresenter()
                         )
                     }

app/src/main/java/io/element/android/x/di/AppBindings.kt

@@ -17,7 +17,7 @@
 package io.element.android.x.di
 
 import com.squareup.anvil.annotations.ContributesTo
-import io.element.android.x.matrix.Matrix
+import io.element.android.x.matrix.auth.MatrixAuthenticationService
 import io.element.android.x.root.RootPresenter
 import kotlinx.coroutines.CoroutineScope
 
@@ -25,5 +25,5 @@ import kotlinx.coroutines.CoroutineScope
 interface AppBindings {
     fun coroutineScope(): CoroutineScope
     fun rootPresenter(): RootPresenter
-    fun matrix(): Matrix
+    fun authenticationService(): MatrixAuthenticationService
 }

app/src/main/java/io/element/android/x/di/AppModule.kt

@@ -16,6 +16,7 @@
 
 package io.element.android.x.di
 
+import android.content.Context
 import com.squareup.anvil.annotations.ContributesTo
 import dagger.Module
 import dagger.Provides
@@ -26,12 +27,18 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.MainScope
 import kotlinx.coroutines.asCoroutineDispatcher
 import kotlinx.coroutines.plus
+import java.io.File
 import java.util.concurrent.Executors
 
 @Module
 @ContributesTo(AppScope::class)
 object AppModule {
 
+    @Provides
+    fun providesBaseDirectory(@ApplicationContext context: Context): File {
+        return File(context.filesDir, "sessions")
+    }
+
     @Provides
     @SingleIn(AppScope::class)
     fun providesAppCoroutineScope(): CoroutineScope {

app/src/main/java/io/element/android/x/node/LoggedInFlowNode.kt

@@ -34,7 +34,7 @@ import com.bumble.appyx.navmodel.backstack.BackStack
 import com.bumble.appyx.navmodel.backstack.operation.push
 import io.element.android.x.architecture.bindings
 import io.element.android.x.architecture.createNode
-import io.element.android.x.core.di.DaggerComponentOwner
+import io.element.android.x.di.DaggerComponentOwner
 import io.element.android.x.di.SessionComponent
 import io.element.android.x.features.preferences.PreferencesFlowNode
 import io.element.android.x.features.roomlist.RoomListNode

app/src/main/java/io/element/android/x/node/RoomFlowNode.kt

@@ -27,7 +27,7 @@ import com.bumble.appyx.core.node.ParentNode
 import com.bumble.appyx.navmodel.backstack.BackStack
 import io.element.android.x.architecture.bindings
 import io.element.android.x.architecture.createNode
-import io.element.android.x.core.di.DaggerComponentOwner
+import io.element.android.x.di.DaggerComponentOwner
 import io.element.android.x.di.RoomComponent
 import io.element.android.x.features.messages.MessagesNode
 import io.element.android.x.matrix.room.MatrixRoom

app/src/main/java/io/element/android/x/node/RootFlowNode.kt

@@ -38,10 +38,10 @@ import com.bumble.appyx.navmodel.backstack.operation.pop
 import com.bumble.appyx.navmodel.backstack.operation.push
 import io.element.android.x.architecture.createNode
 import io.element.android.x.architecture.presenterConnector
-import io.element.android.x.core.di.DaggerComponentOwner
+import io.element.android.x.di.DaggerComponentOwner
 import io.element.android.x.features.rageshake.bugreport.BugReportNode
-import io.element.android.x.matrix.Matrix
 import io.element.android.x.matrix.MatrixClient
+import io.element.android.x.matrix.auth.MatrixAuthenticationService
 import io.element.android.x.matrix.core.SessionId
 import io.element.android.x.root.RootPresenter
 import io.element.android.x.root.RootView
@@ -59,7 +59,7 @@ class RootFlowNode(
         savedStateMap = buildContext.savedStateMap,
     ),
     private val appComponentOwner: DaggerComponentOwner,
-    private val matrix: Matrix,
+    private val authenticationService: MatrixAuthenticationService,
     rootPresenter: RootPresenter
 ) :
     ParentNode<RootFlowNode.NavTarget>(
@@ -79,12 +79,12 @@ class RootFlowNode(
                 onDestroy = { matrixClientsHolder.remove(child.sessionId) }
             )
         }
-        matrix.isLoggedIn()
+        authenticationService.isLoggedIn()
             .distinctUntilChanged()
             .onEach { isLoggedIn ->
                 Timber.v("isLoggedIn=$isLoggedIn")
                 if (isLoggedIn) {
-                    val matrixClient = matrix.restoreSession()
+                    val matrixClient = authenticationService.restoreSession()
                     if (matrixClient == null) {
                         backstack.newRoot(NavTarget.NotLoggedInFlow)
                     } else {

build.gradle.kts

@@ -23,7 +23,6 @@ plugins {
     alias(libs.plugins.kotlin.android) apply false
     alias(libs.plugins.ksp) apply false
     alias(libs.plugins.anvil) apply false
-    alias(libs.plugins.molecule) apply false
     alias(libs.plugins.kotlin.jvm) apply false
     alias(libs.plugins.kapt) apply false
     alias(libs.plugins.dependencycheck) apply false

features/login/src/main/java/io/element/android/x/features/login/changeserver/ChangeServerPresenter.kt

@@ -25,18 +25,18 @@ import androidx.compose.runtime.saveable.rememberSaveable
 import io.element.android.x.architecture.Async
 import io.element.android.x.architecture.Presenter
 import io.element.android.x.architecture.execute
-import io.element.android.x.matrix.Matrix
+import io.element.android.x.matrix.auth.MatrixAuthenticationService
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
 import javax.inject.Inject
 
-class ChangeServerPresenter @Inject constructor(private val matrix: Matrix) : Presenter<ChangeServerState> {
+class ChangeServerPresenter @Inject constructor(private val authenticationService: MatrixAuthenticationService) : Presenter<ChangeServerState> {
 
     @Composable
     override fun present(): ChangeServerState {
         val localCoroutineScope = rememberCoroutineScope()
         val homeserver = rememberSaveable {
-            mutableStateOf(matrix.getHomeserverOrDefault())
+            mutableStateOf(authenticationService.getHomeserverOrDefault())
         }
         val changeServerAction: MutableState<Async<Unit>> = remember {
             mutableStateOf(Async.Uninitialized)
@@ -58,7 +58,7 @@ class ChangeServerPresenter @Inject constructor(private val matrix: Matrix) : Pr
 
     private fun CoroutineScope.submit(homeserver: String, changeServerAction: MutableState<Async<Unit>>) = launch {
         suspend {
-            matrix.setHomeserver(homeserver)
+            authenticationService.setHomeserver(homeserver)
         }.execute(changeServerAction)
     }
 }

features/login/src/main/java/io/element/android/x/features/login/root/LoginRootPresenter.kt

@@ -23,18 +23,18 @@ import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.saveable.rememberSaveable
 import io.element.android.x.architecture.Presenter
-import io.element.android.x.matrix.Matrix
+import io.element.android.x.matrix.auth.MatrixAuthenticationService
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
 import javax.inject.Inject
 
-class LoginRootPresenter @Inject constructor(private val matrix: Matrix) : Presenter<LoginRootState> {
+class LoginRootPresenter @Inject constructor(private val authenticationService: MatrixAuthenticationService) : Presenter<LoginRootState> {
 
     @Composable
     override fun present(): LoginRootState {
         val localCoroutineScope = rememberCoroutineScope()
         val homeserver = rememberSaveable {
-            mutableStateOf(matrix.getHomeserverOrDefault())
+            mutableStateOf(authenticationService.getHomeserverOrDefault())
         }
         val loggedInState: MutableState<LoggedInState> = remember {
             mutableStateOf(LoggedInState.NotLoggedIn)
@@ -67,8 +67,8 @@ class LoginRootPresenter @Inject constructor(private val matrix: Matrix) : Prese
     private fun CoroutineScope.submit(homeserver: String, formState: LoginFormState, loggedInState: MutableState<LoggedInState>) = launch {
         loggedInState.value = LoggedInState.LoggingIn
         try {
-            matrix.setHomeserver(homeserver)
-            val sessionId = matrix.login(formState.login.trim(), formState.password.trim())
+            authenticationService.setHomeserver(homeserver)
+            val sessionId = authenticationService.login(formState.login.trim(), formState.password.trim())
             loggedInState.value = LoggedInState.LoggedIn(sessionId)
         } catch (failure: Throwable) {
             loggedInState.value = LoggedInState.ErrorLoggingIn(failure)
@@ -80,6 +80,6 @@ class LoginRootPresenter @Inject constructor(private val matrix: Matrix) : Prese
     }
 
     private fun refreshHomeServer(homeserver: MutableState<String>) {
-        homeserver.value = matrix.getHomeserverOrDefault()
+        homeserver.value = authenticationService.getHomeserverOrDefault()
     }
 }

features/roomlist/build.gradle.kts

@@ -31,8 +31,9 @@ anvil {
 }
 
 dependencies {
-    implementation(project(":anvilannotations"))
     anvil(project(":anvilcodegen"))
+    implementation(project(":anvilannotations"))
+
     implementation(project(":libraries:di"))
     implementation(project(":libraries:core"))
     implementation(project(":libraries:architecture"))
@@ -43,7 +44,15 @@ dependencies {
     implementation(project(":libraries:elementresources"))
     implementation(libs.datetime)
     implementation(libs.accompanist.placeholder)
+
     testImplementation(libs.test.junit)
+    testImplementation(libs.coroutines.test)
+    testImplementation(libs.molecule.runtime)
+    testImplementation(libs.test.truth)
+    testImplementation(libs.test.turbine)
+
     androidTestImplementation(libs.test.junitext)
+
     ksp(libs.showkase.processor)
+
 }

features/roomlist/src/main/java/io/element/android/x/features/roomlist/model/RoomListState.kt

@@ -26,5 +26,5 @@ data class RoomListState(
     val roomList: ImmutableList<RoomListRoomSummary>,
     val filter: String,
     val isLoginOut: Boolean,
-    val eventSink: (RoomListEvents) -> Unit = {}
+    val eventSink: (RoomListEvents) -> Unit
 )

features/roomlist/src/test/java/io/element/android/x/features/roomlist/RoomListPresenterTests.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.x.features.roomlist
+
+import app.cash.molecule.RecompositionClock
+import app.cash.molecule.moleculeFlow
+import app.cash.turbine.test
+import com.google.common.truth.Truth.assertThat
+import io.element.android.x.matrix.FakeMatrixClient
+import io.element.android.x.matrix.core.SessionId
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+class RoomListPresenterTests {
+
+    @Test
+    fun `present - should start with no user and then load user with success`() = runTest {
+
+        val presenter = RoomListPresenter(FakeMatrixClient(SessionId("sessionId")), LastMessageFormatter())
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            assertThat(initialState.matrixUser).isNull()
+            val withUserState = awaitItem()
+            assertThat(withUserState).isNotNull()
+        }
+    }
+}

gradle/libs.versions.toml

@@ -39,6 +39,7 @@ test_junitext = "1.1.3"
 test_barista = "4.2.0"
 test_hamcrest = "2.2"
 test_orchestrator = "1.4.1"
+test_turbine = "0.12.1"
 
 #other
 coil = "2.2.1"
@@ -112,6 +113,9 @@ test_mockk = { module = "io.mockk:mockk", version.ref = "test_mockk" }
 test_barista = { module = "com.adevinta.android:barista", version.ref = "test_barista" }
 test_hamcrest = { module = "org.hamcrest:hamcrest", version.ref = "test_hamcrest" }
 test_orchestrator = { module = "androidx.test:orchestrator", version.ref = "test_orchestrator" }
+test_turbine = { module = "app.cash.turbine:turbine", version.ref = "test_turbine"}
+test_truth = "com.google.truth:truth:1.1.3"
+
 
 # Others
 coil = { module = "io.coil-kt:coil", version.ref = "coil" }
@@ -124,6 +128,7 @@ showkase = { module = "com.airbnb.android:showkase", version.ref = "showkase" }
 showkase_processor = { module = "com.airbnb.android:showkase-processor", version.ref = "showkase" }
 jsoup = { module = "org.jsoup:jsoup", version.ref = "jsoup" }
 appyx_core = {module = "com.bumble.appyx:core", version.ref = "appyx"}
+molecule-runtime = { module = "app.cash.molecule:molecule-runtime", version.ref = "molecule" }
 
 # Di
 inject = { module = "javax.inject:javax.inject", version = "1" }
@@ -147,6 +152,5 @@ ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" }
 anvil = { id = "com.squareup.anvil", version.ref = "anvil" }
 detekt = { id = "io.gitlab.arturbosch.detekt", version.ref = "detekt" }
 ktlint = { id = "org.jlleitschuh.gradle.ktlint", version.ref = "ktlint" }
-molecule = {id = "app.cash.molecule", version.ref = "molecule"}
 dependencygraph = { id = "com.savvasdalkitsis.module-dependency-graph", version.ref = "dependencygraph" }
 dependencycheck = { id = "org.owasp.dependencycheck", version.ref = "dependencycheck" }

libraries/architecture/build.gradle.kts

@@ -18,16 +18,16 @@
 @Suppress("DSL_SCOPE_VIOLATION")
 plugins {
     id("io.element.android-compose-library")
-    alias(libs.plugins.molecule)
 }
 
 android {
-    namespace = "io.element.android.x.libraries.presentation"
+    namespace = "io.element.android.x.libraries.architecture"
 }
 
 dependencies {
-    api(project(":libraries:core"))
+    api(project(":libraries:di"))
     api(libs.dagger)
     api(libs.appyx.core)
+    api(libs.molecule.runtime)
     api(libs.androidx.lifecycle.runtime)
 }

libraries/architecture/src/main/java/io/element/android/x/architecture/Bindings.kt

@@ -19,7 +19,6 @@ package io.element.android.x.architecture
 import android.content.Context
 import android.content.ContextWrapper
 import com.bumble.appyx.core.node.Node
-import io.element.android.x.core.di.DaggerComponentOwner
 
 inline fun <reified T : Any> Node.bindings() = bindings(T::class.java)
 inline fun <reified T : Any> Context.bindings() = bindings(T::class.java)
@@ -28,7 +27,7 @@ fun <T : Any> Context.bindings(klass: Class<T>): T {
     // search dagger components in the context hierarchy
     return generateSequence(this) { (it as? ContextWrapper)?.baseContext }
         .plus(applicationContext)
-        .filterIsInstance<DaggerComponentOwner>()
+        .filterIsInstance<io.element.android.x.di.DaggerComponentOwner>()
         .map { it.daggerComponent }
         .flatMap { if (it is Collection<*>) it else listOf(it) }
         .filterIsInstance(klass)
@@ -39,7 +38,7 @@ fun <T : Any> Context.bindings(klass: Class<T>): T {
 fun <T : Any> Node.bindings(klass: Class<T>): T {
     // search dagger components in node hierarchy
     return generateSequence(this, Node::parent)
-        .filterIsInstance<DaggerComponentOwner>()
+        .filterIsInstance<io.element.android.x.di.DaggerComponentOwner>()
         .map { it.daggerComponent }
         .flatMap { if (it is Collection<*>) it else listOf(it) }
         .filterIsInstance(klass)

libraries/di/src/main/java/io/element/android/x/di/DaggerComponentOwner.kt

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package io.element.android.x.core.di
+package io.element.android.x.di
 
 /**
  * A [DaggerComponentOwner] is anything that "owns" a Dagger Component.

libraries/matrix/src/main/java/io/element/android/x/matrix/FakeMatrixClient.kt

@@ -0,0 +1,69 @@
+/*
+ * 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.x.matrix
+
+import io.element.android.x.matrix.core.RoomId
+import io.element.android.x.matrix.core.SessionId
+import io.element.android.x.matrix.core.UserId
+import io.element.android.x.matrix.media.FakeMediaResolver
+import io.element.android.x.matrix.media.MediaResolver
+import io.element.android.x.matrix.room.FakeMatrixRoom
+import io.element.android.x.matrix.room.InMemoryRoomSummaryDataSource
+import io.element.android.x.matrix.room.MatrixRoom
+import io.element.android.x.matrix.room.RoomSummaryDataSource
+import org.matrix.rustcomponents.sdk.MediaSource
+
+class FakeMatrixClient(override val sessionId: SessionId) : MatrixClient {
+
+    override fun getRoom(roomId: RoomId): MatrixRoom? {
+        return FakeMatrixRoom(roomId)
+    }
+
+    override fun startSync() = Unit
+
+    override fun stopSync() = Unit
+
+    override fun roomSummaryDataSource(): RoomSummaryDataSource {
+        return InMemoryRoomSummaryDataSource()
+    }
+
+    override fun mediaResolver(): MediaResolver {
+        return FakeMediaResolver()
+    }
+
+    override suspend fun logout() = Unit
+
+    override fun userId(): UserId = UserId("")
+
+    override suspend fun loadUserDisplayName(): Result<String> {
+        return Result.success("")
+    }
+
+    override suspend fun loadUserAvatarURLString(): Result<String> {
+        return Result.success("")
+    }
+
+    override suspend fun loadMediaContentForSource(source: MediaSource): Result<ByteArray> {
+        return Result.success(ByteArray(0))
+    }
+
+    override suspend fun loadMediaThumbnailForSource(source: MediaSource, width: Long, height: Long): Result<ByteArray> {
+        return Result.success(ByteArray(0))
+    }
+
+    override fun close() = Unit
+}

libraries/matrix/src/main/java/io/element/android/x/matrix/RustMatrixClient.kt

@@ -26,6 +26,7 @@ import io.element.android.x.matrix.room.MatrixRoom
 import io.element.android.x.matrix.room.RoomSummaryDataSource
 import io.element.android.x.matrix.room.RustMatrixRoom
 import io.element.android.x.matrix.room.RustRoomSummaryDataSource
+import io.element.android.x.matrix.session.PreferencesSessionStore
 import io.element.android.x.matrix.session.SessionStore
 import io.element.android.x.matrix.session.sessionId
 import io.element.android.x.matrix.sync.SlidingSyncObserverProxy

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

libraries/matrix/src/main/java/io/element/android/x/matrix/auth/RustMatrixAuthenticationService.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022 New Vector Ltd
+ * 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.
@@ -14,13 +14,13 @@
  * limitations under the License.
  */
 
-package io.element.android.x.matrix
+package io.element.android.x.matrix.auth
 
-import android.content.Context
+import com.squareup.anvil.annotations.ContributesBinding
 import io.element.android.x.core.coroutine.CoroutineDispatchers
 import io.element.android.x.di.AppScope
-import io.element.android.x.di.ApplicationContext
-import io.element.android.x.di.SingleIn
+import io.element.android.x.matrix.MatrixClient
+import io.element.android.x.matrix.RustMatrixClient
 import io.element.android.x.matrix.core.SessionId
 import io.element.android.x.matrix.session.SessionStore
 import io.element.android.x.matrix.session.sessionId
@@ -35,26 +35,24 @@ import timber.log.Timber
 import java.io.File
 import javax.inject.Inject
 
-@SingleIn(AppScope::class)
-class Matrix @Inject constructor(
+@ContributesBinding(AppScope::class)
+class RustMatrixAuthenticationService @Inject constructor(
+    private val baseDirectory: File,
     private val coroutineScope: CoroutineScope,
     private val coroutineDispatchers: CoroutineDispatchers,
-    @ApplicationContext context: Context,
-) {
+    private val sessionStore: SessionStore,
+    private val authService: AuthenticationService,
+) : MatrixAuthenticationService {
 
-    private val baseDirectory = File(context.filesDir, "sessions")
-    private val sessionStore = SessionStore(context)
-    private val authService = AuthenticationService(baseDirectory.absolutePath)
-
-    fun isLoggedIn(): Flow<Boolean> {
+    override fun isLoggedIn(): Flow<Boolean> {
         return sessionStore.isLoggedIn()
     }
 
-    suspend fun getLatestSessionId(): SessionId? = withContext(coroutineDispatchers.io) {
+    override suspend fun getLatestSessionId(): SessionId? = withContext(coroutineDispatchers.io) {
         sessionStore.getLatestSession()?.sessionId()
     }
 
-    suspend fun restoreSession() = withContext(coroutineDispatchers.io) {
+    override suspend fun restoreSession() = withContext(coroutineDispatchers.io) {
         sessionStore.getLatestSession()
             ?.let { session ->
                 try {
@@ -73,17 +71,17 @@ class Matrix @Inject constructor(
             }
     }
 
-    fun getHomeserver(): String? = authService.homeserverDetails()?.url()
+    override fun getHomeserver(): String? = authService.homeserverDetails()?.url()
 
-    fun getHomeserverOrDefault(): String = getHomeserver() ?: "matrix.org"
+    override fun getHomeserverOrDefault(): String = getHomeserver() ?: "matrix.org"
 
-    suspend fun setHomeserver(homeserver: String) {
+    override suspend fun setHomeserver(homeserver: String) {
         withContext(coroutineDispatchers.io) {
             authService.configureHomeserver(homeserver)
         }
     }
 
-    suspend fun login(username: String, password: String): SessionId =
+    override suspend fun login(username: String, password: String): SessionId =
         withContext(coroutineDispatchers.io) {
             val client = try {
                 authService.login(username, password, "ElementX Android", null)

libraries/matrix/src/main/java/io/element/android/x/matrix/di/MatrixModule.kt

@@ -0,0 +1,36 @@
+/*
+ * 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.x.matrix.di
+
+import com.squareup.anvil.annotations.ContributesTo
+import dagger.Module
+import dagger.Provides
+import io.element.android.x.di.AppScope
+import io.element.android.x.di.SingleIn
+import org.matrix.rustcomponents.sdk.AuthenticationService
+import java.io.File
+
+@Module
+@ContributesTo(AppScope::class)
+object MatrixModule {
+
+    @Provides
+    @SingleIn(AppScope::class)
+    fun providesRustAuthenticationService(baseDirectory: File): AuthenticationService {
+        return AuthenticationService(baseDirectory.absolutePath)
+    }
+}

libraries/matrix/src/main/java/io/element/android/x/matrix/media/FakeMediaResolver.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022 New Vector Ltd
+ * 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.
@@ -14,19 +14,14 @@
  * limitations under the License.
  */
 
-package io.element.android.x.features.roomlist
+package io.element.android.x.matrix.media
 
-import org.junit.Assert.assertEquals
-import org.junit.Test
+class FakeMediaResolver : MediaResolver {
+    override suspend fun resolve(url: String?, kind: MediaResolver.Kind): ByteArray? {
+        return null
+    }
 
-/**
- * Example local unit test, which will execute on the development machine (host).
- *
- * See [testing documentation](http://d.android.com/tools/testing).
- */
-class ExampleUnitTest {
-    @Test
-    fun addition_isCorrect() {
-        assertEquals(4, 2 + 2)
+    override suspend fun resolve(meta: MediaResolver.Meta): ByteArray? {
+        return null
     }
 }

libraries/matrix/src/main/java/io/element/android/x/matrix/room/FakeMatrixRoom.kt

@@ -0,0 +1,66 @@
+/*
+ * 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.x.matrix.room
+
+import io.element.android.x.matrix.core.EventId
+import io.element.android.x.matrix.core.RoomId
+import io.element.android.x.matrix.timeline.FakeMatrixTimeline
+import io.element.android.x.matrix.timeline.MatrixTimeline
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.emptyFlow
+
+class FakeMatrixRoom(
+    override val roomId: RoomId,
+    override val name: String? = null,
+    override val bestName: String = "",
+    override val displayName: String = "",
+    override val topic: String? = null,
+    override val avatarUrl: String? = null
+) : MatrixRoom {
+
+    override fun syncUpdateFlow(): Flow<Long> {
+        return emptyFlow()
+    }
+
+    override fun timeline(): MatrixTimeline {
+        return FakeMatrixTimeline()
+    }
+
+    override suspend fun userDisplayName(userId: String): Result<String?> {
+        return Result.success("")
+    }
+
+    override suspend fun userAvatarUrl(userId: String): Result<String?> {
+        TODO("Not yet implemented")
+    }
+
+    override suspend fun sendMessage(message: String): Result<Unit> {
+        TODO("Not yet implemented")
+    }
+
+    override suspend fun editMessage(originalEventId: EventId, message: String): Result<Unit> {
+        TODO("Not yet implemented")
+    }
+
+    override suspend fun replyMessage(eventId: EventId, message: String): Result<Unit> {
+        TODO("Not yet implemented")
+    }
+
+    override suspend fun redactEvent(eventId: EventId, reason: String?): Result<Unit> {
+        TODO("Not yet implemented")
+    }
+}

libraries/matrix/src/main/java/io/element/android/x/matrix/room/InMemoryRoomSummaryDataSource.kt

@@ -0,0 +1,29 @@
+/*
+ * 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.x.matrix.room
+
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.emptyFlow
+
+class InMemoryRoomSummaryDataSource : RoomSummaryDataSource {
+
+    override fun roomSummaries(): Flow<List<RoomSummary>> {
+        return emptyFlow()
+    }
+
+    override fun setSlidingSyncRange(range: IntRange) = Unit
+}

libraries/matrix/src/main/java/io/element/android/x/matrix/session/PreferencesSessionStore.kt

@@ -0,0 +1,100 @@
+/*
+ * 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.x.matrix.session
+
+import android.content.Context
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.core.stringPreferencesKey
+import androidx.datastore.preferences.preferencesDataStore
+import com.squareup.anvil.annotations.ContributesBinding
+import io.element.android.x.di.AppScope
+import io.element.android.x.di.ApplicationContext
+import io.element.android.x.di.SingleIn
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.firstOrNull
+import kotlinx.coroutines.flow.map
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.decodeFromString
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+import org.matrix.rustcomponents.sdk.Session
+import javax.inject.Inject
+
+private val Context.dataStore: DataStore<Preferences> by preferencesDataStore(name = "elementx_sessions")
+
+// TODO It contains the access token, so it has to be stored in a more secured storage.
+private val sessionKey = stringPreferencesKey("session")
+
+@SingleIn(AppScope::class)
+@ContributesBinding(AppScope::class)
+class PreferencesSessionStore @Inject constructor(
+    @ApplicationContext context: Context
+) : SessionStore {
+    @Serializable
+    data class SessionData(
+        val accessToken: String,
+        val deviceId: String,
+        val homeserverUrl: String,
+        val isSoftLogout: Boolean,
+        val refreshToken: String?,
+        val userId: String
+    )
+
+    private val store = context.dataStore
+
+    override fun isLoggedIn(): Flow<Boolean> {
+        return store.data.map { prefs ->
+            prefs[sessionKey] != null
+        }
+    }
+
+    override suspend fun storeData(session: Session) {
+        store.edit { prefs ->
+            val sessionData = SessionData(
+                accessToken = session.accessToken,
+                deviceId = session.deviceId,
+                homeserverUrl = session.homeserverUrl,
+                isSoftLogout = session.isSoftLogout,
+                refreshToken = session.refreshToken,
+                userId = session.userId
+            )
+            val encodedSession = Json.encodeToString(sessionData)
+            prefs[sessionKey] = encodedSession
+        }
+    }
+
+    override suspend fun getLatestSession(): Session? {
+        return store.data.firstOrNull()?.let { prefs ->
+            val encodedSession = prefs[sessionKey] ?: return@let null
+            val sessionData = Json.decodeFromString<SessionData>(encodedSession)
+            Session(
+                accessToken = sessionData.accessToken,
+                deviceId = sessionData.deviceId,
+                homeserverUrl = sessionData.homeserverUrl,
+                isSoftLogout = sessionData.isSoftLogout,
+                refreshToken = sessionData.refreshToken,
+                userId = sessionData.userId
+            )
+        }
+    }
+
+    override suspend fun reset() {
+        store.edit { it.clear() }
+    }
+}

libraries/matrix/src/main/java/io/element/android/x/matrix/session/SessionStore.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022 New Vector Ltd
+ * 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.
@@ -16,78 +16,12 @@
 
 package io.element.android.x.matrix.session
 
-import android.content.Context
-import androidx.datastore.core.DataStore
-import androidx.datastore.preferences.core.Preferences
-import androidx.datastore.preferences.core.edit
-import androidx.datastore.preferences.core.stringPreferencesKey
-import androidx.datastore.preferences.preferencesDataStore
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.firstOrNull
-import kotlinx.coroutines.flow.map
-import kotlinx.serialization.Serializable
-import kotlinx.serialization.decodeFromString
-import kotlinx.serialization.encodeToString
-import kotlinx.serialization.json.Json
 import org.matrix.rustcomponents.sdk.Session
 
-private val Context.dataStore: DataStore<Preferences> by preferencesDataStore(name = "elementx_sessions")
-
-// TODO It contains the access token, so it has to be stored in a more secured storage.
-private val sessionKey = stringPreferencesKey("session")
-
-internal class SessionStore(
-    context: Context
-) {
-    @Serializable
-    data class SessionData(
-        val accessToken: String,
-        val deviceId: String,
-        val homeserverUrl: String,
-        val isSoftLogout: Boolean,
-        val refreshToken: String?,
-        val userId: String
-    )
-
-    private val store = context.dataStore
-
-    fun isLoggedIn(): Flow<Boolean> {
-        return store.data.map { prefs ->
-            prefs[sessionKey] != null
-        }
-    }
-
-    suspend fun storeData(session: Session) {
-        store.edit { prefs ->
-            val sessionData = SessionData(
-                accessToken = session.accessToken,
-                deviceId = session.deviceId,
-                homeserverUrl = session.homeserverUrl,
-                isSoftLogout = session.isSoftLogout,
-                refreshToken = session.refreshToken,
-                userId = session.userId
-            )
-            val encodedSession = Json.encodeToString(sessionData)
-            prefs[sessionKey] = encodedSession
-        }
-    }
-
-    suspend fun getLatestSession(): Session? {
-        return store.data.firstOrNull()?.let { prefs ->
-            val encodedSession = prefs[sessionKey] ?: return@let null
-            val sessionData = Json.decodeFromString<SessionData>(encodedSession)
-            Session(
-                accessToken = sessionData.accessToken,
-                deviceId = sessionData.deviceId,
-                homeserverUrl = sessionData.homeserverUrl,
-                isSoftLogout = sessionData.isSoftLogout,
-                refreshToken = sessionData.refreshToken,
-                userId = sessionData.userId
-            )
-        }
-    }
-
-    suspend fun reset() {
-        store.edit { it.clear() }
-    }
+interface SessionStore {
+    fun isLoggedIn(): Flow<Boolean>
+    suspend fun storeData(session: Session)
+    suspend fun getLatestSession(): Session?
+    suspend fun reset()
 }

libraries/matrix/src/main/java/io/element/android/x/matrix/timeline/FakeMatrixTimeline.kt

@@ -0,0 +1,60 @@
+/*
+ * 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.x.matrix.timeline
+
+import io.element.android.x.matrix.core.EventId
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.emptyFlow
+import org.matrix.rustcomponents.sdk.TimelineListener
+
+class FakeMatrixTimeline : MatrixTimeline {
+
+    override var callback: MatrixTimeline.Callback?
+        get() = TODO("Not yet implemented")
+        set(value) {}
+
+    override val hasMoreToLoad: Boolean
+        get() = true
+
+    override fun timelineItems(): Flow<List<MatrixTimelineItem>> {
+        return emptyFlow()
+    }
+
+    override suspend fun paginateBackwards(count: Int): Result<Unit> {
+        return Result.success(Unit)
+    }
+
+    override fun addListener(timelineListener: TimelineListener) {
+        //
+    }
+
+    override fun initialize() = Unit
+
+    override fun dispose() = Unit
+
+    override suspend fun sendMessage(message: String): Result<Unit> {
+        return Result.success(Unit)
+    }
+
+    override suspend fun editMessage(originalEventId: EventId, message: String): Result<Unit> {
+        return Result.success(Unit)
+    }
+
+    override suspend fun replyMessage(inReplyToEventId: EventId, message: String): Result<Unit> {
+        return Result.success(Unit)
+    }
+}

plugins/src/main/java/extension/DependencyHandleScope.kt

@@ -40,9 +40,7 @@ fun DependencyHandlerScope.composeDependencies() {
     implementation("androidx.compose.material3:material3")
     implementation("androidx.compose.material:material-icons-extended")
     implementation("androidx.compose.ui:ui-tooling-preview")
-    implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.5.1")
     implementation("androidx.activity:activity-compose:1.6.1")
-    implementation("androidx.lifecycle:lifecycle-viewmodel-compose:2.5.1")
     debugImplementation("androidx.compose.ui:ui-tooling")
     debugImplementation("androidx.compose.ui:ui-test-manifest")
     implementation("com.airbnb.android:showkase:1.0.0-beta14")