Space list (#5320)

* feature(spaces) : introduce SpaceRoomList matrix api

* feature (space) : extract SpaceRoomItemView

* feature(spaces) : start introducing SpaceScreen

* feature (space) : iterate on space list (and space screen)

* feature (space) : add space cache and navigation to sub space/room

* feature (space) : display top bar title

* Code cleanup, remove dead code and fix compilation issue

* More compilation fixes.

* Update screenshots

* Fix test compilation issues.

* Introduce MatrixClient.rememberHideInvitesAvatar() extension to reduce code duplication.

* Add test on SpacePresenter

* Add test on SpaceRoomCache and fix implementation

* Iterate on SpaceRoomCache thanks to SpaceRoomCacheTest

* Add UT on SpaceListUpdateProcessor

* Fix quality issue.

* Add tests on RustSpaceRoomList

---------

Co-authored-by: ganfra <francoisg@matrix.org>
Co-authored-by: ElementBot <android@element.io>

features/home/impl/build.gradle.kts

@@ -55,6 +55,7 @@ dependencies {
     implementation(libs.haze.materials)
     implementation(projects.features.reportroom.api)
     implementation(projects.features.changeroommemberroles.api)
+    implementation(projects.libraries.previewutils)
     api(projects.features.home.api)
 
     testImplementation(libs.androidx.compose.ui.test.junit)

features/home/impl/src/main/kotlin/io/element/android/features/home/impl/HomeView.kt

@@ -269,7 +269,7 @@ private fun HomeScaffold(
                             .hazeSource(state = hazeState),
                         state = state.homeSpacesState,
                         onSpaceClick = { spaceId ->
-                            // TODO
+                            onRoomClick(spaceId)
                         }
                     )
                 }

features/home/impl/src/main/kotlin/io/element/android/features/home/impl/roomlist/RoomListPresenter.kt

@@ -36,7 +36,6 @@ import io.element.android.features.leaveroom.api.LeaveRoomEvent
 import io.element.android.features.leaveroom.api.LeaveRoomState
 import io.element.android.libraries.architecture.AsyncData
 import io.element.android.libraries.architecture.Presenter
-import io.element.android.libraries.core.coroutine.mapState
 import io.element.android.libraries.fullscreenintent.api.FullScreenIntentPermissionsState
 import io.element.android.libraries.matrix.api.MatrixClient
 import io.element.android.libraries.matrix.api.core.RoomId
@@ -44,6 +43,7 @@ import io.element.android.libraries.matrix.api.encryption.EncryptionService
 import io.element.android.libraries.matrix.api.encryption.RecoveryState
 import io.element.android.libraries.matrix.api.roomlist.RoomList
 import io.element.android.libraries.matrix.api.timeline.ReceiptType
+import io.element.android.libraries.matrix.ui.safety.rememberHideInvitesAvatar
 import io.element.android.libraries.preferences.api.store.AppPreferencesStore
 import io.element.android.libraries.preferences.api.store.SessionPreferencesStore
 import io.element.android.libraries.push.api.battery.BatteryOptimizationState
@@ -101,12 +101,7 @@ class RoomListPresenter(
         var securityBannerDismissed by rememberSaveable { mutableStateOf(false) }
 
         // Avatar indicator
-        val hideInvitesAvatar by remember {
-            client
-                .mediaPreviewService()
-                .mediaPreviewConfigFlow
-                .mapState { config -> config.hideInviteAvatar }
-        }.collectAsState()
+        val hideInvitesAvatar by client.rememberHideInvitesAvatar()
 
         val contextMenu = remember { mutableStateOf<RoomListState.ContextMenu>(RoomListState.ContextMenu.Hidden) }
         val declineInviteMenu = remember { mutableStateOf<RoomListState.DeclineInviteMenu>(RoomListState.DeclineInviteMenu.Hidden) }

features/home/impl/src/main/kotlin/io/element/android/features/home/impl/spaces/HomeSpaceItemView.kt

@@ -1,197 +0,0 @@
-/*
- * 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.features.home.impl.spaces
-
-import androidx.compose.foundation.combinedClickable
-import androidx.compose.foundation.interaction.MutableInteractionSource
-import androidx.compose.foundation.layout.Arrangement.Absolute.spacedBy
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.ColumnScope
-import androidx.compose.foundation.layout.IntrinsicSize
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.layout.width
-import androidx.compose.material3.ripple
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.remember
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.res.pluralStringResource
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.font.FontStyle
-import androidx.compose.ui.text.style.TextOverflow
-import androidx.compose.ui.tooling.preview.PreviewParameter
-import androidx.compose.ui.unit.dp
-import io.element.android.compound.theme.ElementTheme
-import io.element.android.compound.tokens.generated.CompoundIcons
-import io.element.android.libraries.designsystem.atomic.atoms.UnreadIndicatorAtom
-import io.element.android.libraries.designsystem.atomic.molecules.InviteButtonsRowMolecule
-import io.element.android.libraries.designsystem.components.avatar.Avatar
-import io.element.android.libraries.designsystem.components.avatar.AvatarSize
-import io.element.android.libraries.designsystem.components.avatar.AvatarType
-import io.element.android.libraries.designsystem.modifiers.onKeyboardContextMenuAction
-import io.element.android.libraries.designsystem.preview.ElementPreview
-import io.element.android.libraries.designsystem.preview.PreviewsDayNight
-import io.element.android.libraries.designsystem.theme.components.Icon
-import io.element.android.libraries.designsystem.theme.components.Text
-import io.element.android.libraries.designsystem.theme.unreadIndicator
-import io.element.android.libraries.matrix.api.room.CurrentUserMembership
-import io.element.android.libraries.matrix.api.spaces.SpaceRoom
-import io.element.android.libraries.matrix.ui.model.getAvatarData
-import io.element.android.libraries.ui.strings.CommonPlurals
-import io.element.android.libraries.ui.strings.CommonStrings
-
-@Composable
-internal fun HomeSpaceItemView(
-    spaceRoom: SpaceRoom,
-    showUnreadIndicator: Boolean,
-    hideAvatars: Boolean,
-    onClick: () -> Unit,
-    modifier: Modifier = Modifier,
-) {
-    SpaceScaffoldRow(
-        modifier = modifier,
-        spaceRoom = spaceRoom,
-        onClick = onClick,
-        hideAvatars = hideAvatars,
-        onLongClick = { },
-    ) {
-        NameAndIndicatorRow(
-            name = spaceRoom.name,
-            showIndicator = showUnreadIndicator,
-        )
-        Spacer(modifier = Modifier.height(1.dp))
-        if (!spaceRoom.worldReadable) {
-            Row(
-                modifier = Modifier.fillMaxWidth(),
-                verticalAlignment = Alignment.CenterVertically,
-            ) {
-                Icon(
-                    modifier = Modifier
-                        .size(16.dp)
-                        .padding(end = 4.dp),
-                    imageVector = CompoundIcons.LockSolid(),
-                    contentDescription = null,
-                    tint = ElementTheme.colors.iconTertiary,
-                )
-                Text(
-                    modifier = Modifier.weight(1f),
-                    style = ElementTheme.typography.fontBodyMdRegular,
-                    text = stringResource(CommonStrings.common_private_space),
-                    fontStyle = FontStyle.Italic.takeIf { spaceRoom.name == null },
-                    color = ElementTheme.colors.textSecondary,
-                    maxLines = 1,
-                    overflow = TextOverflow.Ellipsis
-                )
-            }
-            Spacer(modifier = Modifier.height(1.dp))
-        }
-        val spaceSummary = stringResource(
-            CommonStrings.screen_space_list_details,
-            pluralStringResource(CommonPlurals.common_rooms, spaceRoom.childrenCount, spaceRoom.childrenCount),
-            pluralStringResource(CommonPlurals.common_member_count, spaceRoom.numJoinedMembers, spaceRoom.numJoinedMembers),
-        )
-        Text(
-            modifier = Modifier.weight(1f),
-            style = ElementTheme.typography.fontBodyMdRegular,
-            text = spaceSummary,
-            fontStyle = FontStyle.Italic.takeIf { spaceRoom.name == null },
-            color = ElementTheme.colors.textSecondary,
-            maxLines = 1,
-            overflow = TextOverflow.Ellipsis
-        )
-        if (spaceRoom.state == CurrentUserMembership.INVITED) {
-            Spacer(modifier = Modifier.height(12.dp))
-            InviteButtonsRowMolecule(
-                onAcceptClick = {},
-                onDeclineClick = {},
-            )
-        }
-    }
-}
-
-@Composable
-private fun NameAndIndicatorRow(
-    name: String?,
-    showIndicator: Boolean,
-    modifier: Modifier = Modifier,
-) {
-    Row(
-        modifier = modifier.fillMaxWidth(),
-        horizontalArrangement = spacedBy(16.dp),
-        verticalAlignment = Alignment.CenterVertically,
-    ) {
-        Text(
-            modifier = Modifier.weight(1f),
-            style = ElementTheme.typography.fontBodyLgMedium,
-            text = name ?: stringResource(id = CommonStrings.common_no_room_name),
-            fontStyle = FontStyle.Italic.takeIf { name == null },
-            color = ElementTheme.colors.textPrimary,
-            maxLines = 1,
-            overflow = TextOverflow.Ellipsis
-        )
-        if (showIndicator) {
-            UnreadIndicatorAtom(
-                color = ElementTheme.colors.unreadIndicator
-            )
-        }
-    }
-}
-
-@Composable
-private fun SpaceScaffoldRow(
-    spaceRoom: SpaceRoom,
-    onClick: () -> Unit,
-    onLongClick: () -> Unit,
-    hideAvatars: Boolean,
-    modifier: Modifier = Modifier,
-    content: @Composable ColumnScope.() -> Unit
-) {
-    val clickModifier = Modifier
-        .combinedClickable(
-            onClick = onClick,
-            onLongClick = onLongClick,
-            onLongClickLabel = stringResource(CommonStrings.action_open_context_menu),
-            indication = ripple(),
-            interactionSource = remember { MutableInteractionSource() }
-        )
-        .onKeyboardContextMenuAction { onLongClick }
-    Row(
-        modifier = modifier
-            .fillMaxWidth()
-            .then(clickModifier)
-            .padding(horizontal = 16.dp, vertical = 8.dp)
-            .height(IntrinsicSize.Min),
-    ) {
-        Avatar(
-            avatarData = spaceRoom.getAvatarData(AvatarSize.SpaceListItem),
-            avatarType = AvatarType.Space(),
-            hideImage = hideAvatars,
-        )
-        Spacer(modifier = Modifier.width(16.dp))
-        Column(
-            modifier = Modifier.weight(1f),
-            content = content,
-        )
-    }
-}
-
-@PreviewsDayNight
-@Composable
-internal fun HomeSpaceItemViewPreview(@PreviewParameter(SpaceRoomProvider::class) spaceRoom: SpaceRoom) = ElementPreview {
-    HomeSpaceItemView(
-        spaceRoom = spaceRoom,
-        showUnreadIndicator = false,
-        hideAvatars = true,
-        onClick = {},
-    )
-}

features/home/impl/src/main/kotlin/io/element/android/features/home/impl/spaces/HomeSpacesPresenter.kt

@@ -13,10 +13,9 @@ import androidx.compose.runtime.getValue
 import androidx.compose.runtime.remember
 import dev.zacsweers.metro.Inject
 import io.element.android.features.invite.api.SeenInvitesStore
-import io.element.android.features.invite.api.seenSpaceIds
 import io.element.android.libraries.architecture.Presenter
-import io.element.android.libraries.core.coroutine.mapState
 import io.element.android.libraries.matrix.api.MatrixClient
+import io.element.android.libraries.matrix.ui.safety.rememberHideInvitesAvatar
 import kotlinx.collections.immutable.persistentSetOf
 import kotlinx.collections.immutable.toPersistentSet
 import kotlinx.coroutines.flow.map
@@ -28,15 +27,10 @@ class HomeSpacesPresenter(
 ) : Presenter<HomeSpacesState> {
     @Composable
     override fun present(): HomeSpacesState {
-        val hideInvitesAvatar by remember {
-            client
-                .mediaPreviewService()
-                .mediaPreviewConfigFlow
-                .mapState { config -> config.hideInviteAvatar }
-        }.collectAsState()
-        val spaceRooms by client.spaceService.spaceRooms.collectAsState(emptyList())
+        val hideInvitesAvatar by client.rememberHideInvitesAvatar()
+        val spaceRooms by client.spaceService.spaceRoomsFlow.collectAsState(emptyList())
         val seenSpaceInvites by remember {
-            seenInvitesStore.seenSpaceIds().map { it.toPersistentSet() }
+            seenInvitesStore.seenRoomIds().map { it.toPersistentSet() }
         }.collectAsState(persistentSetOf())
 
         fun handleEvents(event: HomeSpacesEvents) {

features/home/impl/src/main/kotlin/io/element/android/features/home/impl/spaces/HomeSpacesState.kt

@@ -7,14 +7,14 @@
 
 package io.element.android.features.home.impl.spaces
 
-import io.element.android.libraries.matrix.api.core.SpaceId
+import io.element.android.libraries.matrix.api.core.RoomId
 import io.element.android.libraries.matrix.api.spaces.SpaceRoom
 import kotlinx.collections.immutable.ImmutableSet
 
 data class HomeSpacesState(
     val space: CurrentSpace,
     val spaceRooms: List<SpaceRoom>,
-    val seenSpaceInvites: ImmutableSet<SpaceId>,
+    val seenSpaceInvites: ImmutableSet<RoomId>,
     val hideInvitesAvatar: Boolean,
     val eventSink: (HomeSpacesEvents) -> Unit,
 )

features/home/impl/src/main/kotlin/io/element/android/features/home/impl/spaces/HomeSpacesStateProvider.kt

@@ -8,8 +8,9 @@
 package io.element.android.features.home.impl.spaces
 
 import androidx.compose.ui.tooling.preview.PreviewParameterProvider
-import io.element.android.libraries.matrix.api.core.SpaceId
+import io.element.android.libraries.matrix.api.core.RoomId
 import io.element.android.libraries.matrix.api.spaces.SpaceRoom
+import io.element.android.libraries.previewutils.room.aSpaceRoom
 import kotlinx.collections.immutable.toImmutableSet
 
 open class HomeSpacesStateProvider : PreviewParameterProvider<HomeSpacesState> {
@@ -18,12 +19,12 @@ open class HomeSpacesStateProvider : PreviewParameterProvider<HomeSpacesState> {
             aHomeSpacesState(
                 spaceRooms = SpaceRoomProvider().values.toList(),
                 seenSpaceInvites = setOf(
-                    SpaceId("!spaceId3:example.com"),
+                    RoomId("!spaceId3:example.com"),
                 ),
             ),
             aHomeSpacesState(
                 space = CurrentSpace.Space(
-                    spaceRoom = aSpaceRooms(spaceId = SpaceId("!mySpace:example.com"))
+                    spaceRoom = aSpaceRoom(roomId = RoomId("!mySpace:example.com"))
                 ),
                 spaceRooms = aListOfSpaceRooms(),
             ),
@@ -33,7 +34,7 @@ open class HomeSpacesStateProvider : PreviewParameterProvider<HomeSpacesState> {
 internal fun aHomeSpacesState(
     space: CurrentSpace = CurrentSpace.Root,
     spaceRooms: List<SpaceRoom> = aListOfSpaceRooms(),
-    seenSpaceInvites: Set<SpaceId> = emptySet(),
+    seenSpaceInvites: Set<RoomId> = emptySet(),
     hideInvitesAvatar: Boolean = false,
     eventSink: (HomeSpacesEvents) -> Unit = {},
 ) = HomeSpacesState(
@@ -46,8 +47,8 @@ internal fun aHomeSpacesState(
 
 fun aListOfSpaceRooms(): List<SpaceRoom> {
     return listOf(
-        aSpaceRooms(spaceId = SpaceId("!spaceId0:example.com")),
-        aSpaceRooms(spaceId = SpaceId("!spaceId1:example.com")),
-        aSpaceRooms(spaceId = SpaceId("!spaceId2:example.com")),
+        aSpaceRoom(roomId = RoomId("!spaceId0:example.com")),
+        aSpaceRoom(roomId = RoomId("!spaceId1:example.com")),
+        aSpaceRoom(roomId = RoomId("!spaceId2:example.com")),
     )
 }

features/home/impl/src/main/kotlin/io/element/android/features/home/impl/spaces/HomeSpacesView.kt

@@ -14,17 +14,18 @@ import androidx.compose.ui.tooling.preview.PreviewParameter
 import io.element.android.libraries.designsystem.components.avatar.AvatarSize
 import io.element.android.libraries.designsystem.preview.ElementPreview
 import io.element.android.libraries.designsystem.preview.PreviewsDayNight
-import io.element.android.libraries.matrix.api.core.SpaceId
+import io.element.android.libraries.matrix.api.core.RoomId
 import io.element.android.libraries.matrix.api.room.CurrentUserMembership
 import io.element.android.libraries.matrix.ui.components.SpaceHeaderRootView
 import io.element.android.libraries.matrix.ui.components.SpaceHeaderView
+import io.element.android.libraries.matrix.ui.components.SpaceRoomItemView
 import io.element.android.libraries.matrix.ui.model.getAvatarData
 import kotlinx.collections.immutable.toImmutableList
 
 @Composable
 fun HomeSpacesView(
     state: HomeSpacesState,
-    onSpaceClick: (SpaceId) -> Unit,
+    onSpaceClick: (RoomId) -> Unit,
     modifier: Modifier = Modifier,
 ) {
     LazyColumn(modifier) {
@@ -51,15 +52,18 @@ fun HomeSpacesView(
                 )
             }
         }
-        state.spaceRooms.forEach {
-            item(it.spaceId) {
-                val isInvitation = it.state == CurrentUserMembership.INVITED
-                HomeSpaceItemView(
-                    spaceRoom = it,
-                    showUnreadIndicator = isInvitation && it.spaceId !in state.seenSpaceInvites,
+        state.spaceRooms.forEach { spaceRoom ->
+            item(spaceRoom.roomId) {
+                val isInvitation = spaceRoom.state == CurrentUserMembership.INVITED
+                SpaceRoomItemView(
+                    spaceRoom = spaceRoom,
+                    showUnreadIndicator = isInvitation && spaceRoom.roomId !in state.seenSpaceInvites,
                     hideAvatars = isInvitation && state.hideInvitesAvatar,
                     onClick = {
-                        onSpaceClick(it.spaceId)
+                        onSpaceClick(spaceRoom.roomId)
+                    },
+                    onLongClick = {
+                        // TODO
                     }
                 )
             }

features/home/impl/src/main/kotlin/io/element/android/features/home/impl/spaces/SpaceRoomProvider.kt

@@ -8,77 +8,44 @@
 package io.element.android.features.home.impl.spaces
 
 import androidx.compose.ui.tooling.preview.PreviewParameterProvider
-import io.element.android.libraries.matrix.api.core.RoomAlias
-import io.element.android.libraries.matrix.api.core.SpaceId
+import io.element.android.libraries.matrix.api.core.RoomId
 import io.element.android.libraries.matrix.api.room.CurrentUserMembership
-import io.element.android.libraries.matrix.api.room.RoomType
-import io.element.android.libraries.matrix.api.room.join.JoinRule
 import io.element.android.libraries.matrix.api.spaces.SpaceRoom
-import io.element.android.libraries.matrix.api.user.MatrixUser
+import io.element.android.libraries.previewutils.room.aSpaceRoom
 
 class SpaceRoomProvider : PreviewParameterProvider<SpaceRoom> {
     override val values: Sequence<SpaceRoom> = sequenceOf(
-        aSpaceRooms(),
-        aSpaceRooms(
+        aSpaceRoom(),
+        aSpaceRoom(
             numJoinedMembers = 5,
             childrenCount = 10,
             worldReadable = true,
-            spaceId = SpaceId("!spaceId0:example.com"),
+            roomId = RoomId("!spaceId0:example.com"),
         ),
-        aSpaceRooms(
+        aSpaceRoom(
             numJoinedMembers = 5,
             childrenCount = 10,
             worldReadable = true,
             avatarUrl = "anUrl",
-            spaceId = SpaceId("!spaceId1:example.com"),
+            roomId = RoomId("!spaceId1:example.com"),
         ),
-        aSpaceRooms(
+        aSpaceRoom(
             name = null,
             numJoinedMembers = 5,
             childrenCount = 10,
             worldReadable = true,
             avatarUrl = "anUrl",
-            spaceId = SpaceId("!spaceId2:example.com"),
+            roomId = RoomId("!spaceId2:example.com"),
             state = CurrentUserMembership.INVITED,
         ),
-        aSpaceRooms(
+        aSpaceRoom(
             name = null,
             numJoinedMembers = 5,
             childrenCount = 10,
             worldReadable = true,
             avatarUrl = "anUrl",
-            spaceId = SpaceId("!spaceId3:example.com"),
+            roomId = RoomId("!spaceId3:example.com"),
             state = CurrentUserMembership.INVITED,
         ),
     )
 }
-
-fun aSpaceRooms(
-    name: String? = "Space name",
-    avatarUrl: String? = null,
-    canonicalAlias: RoomAlias? = null,
-    childrenCount: Int = 0,
-    guestCanJoin: Boolean = false,
-    heroes: List<MatrixUser> = emptyList(),
-    joinRule: JoinRule? = null,
-    numJoinedMembers: Int = 0,
-    spaceId: SpaceId = SpaceId("!spaceId:example.com"),
-    roomType: RoomType = RoomType.Space,
-    state: CurrentUserMembership? = null,
-    topic: String? = null,
-    worldReadable: Boolean = false,
-) = SpaceRoom(
-    name = name,
-    avatarUrl = avatarUrl,
-    canonicalAlias = canonicalAlias,
-    childrenCount = childrenCount,
-    guestCanJoin = guestCanJoin,
-    heroes = heroes,
-    joinRule = joinRule,
-    numJoinedMembers = numJoinedMembers,
-    spaceId = spaceId,
-    roomType = roomType,
-    state = state,
-    topic = topic,
-    worldReadable = worldReadable
-)

features/invite/api/src/main/kotlin/io/element/android/features/invite/api/SeenInvitesStore.kt

@@ -8,10 +8,7 @@
 package io.element.android.features.invite.api
 
 import io.element.android.libraries.matrix.api.core.RoomId
-import io.element.android.libraries.matrix.api.core.SpaceId
-import io.element.android.libraries.matrix.api.core.toSpaceId
 import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.map
 
 interface SeenInvitesStore {
     /**
@@ -38,9 +35,3 @@ interface SeenInvitesStore {
      */
     suspend fun clear()
 }
-
-fun SeenInvitesStore.seenSpaceIds(): Flow<Set<SpaceId>> {
-    return seenRoomIds().map { roomIds ->
-        roomIds.map { it.toSpaceId() }.toSet()
-    }
-}

features/joinroom/impl/src/main/kotlin/io/element/android/features/joinroom/impl/JoinRoomPresenter.kt

@@ -34,7 +34,6 @@ import io.element.android.features.roomdirectory.api.RoomDescription
 import io.element.android.libraries.architecture.AsyncAction
 import io.element.android.libraries.architecture.Presenter
 import io.element.android.libraries.architecture.runUpdatingState
-import io.element.android.libraries.core.coroutine.mapState
 import io.element.android.libraries.core.meta.BuildMeta
 import io.element.android.libraries.matrix.api.MatrixClient
 import io.element.android.libraries.matrix.api.core.RoomId
@@ -50,6 +49,7 @@ import io.element.android.libraries.matrix.api.room.join.JoinRoom
 import io.element.android.libraries.matrix.api.room.join.JoinRule
 import io.element.android.libraries.matrix.api.room.preview.RoomPreviewInfo
 import io.element.android.libraries.matrix.ui.model.toInviteSender
+import io.element.android.libraries.matrix.ui.safety.rememberHideInvitesAvatar
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.launch
 import java.util.Optional
@@ -93,12 +93,7 @@ class JoinRoomPresenter(
         val forgetRoomAction: MutableState<AsyncAction<Unit>> = remember { mutableStateOf(AsyncAction.Uninitialized) }
         var knockMessage by rememberSaveable { mutableStateOf("") }
         var isDismissingContent by remember { mutableStateOf(false) }
-        val hideInviteAvatars by remember {
-            matrixClient
-                .mediaPreviewService()
-                .mediaPreviewConfigFlow
-                .mapState { config -> config.hideInviteAvatar }
-        }.collectAsState()
+        val hideInviteAvatars by matrixClient.rememberHideInvitesAvatar()
         val canReportRoom by produceState(false) { value = matrixClient.canReportRoom() }
 
         val contentState by produceState<ContentState>(

features/space/api/build.gradle.kts

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

features/space/api/src/main/kotlin/io/element/android/features/space/api/SpaceEntryPoint.kt

@@ -0,0 +1,35 @@
+/*
+ * 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.features.space.api
+
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.plugin.Plugin
+import io.element.android.libraries.architecture.FeatureEntryPoint
+import io.element.android.libraries.matrix.api.core.RoomId
+
+interface SpaceEntryPoint : FeatureEntryPoint {
+    fun nodeBuilder(
+        parentNode: Node,
+        buildContext: BuildContext,
+    ): NodeBuilder
+
+    interface NodeBuilder {
+        fun inputs(inputs: Inputs): NodeBuilder
+        fun callback(callback: Callback): NodeBuilder
+        fun build(): Node
+    }
+
+    data class Inputs(
+        val roomId: RoomId
+    ) : Plugin
+
+    interface Callback : Plugin {
+        fun onOpenRoom(roomId: RoomId)
+    }
+}

features/space/impl/build.gradle.kts

@@ -0,0 +1,57 @@
+import extension.setupDependencyInjection
+
+/*
+ * 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.
+ */
+
+plugins {
+    id("io.element.android-compose-library")
+    id("kotlin-parcelize")
+}
+
+android {
+    namespace = "io.element.android.features.space.impl"
+
+    testOptions {
+        unitTests {
+            isIncludeAndroidResources = true
+        }
+    }
+}
+
+setupDependencyInjection()
+
+dependencies {
+    implementation(projects.libraries.core)
+    implementation(projects.libraries.architecture)
+    implementation(projects.libraries.matrix.api)
+    implementation(projects.libraries.matrixui)
+    implementation(projects.libraries.designsystem)
+    implementation(projects.libraries.uiStrings)
+    implementation(projects.libraries.androidutils)
+    implementation(projects.libraries.deeplink.api)
+    implementation(projects.services.analytics.api)
+    implementation(libs.coil.compose)
+    implementation(projects.libraries.featureflag.api)
+    implementation(projects.features.invite.api)
+    implementation(projects.libraries.previewutils)
+    api(projects.features.space.api)
+
+    testImplementation(libs.test.junit)
+    testImplementation(libs.test.mockk)
+    testImplementation(libs.coroutines.test)
+    testImplementation(libs.molecule.runtime)
+    testImplementation(libs.test.truth)
+    testImplementation(libs.test.turbine)
+    testImplementation(libs.test.robolectric)
+    testImplementation(projects.services.analytics.test)
+    testImplementation(projects.libraries.matrix.test)
+    testImplementation(projects.libraries.featureflag.test)
+    testImplementation(projects.tests.testutils)
+    testImplementation(libs.androidx.compose.ui.test.junit)
+    testImplementation(projects.features.invite.test)
+    testReleaseImplementation(libs.androidx.compose.ui.test.manifest)
+}

features/space/impl/src/main/kotlin/io/element/android/features/space/impl/DefaultSpaceEntryPoint.kt

@@ -0,0 +1,40 @@
+/*
+ * 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.features.space.impl
+
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.plugin.Plugin
+import dev.zacsweers.metro.ContributesBinding
+import dev.zacsweers.metro.Inject
+import io.element.android.features.space.api.SpaceEntryPoint
+import io.element.android.libraries.architecture.createNode
+import io.element.android.libraries.di.SessionScope
+
+@ContributesBinding(SessionScope::class)
+@Inject
+class DefaultSpaceEntryPoint : SpaceEntryPoint {
+    override fun nodeBuilder(parentNode: Node, buildContext: BuildContext): SpaceEntryPoint.NodeBuilder {
+        val plugins = mutableSetOf<Plugin>()
+        return object : SpaceEntryPoint.NodeBuilder {
+            override fun inputs(inputs: SpaceEntryPoint.Inputs): SpaceEntryPoint.NodeBuilder {
+                plugins.add(inputs)
+                return this
+            }
+
+            override fun callback(callback: SpaceEntryPoint.Callback): SpaceEntryPoint.NodeBuilder {
+                plugins.add(callback)
+                return this
+            }
+
+            override fun build(): Node {
+                return parentNode.createNode<SpaceNode>(buildContext, plugins = plugins.toList())
+            }
+        }
+    }
+}

features/space/impl/src/main/kotlin/io/element/android/features/space/impl/SpaceEvents.kt

@@ -0,0 +1,12 @@
+/*
+ * 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.features.space.impl
+
+sealed interface SpaceEvents {
+    data object LoadMore : SpaceEvents
+}

features/space/impl/src/main/kotlin/io/element/android/features/space/impl/SpaceNode.kt

@@ -0,0 +1,44 @@
+/*
+ * 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.features.space.impl
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.plugin.Plugin
+import dev.zacsweers.metro.Assisted
+import dev.zacsweers.metro.Inject
+import io.element.android.annotations.ContributesNode
+import io.element.android.features.space.api.SpaceEntryPoint
+import io.element.android.libraries.di.SessionScope
+
+@ContributesNode(SessionScope::class)
+@Inject
+class SpaceNode(
+    @Assisted buildContext: BuildContext,
+    @Assisted plugins: List<Plugin>,
+    presenterFactory: SpacePresenter.Factory,
+) : Node(buildContext, plugins = plugins) {
+    private val inputs = plugins.filterIsInstance<SpaceEntryPoint.Inputs>().single()
+    private val callback = plugins.filterIsInstance<SpaceEntryPoint.Callback>().single()
+    private val presenter = presenterFactory.create(inputs)
+
+    @Composable
+    override fun View(modifier: Modifier) {
+        val state = presenter.present()
+        SpaceView(
+            state = state,
+            onBackClick = ::navigateUp,
+            onRoomClick = { roomId ->
+                callback.onOpenRoom(roomId)
+            },
+            modifier = modifier
+        )
+    }
+}

features/space/impl/src/main/kotlin/io/element/android/features/space/impl/SpacePresenter.kt

@@ -0,0 +1,87 @@
+/*
+ * 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.features.space.impl
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import dev.zacsweers.metro.Assisted
+import dev.zacsweers.metro.AssistedFactory
+import dev.zacsweers.metro.Inject
+import io.element.android.features.invite.api.SeenInvitesStore
+import io.element.android.features.space.api.SpaceEntryPoint
+import io.element.android.libraries.architecture.Presenter
+import io.element.android.libraries.core.coroutine.mapState
+import io.element.android.libraries.matrix.api.MatrixClient
+import io.element.android.libraries.matrix.api.spaces.SpaceRoomList
+import io.element.android.libraries.matrix.ui.safety.rememberHideInvitesAvatar
+import kotlinx.collections.immutable.persistentSetOf
+import kotlinx.collections.immutable.toPersistentList
+import kotlinx.collections.immutable.toPersistentSet
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.launch
+
+@Inject
+class SpacePresenter(
+    @Assisted private val inputs: SpaceEntryPoint.Inputs,
+    private val client: MatrixClient,
+    private val seenInvitesStore: SeenInvitesStore,
+) : Presenter<SpaceState> {
+    @AssistedFactory
+    interface Factory {
+        fun create(inputs: SpaceEntryPoint.Inputs): SpacePresenter
+    }
+
+    private val spaceRoomList = client.spaceService.spaceRoomList(inputs.roomId)
+
+    @Composable
+    override fun present(): SpaceState {
+        LaunchedEffect(Unit) {
+            paginate()
+        }
+        val hideInvitesAvatar by client.rememberHideInvitesAvatar()
+        val seenSpaceInvites by remember {
+            seenInvitesStore.seenRoomIds().map { it.toPersistentSet() }
+        }.collectAsState(persistentSetOf())
+
+        val coroutineScope = rememberCoroutineScope()
+        val children by spaceRoomList.spaceRoomsFlow.collectAsState(emptyList())
+        val hasMoreToLoad by remember {
+            spaceRoomList.paginationStatusFlow.mapState { status ->
+                when (status) {
+                    is SpaceRoomList.PaginationStatus.Idle -> status.hasMoreToLoad
+                    SpaceRoomList.PaginationStatus.Loading -> true
+                }
+            }
+        }.collectAsState()
+
+        val currentSpace by remember { spaceRoomList.currentSpaceFlow() }.collectAsState(null)
+
+        fun handleEvents(event: SpaceEvents) {
+            when (event) {
+                SpaceEvents.LoadMore -> coroutineScope.paginate()
+            }
+        }
+        return SpaceState(
+            currentSpace = currentSpace,
+            children = children.toPersistentList(),
+            seenSpaceInvites = seenSpaceInvites,
+            hideInvitesAvatar = hideInvitesAvatar,
+            hasMoreToLoad = hasMoreToLoad,
+            eventSink = ::handleEvents,
+        )
+    }
+
+    private fun CoroutineScope.paginate() = launch {
+        spaceRoomList.paginate()
+    }
+}

features/space/impl/src/main/kotlin/io/element/android/features/space/impl/SpaceState.kt

@@ -0,0 +1,22 @@
+/*
+ * 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.features.space.impl
+
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.api.spaces.SpaceRoom
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.ImmutableSet
+
+data class SpaceState(
+    val currentSpace: SpaceRoom?,
+    val children: ImmutableList<SpaceRoom>,
+    val seenSpaceInvites: ImmutableSet<RoomId>,
+    val hideInvitesAvatar: Boolean,
+    val hasMoreToLoad: Boolean,
+    val eventSink: (SpaceEvents) -> Unit
+)

features/space/impl/src/main/kotlin/io/element/android/features/space/impl/SpaceStateProvider.kt

@@ -0,0 +1,60 @@
+/*
+ * 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.features.space.impl
+
+import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.api.spaces.SpaceRoom
+import io.element.android.libraries.previewutils.room.aSpaceRoom
+import kotlinx.collections.immutable.toImmutableList
+import kotlinx.collections.immutable.toImmutableSet
+
+open class SpaceStateProvider : PreviewParameterProvider<SpaceState> {
+    override val values: Sequence<SpaceState>
+        get() = sequenceOf(
+            aSpaceState(),
+            aSpaceState(hasMoreToLoad = true),
+            aSpaceState(
+                hasMoreToLoad = true,
+                children = aListOfSpaceRooms(),
+            ),
+            aSpaceState(
+                hasMoreToLoad = false,
+                children = aListOfSpaceRooms()
+            )
+            // Add other states here
+        )
+}
+
+fun aSpaceState(
+    parentSpace: SpaceRoom? = aSpaceRoom(
+        numJoinedMembers = 5,
+        childrenCount = 10,
+        worldReadable = true,
+        roomId = RoomId("!spaceId0:example.com"),
+    ),
+    children: List<SpaceRoom> = emptyList(),
+    seenSpaceInvites: Set<RoomId> = emptySet(),
+    hideInvitesAvatar: Boolean = false,
+    hasMoreToLoad: Boolean = false,
+) = SpaceState(
+    currentSpace = parentSpace,
+    children = children.toImmutableList(),
+    seenSpaceInvites = seenSpaceInvites.toImmutableSet(),
+    hideInvitesAvatar = hideInvitesAvatar,
+    hasMoreToLoad = hasMoreToLoad,
+    eventSink = {}
+)
+
+private fun aListOfSpaceRooms(): List<SpaceRoom> {
+    return listOf(
+        aSpaceRoom(roomId = RoomId("!spaceId0:example.com")),
+        aSpaceRoom(roomId = RoomId("!spaceId1:example.com")),
+        aSpaceRoom(roomId = RoomId("!spaceId2:example.com")),
+    )
+}

features/space/impl/src/main/kotlin/io/element/android/features/space/impl/SpaceView.kt

@@ -0,0 +1,205 @@
+/*
+ * 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.features.space.impl
+
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.heading
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.font.FontStyle
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.tooling.preview.PreviewParameter
+import androidx.compose.ui.unit.dp
+import io.element.android.compound.theme.ElementTheme
+import io.element.android.libraries.designsystem.components.avatar.Avatar
+import io.element.android.libraries.designsystem.components.avatar.AvatarData
+import io.element.android.libraries.designsystem.components.avatar.AvatarSize
+import io.element.android.libraries.designsystem.components.avatar.AvatarType
+import io.element.android.libraries.designsystem.components.button.BackButton
+import io.element.android.libraries.designsystem.preview.ElementPreview
+import io.element.android.libraries.designsystem.preview.PreviewsDayNight
+import io.element.android.libraries.designsystem.theme.components.CircularProgressIndicator
+import io.element.android.libraries.designsystem.theme.components.Scaffold
+import io.element.android.libraries.designsystem.theme.components.Text
+import io.element.android.libraries.designsystem.theme.components.TopAppBar
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.api.room.CurrentUserMembership
+import io.element.android.libraries.matrix.api.spaces.SpaceRoom
+import io.element.android.libraries.matrix.ui.components.SpaceHeaderView
+import io.element.android.libraries.matrix.ui.components.SpaceRoomItemView
+import io.element.android.libraries.matrix.ui.model.getAvatarData
+import io.element.android.libraries.ui.strings.CommonStrings
+import kotlinx.collections.immutable.toImmutableList
+
+@Composable
+fun SpaceView(
+    state: SpaceState,
+    onBackClick: () -> Unit,
+    onRoomClick: (roomId: RoomId) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    Scaffold(
+        modifier = modifier,
+        topBar = {
+            SpaceViewTopBar(currentSpace = state.currentSpace, onBackClick = onBackClick)
+        },
+        content = { padding ->
+            Box(
+                modifier = Modifier.padding(padding)
+            ) {
+                SpaceViewContent(
+                    state = state,
+                    onRoomClick = onRoomClick
+                )
+            }
+        },
+    )
+}
+
+@Composable
+private fun SpaceViewContent(
+    state: SpaceState,
+    onRoomClick: (roomId: RoomId) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    LazyColumn(modifier.fillMaxSize()) {
+        val currentSpace = state.currentSpace
+        if (currentSpace != null) {
+            item {
+                SpaceHeaderView(
+                    avatarData = currentSpace.getAvatarData(AvatarSize.SpaceHeader),
+                    name = currentSpace.name,
+                    topic = currentSpace.topic,
+                    joinRule = currentSpace.joinRule,
+                    heroes = currentSpace.heroes.toImmutableList(),
+                    numberOfMembers = currentSpace.numJoinedMembers,
+                    numberOfRooms = currentSpace.childrenCount,
+                )
+            }
+        }
+        state.children.forEach { spaceRoom ->
+            item {
+                val isInvitation = spaceRoom.state == CurrentUserMembership.INVITED
+                SpaceRoomItemView(
+                    spaceRoom = spaceRoom,
+                    showUnreadIndicator = isInvitation && spaceRoom.roomId !in state.seenSpaceInvites,
+                    hideAvatars = isInvitation && state.hideInvitesAvatar,
+                    onClick = {
+                        onRoomClick(spaceRoom.roomId)
+                    },
+                    onLongClick = {
+                        // TODO
+                    }
+                )
+            }
+        }
+        if (state.hasMoreToLoad) {
+            item {
+                LoadingMoreIndicator(eventSink = state.eventSink)
+            }
+        }
+    }
+}
+
+@Composable
+private fun LoadingMoreIndicator(
+    eventSink: (SpaceEvents) -> Unit,
+    modifier: Modifier = Modifier
+) {
+    Box(
+        modifier = modifier.fillMaxWidth(),
+        contentAlignment = Alignment.Center,
+    ) {
+        CircularProgressIndicator(
+            strokeWidth = 2.dp,
+            modifier = Modifier.padding(vertical = 8.dp)
+        )
+        val latestEventSink by rememberUpdatedState(eventSink)
+        LaunchedEffect(Unit) {
+            latestEventSink(SpaceEvents.LoadMore)
+        }
+    }
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun SpaceViewTopBar(
+    currentSpace: SpaceRoom?,
+    onBackClick: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    TopAppBar(
+        modifier = modifier,
+        navigationIcon = {
+            BackButton(onClick = onBackClick)
+        },
+        title = {
+            if (currentSpace != null) {
+                SpaceAvatarAndNameRow(
+                    name = currentSpace.name,
+                    avatarData = currentSpace.getAvatarData(AvatarSize.TimelineRoom),
+                )
+            }
+        },
+        actions = {
+        },
+    )
+}
+
+@Composable
+private fun SpaceAvatarAndNameRow(
+    name: String?,
+    avatarData: AvatarData,
+    modifier: Modifier = Modifier
+) {
+    Row(
+        modifier = modifier,
+        verticalAlignment = Alignment.CenterVertically
+    ) {
+        Avatar(
+            avatarData = avatarData,
+            avatarType = AvatarType.Space(),
+        )
+        Text(
+            modifier = Modifier
+                .padding(horizontal = 8.dp)
+                .semantics {
+                    heading()
+                },
+            text = name ?: stringResource(CommonStrings.common_no_room_name),
+            style = ElementTheme.typography.fontBodyLgMedium,
+            fontStyle = FontStyle.Italic.takeIf { name == null },
+            maxLines = 1,
+            overflow = TextOverflow.Ellipsis
+        )
+    }
+}
+
+@PreviewsDayNight
+@Composable
+internal fun SpaceViewPreview(
+    @PreviewParameter(SpaceStateProvider::class) state: SpaceState
+) = ElementPreview {
+    SpaceView(
+        state = state,
+        onRoomClick = {},
+        onBackClick = {},
+    )
+}

features/space/impl/src/test/kotlin/io/element/android/features/space/impl/SpacePresenterTest.kt

@@ -0,0 +1,167 @@
+/*
+ * 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.
+ */
+
+@file:OptIn(ExperimentalCoroutinesApi::class)
+
+package io.element.android.features.space.impl
+
+import com.google.common.truth.Truth.assertThat
+import io.element.android.features.invite.api.SeenInvitesStore
+import io.element.android.features.invite.test.InMemorySeenInvitesStore
+import io.element.android.features.space.api.SpaceEntryPoint
+import io.element.android.libraries.matrix.api.MatrixClient
+import io.element.android.libraries.matrix.api.spaces.SpaceRoomList
+import io.element.android.libraries.matrix.test.A_ROOM_ID
+import io.element.android.libraries.matrix.test.FakeMatrixClient
+import io.element.android.libraries.matrix.test.spaces.FakeSpaceRoomList
+import io.element.android.libraries.matrix.test.spaces.FakeSpaceService
+import io.element.android.libraries.previewutils.room.aSpaceRoom
+import io.element.android.tests.testutils.lambda.lambdaRecorder
+import io.element.android.tests.testutils.test
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.advanceUntilIdle
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+class SpacePresenterTest {
+    @Test
+    fun `present - initial state`() = runTest {
+        val paginateResult = lambdaRecorder<Result<Unit>> {
+            Result.success(Unit)
+        }
+        val presenter = createSpacePresenter(
+            client = FakeMatrixClient(
+                spaceService = FakeSpaceService(
+                    spaceRoomListResult = {
+                        FakeSpaceRoomList(
+                            paginateResult = paginateResult,
+                        )
+                    },
+                ),
+            ),
+        )
+        presenter.test {
+            val state = awaitItem()
+            assertThat(state.currentSpace).isNull()
+            assertThat(state.children).isEmpty()
+            assertThat(state.seenSpaceInvites).isEmpty()
+            assertThat(state.hideInvitesAvatar).isFalse()
+            assertThat(state.hasMoreToLoad).isTrue()
+            advanceUntilIdle()
+            paginateResult.assertions().isCalledOnce()
+        }
+    }
+
+    @Test
+    fun `present - load more`() = runTest {
+        val paginateResult = lambdaRecorder<Result<Unit>> {
+            Result.success(Unit)
+        }
+        val presenter = createSpacePresenter(
+            client = FakeMatrixClient(
+                spaceService = FakeSpaceService(
+                    spaceRoomListResult = {
+                        FakeSpaceRoomList(
+                            paginateResult = paginateResult,
+                        )
+                    },
+                ),
+            ),
+        )
+        presenter.test {
+            val state = awaitItem()
+            advanceUntilIdle()
+            paginateResult.assertions().isCalledOnce()
+            state.eventSink(SpaceEvents.LoadMore)
+            advanceUntilIdle()
+            paginateResult.assertions().isCalledExactly(2)
+        }
+    }
+
+    @Test
+    fun `present - has more to load value`() = runTest {
+        val fakeSpaceRoomList = FakeSpaceRoomList(
+            paginateResult = { Result.success(Unit) },
+        )
+        val presenter = createSpacePresenter(
+            client = FakeMatrixClient(
+                spaceService = FakeSpaceService(
+                    spaceRoomListResult = { fakeSpaceRoomList },
+                ),
+            ),
+        )
+        presenter.test {
+            val state = awaitItem()
+            advanceUntilIdle()
+            assertThat(state.hasMoreToLoad).isTrue()
+            fakeSpaceRoomList.emitPaginationStatus(
+                SpaceRoomList.PaginationStatus.Idle(hasMoreToLoad = false)
+            )
+            assertThat(awaitItem().hasMoreToLoad).isFalse()
+            fakeSpaceRoomList.emitPaginationStatus(
+                SpaceRoomList.PaginationStatus.Idle(hasMoreToLoad = true)
+            )
+            assertThat(awaitItem().hasMoreToLoad).isTrue()
+        }
+    }
+
+    @Test
+    fun `present - current space value`() = runTest {
+        val fakeSpaceRoomList = FakeSpaceRoomList(
+            paginateResult = { Result.success(Unit) },
+        )
+        val presenter = createSpacePresenter(
+            client = FakeMatrixClient(
+                spaceService = FakeSpaceService(
+                    spaceRoomListResult = { fakeSpaceRoomList },
+                ),
+            ),
+        )
+        presenter.test {
+            val state = awaitItem()
+            advanceUntilIdle()
+            assertThat(state.currentSpace).isNull()
+            val aSpace = aSpaceRoom()
+            fakeSpaceRoomList.emitCurrentSpace(aSpace)
+            assertThat(awaitItem().currentSpace).isEqualTo(aSpace)
+        }
+    }
+
+    @Test
+    fun `present - children value`() = runTest {
+        val fakeSpaceRoomList = FakeSpaceRoomList(
+            paginateResult = { Result.success(Unit) },
+        )
+        val presenter = createSpacePresenter(
+            client = FakeMatrixClient(
+                spaceService = FakeSpaceService(
+                    spaceRoomListResult = { fakeSpaceRoomList },
+                ),
+            ),
+        )
+        presenter.test {
+            val state = awaitItem()
+            advanceUntilIdle()
+            assertThat(state.children).isEmpty()
+            val aSpace = aSpaceRoom()
+            fakeSpaceRoomList.emitSpaceRooms(listOf(aSpace))
+            assertThat(awaitItem().children).containsExactly(aSpace)
+        }
+    }
+
+    private fun createSpacePresenter(
+        inputs: SpaceEntryPoint.Inputs = SpaceEntryPoint.Inputs(A_ROOM_ID),
+        client: MatrixClient = FakeMatrixClient(),
+        seenInvitesStore: SeenInvitesStore = InMemorySeenInvitesStore(),
+    ): SpacePresenter {
+        return SpacePresenter(
+            inputs = inputs,
+            client = client,
+            seenInvitesStore = seenInvitesStore,
+        )
+    }
+}