[Architecture] : create appnav module so we can use only api feature modules

appnav/build.gradle.kts

@@ -0,0 +1,62 @@
+/*
+ * 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.
+ */
+
+@file:Suppress("UnstableApiUsage")
+
+// TODO: Remove once https://youtrack.jetbrains.com/issue/KTIJ-19369 is fixed
+@Suppress("DSL_SCOPE_VIOLATION")
+plugins {
+    id("io.element.android-compose-library")
+    alias(libs.plugins.anvil)
+    alias(libs.plugins.ksp)
+    alias(libs.plugins.kapt)
+    id("kotlin-parcelize")
+}
+
+android {
+    namespace = "io.element.android.appnav"
+
+}
+
+dependencies {
+    implementation(projects.anvilannotations)
+    anvil(projects.anvilcodegen)
+    implementation(libs.dagger)
+    kapt(libs.dagger.compiler)
+
+    implementation(projects.features.messages.api)
+    implementation(projects.features.roomlist)
+    implementation(projects.features.rageshake)
+    implementation(projects.features.login)
+    implementation(projects.features.preferences)
+    implementation(projects.features.logout)
+    implementation(projects.features.onboarding)
+
+    implementation(projects.libraries.core)
+    implementation(projects.libraries.architecture)
+    implementation(projects.libraries.matrix)
+    implementation(projects.libraries.designsystem)
+    implementation(projects.libraries.matrixui)
+    implementation(projects.tests.uitests)
+    implementation(libs.coil)
+
+    testImplementation(libs.test.junit)
+    testImplementation(libs.coroutines.test)
+    testImplementation(libs.molecule.runtime)
+    testImplementation(libs.test.truth)
+    testImplementation(libs.test.turbine)
+    testImplementation(projects.libraries.matrixtest)
+}

appnav/src/main/kotlin/io/element/android/appnav/BackstackExt.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.appnav
+
+import com.bumble.appyx.navmodel.backstack.BackStack
+import com.bumble.appyx.navmodel.backstack.operation.NewRoot
+
+/**
+ * Don't process NewRoot if the nav target already exists in the stack.
+ */
+fun <T : Any> BackStack<T>.safeRoot(element: T) {
+    val containsRoot = elements.value.any {
+        it.key.navTarget == element
+    }
+    if (containsRoot) return
+    accept(NewRoot(element))
+}

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

@@ -0,0 +1,162 @@
+/*
+ * 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.appnav
+
+import android.os.Parcelable
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import coil.Coil
+import com.bumble.appyx.core.composable.Children
+import com.bumble.appyx.core.lifecycle.subscribe
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.node.node
+import com.bumble.appyx.core.plugin.Plugin
+import com.bumble.appyx.core.plugin.plugins
+import com.bumble.appyx.navmodel.backstack.BackStack
+import com.bumble.appyx.navmodel.backstack.operation.push
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedInject
+import io.element.android.anvilannotations.ContributesNode
+import io.element.android.features.preferences.api.PreferencesEntryPoint
+import io.element.android.features.roomlist.api.RoomListEntryPoint
+import io.element.android.libraries.architecture.BackstackNode
+import io.element.android.libraries.architecture.NodeInputs
+import io.element.android.libraries.architecture.animation.rememberDefaultTransitionHandler
+import io.element.android.libraries.architecture.bindings
+import io.element.android.libraries.architecture.createNode
+import io.element.android.libraries.architecture.nodeInputs
+import io.element.android.libraries.architecture.nodeInputsProvider
+import io.element.android.libraries.designsystem.theme.components.Text
+import io.element.android.libraries.di.AppScope
+import io.element.android.libraries.matrix.MatrixClient
+import io.element.android.libraries.matrix.core.RoomId
+import io.element.android.libraries.matrix.ui.di.MatrixUIBindings
+import kotlinx.parcelize.Parcelize
+
+@ContributesNode(AppScope::class)
+class LoggedInFlowNode @AssistedInject constructor(
+    @Assisted buildContext: BuildContext,
+    @Assisted plugins: List<Plugin>,
+    private val roomListEntryPoint: RoomListEntryPoint,
+    private val preferencesEntryPoint: PreferencesEntryPoint,
+) : BackstackNode<LoggedInFlowNode.NavTarget>(
+    backstack = BackStack(
+        initialElement = NavTarget.RoomList,
+        savedStateMap = buildContext.savedStateMap,
+    ),
+    buildContext = buildContext,
+    plugins = plugins
+) {
+
+    interface Callback : Plugin {
+        fun onOpenBugReport() = Unit
+    }
+
+    interface LifecycleCallback : NodeLifecycleCallback {
+        fun onFlowCreated(client: MatrixClient) = Unit
+
+        fun onFlowReleased(client: MatrixClient) = Unit
+    }
+
+    data class Inputs(
+        val matrixClient: MatrixClient
+    ) : NodeInputs
+
+    private val inputs: Inputs by nodeInputs()
+
+    override fun onBuilt() {
+        super.onBuilt()
+        lifecycle.subscribe(
+            onCreate = {
+                plugins<LifecycleCallback>().forEach { it.onFlowCreated(inputs.matrixClient) }
+                val imageLoaderFactory = bindings<MatrixUIBindings>().loggedInImageLoaderFactory()
+                Coil.setImageLoader(imageLoaderFactory)
+                inputs.matrixClient.startSync()
+            },
+            onDestroy = {
+                val imageLoaderFactory = bindings<MatrixUIBindings>().notLoggedInImageLoaderFactory()
+                Coil.setImageLoader(imageLoaderFactory)
+                plugins<LifecycleCallback>().forEach { it.onFlowReleased(inputs.matrixClient) }
+            }
+        )
+    }
+
+    sealed interface NavTarget : Parcelable {
+        @Parcelize
+        object RoomList : NavTarget
+
+        @Parcelize
+        data class Room(val roomId: RoomId) : NavTarget
+
+        @Parcelize
+        object Settings : NavTarget
+    }
+
+    override fun resolve(navTarget: NavTarget, buildContext: BuildContext): Node {
+        return when (navTarget) {
+            NavTarget.RoomList -> {
+                val callback = object : RoomListEntryPoint.Callback {
+                    override fun onRoomClicked(roomId: RoomId) {
+                        backstack.push(NavTarget.Room(roomId))
+                    }
+
+                    override fun onSettingsClicked() {
+                        backstack.push(NavTarget.Settings)
+                    }
+                }
+                roomListEntryPoint.node(this, buildContext, plugins = listOf(callback))
+            }
+            is NavTarget.Room -> {
+                val room = inputs.matrixClient.getRoom(roomId = navTarget.roomId)
+                if (room == null) {
+                    // TODO CREATE UNKNOWN ROOM NODE
+                    node(buildContext) {
+                        Box(modifier = it.fillMaxSize(), contentAlignment = Alignment.Center) {
+                            Text(text = "Unknown room with id = ${navTarget.roomId}")
+                        }
+                    }
+                } else {
+                    val nodeLifecycleCallbacks = plugins<NodeLifecycleCallback>()
+                    val inputsProvider = nodeInputsProvider(RoomFlowNode.Inputs(room))
+                    createNode<RoomFlowNode>(buildContext, plugins = listOf(inputsProvider) + nodeLifecycleCallbacks)
+                }
+            }
+            NavTarget.Settings -> {
+                val callback = object : PreferencesEntryPoint.Callback {
+                    override fun onOpenBugReport() {
+                        plugins<Callback>().forEach { it.onOpenBugReport() }
+                    }
+                }
+                preferencesEntryPoint.node(this, buildContext, plugins = listOf(callback))
+            }
+        }
+    }
+
+    @Composable
+    override fun View(modifier: Modifier) {
+        Children(
+            navModel = backstack,
+            modifier = modifier,
+            // Animate navigation to settings and to a room
+            transitionHandler = rememberDefaultTransitionHandler(),
+        )
+    }
+}

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

@@ -0,0 +1,79 @@
+/*
+ * 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.appnav
+
+import android.os.Bundle
+import io.element.android.libraries.di.AppScope
+import io.element.android.libraries.di.SingleIn
+import io.element.android.libraries.matrix.MatrixClient
+import io.element.android.libraries.matrix.auth.MatrixAuthenticationService
+import io.element.android.libraries.matrix.core.SessionId
+import kotlinx.coroutines.runBlocking
+import timber.log.Timber
+import java.util.concurrent.ConcurrentHashMap
+import javax.inject.Inject
+
+private const val SAVE_INSTANCE_KEY = "io.element.android.x.di.MatrixClientsHolder.SaveInstanceKey"
+
+@SingleIn(AppScope::class)
+class MatrixClientsHolder @Inject constructor(private val authenticationService: MatrixAuthenticationService) {
+
+    private val sessionIdsToMatrixClient = ConcurrentHashMap<SessionId, MatrixClient>()
+
+    fun add(matrixClient: MatrixClient) {
+        sessionIdsToMatrixClient[matrixClient.sessionId] = matrixClient
+    }
+
+    fun removeAll() {
+        sessionIdsToMatrixClient.clear()
+    }
+
+    fun remove(sessionId: SessionId) {
+        sessionIdsToMatrixClient.remove(sessionId)
+    }
+
+    fun isEmpty(): Boolean = sessionIdsToMatrixClient.isEmpty()
+
+    fun knowSession(sessionId: SessionId): Boolean = sessionIdsToMatrixClient.containsKey(sessionId)
+
+    fun getOrNull(sessionId: SessionId): MatrixClient? {
+        return sessionIdsToMatrixClient[sessionId]
+    }
+
+    @Suppress("DEPRECATION")
+    fun restore(savedInstanceState: Bundle?) {
+        if (savedInstanceState == null || sessionIdsToMatrixClient.isNotEmpty()) return
+        val sessionIds = savedInstanceState.getSerializable(SAVE_INSTANCE_KEY) as? Array<SessionId>
+        if (sessionIds.isNullOrEmpty()) return
+        // Not ideal but should only happens in case of process recreation. This ensure we restore all the active sessions before restoring the node graphs.
+        runBlocking {
+            sessionIds.forEach { sessionId ->
+                Timber.v("Restore matrix session: $sessionId")
+                val matrixClient = authenticationService.restoreSession(sessionId)
+                if (matrixClient != null) {
+                    add(matrixClient)
+                }
+            }
+        }
+    }
+
+    fun onSaveInstanceState(outState: Bundle) {
+        val sessionKeys = sessionIdsToMatrixClient.keys.toTypedArray()
+        Timber.v("Save matrix session keys = $sessionKeys")
+        outState.putSerializable(SAVE_INSTANCE_KEY, sessionKeys)
+    }
+}

appnav/src/main/kotlin/io/element/android/appnav/NodeLifecycleCallback.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.appnav
+
+import com.bumble.appyx.core.plugin.Plugin
+
+interface NodeLifecycleCallback : Plugin

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

@@ -0,0 +1,98 @@
+/*
+ * 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.appnav
+
+import android.os.Parcelable
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import com.bumble.appyx.core.composable.Children
+import com.bumble.appyx.core.lifecycle.subscribe
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.plugin.Plugin
+import com.bumble.appyx.navmodel.backstack.BackStack
+import com.bumble.appyx.navmodel.backstack.operation.push
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedInject
+import io.element.android.anvilannotations.ContributesNode
+import io.element.android.features.login.api.LoginEntryPoint
+import io.element.android.features.onboarding.api.OnBoardingEntryPoint
+import io.element.android.libraries.architecture.BackstackNode
+import io.element.android.libraries.architecture.animation.rememberDefaultTransitionHandler
+import io.element.android.libraries.di.AppScope
+import kotlinx.parcelize.Parcelize
+import timber.log.Timber
+
+@ContributesNode(AppScope::class)
+class NotLoggedInFlowNode @AssistedInject constructor(
+    @Assisted buildContext: BuildContext,
+    @Assisted plugins: List<Plugin>,
+    private val onBoardingEntryPoint: OnBoardingEntryPoint,
+    private val loginEntryPoint: LoginEntryPoint,
+) : BackstackNode<NotLoggedInFlowNode.NavTarget>(
+    backstack = BackStack(
+        initialElement = NavTarget.OnBoarding,
+        savedStateMap = buildContext.savedStateMap
+    ),
+    buildContext = buildContext,
+    plugins = plugins,
+) {
+    init {
+        lifecycle.subscribe(
+            onCreate = { Timber.v("OnCreate") },
+            onDestroy = { Timber.v("OnDestroy") }
+        )
+    }
+
+    sealed interface NavTarget : Parcelable {
+        @Parcelize
+        object OnBoarding : NavTarget
+
+        @Parcelize
+        object LoginFlow : NavTarget
+    }
+
+    override fun resolve(navTarget: NavTarget, buildContext: BuildContext): Node {
+        return when (navTarget) {
+            NavTarget.OnBoarding -> {
+                val callback = object : OnBoardingEntryPoint.Callback {
+                    override fun onSignUp() {
+                        //NOOP
+                    }
+
+                    override fun onSignIn() {
+                        backstack.push(NavTarget.LoginFlow)
+                    }
+                }
+                onBoardingEntryPoint.node(this, buildContext, plugins = listOf(callback))
+            }
+            NavTarget.LoginFlow -> {
+                loginEntryPoint.node(this, buildContext)
+            }
+        }
+    }
+
+    @Composable
+    override fun View(modifier: Modifier) {
+        Children(
+            navModel = backstack,
+            modifier = modifier,
+            // Animate navigation to login screen
+            transitionHandler = rememberDefaultTransitionHandler(),
+        )
+    }
+}

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

@@ -0,0 +1,99 @@
+/*
+ * 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.appnav
+
+import android.os.Parcelable
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import com.bumble.appyx.core.composable.Children
+import com.bumble.appyx.core.lifecycle.subscribe
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.plugin.Plugin
+import com.bumble.appyx.core.plugin.plugins
+import com.bumble.appyx.navmodel.backstack.BackStack
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedInject
+import io.element.android.anvilannotations.ContributesNode
+import io.element.android.features.messages.api.MessagesEntryPoint
+import io.element.android.libraries.architecture.BackstackNode
+import io.element.android.libraries.architecture.NodeInputs
+import io.element.android.libraries.architecture.nodeInputs
+import io.element.android.libraries.di.SessionScope
+import io.element.android.libraries.matrix.room.MatrixRoom
+import kotlinx.parcelize.Parcelize
+import timber.log.Timber
+
+@ContributesNode(SessionScope::class)
+class RoomFlowNode @AssistedInject constructor(
+    @Assisted buildContext: BuildContext,
+    @Assisted plugins: List<Plugin>,
+    private val messagesEntryPoint: MessagesEntryPoint,
+) : BackstackNode<RoomFlowNode.NavTarget>(
+    backstack = BackStack(
+        initialElement = NavTarget.Messages,
+        savedStateMap = buildContext.savedStateMap,
+    ),
+    buildContext = buildContext,
+    plugins = plugins,
+) {
+
+    interface LifecycleCallback : NodeLifecycleCallback {
+        fun onFlowCreated(room: MatrixRoom) = Unit
+        fun onFlowReleased(room: MatrixRoom) = Unit
+    }
+
+    data class Inputs(
+        val room: MatrixRoom,
+    ) : NodeInputs
+
+    private val inputs: Inputs by nodeInputs()
+
+    init {
+        lifecycle.subscribe(
+            onCreate = {
+                Timber.v("OnCreate")
+                plugins<LifecycleCallback>().forEach { it.onFlowCreated(inputs.room) }
+            },
+            onDestroy = {
+                Timber.v("OnDestroy")
+                plugins<LifecycleCallback>().forEach { it.onFlowReleased(inputs.room) }
+            }
+        )
+    }
+
+    override fun resolve(navTarget: NavTarget, buildContext: BuildContext): Node {
+        return when (navTarget) {
+            NavTarget.Messages -> {
+                messagesEntryPoint.node(this, buildContext)
+            }
+        }
+    }
+
+    sealed interface NavTarget : Parcelable {
+        @Parcelize
+        object Messages : NavTarget
+    }
+
+    @Composable
+    override fun View(modifier: Modifier) {
+        Children(
+            navModel = backstack,
+            modifier = modifier,
+        )
+    }
+}

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

@@ -0,0 +1,207 @@
+/*
+ * 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.appnav
+
+import android.app.Activity
+import android.content.Context
+import android.os.Parcelable
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalContext
+import androidx.lifecycle.lifecycleScope
+import com.bumble.appyx.core.composable.Children
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.node.node
+import com.bumble.appyx.core.plugin.Plugin
+import com.bumble.appyx.core.plugin.plugins
+import com.bumble.appyx.navmodel.backstack.BackStack
+import com.bumble.appyx.navmodel.backstack.operation.newRoot
+import com.bumble.appyx.navmodel.backstack.operation.pop
+import com.bumble.appyx.navmodel.backstack.operation.push
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedInject
+import io.element.android.anvilannotations.ContributesNode
+import io.element.android.appnav.root.RootPresenter
+import io.element.android.appnav.root.RootView
+import io.element.android.features.rageshake.bugreport.BugReportEntryPoint
+import io.element.android.libraries.architecture.BackstackNode
+import io.element.android.libraries.architecture.animation.rememberDefaultTransitionHandler
+import io.element.android.libraries.architecture.createNode
+import io.element.android.libraries.architecture.nodeInputsProvider
+import io.element.android.libraries.designsystem.theme.components.CircularProgressIndicator
+import io.element.android.libraries.di.AppScope
+import io.element.android.libraries.di.ApplicationContext
+import io.element.android.libraries.matrix.auth.MatrixAuthenticationService
+import io.element.android.libraries.matrix.core.SessionId
+import io.element.android.tests.uitests.openShowkase
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+import kotlinx.parcelize.Parcelize
+import timber.log.Timber
+
+@ContributesNode(AppScope::class)
+class RootFlowNode @AssistedInject constructor(
+    @Assisted val buildContext: BuildContext,
+    @Assisted plugins: List<Plugin>,
+    @ApplicationContext private val appContext: Context,
+    private val authenticationService: MatrixAuthenticationService,
+    private val matrixClientsHolder: MatrixClientsHolder,
+    private val presenter: RootPresenter,
+    private val bugReportEntryPoint: BugReportEntryPoint,
+) :
+    BackstackNode<RootFlowNode.NavTarget>(
+        backstack = BackStack(
+            initialElement = NavTarget.SplashScreen,
+            savedStateMap = buildContext.savedStateMap,
+        ),
+        buildContext = buildContext,
+        plugins = plugins
+    ) {
+
+    override fun onBuilt() {
+        super.onBuilt()
+        observeLoggedInState()
+    }
+
+    private fun observeLoggedInState() {
+        authenticationService.isLoggedIn()
+            .distinctUntilChanged()
+            .onEach { isLoggedIn ->
+                Timber.v("isLoggedIn=$isLoggedIn")
+                if (isLoggedIn) {
+                    tryToRestoreLatestSession(
+                        onSuccess = { switchToLoggedInFlow(it) },
+                        onFailure = { switchToLogoutFlow() }
+                    )
+                } else {
+                    switchToLogoutFlow()
+                }
+            }
+            .launchIn(lifecycleScope)
+    }
+
+    private fun switchToLoggedInFlow(sessionId: SessionId) {
+        backstack.safeRoot(NavTarget.LoggedInFlow(sessionId = sessionId))
+    }
+
+    private fun switchToLogoutFlow() {
+        matrixClientsHolder.removeAll()
+        backstack.safeRoot(NavTarget.NotLoggedInFlow)
+    }
+
+    private suspend fun tryToRestoreLatestSession(
+        onSuccess: (SessionId) -> Unit = {},
+        onFailure: () -> Unit = {}
+    ) {
+        val latestKnownSessionId = authenticationService.getLatestSessionId()
+        if (latestKnownSessionId == null) {
+            onFailure()
+            return
+        }
+        if (matrixClientsHolder.knowSession(latestKnownSessionId)) {
+            onSuccess(latestKnownSessionId)
+            return
+        }
+        val matrixClient = authenticationService.restoreSession(latestKnownSessionId)
+        if (matrixClient == null) {
+            Timber.v("Failed to restore session...")
+            onFailure()
+        } else {
+            matrixClientsHolder.add(matrixClient)
+            onSuccess(matrixClient.sessionId)
+        }
+    }
+
+    private fun onOpenBugReport() {
+        backstack.push(NavTarget.BugReport)
+    }
+
+    @Composable
+    override fun View(modifier: Modifier) {
+        val activity = LocalContext.current as Activity
+        fun openShowkase() {
+            openShowkase(activity)
+        }
+        val state = presenter.present()
+        RootView(
+            state = state,
+            modifier = modifier,
+            onOpenBugReport = this::onOpenBugReport,
+            onOpenShowkase = ::openShowkase
+        ) {
+            Children(
+                navModel = backstack,
+                // Animate opening the bug report screen
+                transitionHandler = rememberDefaultTransitionHandler(),
+            )
+        }
+    }
+
+    sealed interface NavTarget : Parcelable {
+        @Parcelize
+        object SplashScreen : NavTarget
+
+        @Parcelize
+        object NotLoggedInFlow : NavTarget
+
+        @Parcelize
+        data class LoggedInFlow(val sessionId: SessionId) : NavTarget
+
+        @Parcelize
+        object BugReport : NavTarget
+    }
+
+    override fun resolve(navTarget: NavTarget, buildContext: BuildContext): Node {
+        return when (navTarget) {
+            is NavTarget.LoggedInFlow -> {
+                val matrixClient = matrixClientsHolder.getOrNull(navTarget.sessionId) ?: return splashNode(buildContext).also {
+                    Timber.w("Couldn't find any session, go through SplashScreen")
+                    backstack.newRoot(NavTarget.SplashScreen)
+                }
+                val inputsProvider = nodeInputsProvider(LoggedInFlowNode.Inputs(matrixClient))
+                val callback = object : LoggedInFlowNode.Callback {
+                    override fun onOpenBugReport() {
+                        backstack.push(NavTarget.BugReport)
+                    }
+                }
+                val nodeLifecycleCallbacks = plugins<NodeLifecycleCallback>()
+                createNode<LoggedInFlowNode>(buildContext, plugins = listOf(inputsProvider, callback) + nodeLifecycleCallbacks)
+            }
+            NavTarget.NotLoggedInFlow -> createNode<NotLoggedInFlowNode>(buildContext)
+            NavTarget.SplashScreen -> splashNode(buildContext)
+            NavTarget.BugReport -> {
+                val callback = object : BugReportEntryPoint.Callback {
+                    override fun onBugReportSent() {
+                        backstack.pop()
+                    }
+                }
+                bugReportEntryPoint.node(this, buildContext, plugins = listOf(callback))
+            }
+        }
+    }
+
+    private fun splashNode(buildContext: BuildContext) = node(buildContext) {
+        Box(modifier = it.fillMaxSize(), contentAlignment = Alignment.Center) {
+            CircularProgressIndicator()
+        }
+    }
+}

appnav/src/main/kotlin/io/element/android/appnav/root/RootEvents.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.appnav.root
+
+sealed interface RootEvents {
+    object HideShowkaseButton : RootEvents
+}

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

@@ -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.
+ */
+
+package io.element.android.appnav.root
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.saveable.rememberSaveable
+import io.element.android.features.rageshake.crash.ui.CrashDetectionPresenter
+import io.element.android.features.rageshake.detection.RageshakeDetectionPresenter
+import io.element.android.libraries.architecture.Presenter
+import javax.inject.Inject
+
+class RootPresenter @Inject constructor(
+    private val crashDetectionPresenter: CrashDetectionPresenter,
+    private val rageshakeDetectionPresenter: RageshakeDetectionPresenter,
+) : Presenter<RootState> {
+
+    @Composable
+    override fun present(): RootState {
+        val isShowkaseButtonVisible = rememberSaveable {
+            mutableStateOf(true)
+        }
+        val rageshakeDetectionState = rageshakeDetectionPresenter.present()
+        val crashDetectionState = crashDetectionPresenter.present()
+
+        fun handleEvent(event: RootEvents) {
+            when (event) {
+                RootEvents.HideShowkaseButton -> isShowkaseButtonVisible.value = false
+            }
+        }
+
+        return RootState(
+            isShowkaseButtonVisible = isShowkaseButtonVisible.value,
+            rageshakeDetectionState = rageshakeDetectionState,
+            crashDetectionState = crashDetectionState,
+            eventSink = ::handleEvent
+        )
+    }
+}

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

@@ -0,0 +1,30 @@
+/*
+ * 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.appnav.root
+
+import androidx.compose.runtime.Stable
+import io.element.android.appnav.root.RootEvents
+import io.element.android.features.rageshake.crash.ui.CrashDetectionState
+import io.element.android.features.rageshake.detection.RageshakeDetectionState
+
+@Stable
+data class RootState(
+    val isShowkaseButtonVisible: Boolean,
+    val rageshakeDetectionState: RageshakeDetectionState,
+    val crashDetectionState: CrashDetectionState,
+    val eventSink: (RootEvents) -> Unit
+)

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

@@ -0,0 +1,44 @@
+/*
+ * 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.appnav.root
+
+import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+import io.element.android.features.rageshake.crash.ui.aCrashDetectionState
+import io.element.android.features.rageshake.detection.aRageshakeDetectionState
+
+open class RootStateProvider : PreviewParameterProvider<RootState> {
+    override val values: Sequence<RootState>
+        get() = sequenceOf(
+            aRootState().copy(
+                isShowkaseButtonVisible = true,
+                rageshakeDetectionState = aRageshakeDetectionState().copy(showDialog = false),
+                crashDetectionState = aCrashDetectionState().copy(crashDetected = true),
+            ),
+            aRootState().copy(
+                isShowkaseButtonVisible = true,
+                rageshakeDetectionState = aRageshakeDetectionState().copy(showDialog = true),
+                crashDetectionState = aCrashDetectionState().copy(crashDetected = false),
+            )
+        )
+}
+
+fun aRootState() = RootState(
+    isShowkaseButtonVisible = false,
+    rageshakeDetectionState = aRageshakeDetectionState(),
+    crashDetectionState = aCrashDetectionState(),
+    eventSink = {}
+)

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

@@ -0,0 +1,86 @@
+/*
+ * 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.appnav.root
+
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.BoxScope
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.tooling.preview.PreviewParameter
+import io.element.android.features.rageshake.crash.ui.CrashDetectionEvents
+import io.element.android.features.rageshake.crash.ui.CrashDetectionView
+import io.element.android.features.rageshake.detection.RageshakeDetectionEvents
+import io.element.android.features.rageshake.detection.RageshakeDetectionView
+import io.element.android.libraries.designsystem.preview.ElementPreviewDark
+import io.element.android.libraries.designsystem.preview.ElementPreviewLight
+import io.element.android.libraries.designsystem.theme.components.Text
+
+@Composable
+fun RootView(
+    state: RootState,
+    modifier: Modifier = Modifier,
+    onOpenBugReport: () -> Unit = {},
+    onOpenShowkase: () -> Unit = {},
+    children: @Composable BoxScope.() -> Unit,
+) {
+    Box(
+        modifier = modifier
+            .fillMaxSize(),
+        contentAlignment = Alignment.TopCenter,
+    ) {
+        children()
+        val eventSink = state.eventSink
+
+        fun onOpenBugReport() {
+            state.crashDetectionState.eventSink(CrashDetectionEvents.ResetAppHasCrashed)
+            state.rageshakeDetectionState.eventSink(RageshakeDetectionEvents.Dismiss)
+            onOpenBugReport.invoke()
+        }
+
+        ShowkaseButton(
+            isVisible = state.isShowkaseButtonVisible,
+            onCloseClicked = { eventSink(RootEvents.HideShowkaseButton) },
+            onClick = onOpenShowkase
+        )
+        RageshakeDetectionView(
+            state = state.rageshakeDetectionState,
+            onOpenBugReport = ::onOpenBugReport,
+        )
+        CrashDetectionView(
+            state = state.crashDetectionState,
+            onOpenBugReport = ::onOpenBugReport,
+        )
+    }
+}
+
+@Preview
+@Composable
+internal fun RootLightPreview(@PreviewParameter(RootStateProvider::class) rootState: RootState) = ElementPreviewLight { ContentToPreview(rootState) }
+
+@Preview
+@Composable
+internal fun RootDarkPreview(@PreviewParameter(RootStateProvider::class) rootState: RootState) = ElementPreviewDark { ContentToPreview(rootState) }
+
+@Composable
+private fun ContentToPreview(rootState: RootState) {
+    RootView(rootState) {
+        Text("Children")
+    }
+}

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

@@ -0,0 +1,71 @@
+/*
+ * 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.appnav.root
+
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Close
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import io.element.android.libraries.designsystem.preview.ElementPreviewDark
+import io.element.android.libraries.designsystem.preview.ElementPreviewLight
+import io.element.android.libraries.designsystem.theme.components.Button
+import io.element.android.libraries.designsystem.theme.components.Icon
+import io.element.android.libraries.designsystem.theme.components.IconButton
+import io.element.android.libraries.designsystem.theme.components.Text
+
+@Composable
+internal fun ShowkaseButton(
+    isVisible: Boolean,
+    modifier: Modifier = Modifier,
+    onClick: () -> Unit = {},
+    onCloseClicked: () -> Unit = {},
+) {
+    if (isVisible) {
+        Button(
+            modifier = modifier
+                .padding(top = 32.dp),
+            onClick = onClick
+        ) {
+            Text(text = "Showkase Browser")
+            IconButton(
+                modifier = Modifier
+                    .padding(start = 8.dp)
+                    .size(16.dp),
+                onClick = onCloseClicked,
+            ) {
+                Icon(imageVector = Icons.Filled.Close, contentDescription = "Close showkase button")
+            }
+        }
+    }
+}
+
+@Preview
+@Composable
+internal fun ShowkaseButtonLightPreview() = ElementPreviewLight { ContentToPreview() }
+
+@Preview
+@Composable
+internal fun ShowkaseButtonDarkPreview() = ElementPreviewDark { ContentToPreview() }
+
+@Composable
+private fun ContentToPreview() {
+    ShowkaseButton(isVisible = true)
+}

appnav/src/test/kotlin/io/element/android/appnav/FakeBugReporter.kt

@@ -0,0 +1,70 @@
+/*
+ * 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.appnav
+
+import io.element.android.features.rageshake.reporter.BugReporter
+import io.element.android.features.rageshake.reporter.BugReporterListener
+import io.element.android.features.rageshake.reporter.ReportType
+import io.element.android.libraries.matrixtest.A_FAILURE_REASON
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+
+// TODO Remove this duplicated class when we will rework modules.
+class FakeBugReporter(val mode: FakeBugReporterMode = FakeBugReporterMode.Success) : BugReporter {
+    override fun sendBugReport(
+        coroutineScope: CoroutineScope,
+        reportType: ReportType,
+        withDevicesLogs: Boolean,
+        withCrashLogs: Boolean,
+        withKeyRequestHistory: Boolean,
+        withScreenshot: Boolean,
+        theBugDescription: String,
+        serverVersion: String,
+        canContact: Boolean,
+        customFields: Map<String, String>?,
+        listener: BugReporterListener?,
+    ) {
+        coroutineScope.launch {
+            delay(100)
+            listener?.onProgress(0)
+            delay(100)
+            listener?.onProgress(50)
+            delay(100)
+            when (mode) {
+                FakeBugReporterMode.Success -> Unit
+                FakeBugReporterMode.Failure -> {
+                    listener?.onUploadFailed(A_FAILURE_REASON)
+                    return@launch
+                }
+                FakeBugReporterMode.Cancel -> {
+                    listener?.onUploadCancelled()
+                    return@launch
+                }
+            }
+            listener?.onProgress(100)
+            delay(100)
+            listener?.onUploadSucceed(null)
+        }
+    }
+}
+
+enum class FakeBugReporterMode {
+    Success,
+    Failure,
+    Cancel
+}

appnav/src/test/kotlin/io/element/android/appnav/FakeCrashDataStore.kt

@@ -0,0 +1,50 @@
+/*
+ * 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.appnav
+
+import io.element.android.features.rageshake.crash.CrashDataStore
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+
+const val A_CRASH_DATA = "Some crash data"
+
+// TODO Remove this duplicated class when we will rework modules.
+
+class FakeCrashDataStore(
+    crashData: String = "",
+    appHasCrashed: Boolean = false,
+) : CrashDataStore {
+    private val appHasCrashedFlow = MutableStateFlow(appHasCrashed)
+    private val crashDataFlow = MutableStateFlow(crashData)
+
+    override fun setCrashData(crashData: String) {
+        crashDataFlow.value = crashData
+    }
+
+    override suspend fun resetAppHasCrashed() {
+        appHasCrashedFlow.value = false
+    }
+
+    override fun appHasCrashed(): Flow<Boolean> = appHasCrashedFlow
+
+    override fun crashInfo(): Flow<String> = crashDataFlow
+
+    override suspend fun reset() {
+        appHasCrashedFlow.value = false
+        crashDataFlow.value = ""
+    }
+}

appnav/src/test/kotlin/io/element/android/appnav/FakeRageShake.kt

@@ -0,0 +1,44 @@
+/*
+ * 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.appnav
+
+import io.element.android.features.rageshake.rageshake.RageShake
+
+// TODO Remove this duplicated class when we will rework modules.
+class FakeRageShake(
+    private var isAvailableValue: Boolean = true
+) : RageShake {
+
+    private var interceptor: (() -> Unit)? = null
+
+    override fun isAvailable() = isAvailableValue
+
+    override fun start(sensitivity: Float) {
+    }
+
+    override fun stop() {
+    }
+
+    override fun setSensitivity(sensitivity: Float) {
+    }
+
+    override fun setInterceptor(interceptor: (() -> Unit)?) {
+        this.interceptor = interceptor
+    }
+
+    fun triggerPhoneRageshake() = interceptor?.invoke()
+}

appnav/src/test/kotlin/io/element/android/appnav/FakeRageshakeDataStore.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.appnav
+
+import io.element.android.features.rageshake.rageshake.RageshakeDataStore
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+
+const val A_SENSITIVITY = 1f
+
+// TODO Remove this duplicated class when we will rework modules.
+class FakeRageshakeDataStore(
+    isEnabled: Boolean = true,
+    sensitivity: Float = A_SENSITIVITY,
+) : RageshakeDataStore {
+
+    private val isEnabledFlow = MutableStateFlow(isEnabled)
+    override fun isEnabled(): Flow<Boolean> = isEnabledFlow
+
+    override suspend fun setIsEnabled(isEnabled: Boolean) {
+        isEnabledFlow.value = isEnabled
+    }
+
+    private val sensitivityFlow = MutableStateFlow(sensitivity)
+    override fun sensitivity(): Flow<Float> = sensitivityFlow
+
+    override suspend fun setSensitivity(sensitivity: Float) {
+        sensitivityFlow.value = sensitivity
+    }
+
+    override suspend fun reset() = Unit
+}

appnav/src/test/kotlin/io/element/android/appnav/FakeScreenshotHolder.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.appnav
+
+import android.graphics.Bitmap
+import io.element.android.features.rageshake.screenshot.ScreenshotHolder
+
+const val A_SCREENSHOT_URI = "file://content/uri"
+
+// TODO Remove this duplicated class when we will rework modules.
+class FakeScreenshotHolder(private val screenshotUri: String? = null) : ScreenshotHolder {
+    override fun writeBitmap(data: Bitmap) = Unit
+
+    override fun getFileUri() = screenshotUri
+
+    override fun reset() = Unit
+}

appnav/src/test/kotlin/io/element/android/appnav/RootPresenterTest.kt

@@ -0,0 +1,82 @@
+/*
+ * 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.
+ */
+
+@file:OptIn(ExperimentalCoroutinesApi::class)
+
+package io.element.android.appnav
+
+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.appnav.root.RootEvents
+import io.element.android.appnav.root.RootPresenter
+import io.element.android.features.rageshake.crash.ui.CrashDetectionPresenter
+import io.element.android.features.rageshake.detection.RageshakeDetectionPresenter
+import io.element.android.features.rageshake.preferences.RageshakePreferencesPresenter
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+class RootPresenterTest {
+    @Test
+    fun `present - initial state`() = runTest {
+        val presenter = createPresenter()
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            skipItems(1)
+            val initialState = awaitItem()
+            assertThat(initialState.isShowkaseButtonVisible).isTrue()
+        }
+    }
+
+    @Test
+    fun `present - hide showkase button`() = runTest {
+        val presenter = createPresenter()
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.present()
+        }.test {
+            skipItems(1)
+            val initialState = awaitItem()
+            assertThat(initialState.isShowkaseButtonVisible).isTrue()
+            initialState.eventSink.invoke(RootEvents.HideShowkaseButton)
+            assertThat(awaitItem().isShowkaseButtonVisible).isFalse()
+        }
+    }
+
+    private fun createPresenter(): RootPresenter {
+        val crashDataStore = FakeCrashDataStore()
+        val rageshakeDataStore = FakeRageshakeDataStore()
+        val rageshake = FakeRageShake()
+        val screenshotHolder = FakeScreenshotHolder()
+        val crashDetectionPresenter = CrashDetectionPresenter(
+            crashDataStore = crashDataStore
+        )
+        val rageshakeDetectionPresenter = RageshakeDetectionPresenter(
+            screenshotHolder = screenshotHolder,
+            rageShake = rageshake,
+            preferencesPresenter = RageshakePreferencesPresenter(
+                rageshake = rageshake,
+                rageshakeDataStore = rageshakeDataStore,
+            )
+        )
+        return RootPresenter(
+            crashDetectionPresenter = crashDetectionPresenter,
+            rageshakeDetectionPresenter = rageshakeDetectionPresenter,
+        )
+    }
+}