Merge branch 'develop' into feature/fga/presenter_tests

app/src/main/kotlin/io/element/android/x/ElementRootModule.kt

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2022 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.x
+
+import com.airbnb.android.showkase.annotation.ShowkaseRoot
+import com.airbnb.android.showkase.annotation.ShowkaseRootModule
+
+@ShowkaseRoot
+class ElementRootModule : ShowkaseRootModule

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

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2022 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.x
+
+import android.app.Application
+import androidx.startup.AppInitializer
+import io.element.android.x.di.DaggerComponentOwner
+import io.element.android.x.di.AppComponent
+import io.element.android.x.di.DaggerAppComponent
+import io.element.android.x.initializer.CrashInitializer
+import io.element.android.x.initializer.MatrixInitializer
+import io.element.android.x.initializer.TimberInitializer
+
+class ElementXApplication : Application(), DaggerComponentOwner {
+
+    private lateinit var appComponent: AppComponent
+
+    override val daggerComponent: Any
+        get() = appComponent
+
+    override fun onCreate() {
+        super.onCreate()
+        appComponent = DaggerAppComponent.factory().create(applicationContext)
+        AppInitializer.getInstance(this).apply {
+            initializeComponent(CrashInitializer::class.java)
+            initializeComponent(TimberInitializer::class.java)
+            initializeComponent(MatrixInitializer::class.java)
+        }
+    }
+}

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

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2022 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.x
+
+import android.os.Bundle
+import androidx.activity.compose.setContent
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
+import androidx.compose.ui.Modifier
+import androidx.core.view.WindowCompat
+import com.bumble.appyx.core.integration.NodeHost
+import com.bumble.appyx.core.integrationpoint.NodeComponentActivity
+import io.element.android.x.architecture.bindings
+import io.element.android.x.di.DaggerComponentOwner
+import io.element.android.x.designsystem.ElementXTheme
+import io.element.android.x.di.AppBindings
+import io.element.android.x.node.RootFlowNode
+
+class MainActivity : NodeComponentActivity() {
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        val appBindings = bindings<AppBindings>()
+        WindowCompat.setDecorFitsSystemWindows(window, false)
+        setContent {
+            ElementXTheme {
+                Surface(
+                    modifier = Modifier.fillMaxSize(),
+                    color = MaterialTheme.colorScheme.background
+                ) {
+                    NodeHost(integrationPoint = appyxIntegrationPoint) {
+                        RootFlowNode(
+                            buildContext = it,
+                            appComponentOwner = applicationContext as DaggerComponentOwner,
+                            authenticationService = appBindings.authenticationService(),
+                            rootPresenter = appBindings.rootPresenter()
+                        )
+                    }
+                }
+            }
+        }
+    }
+}

app/src/main/kotlin/io/element/android/x/component/ShowkaseButton.kt

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.x.component
+
+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.material3.Button
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.unit.dp
+
+@Composable
+internal fun ShowkaseButton(
+    isVisible: Boolean,
+    onClick: () -> Unit,
+    onCloseClicked: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    if (isVisible) {
+        Button(
+            modifier = modifier
+                .padding(top = 32.dp, start = 16.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")
+            }
+        }
+    }
+}

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

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2022 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.x.di
+
+import com.squareup.anvil.annotations.ContributesTo
+import io.element.android.x.matrix.auth.MatrixAuthenticationService
+import io.element.android.x.root.RootPresenter
+import kotlinx.coroutines.CoroutineScope
+
+@ContributesTo(AppScope::class)
+interface AppBindings {
+    fun coroutineScope(): CoroutineScope
+    fun rootPresenter(): RootPresenter
+    fun authenticationService(): MatrixAuthenticationService
+}

app/src/main/kotlin/io/element/android/x/di/AppComponent.kt

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2022 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.x.di
+
+import android.content.Context
+import com.squareup.anvil.annotations.MergeComponent
+import dagger.BindsInstance
+import dagger.Component
+import io.element.android.x.architecture.NodeFactoriesBindings
+
+@SingleIn(AppScope::class)
+@MergeComponent(AppScope::class)
+interface AppComponent : NodeFactoriesBindings {
+
+    @Component.Factory
+    interface Factory {
+        fun create(@ApplicationContext @BindsInstance context: Context): AppComponent
+    }
+}

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

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2022 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.x.di
+
+import android.content.Context
+import com.squareup.anvil.annotations.ContributesTo
+import dagger.Module
+import dagger.Provides
+import io.element.android.x.core.coroutine.CoroutineDispatchers
+import kotlinx.coroutines.CoroutineName
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.MainScope
+import kotlinx.coroutines.asCoroutineDispatcher
+import kotlinx.coroutines.plus
+import java.io.File
+import java.util.concurrent.Executors
+
+@Module
+@ContributesTo(AppScope::class)
+object AppModule {
+
+    @Provides
+    fun providesBaseDirectory(@ApplicationContext context: Context): File {
+        return File(context.filesDir, "sessions")
+    }
+
+    @Provides
+    @SingleIn(AppScope::class)
+    fun providesAppCoroutineScope(): CoroutineScope {
+        return MainScope() + CoroutineName("ElementX Scope")
+    }
+
+    @Provides
+    @SingleIn(AppScope::class)
+    fun providesCoroutineDispatchers(): CoroutineDispatchers {
+        return CoroutineDispatchers(
+            io = Dispatchers.IO,
+            computation = Dispatchers.Default,
+            main = Dispatchers.Main,
+            diffUpdateDispatcher = Executors.newSingleThreadExecutor().asCoroutineDispatcher()
+        )
+    }
+}

app/src/main/kotlin/io/element/android/x/di/RoomComponent.kt

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2022 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.x.di
+
+import com.squareup.anvil.annotations.ContributesTo
+import com.squareup.anvil.annotations.MergeSubcomponent
+import dagger.BindsInstance
+import dagger.Subcomponent
+import io.element.android.x.architecture.NodeFactoriesBindings
+import io.element.android.x.matrix.room.MatrixRoom
+
+@SingleIn(RoomScope::class)
+@MergeSubcomponent(RoomScope::class)
+interface RoomComponent : NodeFactoriesBindings {
+
+    @Subcomponent.Builder
+    interface Builder {
+        @BindsInstance
+        fun room(room: MatrixRoom): Builder
+        fun build(): RoomComponent
+    }
+
+    @ContributesTo(SessionScope::class)
+    interface ParentBindings {
+        fun roomComponentBuilder(): Builder
+    }
+}

app/src/main/kotlin/io/element/android/x/di/SessionComponent.kt

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2022 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.x.di
+
+import com.squareup.anvil.annotations.ContributesTo
+import com.squareup.anvil.annotations.MergeSubcomponent
+import dagger.BindsInstance
+import dagger.Subcomponent
+import io.element.android.x.architecture.NodeFactoriesBindings
+import io.element.android.x.matrix.MatrixClient
+
+@SingleIn(SessionScope::class)
+@MergeSubcomponent(SessionScope::class)
+interface SessionComponent : NodeFactoriesBindings, RoomComponent.ParentBindings {
+
+    @Subcomponent.Builder
+    interface Builder {
+        @BindsInstance
+        fun client(matrixClient: MatrixClient): Builder
+        fun build(): SessionComponent
+    }
+
+    @ContributesTo(AppScope::class)
+    interface ParentBindings {
+        fun sessionComponentBuilder(): Builder
+    }
+}

app/src/main/kotlin/io/element/android/x/initializer/CrashInitializer.kt

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2022 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.x.initializer
+
+import android.content.Context
+import androidx.startup.Initializer
+import io.element.android.x.features.rageshake.crash.VectorUncaughtExceptionHandler
+
+class CrashInitializer : Initializer<Unit> {
+
+    override fun create(context: Context) {
+        VectorUncaughtExceptionHandler(context).activate()
+    }
+
+    override fun dependencies(): List<Class<out Initializer<*>>> = emptyList()
+}

app/src/main/kotlin/io/element/android/x/initializer/MatrixInitializer.kt

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2022 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.x.initializer
+
+import android.content.Context
+import androidx.startup.Initializer
+import io.element.android.x.BuildConfig
+import io.element.android.x.matrix.tracing.TracingConfigurations
+import io.element.android.x.matrix.tracing.setupTracing
+
+class MatrixInitializer : Initializer<Unit> {
+
+    override fun create(context: Context) {
+        if (BuildConfig.DEBUG) {
+            setupTracing(TracingConfigurations.debug)
+        } else {
+            setupTracing(TracingConfigurations.release)
+        }
+    }
+
+    override fun dependencies(): List<Class<out Initializer<*>>> = listOf(TimberInitializer::class.java)
+}

app/src/main/kotlin/io/element/android/x/initializer/TimberInitializer.kt

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2022 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.x.initializer
+
+import android.content.Context
+import androidx.startup.Initializer
+import io.element.android.x.BuildConfig
+import io.element.android.x.features.rageshake.logs.VectorFileLogger
+import timber.log.Timber
+
+class TimberInitializer : Initializer<Unit> {
+
+    override fun create(context: Context) {
+        if (BuildConfig.DEBUG) {
+            Timber.plant(Timber.DebugTree())
+        }
+        Timber.plant(VectorFileLogger(context))
+    }
+
+    override fun dependencies(): List<Class<out Initializer<*>>> = emptyList()
+}

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

@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.x.node
+
+import android.os.Parcelable
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.material3.Text
+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.ParentNode
+import com.bumble.appyx.core.node.node
+import com.bumble.appyx.navmodel.backstack.BackStack
+import com.bumble.appyx.navmodel.backstack.operation.push
+import io.element.android.x.architecture.bindings
+import io.element.android.x.architecture.createNode
+import io.element.android.x.di.DaggerComponentOwner
+import io.element.android.x.di.SessionComponent
+import io.element.android.x.features.preferences.PreferencesFlowNode
+import io.element.android.x.features.roomlist.RoomListNode
+import io.element.android.x.matrix.MatrixClient
+import io.element.android.x.matrix.core.RoomId
+import io.element.android.x.matrix.core.SessionId
+import io.element.android.x.matrix.ui.di.MatrixUIBindings
+import kotlinx.parcelize.Parcelize
+
+class LoggedInFlowNode(
+    buildContext: BuildContext,
+    val sessionId: SessionId,
+    private val matrixClient: MatrixClient,
+    private val onOpenBugReport: () -> Unit,
+    private val backstack: BackStack<NavTarget> = BackStack(
+        initialElement = NavTarget.RoomList,
+        savedStateMap = buildContext.savedStateMap,
+    ),
+) : ParentNode<LoggedInFlowNode.NavTarget>(
+    navModel = backstack,
+    buildContext = buildContext
+), DaggerComponentOwner {
+
+    override val daggerComponent: Any by lazy {
+        parent!!.bindings<SessionComponent.ParentBindings>().sessionComponentBuilder().client(matrixClient).build()
+    }
+
+    override fun onBuilt() {
+        super.onBuilt()
+        lifecycle.subscribe(
+            onCreate = {
+                val imageLoaderFactory = bindings<MatrixUIBindings>().loggedInImageLoaderFactory()
+                Coil.setImageLoader(imageLoaderFactory)
+                matrixClient.startSync()
+            },
+            onDestroy = {
+                val imageLoaderFactory = bindings<MatrixUIBindings>().notLoggedInImageLoaderFactory()
+                Coil.setImageLoader(imageLoaderFactory)
+            }
+        )
+    }
+
+    private val roomListCallback = object : RoomListNode.Callback {
+        override fun onRoomClicked(roomId: RoomId) {
+            backstack.push(NavTarget.Room(roomId))
+        }
+
+        override fun onSettingsClicked() {
+            backstack.push(NavTarget.Settings)
+        }
+    }
+
+    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 -> {
+                createNode<RoomListNode>(buildContext, plugins = listOf(roomListCallback))
+            }
+            is NavTarget.Room -> {
+                val room = 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 {
+                    RoomFlowNode(buildContext, room)
+                }
+            }
+            NavTarget.Settings -> {
+                PreferencesFlowNode(buildContext, onOpenBugReport)
+            }
+        }
+    }
+
+    @Composable
+    override fun View(modifier: Modifier) {
+        Children(navModel = backstack)
+    }
+}

app/src/main/kotlin/io/element/android/x/node/NotLoggedInFlowNode.kt

@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.x.node
+
+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.node.ParentNode
+import com.bumble.appyx.core.node.node
+import com.bumble.appyx.navmodel.backstack.BackStack
+import com.bumble.appyx.navmodel.backstack.operation.replace
+import io.element.android.x.features.login.LoginFlowNode
+import io.element.android.x.features.onboarding.OnBoardingScreen
+import kotlinx.parcelize.Parcelize
+import timber.log.Timber
+
+class NotLoggedInFlowNode(
+    buildContext: BuildContext,
+    private val backstack: BackStack<NavTarget> = BackStack(
+        initialElement = NavTarget.OnBoarding,
+        savedStateMap = buildContext.savedStateMap,
+    ),
+) : ParentNode<NotLoggedInFlowNode.NavTarget>(
+    navModel = backstack,
+    buildContext = buildContext
+) {
+
+    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 -> node(buildContext) {
+                OnBoardingScreen(
+                    onSignIn = { backstack.replace(NavTarget.LoginFlow) }
+                )
+            }
+            NavTarget.LoginFlow -> LoginFlowNode(buildContext)
+        }
+    }
+
+    @Composable
+    override fun View(modifier: Modifier) {
+        Children(navModel = backstack)
+    }
+}

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

@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.x.node
+
+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.node.ParentNode
+import com.bumble.appyx.navmodel.backstack.BackStack
+import io.element.android.x.architecture.bindings
+import io.element.android.x.architecture.createNode
+import io.element.android.x.di.DaggerComponentOwner
+import io.element.android.x.di.RoomComponent
+import io.element.android.x.features.messages.MessagesNode
+import io.element.android.x.matrix.room.MatrixRoom
+import kotlinx.parcelize.Parcelize
+import timber.log.Timber
+
+class RoomFlowNode(
+    buildContext: BuildContext,
+    private val room: MatrixRoom,
+    private val backstack: BackStack<NavTarget> = BackStack(
+        initialElement = NavTarget.Messages,
+        savedStateMap = buildContext.savedStateMap,
+    ),
+) : ParentNode<RoomFlowNode.NavTarget>(
+    navModel = backstack,
+    buildContext = buildContext
+), DaggerComponentOwner {
+
+    override val daggerComponent: Any by lazy {
+        parent!!.bindings<RoomComponent.ParentBindings>().roomComponentBuilder().room(room).build()
+    }
+
+    init {
+        lifecycle.subscribe(
+            onCreate = { Timber.v("OnCreate") },
+            onDestroy = { Timber.v("OnDestroy") }
+        )
+    }
+
+    override fun resolve(navTarget: NavTarget, buildContext: BuildContext): Node {
+        return when (navTarget) {
+            NavTarget.Messages -> createNode<MessagesNode>(buildContext)
+        }
+    }
+
+    sealed interface NavTarget : Parcelable {
+        @Parcelize
+        object Messages : NavTarget
+    }
+
+    @Composable
+    override fun View(modifier: Modifier) {
+        Children(navModel = backstack)
+    }
+}

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

@@ -0,0 +1,157 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.x.node
+
+import android.os.Parcelable
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.lifecycle.lifecycleScope
+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.ParentNode
+import com.bumble.appyx.core.node.node
+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 io.element.android.x.architecture.createNode
+import io.element.android.x.architecture.presenterConnector
+import io.element.android.x.di.DaggerComponentOwner
+import io.element.android.x.features.rageshake.bugreport.BugReportNode
+import io.element.android.x.matrix.MatrixClient
+import io.element.android.x.matrix.auth.MatrixAuthenticationService
+import io.element.android.x.matrix.core.SessionId
+import io.element.android.x.root.RootPresenter
+import io.element.android.x.root.RootView
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+import kotlinx.parcelize.Parcelize
+import timber.log.Timber
+import java.util.concurrent.ConcurrentHashMap
+
+class RootFlowNode(
+    buildContext: BuildContext,
+    private val backstack: BackStack<NavTarget> = BackStack(
+        initialElement = NavTarget.SplashScreen,
+        savedStateMap = buildContext.savedStateMap,
+    ),
+    private val appComponentOwner: DaggerComponentOwner,
+    private val authenticationService: MatrixAuthenticationService,
+    rootPresenter: RootPresenter
+) :
+    ParentNode<RootFlowNode.NavTarget>(
+        navModel = backstack,
+        buildContext = buildContext,
+    ),
+
+    DaggerComponentOwner by appComponentOwner {
+
+    private val matrixClientsHolder = ConcurrentHashMap<SessionId, MatrixClient>()
+    private val presenterConnector = presenterConnector(rootPresenter)
+
+    override fun onBuilt() {
+        super.onBuilt()
+        whenChildAttached(LoggedInFlowNode::class) { _, child ->
+            child.lifecycle.subscribe(
+                onDestroy = { matrixClientsHolder.remove(child.sessionId) }
+            )
+        }
+        authenticationService.isLoggedIn()
+            .distinctUntilChanged()
+            .onEach { isLoggedIn ->
+                Timber.v("isLoggedIn=$isLoggedIn")
+                if (isLoggedIn) {
+                    val matrixClient = authenticationService.restoreSession()
+                    if (matrixClient == null) {
+                        backstack.newRoot(NavTarget.NotLoggedInFlow)
+                    } else {
+                        matrixClientsHolder[matrixClient.sessionId] = matrixClient
+                        backstack.newRoot(NavTarget.LoggedInFlow(matrixClient.sessionId))
+                    }
+                } else {
+                    backstack.newRoot(NavTarget.NotLoggedInFlow)
+                }
+            }
+            .launchIn(lifecycleScope)
+    }
+
+    private fun onOpenBugReport() {
+        backstack.push(NavTarget.BugReport)
+    }
+
+    @Composable
+    override fun View(modifier: Modifier) {
+        val state by presenterConnector.stateFlow.collectAsState()
+        RootView(
+            state = state,
+            onOpenBugReport = this::onOpenBugReport,
+        ) {
+            Children(navModel = backstack)
+        }
+    }
+
+    private val bugReportNodeCallback = object : BugReportNode.Callback {
+        override fun onBugReportSent() {
+            backstack.pop()
+        }
+    }
+
+    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[navTarget.sessionId] ?: throw IllegalStateException("Makes sure to give a matrixClient with the given sessionId")
+                LoggedInFlowNode(
+                    buildContext = buildContext,
+                    sessionId = navTarget.sessionId,
+                    matrixClient = matrixClient,
+                    onOpenBugReport = this::onOpenBugReport
+                )
+            }
+            NavTarget.NotLoggedInFlow -> NotLoggedInFlowNode(buildContext)
+            NavTarget.SplashScreen -> node(buildContext) {
+                Box(modifier = it.fillMaxSize(), contentAlignment = Alignment.Center) {
+                    CircularProgressIndicator()
+                }
+            }
+            NavTarget.BugReport -> createNode<BugReportNode>(buildContext, plugins = listOf(bugReportNodeCallback))
+        }
+    }
+}

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

app/src/main/kotlin/io/element/android/x/root/RootPresenter.kt

@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.x.root
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.saveable.rememberSaveable
+import io.element.android.x.architecture.Presenter
+import io.element.android.x.features.rageshake.bugreport.BugReportPresenter
+import io.element.android.x.features.rageshake.crash.ui.CrashDetectionPresenter
+import io.element.android.x.features.rageshake.detection.RageshakeDetectionPresenter
+import javax.inject.Inject
+
+class RootPresenter @Inject constructor(
+    private val bugReportPresenter: BugReportPresenter,
+    private val crashDetectionPresenter: CrashDetectionPresenter,
+    private val rageshakeDetectionPresenter: RageshakeDetectionPresenter,
+) : Presenter<RootState> {
+
+    @Composable
+    override fun present(): RootState {
+        val isBugReportVisible = rememberSaveable {
+            mutableStateOf(false)
+        }
+        val isShowkaseButtonVisible = rememberSaveable {
+            mutableStateOf(true)
+        }
+        val rageshakeDetectionState = rageshakeDetectionPresenter.present()
+        val crashDetectionState = crashDetectionPresenter.present()
+        val bugReportState = bugReportPresenter.present()
+
+        fun handleEvent(event: RootEvents) {
+            when (event) {
+                RootEvents.HideShowkaseButton -> isShowkaseButtonVisible.value = false
+            }
+        }
+
+        return RootState(
+            isBugReportVisible = isBugReportVisible.value,
+            isShowkaseButtonVisible = isShowkaseButtonVisible.value,
+            rageshakeDetectionState = rageshakeDetectionState,
+            crashDetectionState = crashDetectionState,
+            bugReportState = bugReportState,
+            eventSink = ::handleEvent
+        )
+    }
+}

app/src/main/kotlin/io/element/android/x/root/RootState.kt

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.x.root
+
+import androidx.compose.runtime.Stable
+import io.element.android.x.features.rageshake.bugreport.BugReportState
+import io.element.android.x.features.rageshake.crash.ui.CrashDetectionState
+import io.element.android.x.features.rageshake.detection.RageshakeDetectionState
+
+@Stable
+data class RootState(
+    val isBugReportVisible: Boolean,
+    val isShowkaseButtonVisible: Boolean,
+    val rageshakeDetectionState: RageshakeDetectionState,
+    val crashDetectionState: CrashDetectionState,
+    val bugReportState: BugReportState,
+    val eventSink: (RootEvents) -> Unit
+)

app/src/main/kotlin/io/element/android/x/root/RootView.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.x.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.platform.LocalContext
+import androidx.core.content.ContextCompat
+import com.airbnb.android.showkase.models.Showkase
+import io.element.android.x.component.ShowkaseButton
+import io.element.android.x.features.rageshake.crash.ui.CrashDetectionEvents
+import io.element.android.x.features.rageshake.crash.ui.CrashDetectionView
+import io.element.android.x.features.rageshake.detection.RageshakeDetectionEvents
+import io.element.android.x.features.rageshake.detection.RageshakeDetectionView
+import io.element.android.x.getBrowserIntent
+
+@Composable
+fun RootView(
+    state: RootState,
+    modifier: Modifier = Modifier,
+    onOpenBugReport: () -> Unit = {},
+    children: @Composable BoxScope.() -> Unit,
+) {
+    Box(
+        modifier = modifier
+            .fillMaxSize(),
+        contentAlignment = Alignment.TopCenter,
+    ) {
+        children()
+        val eventSink = state.eventSink
+        val context = LocalContext.current
+
+        fun onOpenBugReport() {
+            state.crashDetectionState.eventSink(CrashDetectionEvents.ResetAppHasCrashed)
+            state.rageshakeDetectionState.eventSink(RageshakeDetectionEvents.Dismiss)
+            onOpenBugReport.invoke()
+        }
+
+        ShowkaseButton(
+            isVisible = state.isShowkaseButtonVisible,
+            onCloseClicked = { eventSink(RootEvents.HideShowkaseButton) },
+            onClick = { ContextCompat.startActivity(context, Showkase.getBrowserIntent(context), null) }
+        )
+        RageshakeDetectionView(
+            state = state.rageshakeDetectionState,
+            onOpenBugReport = ::onOpenBugReport,
+        )
+        CrashDetectionView(
+            state = state.crashDetectionState,
+            onOpenBugReport = ::onOpenBugReport,
+        )
+    }
+}