Restore session

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

@@ -2,6 +2,7 @@ package io.element.android.x.sdk.matrix
 
 import android.content.Context
 import io.element.android.x.sdk.matrix.store.SessionStore
+import io.element.android.x.sdk.matrix.util.logError
 import org.matrix.rustcomponents.sdk.AuthenticationService
 import org.matrix.rustcomponents.sdk.ClientBuilder
 import java.io.File
@@ -9,27 +10,33 @@ import java.io.File
 class Matrix(
     context: Context,
 ) {
-    private val authFolder = File(context.filesDir, "auth")
+    private val baseFolder = File(context.filesDir, "matrix")
     private val sessionStore = SessionStore(context)
 
     suspend fun restoreSession(): MatrixClient? {
         return sessionStore.getStoredData()
             ?.let { sessionData ->
-                val client = ClientBuilder()
-                    .username(sessionData.userId)
-                    .build()
-                client.restoreLogin(sessionData.restoreToken)
-                client
+                try {
+                    val client = ClientBuilder()
+                        .basePath(baseFolder.absolutePath)
+                        .username(sessionData.userId)
+                        .build()
+                    client.restoreLogin(sessionData.restoreToken)
+                    client
+                } catch (throwable: Throwable) {
+                    logError(throwable)
+                    null
+                }
             }?.let {
-                MatrixClient(it)
+                MatrixClient(it, sessionStore)
             }
     }
 
     suspend fun login(homeserver: String, username: String, password: String): MatrixClient {
-        val authService = AuthenticationService(authFolder.absolutePath)
+        val authService = AuthenticationService(baseFolder.absolutePath)
         authService.configureHomeserver(homeserver)
         val client = authService.login(username, password, "MatrixRustSDKSample", null)
-        sessionStore.storeData(SessionStore.SessionData(username, client.restoreToken()))
-        return MatrixClient(client)
+        sessionStore.storeData(SessionStore.SessionData(client.userId(), client.restoreToken()))
+        return MatrixClient(client, sessionStore)
     }
 }

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

@@ -1,11 +1,12 @@
 package io.element.android.x.sdk.matrix
 
 import android.util.Log
-import org.matrix.rustcomponents.sdk.Client
-import org.matrix.rustcomponents.sdk.ClientDelegate
+import io.element.android.x.sdk.matrix.store.SessionStore
+import org.matrix.rustcomponents.sdk.*
 
 class MatrixClient internal constructor(
-    private val client: Client
+    private val client: Client,
+    private val sessionStore: SessionStore,
 ) {
     fun startSync() {
         val clientDelegate = object : ClientDelegate {
@@ -31,7 +32,31 @@ class MatrixClient internal constructor(
         }
     }
 
-    fun logout() {
+    fun slidingSync(onSyncUpdate: (UpdateSummary) -> Unit): StoppableSpawn {
+        val slidingSyncView = SlidingSyncViewBuilder()
+            .timelineLimit(limit = 10u)
+            .requiredState(requiredState = listOf(RequiredState(key = "m.room.avatar", value = "")))
+            .name(name = "HomeScreenView")
+            .syncMode(mode = SlidingSyncMode.FULL_SYNC)
+            .build()
+
+        val slidingSync = client
+            .slidingSync()
+            .homeserver("https://slidingsync.lab.element.dev")
+            .addView(slidingSyncView)
+            .build()
+
+        slidingSync.setObserver(object : SlidingSyncObserver {
+            override fun didReceiveSyncUpdate(summary: UpdateSummary) {
+                Log.v(LOG_TAG, "didReceiveSyncUpdate=$summary")
+                onSyncUpdate.invoke(summary)
+            }
+        })
+        return slidingSync.sync()
+    }
+
+    suspend fun logout() {
         client.logout()
+        sessionStore.reset()
     }
 }

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

@@ -22,6 +22,8 @@ internal class SessionStore(
     private val store = context.dataStore
 
     private val userIdPreference = stringPreferencesKey("userId")
+    // TODO It contains the access token, so it has to be stored in a more secured storage.
+    // I would expect the Rust SDK to provide a more obscure token.
     private val restoreTokenPreference = stringPreferencesKey("restoreToken")
 
     suspend fun storeData(sessionData: SessionData) {

libraries/sdk/matrix/src/main/java/io/element/android/x/sdk/matrix/util/Error.kt

@@ -0,0 +1,16 @@
+package io.element.android.x.sdk.matrix.util
+
+import android.util.Log
+import io.element.android.x.sdk.matrix.LOG_TAG
+import org.matrix.rustcomponents.sdk.ClientException
+
+fun logError(throwable: Throwable) {
+    when (throwable) {
+        is ClientException.Generic -> {
+            Log.e(LOG_TAG, "Error ${throwable.msg}", throwable)
+        }
+        else -> {
+            Log.e(LOG_TAG, "Error", throwable)
+        }
+    }
+}