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

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)
+}