Merge pull request #1520 from vector-im/feature/bma/sessionDb

Improve session db and improve deleted session behavior

Author: bmarty

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

@@ -45,6 +45,7 @@ import io.element.android.appnav.root.RootView
 import io.element.android.features.login.api.oidc.OidcAction
 import io.element.android.features.login.api.oidc.OidcActionFlow
 import io.element.android.features.rageshake.api.bugreport.BugReportEntryPoint
+import io.element.android.features.signedout.api.SignedOutEntryPoint
 import io.element.android.libraries.architecture.BackstackNode
 import io.element.android.libraries.architecture.animation.rememberDefaultTransitionHandler
 import io.element.android.libraries.architecture.createNode
@@ -54,6 +55,7 @@ import io.element.android.libraries.designsystem.theme.components.CircularProgre
 import io.element.android.libraries.di.AppScope
 import io.element.android.libraries.matrix.api.auth.MatrixAuthenticationService
 import io.element.android.libraries.matrix.api.core.SessionId
+import io.element.android.libraries.sessionstorage.api.LoggedInState
 import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
@@ -69,6 +71,7 @@ class RootFlowNode @AssistedInject constructor(
     private val matrixClientsHolder: MatrixClientsHolder,
     private val presenter: RootPresenter,
     private val bugReportEntryPoint: BugReportEntryPoint,
+    private val signedOutEntryPoint: SignedOutEntryPoint,
     private val intentResolver: IntentResolver,
     private val oidcActionFlow: OidcActionFlow,
 ) : BackstackNode<RootFlowNode.NavTarget>(
@@ -97,13 +100,20 @@ class RootFlowNode @AssistedInject constructor(
             .distinctUntilChanged()
             .onEach { navState ->
                 Timber.v("navState=$navState")
-                if (navState.isLoggedIn) {
-                    tryToRestoreLatestSession(
-                        onSuccess = { sessionId -> switchToLoggedInFlow(sessionId, navState.cacheIndex) },
-                        onFailure = { switchToNotLoggedInFlow() }
-                    )
-                } else {
-                    switchToNotLoggedInFlow()
+                when (navState.loggedInState) {
+                    is LoggedInState.LoggedIn -> {
+                        if (navState.loggedInState.isTokenValid) {
+                            tryToRestoreLatestSession(
+                                onSuccess = { sessionId -> switchToLoggedInFlow(sessionId, navState.cacheIndex) },
+                                onFailure = { switchToNotLoggedInFlow() }
+                            )
+                        } else {
+                            switchToSignedOutFlow(SessionId(navState.loggedInState.sessionId))
+                        }
+                    }
+                    LoggedInState.NotLoggedIn -> {
+                        switchToNotLoggedInFlow()
+                    }
                 }
             }
             .launchIn(lifecycleScope)
@@ -118,6 +128,10 @@ class RootFlowNode @AssistedInject constructor(
         backstack.safeRoot(NavTarget.NotLoggedInFlow)
     }
 
+    private fun switchToSignedOutFlow(sessionId: SessionId) {
+        backstack.safeRoot(NavTarget.SignedOutFlow(sessionId))
+    }
+
     private suspend fun restoreSessionIfNeeded(
         sessionId: SessionId,
         onFailure: () -> Unit = {},
@@ -179,6 +193,11 @@ class RootFlowNode @AssistedInject constructor(
             val navId: Int
         ) : NavTarget
 
+        @Parcelize
+        data class SignedOutFlow(
+            val sessionId: SessionId
+        ) : NavTarget
+
         @Parcelize
         data object BugReport : NavTarget
     }
@@ -198,6 +217,15 @@ class RootFlowNode @AssistedInject constructor(
                 createNode<LoggedInAppScopeFlowNode>(buildContext, plugins = listOf(inputs, callback))
             }
             NavTarget.NotLoggedInFlow -> createNode<NotLoggedInFlowNode>(buildContext)
+            is NavTarget.SignedOutFlow -> {
+                signedOutEntryPoint.nodeBuilder(this, buildContext)
+                    .params(
+                        SignedOutEntryPoint.Params(
+                            sessionId = navTarget.sessionId
+                        )
+                    )
+                    .build()
+            }
             NavTarget.SplashScreen -> splashNode(buildContext)
             NavTarget.BugReport -> {
                 val callback = object : BugReportEntryPoint.Callback {

appnav/src/main/kotlin/io/element/android/appnav/root/RootNavState.kt

@@ -16,6 +16,8 @@
 
 package io.element.android.appnav.root
 
+import io.element.android.libraries.sessionstorage.api.LoggedInState
+
 /**
  * [RootNavState] produced by [RootNavStateFlowFactory].
  */
@@ -26,7 +28,7 @@ data class RootNavState(
      */
     val cacheIndex: Int,
     /**
-     * true if we are currently loggedIn.
+     * LoggedInState.
      */
-    val isLoggedIn: Boolean
+    val loggedInState: LoggedInState,
 )

appnav/src/main/kotlin/io/element/android/appnav/root/RootNavStateFlowFactory.kt

@@ -22,9 +22,9 @@ import io.element.android.appnav.di.MatrixClientsHolder
 import io.element.android.features.login.api.LoginUserStory
 import io.element.android.features.preferences.api.CacheService
 import io.element.android.libraries.matrix.api.auth.MatrixAuthenticationService
+import io.element.android.libraries.sessionstorage.api.LoggedInState
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.combine
-import kotlinx.coroutines.flow.distinctUntilChanged
 import kotlinx.coroutines.flow.flow
 import kotlinx.coroutines.flow.onEach
 import javax.inject.Inject
@@ -47,9 +47,14 @@ class RootNavStateFlowFactory @Inject constructor(
     fun create(savedStateMap: SavedStateMap?): Flow<RootNavState> {
         return combine(
             cacheIndexFlow(savedStateMap),
-            isUserLoggedInFlow(),
-        ) { cacheIndex, isLoggedIn ->
-            RootNavState(cacheIndex = cacheIndex, isLoggedIn = isLoggedIn)
+            authenticationService.loggedInStateFlow(),
+            loginUserStory.loginFlowIsDone,
+        ) { cacheIndex, loggedInState, loginFlowIsDone ->
+            if (loginFlowIsDone) {
+                RootNavState(cacheIndex = cacheIndex, loggedInState = loggedInState)
+            } else {
+                RootNavState(cacheIndex = cacheIndex, loggedInState = LoggedInState.NotLoggedIn)
+            }
         }
     }
 
@@ -72,16 +77,6 @@ class RootNavStateFlowFactory @Inject constructor(
             }
     }
 
-    private fun isUserLoggedInFlow(): Flow<Boolean> {
-        return combine(
-            authenticationService.isLoggedIn(),
-            loginUserStory.loginFlowIsDone
-        ) { isLoggedIn, loginFlowIsDone ->
-            isLoggedIn && loginFlowIsDone
-        }
-            .distinctUntilChanged()
-    }
-
     /**
      * @return a flow of integer that increments the value by one each time a new element is emitted upstream.
      */

changelog.d/1520.feature

@@ -0,0 +1 @@
+Improve deleted session behavior.

features/signedout/api/build.gradle.kts

@@ -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.
+ */
+
+plugins {
+    id("io.element.android-library")
+}
+
+android {
+    namespace = "io.element.android.features.signedout.api"
+}
+
+dependencies {
+    implementation(projects.libraries.architecture)
+    implementation(projects.libraries.matrix.api)
+}

features/signedout/api/src/main/kotlin/io/element/android/features/signedout/api/SignedOutEntryPoint.kt

@@ -0,0 +1,37 @@
+/*
+ * 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.features.signedout.api
+
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import io.element.android.libraries.architecture.FeatureEntryPoint
+import io.element.android.libraries.matrix.api.core.SessionId
+
+interface SignedOutEntryPoint : FeatureEntryPoint {
+
+    data class Params(
+        val sessionId: SessionId,
+    )
+
+    fun nodeBuilder(parentNode: Node, buildContext: BuildContext): NodeBuilder
+
+    interface NodeBuilder {
+        fun params(params: Params): NodeBuilder
+        fun build(): Node
+    }
+}
+

features/signedout/impl/build.gradle.kts

@@ -0,0 +1,53 @@
+/*
+ * 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.
+ */
+
+plugins {
+    id("io.element.android-compose-library")
+    alias(libs.plugins.anvil)
+    alias(libs.plugins.ksp)
+    id("kotlin-parcelize")
+}
+
+android {
+    namespace = "io.element.android.features.signedout.impl"
+}
+
+anvil {
+    generateDaggerFactories.set(true)
+}
+
+dependencies {
+    implementation(projects.anvilannotations)
+    anvil(projects.anvilcodegen)
+    api(projects.features.signedout.api)
+    implementation(projects.libraries.core)
+    implementation(projects.libraries.architecture)
+    implementation(projects.libraries.matrix.api)
+    implementation(projects.libraries.matrixui)
+    implementation(projects.libraries.designsystem)
+    implementation(projects.libraries.uiStrings)
+
+    testImplementation(libs.test.junit)
+    testImplementation(libs.coroutines.test)
+    testImplementation(libs.molecule.runtime)
+    testImplementation(libs.test.truth)
+    testImplementation(libs.test.turbine)
+    testImplementation(projects.libraries.matrix.test)
+    testImplementation(projects.libraries.sessionStorage.implMemory)
+    testImplementation(projects.tests.testutils)
+
+    ksp(libs.showkase.processor)
+}

features/signedout/impl/src/main/kotlin/io/element/android/features/signedout/impl/DefaultSignedOutEntryPoint.kt

@@ -0,0 +1,46 @@
+/*
+ * 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.features.signedout.impl
+
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.plugin.Plugin
+import com.squareup.anvil.annotations.ContributesBinding
+import io.element.android.features.signedout.api.SignedOutEntryPoint
+import io.element.android.libraries.architecture.createNode
+import io.element.android.libraries.di.AppScope
+import javax.inject.Inject
+
+@ContributesBinding(AppScope::class)
+class DefaultSignedOutEntryPoint @Inject constructor() : SignedOutEntryPoint {
+
+    override fun nodeBuilder(parentNode: Node, buildContext: BuildContext): SignedOutEntryPoint.NodeBuilder {
+        val plugins = ArrayList<Plugin>()
+
+        return object : SignedOutEntryPoint.NodeBuilder {
+
+            override fun params(params: SignedOutEntryPoint.Params): SignedOutEntryPoint.NodeBuilder {
+                plugins += SignedOutNode.Inputs(params.sessionId)
+                return this
+            }
+
+            override fun build(): Node {
+                return parentNode.createNode<SignedOutNode>(buildContext, plugins)
+            }
+        }
+    }
+}

features/signedout/impl/src/main/kotlin/io/element/android/features/signedout/impl/SignedOutEvents.kt

@@ -0,0 +1,21 @@
+/*
+ * 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.features.signedout.impl
+
+sealed interface SignedOutEvents {
+    data object SignInAgain : SignedOutEvents
+}