First Commit

services/appnavstate/impl/build.gradle.kts

@@ -0,0 +1,36 @@
+import extension.setupDependencyInjection
+import extension.testCommonDependencies
+
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2022-2024 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+plugins {
+    id("io.element.android-library")
+}
+
+setupDependencyInjection()
+
+android {
+    namespace = "io.element.android.services.appnavstate.impl"
+}
+
+dependencies {
+    implementation(projects.libraries.core)
+    implementation(projects.libraries.di)
+    implementation(projects.libraries.matrix.api)
+
+    implementation(libs.coroutines.core)
+    implementation(libs.androidx.corektx)
+    implementation(libs.androidx.lifecycle.process)
+
+    api(projects.services.appnavstate.api)
+
+    testCommonDependencies(libs)
+    testImplementation(projects.libraries.matrix.test)
+    testImplementation(projects.services.appnavstate.test)
+}

services/appnavstate/impl/src/main/kotlin/io/element/android/services/appnavstate/impl/DefaultActiveRoomsHolder.kt

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.services.appnavstate.impl
+
+import dev.zacsweers.metro.AppScope
+import dev.zacsweers.metro.ContributesBinding
+import dev.zacsweers.metro.SingleIn
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.api.core.SessionId
+import io.element.android.libraries.matrix.api.room.JoinedRoom
+import io.element.android.services.appnavstate.api.ActiveRoomsHolder
+import java.util.concurrent.ConcurrentHashMap
+
+@SingleIn(AppScope::class)
+@ContributesBinding(AppScope::class)
+class DefaultActiveRoomsHolder : ActiveRoomsHolder {
+    private val rooms = ConcurrentHashMap<SessionId, MutableSet<JoinedRoom>>()
+
+    override fun addRoom(room: JoinedRoom) {
+        val roomsForSessionId = rooms.getOrPut(key = room.sessionId, defaultValue = { mutableSetOf() })
+        if (roomsForSessionId.none { it.roomId == room.roomId }) {
+            // We don't want to add the same room multiple times
+            roomsForSessionId.add(room)
+        }
+    }
+
+    override fun getActiveRoom(sessionId: SessionId): JoinedRoom? {
+        return rooms[sessionId]?.lastOrNull()
+    }
+
+    override fun getActiveRoomMatching(sessionId: SessionId, roomId: RoomId): JoinedRoom? {
+        return rooms[sessionId]?.find { it.roomId == roomId }
+    }
+
+    override fun removeRoom(sessionId: SessionId, roomId: RoomId) {
+        val roomsForSessionId = rooms[sessionId] ?: return
+        roomsForSessionId.removeIf { it.roomId == roomId }
+    }
+
+    override fun clear(sessionId: SessionId) {
+        val activeRooms = rooms.remove(sessionId) ?: return
+        for (room in activeRooms) {
+            // Destroy the room to reset the live timelines
+            room.destroy()
+        }
+    }
+}

services/appnavstate/impl/src/main/kotlin/io/element/android/services/appnavstate/impl/DefaultAppForegroundStateService.kt

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.services.appnavstate.impl
+
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleEventObserver
+import androidx.lifecycle.ProcessLifecycleOwner
+import io.element.android.services.appnavstate.api.AppForegroundStateService
+import kotlinx.coroutines.flow.MutableStateFlow
+
+class DefaultAppForegroundStateService : AppForegroundStateService {
+    override val isInForeground = MutableStateFlow(false)
+    override val isInCall = MutableStateFlow(false)
+    override val isSyncingNotificationEvent = MutableStateFlow(false)
+    override val hasRingingCall = MutableStateFlow(false)
+
+    private val appLifecycle: Lifecycle by lazy { ProcessLifecycleOwner.get().lifecycle }
+
+    override fun startObservingForeground() {
+        appLifecycle.addObserver(lifecycleObserver)
+    }
+
+    override fun updateIsInCallState(isInCall: Boolean) {
+        this.isInCall.value = isInCall
+    }
+
+    override fun updateHasRingingCall(hasRingingCall: Boolean) {
+        this.hasRingingCall.value = hasRingingCall
+    }
+
+    override fun updateIsSyncingNotificationEvent(isSyncingNotificationEvent: Boolean) {
+        this.isSyncingNotificationEvent.value = isSyncingNotificationEvent
+    }
+
+    private val lifecycleObserver = LifecycleEventObserver { _, _ -> isInForeground.value = getCurrentState() }
+
+    private fun getCurrentState(): Boolean = appLifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)
+}

services/appnavstate/impl/src/main/kotlin/io/element/android/services/appnavstate/impl/DefaultAppNavigationStateService.kt

@@ -0,0 +1,172 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.services.appnavstate.impl
+
+import dev.zacsweers.metro.AppScope
+import dev.zacsweers.metro.ContributesBinding
+import dev.zacsweers.metro.SingleIn
+import io.element.android.libraries.core.log.logger.LoggerTag
+import io.element.android.libraries.di.annotations.AppCoroutineScope
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.api.core.SessionId
+import io.element.android.libraries.matrix.api.core.SpaceId
+import io.element.android.libraries.matrix.api.core.ThreadId
+import io.element.android.services.appnavstate.api.AppForegroundStateService
+import io.element.android.services.appnavstate.api.AppNavigationState
+import io.element.android.services.appnavstate.api.AppNavigationStateService
+import io.element.android.services.appnavstate.api.NavigationState
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.getAndUpdate
+import kotlinx.coroutines.launch
+import timber.log.Timber
+
+private val loggerTag = LoggerTag("Navigation")
+
+/**
+ * TODO This will maybe not support properly navigation using permalink.
+ */
+@ContributesBinding(AppScope::class)
+@SingleIn(AppScope::class)
+class DefaultAppNavigationStateService(
+    private val appForegroundStateService: AppForegroundStateService,
+    @AppCoroutineScope
+    coroutineScope: CoroutineScope,
+) : AppNavigationStateService {
+    private val state = MutableStateFlow(
+        AppNavigationState(
+            navigationState = NavigationState.Root,
+            isInForeground = true,
+        )
+    )
+    override val appNavigationState: StateFlow<AppNavigationState> = state
+
+    init {
+        coroutineScope.launch {
+            appForegroundStateService.startObservingForeground()
+            appForegroundStateService.isInForeground.collect { isInForeground ->
+                state.getAndUpdate { it.copy(isInForeground = isInForeground) }
+            }
+        }
+    }
+
+    override fun onNavigateToSession(owner: String, sessionId: SessionId) {
+        val currentValue = state.value.navigationState
+        Timber.tag(loggerTag.value).d("Navigating to session $sessionId. Current state: $currentValue")
+        val newValue: NavigationState.Session = when (currentValue) {
+            is NavigationState.Session,
+            is NavigationState.Space,
+            is NavigationState.Room,
+            is NavigationState.Thread,
+            is NavigationState.Root -> NavigationState.Session(owner, sessionId)
+        }
+        state.getAndUpdate { it.copy(navigationState = newValue) }
+    }
+
+    override fun onNavigateToSpace(owner: String, spaceId: SpaceId) {
+        val currentValue = state.value.navigationState
+        Timber.tag(loggerTag.value).d("Navigating to space $spaceId. Current state: $currentValue")
+        val newValue: NavigationState.Space = when (currentValue) {
+            NavigationState.Root -> return logError("onNavigateToSession()")
+            is NavigationState.Session -> NavigationState.Space(owner, spaceId, currentValue)
+            is NavigationState.Space -> NavigationState.Space(owner, spaceId, currentValue.parentSession)
+            is NavigationState.Room -> NavigationState.Space(owner, spaceId, currentValue.parentSpace.parentSession)
+            is NavigationState.Thread -> NavigationState.Space(owner, spaceId, currentValue.parentRoom.parentSpace.parentSession)
+        }
+        state.getAndUpdate { it.copy(navigationState = newValue) }
+    }
+
+    override fun onNavigateToRoom(owner: String, roomId: RoomId) {
+        val currentValue = state.value.navigationState
+        Timber.tag(loggerTag.value).d("Navigating to room $roomId. Current state: $currentValue")
+        val newValue: NavigationState.Room = when (currentValue) {
+            NavigationState.Root -> return logError("onNavigateToSession()")
+            is NavigationState.Session -> return logError("onNavigateToSpace()")
+            is NavigationState.Space -> NavigationState.Room(owner, roomId, currentValue)
+            is NavigationState.Room -> NavigationState.Room(owner, roomId, currentValue.parentSpace)
+            is NavigationState.Thread -> NavigationState.Room(owner, roomId, currentValue.parentRoom.parentSpace)
+        }
+        state.getAndUpdate { it.copy(navigationState = newValue) }
+    }
+
+    override fun onNavigateToThread(owner: String, threadId: ThreadId) {
+        val currentValue = state.value.navigationState
+        Timber.tag(loggerTag.value).d("Navigating to thread $threadId. Current state: $currentValue")
+        val newValue: NavigationState.Thread = when (currentValue) {
+            NavigationState.Root -> return logError("onNavigateToSession()")
+            is NavigationState.Session -> return logError("onNavigateToSpace()")
+            is NavigationState.Space -> return logError("onNavigateToRoom()")
+            is NavigationState.Room -> NavigationState.Thread(owner, threadId, currentValue)
+            is NavigationState.Thread -> NavigationState.Thread(owner, threadId, currentValue.parentRoom)
+        }
+        state.getAndUpdate { it.copy(navigationState = newValue) }
+    }
+
+    override fun onLeavingThread(owner: String) {
+        val currentValue = state.value.navigationState
+        Timber.tag(loggerTag.value).d("Leaving thread. Current state: $currentValue")
+        if (!currentValue.assertOwner(owner)) return
+        val newValue: NavigationState.Room = when (currentValue) {
+            NavigationState.Root -> return logError("onNavigateToSession()")
+            is NavigationState.Session -> return logError("onNavigateToSpace()")
+            is NavigationState.Space -> return logError("onNavigateToRoom()")
+            is NavigationState.Room -> return logError("onNavigateToThread()")
+            is NavigationState.Thread -> currentValue.parentRoom
+        }
+        state.getAndUpdate { it.copy(navigationState = newValue) }
+    }
+
+    override fun onLeavingRoom(owner: String) {
+        val currentValue = state.value.navigationState
+        Timber.tag(loggerTag.value).d("Leaving room. Current state: $currentValue")
+        if (!currentValue.assertOwner(owner)) return
+        val newValue: NavigationState.Space = when (currentValue) {
+            NavigationState.Root -> return logError("onNavigateToSession()")
+            is NavigationState.Session -> return logError("onNavigateToSpace()")
+            is NavigationState.Space -> return logError("onNavigateToRoom()")
+            is NavigationState.Room -> currentValue.parentSpace
+            is NavigationState.Thread -> currentValue.parentRoom.parentSpace
+        }
+        state.getAndUpdate { it.copy(navigationState = newValue) }
+    }
+
+    override fun onLeavingSpace(owner: String) {
+        val currentValue = state.value.navigationState
+        Timber.tag(loggerTag.value).d("Leaving space. Current state: $currentValue")
+        if (!currentValue.assertOwner(owner)) return
+        val newValue: NavigationState.Session = when (currentValue) {
+            NavigationState.Root -> return logError("onNavigateToSession()")
+            is NavigationState.Session -> return logError("onNavigateToSpace()")
+            is NavigationState.Space -> currentValue.parentSession
+            is NavigationState.Room -> currentValue.parentSpace.parentSession
+            is NavigationState.Thread -> currentValue.parentRoom.parentSpace.parentSession
+        }
+        state.getAndUpdate { it.copy(navigationState = newValue) }
+    }
+
+    override fun onLeavingSession(owner: String) {
+        val currentValue = state.value.navigationState
+        Timber.tag(loggerTag.value).d("Leaving session. Current state: $currentValue")
+        if (!currentValue.assertOwner(owner)) return
+        state.getAndUpdate { it.copy(navigationState = NavigationState.Root) }
+    }
+
+    private fun logError(logPrefix: String) {
+        Timber.tag(loggerTag.value).w("$logPrefix must be call first.")
+    }
+
+    private fun NavigationState.assertOwner(owner: String): Boolean {
+        if (this.owner != owner) {
+            Timber.tag(loggerTag.value).d("Can't leave current state as the owner is not the same (current = ${this.owner}, new = $owner)")
+            return false
+        }
+        return true
+    }
+}

services/appnavstate/impl/src/main/kotlin/io/element/android/services/appnavstate/impl/di/AppNavStateModule.kt

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.services.appnavstate.impl.di
+
+import android.content.Context
+import androidx.startup.AppInitializer
+import dev.zacsweers.metro.AppScope
+import dev.zacsweers.metro.BindingContainer
+import dev.zacsweers.metro.ContributesTo
+import dev.zacsweers.metro.Provides
+import io.element.android.libraries.di.annotations.ApplicationContext
+import io.element.android.services.appnavstate.api.AppForegroundStateService
+import io.element.android.services.appnavstate.impl.initializer.AppForegroundStateServiceInitializer
+
+@BindingContainer
+@ContributesTo(AppScope::class)
+object AppNavStateModule {
+    @Provides
+    fun provideAppForegroundStateService(
+        @ApplicationContext context: Context
+    ): AppForegroundStateService =
+        AppInitializer.getInstance(context).initializeComponent(AppForegroundStateServiceInitializer::class.java)
+}

services/appnavstate/impl/src/main/kotlin/io/element/android/services/appnavstate/impl/initializer/AppForegroundStateServiceInitializer.kt

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.services.appnavstate.impl.initializer
+
+import android.content.Context
+import androidx.lifecycle.ProcessLifecycleInitializer
+import androidx.startup.Initializer
+import io.element.android.services.appnavstate.api.AppForegroundStateService
+import io.element.android.services.appnavstate.impl.DefaultAppForegroundStateService
+
+class AppForegroundStateServiceInitializer : Initializer<AppForegroundStateService> {
+    override fun create(context: Context): AppForegroundStateService {
+        return DefaultAppForegroundStateService()
+    }
+
+    override fun dependencies(): MutableList<Class<out Initializer<*>>> = mutableListOf(
+        ProcessLifecycleInitializer::class.java
+    )
+}

services/appnavstate/impl/src/test/kotlin/io/element/android/services/appnavstate/impl/DefaultNavigationStateServiceTest.kt

@@ -0,0 +1,340 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.services.appnavstate.impl
+
+import com.google.common.truth.Truth.assertThat
+import io.element.android.libraries.matrix.test.A_ROOM_ID
+import io.element.android.libraries.matrix.test.A_ROOM_ID_2
+import io.element.android.libraries.matrix.test.A_SESSION_ID
+import io.element.android.libraries.matrix.test.A_SESSION_ID_2
+import io.element.android.libraries.matrix.test.A_SPACE_ID
+import io.element.android.libraries.matrix.test.A_SPACE_ID_2
+import io.element.android.libraries.matrix.test.A_THREAD_ID
+import io.element.android.libraries.matrix.test.A_THREAD_ID_2
+import io.element.android.services.appnavstate.api.AppNavigationStateService
+import io.element.android.services.appnavstate.api.NavigationState
+import io.element.android.services.appnavstate.test.A_ROOM_OWNER
+import io.element.android.services.appnavstate.test.A_SESSION_OWNER
+import io.element.android.services.appnavstate.test.A_SPACE_OWNER
+import io.element.android.services.appnavstate.test.A_THREAD_OWNER
+import io.element.android.services.appnavstate.test.FakeAppForegroundStateService
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.test.TestScope
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+class DefaultNavigationStateServiceTest {
+    private val navigationStateRoot = NavigationState.Root
+    private val navigationStateSession = NavigationState.Session(
+        owner = A_SESSION_OWNER,
+        sessionId = A_SESSION_ID
+    )
+    private val navigationStateSpace = NavigationState.Space(
+        owner = A_SPACE_OWNER,
+        spaceId = A_SPACE_ID,
+        parentSession = navigationStateSession
+    )
+    private val navigationStateRoom = NavigationState.Room(
+        owner = A_ROOM_OWNER,
+        roomId = A_ROOM_ID,
+        parentSpace = navigationStateSpace
+    )
+    private val navigationStateThread = NavigationState.Thread(
+        owner = A_THREAD_OWNER,
+        threadId = A_THREAD_ID,
+        parentRoom = navigationStateRoom
+    )
+
+    @Test
+    fun testNavigation() = runTest {
+        val service = createStateService()
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoot)
+        service.onNavigateToSession(A_SESSION_OWNER, A_SESSION_ID)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSession)
+        service.onNavigateToSpace(A_SPACE_OWNER, A_SPACE_ID)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSpace)
+        service.onNavigateToRoom(A_ROOM_OWNER, A_ROOM_ID)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoom)
+        service.onNavigateToThread(A_THREAD_OWNER, A_THREAD_ID)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateThread)
+        // Leaving the states
+        service.onLeavingThread(A_THREAD_OWNER)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoom)
+        service.onLeavingRoom(A_ROOM_OWNER)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSpace)
+        service.onLeavingSpace(A_SPACE_OWNER)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSession)
+        service.onLeavingSession(A_SESSION_OWNER)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoot)
+    }
+
+    @Test
+    fun testFailure() = runTest {
+        val service = createStateService()
+        service.onNavigateToSpace(A_SPACE_OWNER, A_SPACE_ID)
+        assertThat(service.appNavigationState.value.navigationState).isEqualTo(NavigationState.Root)
+    }
+
+    @Test
+    fun testOnNavigateToThread() = runTest {
+        val service = createStateService()
+        // From root (no effect)
+        service.onNavigateToThread(A_THREAD_OWNER, A_THREAD_ID)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoot)
+        // From session (no effect)
+        service.reset()
+        service.navigateToSession()
+        service.onNavigateToThread(A_THREAD_OWNER, A_THREAD_ID)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSession)
+        // From space (no effect)
+        service.reset()
+        service.navigateToSpace()
+        service.onNavigateToThread(A_THREAD_OWNER, A_THREAD_ID)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSpace)
+        // From room
+        service.reset()
+        service.navigateToRoom()
+        service.onNavigateToThread(A_THREAD_OWNER, A_THREAD_ID)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateThread)
+        // From thread
+        service.reset()
+        service.navigateToThread()
+        // Navigate to another thread
+        service.onNavigateToThread(A_THREAD_OWNER, A_THREAD_ID_2)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateThread.copy(threadId = A_THREAD_ID_2))
+    }
+
+    @Test
+    fun testOnNavigateToRoom() = runTest {
+        val service = createStateService()
+        // From root (no effect)
+        service.onNavigateToRoom(A_ROOM_OWNER, A_ROOM_ID)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoot)
+        // From session (no effect)
+        service.reset()
+        service.navigateToSession()
+        service.onNavigateToRoom(A_ROOM_OWNER, A_ROOM_ID)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSession)
+        // From space
+        service.reset()
+        service.navigateToSpace()
+        service.onNavigateToRoom(A_ROOM_OWNER, A_ROOM_ID)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoom)
+        // From room
+        service.reset()
+        service.navigateToRoom()
+        // Navigate to another room
+        service.onNavigateToRoom(A_ROOM_OWNER, A_ROOM_ID_2)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoom.copy(roomId = A_ROOM_ID_2))
+        // From thread
+        service.reset()
+        service.navigateToThread()
+        service.onNavigateToRoom(A_ROOM_OWNER, A_ROOM_ID)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoom)
+    }
+
+    @Test
+    fun testOnNavigateToSpace() = runTest {
+        val service = createStateService()
+        // From root (no effect)
+        service.onNavigateToSpace(A_SPACE_OWNER, A_SPACE_ID)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoot)
+        // From session
+        service.reset()
+        service.navigateToSession()
+        service.onNavigateToSpace(A_SPACE_OWNER, A_SPACE_ID)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSpace)
+        // From space
+        service.reset()
+        service.navigateToSpace()
+        // Navigate to another space
+        service.onNavigateToSpace(A_SPACE_OWNER, A_SPACE_ID_2)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSpace.copy(spaceId = A_SPACE_ID_2))
+        // From room (no effect)
+        service.reset()
+        service.navigateToRoom()
+        service.onNavigateToSpace(A_SPACE_OWNER, A_SPACE_ID)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSpace)
+        // From thread (no effect)
+        service.reset()
+        service.navigateToThread()
+        service.onNavigateToSpace(A_SPACE_OWNER, A_SPACE_ID)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSpace)
+    }
+
+    @Test
+    fun testOnNavigateToSession() = runTest {
+        val service = createStateService()
+        // From root
+        service.onNavigateToSession(A_SESSION_OWNER, A_SESSION_ID)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSession)
+        // From session
+        service.reset()
+        service.navigateToSession()
+        // Navigate to another session
+        service.onNavigateToSession(A_SESSION_OWNER, A_SESSION_ID_2)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSession.copy(sessionId = A_SESSION_ID_2))
+        // From space
+        service.reset()
+        service.navigateToSpace()
+        service.onNavigateToSession(A_SESSION_OWNER, A_SESSION_ID)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSession)
+        // From room
+        service.reset()
+        service.navigateToRoom()
+        service.onNavigateToSession(A_SESSION_OWNER, A_SESSION_ID)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSession)
+        // From thread
+        service.reset()
+        service.navigateToThread()
+        service.onNavigateToSession(A_SESSION_OWNER, A_SESSION_ID)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSession)
+    }
+
+    @Test
+    fun testOnLeavingThread() = runTest {
+        val service = createStateService()
+        // From root (no effect)
+        service.onLeavingThread(A_THREAD_OWNER)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoot)
+        // From session (no effect)
+        service.reset()
+        service.navigateToSession()
+        service.onLeavingThread(A_THREAD_OWNER)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSession)
+        // From space (no effect)
+        service.reset()
+        service.navigateToSpace()
+        service.onLeavingThread(A_THREAD_OWNER)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSpace)
+        // From room (no effect)
+        service.reset()
+        service.navigateToRoom()
+        service.onLeavingThread(A_THREAD_OWNER)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoom)
+        // From thread
+        service.reset()
+        service.navigateToThread()
+        service.onLeavingThread(A_THREAD_OWNER)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoom)
+    }
+
+    @Test
+    fun testOnLeavingRoom() = runTest {
+        val service = createStateService()
+        // From root (no effect)
+        service.onLeavingRoom(A_ROOM_OWNER)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoot)
+        // From session (no effect)
+        service.reset()
+        service.navigateToSession()
+        service.onLeavingRoom(A_ROOM_OWNER)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSession)
+        // From space (no effect)
+        service.reset()
+        service.navigateToSpace()
+        service.onLeavingRoom(A_ROOM_OWNER)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSpace)
+        // From room
+        service.reset()
+        service.navigateToRoom()
+        service.onLeavingRoom(A_ROOM_OWNER)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSpace)
+        // From thread (no effect)
+        service.reset()
+        service.navigateToThread()
+        service.onLeavingRoom(A_ROOM_OWNER)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateThread)
+    }
+
+    @Test
+    fun testOnLeavingSpace() = runTest {
+        val service = createStateService()
+        // From root (no effect)
+        service.onLeavingSpace(A_SPACE_OWNER)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoot)
+        // From session (no effect)
+        service.reset()
+        service.navigateToSession()
+        service.onLeavingSpace(A_SPACE_OWNER)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSession)
+        // From space
+        service.reset()
+        service.navigateToSpace()
+        service.onLeavingSpace(A_SPACE_OWNER)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSession)
+        // From room (no effect)
+        service.reset()
+        service.navigateToRoom()
+        service.onLeavingSpace(A_SPACE_OWNER)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoom)
+        // From thread (no effect)
+        service.reset()
+        service.navigateToThread()
+        service.onLeavingSpace(A_SPACE_OWNER)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateThread)
+    }
+
+    @Test
+    fun testOnLeavingSession() = runTest {
+        val service = createStateService()
+        // From root
+        service.onLeavingSession(A_SESSION_OWNER)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoot)
+        // From session
+        service.reset()
+        service.navigateToSession()
+        service.onLeavingSession(A_SESSION_OWNER)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoot)
+        // From space (no effect)
+        service.reset()
+        service.navigateToSpace()
+        service.onLeavingSession(A_SESSION_OWNER)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateSpace)
+        // From room (no effect)
+        service.reset()
+        service.navigateToRoom()
+        service.onLeavingSession(A_SESSION_OWNER)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateRoom)
+        // From thread (no effect)
+        service.reset()
+        service.navigateToThread()
+        service.onLeavingSession(A_SESSION_OWNER)
+        assertThat(service.appNavigationState.first().navigationState).isEqualTo(navigationStateThread)
+    }
+
+    private fun AppNavigationStateService.reset() {
+        navigateToSession()
+        onLeavingSession(A_SESSION_OWNER)
+    }
+
+    private fun AppNavigationStateService.navigateToSession() {
+        onNavigateToSession(A_SESSION_OWNER, A_SESSION_ID)
+    }
+
+    private fun AppNavigationStateService.navigateToSpace() {
+        navigateToSession()
+        onNavigateToSpace(A_SPACE_OWNER, A_SPACE_ID)
+    }
+
+    private fun AppNavigationStateService.navigateToRoom() {
+        navigateToSpace()
+        onNavigateToRoom(A_ROOM_OWNER, A_ROOM_ID)
+    }
+
+    private fun AppNavigationStateService.navigateToThread() {
+        navigateToRoom()
+        onNavigateToThread(A_THREAD_OWNER, A_THREAD_ID)
+    }
+
+    private fun TestScope.createStateService() = DefaultAppNavigationStateService(
+        appForegroundStateService = FakeAppForegroundStateService(),
+        coroutineScope = backgroundScope,
+    )
+}