refactor (start chat) : start splitting things (create room, invite people, start chat)

features/startchat/api/build.gradle.kts

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

features/startchat/api/src/main/kotlin/io/element/android/features/startchat/api/ConfirmingStartDmWithMatrixUser.kt

@@ -0,0 +1,15 @@
+/*
+ * 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.startchat.api
+
+import io.element.android.libraries.architecture.AsyncAction
+import io.element.android.libraries.matrix.api.user.MatrixUser
+
+data class ConfirmingStartDmWithMatrixUser(
+    val matrixUser: MatrixUser,
+) : AsyncAction.Confirming

features/startchat/api/src/main/kotlin/io/element/android/features/startchat/api/StartChatEntryPoint.kt

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2023, 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.
+ */
+
+package io.element.android.features.startchat.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.RoomIdOrAlias
+
+interface StartChatEntryPoint : FeatureEntryPoint {
+    fun nodeBuilder(parentNode: Node, buildContext: BuildContext): NodeBuilder
+    interface NodeBuilder {
+        fun callback(callback: Callback): NodeBuilder
+        fun build(): Node
+    }
+
+    interface Callback : Plugin {
+        fun onOpenRoom(roomIdOrAlias: RoomIdOrAlias, serverNames: List<String>)
+        fun onOpenRoomDirectory()
+    }
+}

features/startchat/api/src/main/kotlin/io/element/android/features/startchat/api/StartDMAction.kt

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2023, 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.
+ */
+
+package io.element.android.features.startchat.api
+
+import androidx.compose.runtime.MutableState
+import io.element.android.libraries.architecture.AsyncAction
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.api.user.MatrixUser
+
+interface StartDMAction {
+    /**
+     * Try to find an existing DM with the given user, or create one if none exists.
+     * @param matrixUser The user to start a DM with.
+     * @param createIfDmDoesNotExist If true, create a DM if one does not exist. If false and the DM
+     * does not exist, the action will fail with the value [ConfirmingStartDmWithMatrixUser].
+     * @param actionState The state to update with the result of the action.
+     */
+    suspend fun execute(
+        matrixUser: MatrixUser,
+        createIfDmDoesNotExist: Boolean,
+        actionState: MutableState<AsyncAction<RoomId>>,
+    )
+}

features/startchat/impl/build.gradle.kts

@@ -0,0 +1,64 @@
+import extension.ComponentMergingStrategy
+import extension.setupAnvil
+
+/*
+ * 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-compose-library")
+    id("kotlin-parcelize")
+}
+
+android {
+    namespace = "io.element.android.features.startchat.impl"
+
+    testOptions {
+        unitTests {
+            isIncludeAndroidResources = true
+        }
+    }
+}
+
+setupAnvil(componentMergingStrategy = ComponentMergingStrategy.KSP)
+
+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)
+    implementation(projects.libraries.mediapickers.api)
+    implementation(projects.libraries.mediaupload.api)
+    implementation(projects.libraries.permissions.api)
+    implementation(projects.libraries.usersearch.impl)
+    implementation(projects.services.analytics.api)
+    implementation(libs.coil.compose)
+    implementation(projects.libraries.featureflag.api)
+    api(projects.features.startchat.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.mediapickers.test)
+    testImplementation(projects.libraries.mediaupload.test)
+    testImplementation(projects.libraries.permissions.test)
+    testImplementation(projects.libraries.usersearch.test)
+    testImplementation(projects.features.startchat.test)
+    testImplementation(projects.libraries.featureflag.test)
+    testImplementation(projects.tests.testutils)
+    testImplementation(libs.androidx.compose.ui.test.junit)
+    testReleaseImplementation(libs.androidx.compose.ui.test.manifest)
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/StartChatNavigator.kt

@@ -0,0 +1,48 @@
+/*
+ * 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.startchat
+
+import com.bumble.appyx.core.plugin.Plugin
+import com.bumble.appyx.navmodel.backstack.BackStack
+import com.bumble.appyx.navmodel.backstack.operation.push
+import io.element.android.features.startchat.impl.StartChatFlowNode.NavTarget
+import io.element.android.libraries.architecture.overlay.Overlay
+import io.element.android.libraries.architecture.overlay.operation.hide
+import io.element.android.libraries.architecture.overlay.operation.show
+import io.element.android.libraries.matrix.api.core.RoomIdOrAlias
+
+interface StartChatNavigator : Plugin {
+    fun onOpenRoom(roomIdOrAlias: RoomIdOrAlias, serverNames: List<String>)
+    fun onCreateNewRoom()
+    fun onShowJoinRoomByAddress()
+    fun onDismissJoinRoomByAddress()
+    fun onOpenRoomDirectory()
+}
+
+class DefaultStartChatNavigator(
+    private val backstack: BackStack<NavTarget>,
+    private val overlay: Overlay<NavTarget>,
+    private val openRoom: (RoomIdOrAlias, List<String>) -> Unit,
+    private val openRoomDirectory: () -> Unit,
+) : StartChatNavigator {
+    override fun onOpenRoom(roomIdOrAlias: RoomIdOrAlias, serverNames: List<String>) = openRoom(roomIdOrAlias, serverNames)
+
+    override fun onOpenRoomDirectory() = openRoomDirectory()
+
+    override fun onCreateNewRoom() {
+        backstack.push(NavTarget.NewRoom)
+    }
+
+    override fun onShowJoinRoomByAddress() {
+        overlay.show(NavTarget.JoinByAddress)
+    }
+
+    override fun onDismissJoinRoomByAddress() {
+        overlay.hide()
+    }
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/CreateRoomConfig.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.startchat.impl
+
+import android.net.Uri
+import io.element.android.features.startchat.impl.configureroom.RoomVisibilityState
+import io.element.android.libraries.matrix.api.user.MatrixUser
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.persistentListOf
+
+data class CreateRoomConfig(
+    val roomName: String? = null,
+    val topic: String? = null,
+    val avatarUri: Uri? = null,
+    val invites: ImmutableList<MatrixUser> = persistentListOf(),
+    val roomVisibility: RoomVisibilityState = RoomVisibilityState.Private,
+)

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/CreateRoomDataStore.kt

@@ -0,0 +1,134 @@
+/*
+ * 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.startchat.impl
+
+import android.net.Uri
+import io.element.android.features.startchat.impl.configureroom.RoomAccess
+import io.element.android.features.startchat.impl.configureroom.RoomAccessItem
+import io.element.android.features.startchat.impl.configureroom.RoomAddress
+import io.element.android.features.startchat.impl.configureroom.RoomVisibilityItem
+import io.element.android.features.startchat.impl.configureroom.RoomVisibilityState
+import io.element.android.features.startchat.impl.di.CreateRoomScope
+import io.element.android.features.startchat.impl.userlist.UserListDataStore
+import io.element.android.libraries.androidutils.file.safeDelete
+import io.element.android.libraries.di.SingleIn
+import io.element.android.libraries.matrix.api.room.alias.RoomAliasHelper
+import kotlinx.collections.immutable.toImmutableList
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.getAndUpdate
+import java.io.File
+import javax.inject.Inject
+
+@SingleIn(CreateRoomScope::class)
+class CreateRoomDataStore @Inject constructor(
+    val selectedUserListDataStore: UserListDataStore,
+    private val roomAliasHelper: RoomAliasHelper,
+) {
+    private val createRoomConfigFlow: MutableStateFlow<CreateRoomConfig> = MutableStateFlow(CreateRoomConfig())
+    private var cachedAvatarUri: Uri? = null
+        set(value) {
+            field?.path?.let { File(it) }?.safeDelete()
+            field = value
+        }
+
+    val createRoomConfigWithInvites: Flow<CreateRoomConfig> = combine(
+        selectedUserListDataStore.selectedUsers,
+        createRoomConfigFlow,
+    ) { selectedUsers, config ->
+        config.copy(invites = selectedUsers.toImmutableList())
+    }
+
+    fun setRoomName(roomName: String) {
+        createRoomConfigFlow.getAndUpdate { config ->
+            val newVisibility = when (config.roomVisibility) {
+                is RoomVisibilityState.Public -> {
+                    val roomAddress = config.roomVisibility.roomAddress
+                    if (roomAddress is RoomAddress.AutoFilled || roomName.isEmpty()) {
+                        val roomAliasName = roomAliasHelper.roomAliasNameFromRoomDisplayName(roomName)
+                        config.roomVisibility.copy(
+                            roomAddress = RoomAddress.AutoFilled(roomAliasName),
+                        )
+                    } else {
+                        config.roomVisibility
+                    }
+                }
+                else -> config.roomVisibility
+            }
+            config.copy(
+                roomName = roomName.takeIf { it.isNotEmpty() },
+                roomVisibility = newVisibility,
+            )
+        }
+    }
+
+    fun setTopic(topic: String) {
+        createRoomConfigFlow.getAndUpdate { config ->
+            config.copy(topic = topic.takeIf { it.isNotEmpty() })
+        }
+    }
+
+    fun setAvatarUri(uri: Uri?, cached: Boolean = false) {
+        cachedAvatarUri = uri.takeIf { cached }
+        createRoomConfigFlow.getAndUpdate { config ->
+            config.copy(avatarUri = uri)
+        }
+    }
+
+    fun setRoomVisibility(visibility: RoomVisibilityItem) {
+        createRoomConfigFlow.getAndUpdate { config ->
+            config.copy(
+                roomVisibility = when (visibility) {
+                    RoomVisibilityItem.Private -> RoomVisibilityState.Private
+                    RoomVisibilityItem.Public -> {
+                        val roomAliasName = roomAliasHelper.roomAliasNameFromRoomDisplayName(config.roomName.orEmpty())
+                        RoomVisibilityState.Public(
+                            roomAddress = RoomAddress.AutoFilled(roomAliasName),
+                            roomAccess = RoomAccess.Anyone,
+                        )
+                    }
+                }
+            )
+        }
+    }
+
+    fun setRoomAddress(address: String) {
+        createRoomConfigFlow.getAndUpdate { config ->
+            config.copy(
+                roomVisibility = when (config.roomVisibility) {
+                    is RoomVisibilityState.Public -> {
+                        val sanitizedAddress = address.lowercase()
+                        config.roomVisibility.copy(roomAddress = RoomAddress.Edited(sanitizedAddress))
+                    }
+                    else -> config.roomVisibility
+                }
+            )
+        }
+    }
+
+    fun setRoomAccess(access: RoomAccessItem) {
+        createRoomConfigFlow.getAndUpdate { config ->
+            config.copy(
+                roomVisibility = when (config.roomVisibility) {
+                    is RoomVisibilityState.Public -> {
+                        when (access) {
+                            RoomAccessItem.Anyone -> config.roomVisibility.copy(roomAccess = RoomAccess.Anyone)
+                            RoomAccessItem.AskToJoin -> config.roomVisibility.copy(roomAccess = RoomAccess.Knocking)
+                        }
+                    }
+                    else -> config.roomVisibility
+                }
+            )
+        }
+    }
+
+    fun clearCachedData() {
+        cachedAvatarUri = null
+    }
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/CreateRoomFlowNode.kt

@@ -0,0 +1,83 @@
+/*
+ * 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.startchat.impl
+
+import android.os.Parcelable
+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 com.bumble.appyx.core.plugin.plugins
+import com.bumble.appyx.navmodel.backstack.BackStack
+import com.bumble.appyx.navmodel.backstack.operation.push
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedInject
+import io.element.android.anvilannotations.ContributesNode
+import io.element.android.features.startchat.StartChatNavigator
+import io.element.android.features.startchat.impl.addpeople.AddPeopleNode
+import io.element.android.features.startchat.impl.configureroom.ConfigureRoomNode
+import io.element.android.features.startchat.impl.di.CreateRoomComponent
+import io.element.android.libraries.architecture.BackstackView
+import io.element.android.libraries.architecture.BaseFlowNode
+import io.element.android.libraries.architecture.bindings
+import io.element.android.libraries.architecture.createNode
+import io.element.android.libraries.di.DaggerComponentOwner
+import io.element.android.libraries.di.SessionScope
+import kotlinx.parcelize.Parcelize
+
+@ContributesNode(SessionScope::class)
+class CreateRoomFlowNode @AssistedInject constructor(
+    @Assisted buildContext: BuildContext,
+    @Assisted plugins: List<Plugin>,
+) : DaggerComponentOwner,
+    BaseFlowNode<CreateRoomFlowNode.NavTarget>(
+        backstack = BackStack(
+            initialElement = NavTarget.ConfigureRoom,
+            savedStateMap = buildContext.savedStateMap,
+        ),
+        buildContext = buildContext,
+        plugins = plugins
+    ) {
+    private val component by lazy {
+        parent!!.bindings<CreateRoomComponent.ParentBindings>().createRoomComponentBuilder().build()
+    }
+    private val navigator = plugins<StartChatNavigator>().first()
+
+    override val daggerComponent: Any
+        get() = component
+
+    sealed interface NavTarget : Parcelable {
+        @Parcelize
+        data object AddPeople : NavTarget
+
+        @Parcelize
+        data object ConfigureRoom : NavTarget
+    }
+
+    override fun resolve(navTarget: NavTarget, buildContext: BuildContext): Node {
+        return when (navTarget) {
+            NavTarget.AddPeople -> {
+                val callback = object : AddPeopleNode.Callback {
+                    override fun onContinue() {
+                        backstack.push(NavTarget.ConfigureRoom)
+                    }
+                }
+                createNode<AddPeopleNode>(buildContext = buildContext, plugins = listOf(callback))
+            }
+            NavTarget.ConfigureRoom -> {
+                createNode<ConfigureRoomNode>(buildContext = buildContext, plugins = listOf(navigator))
+            }
+        }
+    }
+
+    @Composable
+    override fun View(modifier: Modifier) {
+        BackstackView()
+    }
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/DefaultStartChatEntryPoint.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.startchat.impl
+
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.plugin.Plugin
+import com.squareup.anvil.annotations.ContributesBinding
+import io.element.android.features.startchat.api.StartChatEntryPoint
+import io.element.android.libraries.architecture.createNode
+import io.element.android.libraries.di.AppScope
+import javax.inject.Inject
+
+@ContributesBinding(AppScope::class)
+class DefaultStartChatEntryPoint @Inject constructor() : StartChatEntryPoint {
+    override fun nodeBuilder(parentNode: Node, buildContext: BuildContext): StartChatEntryPoint.NodeBuilder {
+        val plugins = ArrayList<Plugin>()
+
+        return object : StartChatEntryPoint.NodeBuilder {
+            override fun callback(callback: StartChatEntryPoint.Callback): StartChatEntryPoint.NodeBuilder {
+                plugins += callback
+                return this
+            }
+
+            override fun build(): Node {
+                return parentNode.createNode<StartChatFlowNode>(buildContext, plugins)
+            }
+        }
+    }
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/DefaultStartDMAction.kt

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2023, 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.
+ */
+
+package io.element.android.features.startchat.impl
+
+import androidx.compose.runtime.MutableState
+import com.squareup.anvil.annotations.ContributesBinding
+import im.vector.app.features.analytics.plan.CreatedRoom
+import io.element.android.features.startchat.api.ConfirmingStartDmWithMatrixUser
+import io.element.android.features.startchat.api.StartDMAction
+import io.element.android.libraries.architecture.AsyncAction
+import io.element.android.libraries.di.SessionScope
+import io.element.android.libraries.matrix.api.MatrixClient
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.api.room.StartDMResult
+import io.element.android.libraries.matrix.api.room.startDM
+import io.element.android.libraries.matrix.api.user.MatrixUser
+import io.element.android.services.analytics.api.AnalyticsService
+import javax.inject.Inject
+
+@ContributesBinding(SessionScope::class)
+class DefaultStartDMAction @Inject constructor(
+    private val matrixClient: MatrixClient,
+    private val analyticsService: AnalyticsService,
+) : StartDMAction {
+    override suspend fun execute(
+        matrixUser: MatrixUser,
+        createIfDmDoesNotExist: Boolean,
+        actionState: MutableState<AsyncAction<RoomId>>,
+    ) {
+        actionState.value = AsyncAction.Loading
+        when (val result = matrixClient.startDM(matrixUser.userId, createIfDmDoesNotExist)) {
+            is StartDMResult.Success -> {
+                if (result.isNew) {
+                    analyticsService.capture(CreatedRoom(isDM = true))
+                }
+                actionState.value = AsyncAction.Success(result.roomId)
+            }
+            is StartDMResult.Failure -> {
+                actionState.value = AsyncAction.Failure(result.throwable)
+            }
+            StartDMResult.DmDoesNotExist -> {
+                actionState.value = ConfirmingStartDmWithMatrixUser(matrixUser = matrixUser)
+            }
+        }
+    }
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/StartChatFlowNode.kt

@@ -0,0 +1,90 @@
+/*
+ * 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.startchat.impl
+
+import android.os.Parcelable
+import androidx.compose.foundation.layout.Box
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.navigation.transition.JumpToEndTransitionHandler
+import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.plugin.Plugin
+import com.bumble.appyx.core.plugin.plugins
+import com.bumble.appyx.navmodel.backstack.BackStack
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedInject
+import io.element.android.anvilannotations.ContributesNode
+import io.element.android.features.startchat.DefaultStartChatNavigator
+import io.element.android.features.startchat.api.StartChatEntryPoint
+import io.element.android.features.startchat.impl.joinbyaddress.JoinRoomByAddressNode
+import io.element.android.features.startchat.impl.root.StartChatNode
+import io.element.android.libraries.architecture.BackstackView
+import io.element.android.libraries.architecture.BaseFlowNode
+import io.element.android.libraries.architecture.OverlayView
+import io.element.android.libraries.architecture.createNode
+import io.element.android.libraries.di.SessionScope
+import kotlinx.parcelize.Parcelize
+
+@ContributesNode(SessionScope::class)
+class StartChatFlowNode @AssistedInject constructor(
+    @Assisted buildContext: BuildContext,
+    @Assisted plugins: List<Plugin>,
+) : BaseFlowNode<StartChatFlowNode.NavTarget>(
+    backstack = BackStack(
+        initialElement = NavTarget.Root,
+        savedStateMap = buildContext.savedStateMap,
+    ),
+    buildContext = buildContext,
+    plugins = plugins
+) {
+    sealed interface NavTarget : Parcelable {
+        @Parcelize
+        data object Root : NavTarget
+
+        @Parcelize
+        data object NewRoom : NavTarget
+
+        @Parcelize
+        data object JoinByAddress : NavTarget
+    }
+
+    private val navigator = DefaultStartChatNavigator(
+        backstack = backstack,
+        overlay = overlay,
+        openRoom = { roomIdOrAlias, viaServers ->
+            plugins<StartChatEntryPoint.Callback>().forEach { it.onOpenRoom(roomIdOrAlias, viaServers) }
+        },
+        openRoomDirectory = {
+            plugins<StartChatEntryPoint.Callback>().forEach { it.onOpenRoomDirectory() }
+        }
+    )
+
+    override fun resolve(navTarget: NavTarget, buildContext: BuildContext): Node {
+        return when (navTarget) {
+            NavTarget.Root -> {
+                createNode<StartChatNode>(buildContext = buildContext, plugins = listOf(navigator))
+            }
+            NavTarget.NewRoom -> {
+                createNode<CreateRoomFlowNode>(buildContext = buildContext, plugins = listOf(navigator))
+            }
+            NavTarget.JoinByAddress -> {
+                createNode<JoinRoomByAddressNode>(buildContext = buildContext, plugins = listOf(navigator))
+            }
+        }
+    }
+
+    @Composable
+    override fun View(modifier: Modifier) {
+        Box(modifier = modifier) {
+            BackstackView()
+            OverlayView(transitionHandler = remember { JumpToEndTransitionHandler() })
+        }
+    }
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/addpeople/AddPeopleNode.kt

@@ -0,0 +1,45 @@
+/*
+ * 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.startchat.impl.addpeople
+
+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 com.bumble.appyx.core.plugin.plugins
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedInject
+import io.element.android.anvilannotations.ContributesNode
+import io.element.android.features.startchat.impl.di.CreateRoomScope
+
+@ContributesNode(CreateRoomScope::class)
+class AddPeopleNode @AssistedInject constructor(
+    @Assisted buildContext: BuildContext,
+    @Assisted plugins: List<Plugin>,
+    private val presenter: AddPeoplePresenter,
+) : Node(buildContext, plugins = plugins) {
+    interface Callback : Plugin {
+        fun onContinue()
+    }
+
+    private fun onContinue() {
+        plugins<Callback>().forEach { it.onContinue() }
+    }
+
+    @Composable
+    override fun View(modifier: Modifier) {
+        val state = presenter.present()
+        AddPeopleView(
+            state = state,
+            modifier = modifier,
+            onBackClick = this::navigateUp,
+            onSkipClick = this::onContinue,
+        )
+    }
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/addpeople/AddPeoplePresenter.kt

@@ -0,0 +1,37 @@
+/*
+ * 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.startchat.impl.addpeople
+
+import androidx.compose.runtime.Composable
+import io.element.android.features.startchat.impl.CreateRoomDataStore
+import io.element.android.features.startchat.impl.userlist.SelectionMode
+import io.element.android.features.startchat.impl.userlist.UserListPresenter
+import io.element.android.features.startchat.impl.userlist.UserListPresenterArgs
+import io.element.android.features.startchat.impl.userlist.UserListState
+import io.element.android.libraries.architecture.Presenter
+import io.element.android.libraries.usersearch.api.UserRepository
+import javax.inject.Inject
+
+class AddPeoplePresenter @Inject constructor(
+    userListPresenterFactory: UserListPresenter.Factory,
+    userRepository: UserRepository,
+    dataStore: CreateRoomDataStore,
+) : Presenter<UserListState> {
+    private val userListPresenter = userListPresenterFactory.create(
+        UserListPresenterArgs(
+            selectionMode = SelectionMode.Multiple,
+        ),
+        userRepository,
+        dataStore.selectedUserListDataStore,
+    )
+
+    @Composable
+    override fun present(): UserListState {
+        return userListPresenter.present()
+    }
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/addpeople/AddPeopleUserListStateProvider.kt

@@ -0,0 +1,46 @@
+/*
+ * 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.startchat.impl.addpeople
+
+import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+import io.element.android.features.startchat.impl.userlist.SelectionMode
+import io.element.android.features.startchat.impl.userlist.UserListState
+import io.element.android.features.startchat.impl.userlist.aRecentDirectRoomList
+import io.element.android.features.startchat.impl.userlist.aUserListState
+import io.element.android.libraries.designsystem.theme.components.SearchBarResultState
+import io.element.android.libraries.matrix.ui.components.aMatrixUserList
+import io.element.android.libraries.usersearch.api.UserSearchResult
+import kotlinx.collections.immutable.toImmutableList
+
+open class AddPeopleUserListStateProvider : PreviewParameterProvider<UserListState> {
+    override val values: Sequence<UserListState>
+        get() = sequenceOf(
+            aUserListState(),
+            aUserListState(
+                searchResults = SearchBarResultState.Results(aMatrixUserList().toImmutableList()),
+                selectedUsers = aMatrixUserList().toImmutableList(),
+                isSearchActive = false,
+                selectionMode = SelectionMode.Multiple,
+            ),
+            aUserListState(
+                searchResults = SearchBarResultState.Results(
+                    aMatrixUserList()
+                        .mapIndexed { index, matrixUser ->
+                            UserSearchResult(matrixUser, index % 2 == 0)
+                        }
+                        .toImmutableList()
+                ),
+                selectedUsers = aMatrixUserList().toImmutableList(),
+                isSearchActive = true,
+                selectionMode = SelectionMode.Multiple,
+            ),
+            aUserListState(
+                recentDirectRooms = aRecentDirectRoomList(),
+            ),
+        )
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/addpeople/AddPeopleView.kt

@@ -0,0 +1,94 @@
+/*
+ * 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.startchat.impl.addpeople
+
+import androidx.compose.foundation.layout.consumeWindowInsets
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.PreviewParameter
+import io.element.android.features.startchat.impl.R
+import io.element.android.features.startchat.impl.components.UserListView
+import io.element.android.features.startchat.impl.userlist.UserListEvents
+import io.element.android.features.startchat.impl.userlist.UserListState
+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.Scaffold
+import io.element.android.libraries.designsystem.theme.components.TextButton
+import io.element.android.libraries.designsystem.theme.components.TopAppBar
+import io.element.android.libraries.ui.strings.CommonStrings
+
+@Composable
+fun AddPeopleView(
+    state: UserListState,
+    onBackClick: () -> Unit,
+    onSkipClick: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    Scaffold(
+        modifier = modifier,
+        topBar = {
+            AddPeopleViewTopBar(
+                hasSelectedUsers = state.selectedUsers.isNotEmpty(),
+                onBackClick = {
+                    if (state.isSearchActive) {
+                        state.eventSink(UserListEvents.OnSearchActiveChanged(false))
+                    } else {
+                        onBackClick()
+                    }
+                },
+                onNextClick = onSkipClick,
+            )
+        }
+    ) { padding ->
+        UserListView(
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(padding)
+                .consumeWindowInsets(padding),
+            state = state,
+            showBackButton = false,
+            onSelectUser = {},
+            onDeselectUser = {},
+        )
+    }
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun AddPeopleViewTopBar(
+    hasSelectedUsers: Boolean,
+    onBackClick: () -> Unit,
+    onNextClick: () -> Unit,
+) {
+    TopAppBar(
+        titleStr = stringResource(id = R.string.screen_create_room_add_people_title),
+        navigationIcon = { BackButton(onClick = onBackClick) },
+        actions = {
+            val textActionResId = if (hasSelectedUsers) CommonStrings.action_next else CommonStrings.action_skip
+            TextButton(
+                text = stringResource(id = textActionResId),
+                onClick = onNextClick,
+            )
+        }
+    )
+}
+
+@PreviewsDayNight
+@Composable
+internal fun AddPeopleViewPreview(@PreviewParameter(AddPeopleUserListStateProvider::class) state: UserListState) = ElementPreview {
+    AddPeopleView(
+        state = state,
+        onBackClick = {},
+        onSkipClick = {},
+    )
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/components/SearchMultipleUsersResultItem.kt

@@ -0,0 +1,91 @@
+/*
+ * Copyright 2023, 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.
+ */
+
+package io.element.android.features.startchat.impl.components
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import io.element.android.libraries.designsystem.components.avatar.AvatarSize
+import io.element.android.libraries.designsystem.preview.ElementThemedPreview
+import io.element.android.libraries.designsystem.theme.components.HorizontalDivider
+import io.element.android.libraries.matrix.ui.components.CheckableUserRow
+import io.element.android.libraries.matrix.ui.components.CheckableUserRowData
+import io.element.android.libraries.matrix.ui.components.aMatrixUser
+import io.element.android.libraries.matrix.ui.model.getAvatarData
+import io.element.android.libraries.matrix.ui.model.getBestName
+import io.element.android.libraries.usersearch.api.UserSearchResult
+
+@Composable
+fun SearchMultipleUsersResultItem(
+    searchResult: UserSearchResult,
+    isUserSelected: Boolean,
+    onCheckedChange: (Boolean) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val data = if (searchResult.isUnresolved) {
+        CheckableUserRowData.Unresolved(
+            avatarData = searchResult.matrixUser.getAvatarData(AvatarSize.UserListItem),
+            id = searchResult.matrixUser.userId.value,
+        )
+    } else {
+        CheckableUserRowData.Resolved(
+            name = searchResult.matrixUser.getBestName(),
+            subtext = if (searchResult.matrixUser.displayName.isNullOrEmpty()) null else searchResult.matrixUser.userId.value,
+            avatarData = searchResult.matrixUser.getAvatarData(AvatarSize.UserListItem),
+        )
+    }
+    CheckableUserRow(
+        checked = isUserSelected,
+        modifier = modifier,
+        data = data,
+        onCheckedChange = onCheckedChange,
+    )
+}
+
+@Preview
+@Composable
+internal fun SearchMultipleUsersResultItemPreview() = ElementThemedPreview {
+    Column {
+        SearchMultipleUsersResultItem(
+            searchResult = UserSearchResult(
+                aMatrixUser(),
+                isUnresolved = false
+            ),
+            isUserSelected = false,
+            onCheckedChange = {}
+        )
+        HorizontalDivider()
+        SearchMultipleUsersResultItem(
+            searchResult = UserSearchResult(
+                aMatrixUser(),
+                isUnresolved = false
+            ),
+            isUserSelected = true,
+            onCheckedChange = {}
+        )
+        HorizontalDivider()
+        SearchMultipleUsersResultItem(
+            searchResult = UserSearchResult(
+                aMatrixUser(),
+                isUnresolved = true
+            ),
+            isUserSelected = false,
+            onCheckedChange = {}
+        )
+        HorizontalDivider()
+        SearchMultipleUsersResultItem(
+            searchResult = UserSearchResult(
+                aMatrixUser(),
+                isUnresolved = true
+            ),
+            isUserSelected = true,
+            onCheckedChange = {}
+        )
+    }
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/components/SearchSingleUserResultItem.kt

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2023, 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.
+ */
+
+package io.element.android.features.startchat.impl.components
+
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Column
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import io.element.android.libraries.designsystem.components.avatar.AvatarSize
+import io.element.android.libraries.designsystem.preview.ElementThemedPreview
+import io.element.android.libraries.designsystem.theme.components.HorizontalDivider
+import io.element.android.libraries.matrix.ui.components.MatrixUserRow
+import io.element.android.libraries.matrix.ui.components.UnresolvedUserRow
+import io.element.android.libraries.matrix.ui.components.aMatrixUser
+import io.element.android.libraries.matrix.ui.model.getAvatarData
+import io.element.android.libraries.usersearch.api.UserSearchResult
+
+@Composable
+fun SearchSingleUserResultItem(
+    searchResult: UserSearchResult,
+    onClick: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    if (searchResult.isUnresolved) {
+        UnresolvedUserRow(
+            modifier = modifier.clickable(onClick = onClick),
+            avatarData = searchResult.matrixUser.getAvatarData(AvatarSize.UserListItem),
+            id = searchResult.matrixUser.userId.value,
+        )
+    } else {
+        MatrixUserRow(
+            modifier = modifier.clickable(onClick = onClick),
+            matrixUser = searchResult.matrixUser,
+            avatarSize = AvatarSize.UserListItem,
+        )
+    }
+}
+
+@Preview
+@Composable
+internal fun SearchSingleUserResultItemPreview() = ElementThemedPreview {
+    Column {
+        SearchSingleUserResultItem(
+            searchResult = UserSearchResult(aMatrixUser(), isUnresolved = false),
+            onClick = {},
+        )
+        HorizontalDivider()
+        SearchSingleUserResultItem(
+            searchResult = UserSearchResult(aMatrixUser(), isUnresolved = true),
+            onClick = {},
+        )
+    }
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/components/SearchUserBar.kt

@@ -0,0 +1,136 @@
+/*
+ * Copyright 2023, 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.
+ */
+
+package io.element.android.features.startchat.impl.components
+
+import androidx.compose.animation.animateColorAsState
+import androidx.compose.animation.core.Spring
+import androidx.compose.animation.core.spring
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.itemsIndexed
+import androidx.compose.foundation.lazy.rememberLazyListState
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.surfaceColorAtElevation
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.derivedStateOf
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import io.element.android.libraries.designsystem.components.async.AsyncLoading
+import io.element.android.libraries.designsystem.theme.components.HorizontalDivider
+import io.element.android.libraries.designsystem.theme.components.SearchBar
+import io.element.android.libraries.designsystem.theme.components.SearchBarResultState
+import io.element.android.libraries.matrix.api.user.MatrixUser
+import io.element.android.libraries.matrix.ui.components.SelectedUsersRowList
+import io.element.android.libraries.ui.strings.CommonStrings
+import io.element.android.libraries.usersearch.api.UserSearchResult
+import kotlinx.collections.immutable.ImmutableList
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun SearchUserBar(
+    query: String,
+    state: SearchBarResultState<ImmutableList<UserSearchResult>>,
+    showLoader: Boolean,
+    selectedUsers: ImmutableList<MatrixUser>,
+    active: Boolean,
+    isMultiSelectionEnable: Boolean,
+    onActiveChange: (Boolean) -> Unit,
+    onTextChange: (String) -> Unit,
+    onUserSelect: (MatrixUser) -> Unit,
+    onUserDeselect: (MatrixUser) -> Unit,
+    modifier: Modifier = Modifier,
+    showBackButton: Boolean = true,
+    placeHolderTitle: String = stringResource(CommonStrings.common_search_for_someone),
+) {
+    val columnState = rememberLazyListState()
+
+    SearchBar(
+        query = query,
+        onQueryChange = onTextChange,
+        active = active,
+        onActiveChange = onActiveChange,
+        modifier = modifier,
+        placeHolderTitle = placeHolderTitle,
+        showBackButton = showBackButton,
+        contentPrefix = {
+            if (isMultiSelectionEnable && active && selectedUsers.isNotEmpty()) {
+                // We want the selected users to behave a bit like a top bar - when the list below is scrolled, the colour
+                // should change to indicate elevation.
+
+                val elevation = remember {
+                    derivedStateOf {
+                        if (columnState.canScrollBackward) {
+                            4.dp
+                        } else {
+                            0.dp
+                        }
+                    }
+                }
+
+                val appBarContainerColor by animateColorAsState(
+                    targetValue = MaterialTheme.colorScheme.surfaceColorAtElevation(elevation.value),
+                    animationSpec = spring(stiffness = Spring.StiffnessMediumLow)
+                )
+
+                SelectedUsersRowList(
+                    contentPadding = PaddingValues(16.dp),
+                    selectedUsers = selectedUsers,
+                    autoScroll = true,
+                    onUserRemove = onUserDeselect,
+                    modifier = Modifier.background(appBarContainerColor)
+                )
+            }
+        },
+        contentSuffix = {
+            if (showLoader) {
+                AsyncLoading()
+            }
+        },
+        resultState = state,
+        resultHandler = { users ->
+            LazyColumn(state = columnState) {
+                if (isMultiSelectionEnable) {
+                    itemsIndexed(users) { index, searchResult ->
+                        SearchMultipleUsersResultItem(
+                            modifier = Modifier.fillMaxWidth(),
+                            searchResult = searchResult,
+                            isUserSelected = selectedUsers.contains(searchResult.matrixUser),
+                            onCheckedChange = { checked ->
+                                if (checked) {
+                                    onUserSelect(searchResult.matrixUser)
+                                } else {
+                                    onUserDeselect(searchResult.matrixUser)
+                                }
+                            }
+                        )
+                        if (index < users.lastIndex) {
+                            HorizontalDivider()
+                        }
+                    }
+                } else {
+                    itemsIndexed(users) { index, searchResult ->
+                        SearchSingleUserResultItem(
+                            modifier = Modifier.fillMaxWidth(),
+                            searchResult = searchResult,
+                            onClick = { onUserSelect(searchResult.matrixUser) }
+                        )
+                        if (index < users.lastIndex) {
+                            HorizontalDivider()
+                        }
+                    }
+                }
+            }
+        },
+    )
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/components/UserListView.kt

@@ -0,0 +1,126 @@
+/*
+ * 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.startchat.impl.components
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.PreviewParameter
+import androidx.compose.ui.unit.dp
+import io.element.android.features.startchat.impl.userlist.UserListEvents
+import io.element.android.features.startchat.impl.userlist.UserListState
+import io.element.android.features.startchat.impl.userlist.UserListStateProvider
+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.designsystem.theme.components.HorizontalDivider
+import io.element.android.libraries.designsystem.theme.components.ListSectionHeader
+import io.element.android.libraries.matrix.api.user.MatrixUser
+import io.element.android.libraries.matrix.ui.components.CheckableUserRow
+import io.element.android.libraries.matrix.ui.components.CheckableUserRowData
+import io.element.android.libraries.matrix.ui.components.SelectedUsersRowList
+import io.element.android.libraries.matrix.ui.model.getAvatarData
+import io.element.android.libraries.matrix.ui.model.getBestName
+import io.element.android.libraries.ui.strings.CommonStrings
+
+@Composable
+fun UserListView(
+    state: UserListState,
+    onSelectUser: (MatrixUser) -> Unit,
+    onDeselectUser: (MatrixUser) -> Unit,
+    modifier: Modifier = Modifier,
+    showBackButton: Boolean = true,
+) {
+    Column(
+        modifier = modifier,
+    ) {
+        SearchUserBar(
+            modifier = Modifier.fillMaxWidth(),
+            query = state.searchQuery,
+            state = state.searchResults,
+            selectedUsers = state.selectedUsers,
+            active = state.isSearchActive,
+            showLoader = state.showSearchLoader,
+            isMultiSelectionEnable = state.isMultiSelectionEnabled,
+            showBackButton = showBackButton,
+            onActiveChange = { state.eventSink(UserListEvents.OnSearchActiveChanged(it)) },
+            onTextChange = { state.eventSink(UserListEvents.UpdateSearchQuery(it)) },
+            onUserSelect = {
+                state.eventSink(UserListEvents.AddToSelection(it))
+                onSelectUser(it)
+            },
+            onUserDeselect = {
+                state.eventSink(UserListEvents.RemoveFromSelection(it))
+                onDeselectUser(it)
+            },
+        )
+
+        if (state.isMultiSelectionEnabled && !state.isSearchActive && state.selectedUsers.isNotEmpty()) {
+            SelectedUsersRowList(
+                contentPadding = PaddingValues(16.dp),
+                selectedUsers = state.selectedUsers,
+                autoScroll = true,
+                onUserRemove = {
+                    state.eventSink(UserListEvents.RemoveFromSelection(it))
+                    onDeselectUser(it)
+                },
+            )
+        }
+        if (!state.isSearchActive && state.recentDirectRooms.isNotEmpty()) {
+            LazyColumn {
+                item {
+                    ListSectionHeader(
+                        title = stringResource(id = CommonStrings.common_suggestions),
+                        hasDivider = false,
+                    )
+                }
+                state.recentDirectRooms.forEachIndexed { index, recentDirectRoom ->
+                    item {
+                        val isSelected = state.selectedUsers.any {
+                            recentDirectRoom.matrixUser.userId == it.userId
+                        }
+                        CheckableUserRow(
+                            checked = isSelected,
+                            onCheckedChange = {
+                                if (isSelected) {
+                                    state.eventSink(UserListEvents.RemoveFromSelection(recentDirectRoom.matrixUser))
+                                    onDeselectUser(recentDirectRoom.matrixUser)
+                                } else {
+                                    state.eventSink(UserListEvents.AddToSelection(recentDirectRoom.matrixUser))
+                                    onSelectUser(recentDirectRoom.matrixUser)
+                                }
+                            },
+                            data = CheckableUserRowData.Resolved(
+                                avatarData = recentDirectRoom.matrixUser.getAvatarData(AvatarSize.UserListItem),
+                                name = recentDirectRoom.matrixUser.getBestName(),
+                                subtext = recentDirectRoom.matrixUser.userId.value,
+                            ),
+                        )
+                        if (index < state.recentDirectRooms.lastIndex) {
+                            HorizontalDivider()
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+@PreviewsDayNight
+@Composable
+internal fun UserListViewPreview(@PreviewParameter(UserListStateProvider::class) state: UserListState) = ElementPreview {
+    UserListView(
+        state = state,
+        onSelectUser = {},
+        onDeselectUser = {},
+    )
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/configureroom/ConfigureRoomEvents.kt

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2023, 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.
+ */
+
+package io.element.android.features.startchat.impl.configureroom
+
+import io.element.android.libraries.matrix.api.user.MatrixUser
+import io.element.android.libraries.matrix.ui.media.AvatarAction
+
+sealed interface ConfigureRoomEvents {
+    data class RoomNameChanged(val name: String) : ConfigureRoomEvents
+    data class TopicChanged(val topic: String) : ConfigureRoomEvents
+    data class RoomVisibilityChanged(val visibilityItem: RoomVisibilityItem) : ConfigureRoomEvents
+    data class RoomAccessChanged(val roomAccess: RoomAccessItem) : ConfigureRoomEvents
+    data class RoomAddressChanged(val roomAddress: String) : ConfigureRoomEvents
+    data class RemoveUserFromSelection(val matrixUser: MatrixUser) : ConfigureRoomEvents
+    data object CreateRoom : ConfigureRoomEvents
+    data class HandleAvatarAction(val action: AvatarAction) : ConfigureRoomEvents
+    data object CancelCreateRoom : ConfigureRoomEvents
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/configureroom/ConfigureRoomNode.kt

@@ -0,0 +1,55 @@
+/*
+ * 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.startchat.impl.configureroom
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import com.bumble.appyx.core.lifecycle.subscribe
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.plugin.Plugin
+import com.bumble.appyx.core.plugin.plugins
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedInject
+import im.vector.app.features.analytics.plan.MobileScreen
+import io.element.android.anvilannotations.ContributesNode
+import io.element.android.features.startchat.StartChatNavigator
+import io.element.android.features.startchat.impl.di.CreateRoomScope
+import io.element.android.libraries.matrix.api.core.toRoomIdOrAlias
+import io.element.android.services.analytics.api.AnalyticsService
+
+@ContributesNode(CreateRoomScope::class)
+class ConfigureRoomNode @AssistedInject constructor(
+    @Assisted buildContext: BuildContext,
+    @Assisted plugins: List<Plugin>,
+    private val presenter: ConfigureRoomPresenter,
+    private val analyticsService: AnalyticsService,
+) : Node(buildContext, plugins = plugins) {
+    private val navigator = plugins<StartChatNavigator>().first()
+
+    init {
+        lifecycle.subscribe(
+            onResume = {
+                analyticsService.screen(MobileScreen(screenName = MobileScreen.ScreenName.CreateRoom))
+            }
+        )
+    }
+
+    @Composable
+    override fun View(modifier: Modifier) {
+        val state = presenter.present()
+        ConfigureRoomView(
+            state = state,
+            modifier = modifier,
+            onBackClick = this::navigateUp,
+            onCreateRoomSuccess = {
+                navigator.onOpenRoom(roomIdOrAlias = it.toRoomIdOrAlias(), serverNames = emptyList())
+            },
+        )
+    }
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/configureroom/ConfigureRoomPresenter.kt

@@ -0,0 +1,209 @@
+/*
+ * 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.startchat.impl.configureroom
+
+import android.net.Uri
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.derivedStateOf
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import im.vector.app.features.analytics.plan.CreatedRoom
+import io.element.android.features.startchat.impl.CreateRoomConfig
+import io.element.android.features.startchat.impl.CreateRoomDataStore
+import io.element.android.libraries.architecture.AsyncAction
+import io.element.android.libraries.architecture.Presenter
+import io.element.android.libraries.architecture.runCatchingUpdatingState
+import io.element.android.libraries.core.mimetype.MimeTypes
+import io.element.android.libraries.featureflag.api.FeatureFlagService
+import io.element.android.libraries.featureflag.api.FeatureFlags
+import io.element.android.libraries.matrix.api.MatrixClient
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.api.createroom.CreateRoomParameters
+import io.element.android.libraries.matrix.api.createroom.RoomPreset
+import io.element.android.libraries.matrix.api.room.alias.RoomAliasHelper
+import io.element.android.libraries.matrix.api.room.history.RoomHistoryVisibility
+import io.element.android.libraries.matrix.api.roomdirectory.RoomVisibility
+import io.element.android.libraries.matrix.ui.media.AvatarAction
+import io.element.android.libraries.matrix.ui.room.address.RoomAddressValidity
+import io.element.android.libraries.matrix.ui.room.address.RoomAddressValidityEffect
+import io.element.android.libraries.mediapickers.api.PickerProvider
+import io.element.android.libraries.mediaupload.api.MediaPreProcessor
+import io.element.android.libraries.permissions.api.PermissionsEvents
+import io.element.android.libraries.permissions.api.PermissionsPresenter
+import io.element.android.services.analytics.api.AnalyticsService
+import kotlinx.collections.immutable.toImmutableList
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import timber.log.Timber
+import javax.inject.Inject
+import kotlin.jvm.optionals.getOrDefault
+
+class ConfigureRoomPresenter @Inject constructor(
+    private val dataStore: CreateRoomDataStore,
+    private val matrixClient: MatrixClient,
+    private val mediaPickerProvider: PickerProvider,
+    private val mediaPreProcessor: MediaPreProcessor,
+    private val analyticsService: AnalyticsService,
+    permissionsPresenterFactory: PermissionsPresenter.Factory,
+    private val featureFlagService: FeatureFlagService,
+    private val roomAliasHelper: RoomAliasHelper,
+) : Presenter<ConfigureRoomState> {
+    private val cameraPermissionPresenter: PermissionsPresenter = permissionsPresenterFactory.create(android.Manifest.permission.CAMERA)
+    private var pendingPermissionRequest = false
+
+    @Composable
+    override fun present(): ConfigureRoomState {
+        val cameraPermissionState = cameraPermissionPresenter.present()
+        val createRoomConfig by dataStore.createRoomConfigWithInvites.collectAsState(CreateRoomConfig())
+        val homeserverName = remember { matrixClient.userIdServerName() }
+        val isKnockFeatureEnabled by remember {
+            featureFlagService.isFeatureEnabledFlow(FeatureFlags.Knock)
+        }.collectAsState(initial = false)
+        val roomAddressValidity = remember {
+            mutableStateOf<RoomAddressValidity>(RoomAddressValidity.Unknown)
+        }
+
+        val cameraPhotoPicker = mediaPickerProvider.registerCameraPhotoPicker(
+            onResult = { uri -> if (uri != null) dataStore.setAvatarUri(uri = uri, cached = true) },
+        )
+        val galleryImagePicker = mediaPickerProvider.registerGalleryImagePicker(
+            onResult = { uri -> if (uri != null) dataStore.setAvatarUri(uri = uri) }
+        )
+
+        val avatarActions by remember(createRoomConfig.avatarUri) {
+            derivedStateOf {
+                listOfNotNull(
+                    AvatarAction.TakePhoto,
+                    AvatarAction.ChoosePhoto,
+                    AvatarAction.Remove.takeIf { createRoomConfig.avatarUri != null },
+                ).toImmutableList()
+            }
+        }
+
+        LaunchedEffect(cameraPermissionState.permissionGranted) {
+            if (cameraPermissionState.permissionGranted && pendingPermissionRequest) {
+                pendingPermissionRequest = false
+                cameraPhotoPicker.launch()
+            }
+        }
+
+        RoomAddressValidityEffect(
+            client = matrixClient,
+            roomAliasHelper = roomAliasHelper,
+            newRoomAddress = createRoomConfig.roomVisibility.roomAddress().getOrDefault(""),
+            knownRoomAddress = null,
+        ) { newRoomAddressValidity ->
+            roomAddressValidity.value = newRoomAddressValidity
+        }
+
+        val localCoroutineScope = rememberCoroutineScope()
+        val createRoomAction: MutableState<AsyncAction<RoomId>> = remember { mutableStateOf(AsyncAction.Uninitialized) }
+
+        fun createRoom(config: CreateRoomConfig) {
+            createRoomAction.value = AsyncAction.Uninitialized
+            localCoroutineScope.createRoom(config, createRoomAction)
+        }
+
+        fun handleEvents(event: ConfigureRoomEvents) {
+            when (event) {
+                is ConfigureRoomEvents.RoomNameChanged -> dataStore.setRoomName(event.name)
+                is ConfigureRoomEvents.TopicChanged -> dataStore.setTopic(event.topic)
+                is ConfigureRoomEvents.RoomVisibilityChanged -> dataStore.setRoomVisibility(event.visibilityItem)
+                is ConfigureRoomEvents.RemoveUserFromSelection -> dataStore.selectedUserListDataStore.removeUserFromSelection(event.matrixUser)
+                is ConfigureRoomEvents.RoomAccessChanged -> dataStore.setRoomAccess(event.roomAccess)
+                is ConfigureRoomEvents.RoomAddressChanged -> dataStore.setRoomAddress(event.roomAddress)
+                is ConfigureRoomEvents.CreateRoom -> createRoom(createRoomConfig)
+                is ConfigureRoomEvents.HandleAvatarAction -> {
+                    when (event.action) {
+                        AvatarAction.ChoosePhoto -> galleryImagePicker.launch()
+                        AvatarAction.TakePhoto -> if (cameraPermissionState.permissionGranted) {
+                            cameraPhotoPicker.launch()
+                        } else {
+                            pendingPermissionRequest = true
+                            cameraPermissionState.eventSink(PermissionsEvents.RequestPermissions)
+                        }
+                        AvatarAction.Remove -> dataStore.setAvatarUri(uri = null)
+                    }
+                }
+
+                ConfigureRoomEvents.CancelCreateRoom -> createRoomAction.value = AsyncAction.Uninitialized
+            }
+        }
+
+        return ConfigureRoomState(
+            isKnockFeatureEnabled = isKnockFeatureEnabled,
+            config = createRoomConfig,
+            avatarActions = avatarActions,
+            createRoomAction = createRoomAction.value,
+            cameraPermissionState = cameraPermissionState,
+            homeserverName = homeserverName,
+            roomAddressValidity = roomAddressValidity.value,
+            eventSink = ::handleEvents,
+        )
+    }
+
+    private fun CoroutineScope.createRoom(
+        config: CreateRoomConfig,
+        createRoomAction: MutableState<AsyncAction<RoomId>>
+    ) = launch {
+        suspend {
+            val avatarUrl = config.avatarUri?.let { uploadAvatar(it) }
+            val params = if (config.roomVisibility is RoomVisibilityState.Public) {
+                CreateRoomParameters(
+                    name = config.roomName,
+                    topic = config.topic,
+                    isEncrypted = false,
+                    isDirect = false,
+                    visibility = RoomVisibility.Public,
+                    joinRuleOverride = config.roomVisibility.roomAccess.toJoinRule(),
+                    preset = RoomPreset.PUBLIC_CHAT,
+                    invite = config.invites.map { it.userId },
+                    avatar = avatarUrl,
+                    roomAliasName = config.roomVisibility.roomAddress()
+                )
+            } else {
+                CreateRoomParameters(
+                    name = config.roomName,
+                    topic = config.topic,
+                    isEncrypted = config.roomVisibility is RoomVisibilityState.Private,
+                    isDirect = false,
+                    visibility = RoomVisibility.Private,
+                    historyVisibilityOverride = RoomHistoryVisibility.Invited,
+                    preset = RoomPreset.PRIVATE_CHAT,
+                    invite = config.invites.map { it.userId },
+                    avatar = avatarUrl,
+                )
+            }
+            matrixClient.createRoom(params)
+                .onFailure { failure ->
+                    Timber.e(failure, "Failed to create room")
+                }
+                .onSuccess {
+                    dataStore.clearCachedData()
+                    analyticsService.capture(CreatedRoom(isDM = false))
+                }
+                .getOrThrow()
+        }.runCatchingUpdatingState(createRoomAction)
+    }
+
+    private suspend fun uploadAvatar(avatarUri: Uri): String {
+        val preprocessed = mediaPreProcessor.process(
+            uri = avatarUri,
+            mimeType = MimeTypes.Jpeg,
+            deleteOriginal = false,
+            compressIfPossible = false,
+        ).getOrThrow()
+        val byteArray = preprocessed.file.readBytes()
+        return matrixClient.uploadMedia(MimeTypes.Jpeg, byteArray, null).getOrThrow()
+    }
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/configureroom/ConfigureRoomPresenterArgs.kt

@@ -0,0 +1,14 @@
+/*
+ * 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.startchat.impl.configureroom
+
+import io.element.android.libraries.matrix.api.user.MatrixUser
+
+data class ConfigureRoomPresenterArgs(
+    val selectedUsers: List<MatrixUser>,
+)

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/configureroom/ConfigureRoomState.kt

@@ -0,0 +1,30 @@
+/*
+ * 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.startchat.impl.configureroom
+
+import io.element.android.features.startchat.impl.CreateRoomConfig
+import io.element.android.libraries.architecture.AsyncAction
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.ui.media.AvatarAction
+import io.element.android.libraries.matrix.ui.room.address.RoomAddressValidity
+import io.element.android.libraries.permissions.api.PermissionsState
+import kotlinx.collections.immutable.ImmutableList
+
+data class ConfigureRoomState(
+    val isKnockFeatureEnabled: Boolean,
+    val config: CreateRoomConfig,
+    val avatarActions: ImmutableList<AvatarAction>,
+    val createRoomAction: AsyncAction<RoomId>,
+    val cameraPermissionState: PermissionsState,
+    val roomAddressValidity: RoomAddressValidity,
+    val homeserverName: String,
+    val eventSink: (ConfigureRoomEvents) -> Unit
+) {
+    val isValid: Boolean = config.roomName?.isNotEmpty() == true &&
+        (config.roomVisibility is RoomVisibilityState.Private || roomAddressValidity == RoomAddressValidity.Valid)
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/configureroom/ConfigureRoomStateProvider.kt

@@ -0,0 +1,102 @@
+/*
+ * 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.startchat.impl.configureroom
+
+import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+import io.element.android.features.startchat.impl.CreateRoomConfig
+import io.element.android.libraries.architecture.AsyncAction
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.ui.components.aMatrixUserList
+import io.element.android.libraries.matrix.ui.media.AvatarAction
+import io.element.android.libraries.matrix.ui.room.address.RoomAddressValidity
+import io.element.android.libraries.permissions.api.PermissionsState
+import io.element.android.libraries.permissions.api.aPermissionsState
+import kotlinx.collections.immutable.toImmutableList
+
+open class ConfigureRoomStateProvider : PreviewParameterProvider<ConfigureRoomState> {
+    override val values: Sequence<ConfigureRoomState>
+        get() = sequenceOf(
+            aConfigureRoomState(),
+            aConfigureRoomState(
+                isKnockFeatureEnabled = false,
+                config = CreateRoomConfig(
+                    roomName = "Room 101",
+                    topic = "Room topic for this room when the text goes onto multiple lines and is really long, there shouldn’t be more than 3 lines",
+                    invites = aMatrixUserList().toImmutableList(),
+                    roomVisibility = RoomVisibilityState.Public(
+                        roomAddress = RoomAddress.AutoFilled("Room-101"),
+                        roomAccess = RoomAccess.Knocking,
+                    ),
+                ),
+            ),
+            aConfigureRoomState(
+                config = CreateRoomConfig(
+                    roomName = "Room 101",
+                    topic = "Room topic for this room when the text goes onto multiple lines and is really long, there shouldn’t be more than 3 lines",
+                    invites = aMatrixUserList().toImmutableList(),
+                    roomVisibility = RoomVisibilityState.Public(
+                        roomAddress = RoomAddress.AutoFilled("Room-101"),
+                        roomAccess = RoomAccess.Knocking,
+                    ),
+                ),
+            ),
+            aConfigureRoomState(
+                config = CreateRoomConfig(
+                    roomName = "Room 101",
+                    topic = "Room topic for this room when the text goes onto multiple lines and is really long, there shouldn’t be more than 3 lines",
+                    roomVisibility = RoomVisibilityState.Public(
+                        roomAddress = RoomAddress.AutoFilled("Room-101"),
+                        roomAccess = RoomAccess.Knocking,
+                    ),
+                ),
+                roomAddressValidity = RoomAddressValidity.NotAvailable,
+            ),
+            aConfigureRoomState(
+                config = CreateRoomConfig(
+                    roomName = "Room 101",
+                    topic = "Room topic for this room when the text goes onto multiple lines and is really long, there shouldn’t be more than 3 lines",
+                    roomVisibility = RoomVisibilityState.Public(
+                        roomAddress = RoomAddress.AutoFilled("Room-101"),
+                        roomAccess = RoomAccess.Knocking,
+                    ),
+                ),
+                roomAddressValidity = RoomAddressValidity.InvalidSymbols,
+            ),
+            aConfigureRoomState(
+                config = CreateRoomConfig(
+                    roomName = "Room 101",
+                    topic = "Room topic for this room when the text goes onto multiple lines and is really long, there shouldn’t be more than 3 lines",
+                    roomVisibility = RoomVisibilityState.Public(
+                        roomAddress = RoomAddress.AutoFilled("Room-101"),
+                        roomAccess = RoomAccess.Knocking,
+                    ),
+                ),
+                roomAddressValidity = RoomAddressValidity.Valid,
+            ),
+        )
+}
+
+fun aConfigureRoomState(
+    config: CreateRoomConfig = CreateRoomConfig(),
+    isKnockFeatureEnabled: Boolean = true,
+    avatarActions: List<AvatarAction> = emptyList(),
+    createRoomAction: AsyncAction<RoomId> = AsyncAction.Uninitialized,
+    cameraPermissionState: PermissionsState = aPermissionsState(showDialog = false),
+    homeserverName: String = "matrix.org",
+    roomAddressValidity: RoomAddressValidity = RoomAddressValidity.Valid,
+    eventSink: (ConfigureRoomEvents) -> Unit = { },
+) = ConfigureRoomState(
+    config = config,
+    isKnockFeatureEnabled = isKnockFeatureEnabled,
+    avatarActions = avatarActions.toImmutableList(),
+    createRoomAction = createRoomAction,
+    cameraPermissionState = cameraPermissionState,
+    homeserverName = homeserverName,
+    roomAddressValidity = roomAddressValidity,
+    eventSink = eventSink,
+)

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/configureroom/ConfigureRoomView.kt

@@ -0,0 +1,339 @@
+/*
+ * 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.startchat.impl.configureroom
+
+import android.net.Uri
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ColumnScope
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.consumeWindowInsets
+import androidx.compose.foundation.layout.imePadding
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.selection.selectableGroup
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalFocusManager
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.input.KeyboardCapitalization
+import androidx.compose.ui.tooling.preview.PreviewParameter
+import androidx.compose.ui.unit.dp
+import io.element.android.compound.theme.ElementTheme
+import io.element.android.features.startchat.impl.R
+import io.element.android.libraries.architecture.coverage.ExcludeFromCoverage
+import io.element.android.libraries.designsystem.atomic.atoms.RoundedIconAtom
+import io.element.android.libraries.designsystem.atomic.atoms.RoundedIconAtomSize
+import io.element.android.libraries.designsystem.components.async.AsyncActionView
+import io.element.android.libraries.designsystem.components.async.AsyncActionViewDefaults
+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.components.list.ListItemContent
+import io.element.android.libraries.designsystem.modifiers.clearFocusOnTap
+import io.element.android.libraries.designsystem.preview.ElementPreviewDark
+import io.element.android.libraries.designsystem.preview.ElementPreviewLight
+import io.element.android.libraries.designsystem.preview.PreviewWithLargeHeight
+import io.element.android.libraries.designsystem.theme.components.ListItem
+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.TextButton
+import io.element.android.libraries.designsystem.theme.components.TextField
+import io.element.android.libraries.designsystem.theme.components.TopAppBar
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.ui.components.AvatarActionBottomSheet
+import io.element.android.libraries.matrix.ui.components.SelectedUsersRowList
+import io.element.android.libraries.matrix.ui.components.UnsavedAvatar
+import io.element.android.libraries.matrix.ui.room.address.RoomAddressField
+import io.element.android.libraries.permissions.api.PermissionsView
+import io.element.android.libraries.ui.strings.CommonStrings
+
+@Composable
+fun ConfigureRoomView(
+    state: ConfigureRoomState,
+    onBackClick: () -> Unit,
+    onCreateRoomSuccess: (RoomId) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val focusManager = LocalFocusManager.current
+    val isAvatarActionsSheetVisible = remember { mutableStateOf(false) }
+
+    fun onAvatarClick() {
+        focusManager.clearFocus()
+        isAvatarActionsSheetVisible.value = true
+    }
+
+    Scaffold(
+        modifier = modifier.clearFocusOnTap(focusManager),
+        topBar = {
+            ConfigureRoomToolbar(
+                isNextActionEnabled = state.isValid,
+                onBackClick = onBackClick,
+                onNextClick = {
+                    focusManager.clearFocus()
+                    state.eventSink(ConfigureRoomEvents.CreateRoom)
+                },
+            )
+        }
+    ) { padding ->
+        Column(
+            modifier = Modifier
+                .padding(padding)
+                .imePadding()
+                .verticalScroll(rememberScrollState())
+                .consumeWindowInsets(padding),
+            verticalArrangement = Arrangement.spacedBy(24.dp),
+        ) {
+            RoomNameWithAvatar(
+                modifier = Modifier.padding(horizontal = 16.dp),
+                avatarUri = state.config.avatarUri,
+                roomName = state.config.roomName.orEmpty(),
+                onAvatarClick = ::onAvatarClick,
+                onChangeRoomName = { state.eventSink(ConfigureRoomEvents.RoomNameChanged(it)) },
+            )
+            RoomTopic(
+                modifier = Modifier.padding(horizontal = 16.dp),
+                topic = state.config.topic.orEmpty(),
+                onTopicChange = { state.eventSink(ConfigureRoomEvents.TopicChanged(it)) },
+            )
+            if (state.config.invites.isNotEmpty()) {
+                SelectedUsersRowList(
+                    contentPadding = PaddingValues(horizontal = 24.dp),
+                    selectedUsers = state.config.invites,
+                    onUserRemove = {
+                        focusManager.clearFocus()
+                        state.eventSink(ConfigureRoomEvents.RemoveUserFromSelection(it))
+                    },
+                )
+            }
+            RoomVisibilityOptions(
+                selected = when (state.config.roomVisibility) {
+                    is RoomVisibilityState.Private -> RoomVisibilityItem.Private
+                    is RoomVisibilityState.Public -> RoomVisibilityItem.Public
+                },
+                onOptionClick = {
+                    focusManager.clearFocus()
+                    state.eventSink(ConfigureRoomEvents.RoomVisibilityChanged(it))
+                },
+            )
+            if (state.config.roomVisibility is RoomVisibilityState.Public && state.isKnockFeatureEnabled) {
+                RoomAccessOptions(
+                    selected = when (state.config.roomVisibility.roomAccess) {
+                        RoomAccess.Anyone -> RoomAccessItem.Anyone
+                        RoomAccess.Knocking -> RoomAccessItem.AskToJoin
+                    },
+                    onOptionClick = {
+                        focusManager.clearFocus()
+                        state.eventSink(ConfigureRoomEvents.RoomAccessChanged(it))
+                    },
+                )
+                RoomAddressField(
+                    modifier = Modifier.padding(horizontal = 16.dp),
+                    address = state.config.roomVisibility.roomAddress.value,
+                    homeserverName = state.homeserverName,
+                    addressValidity = state.roomAddressValidity,
+                    onAddressChange = { state.eventSink(ConfigureRoomEvents.RoomAddressChanged(it)) },
+                    label = stringResource(R.string.screen_create_room_room_address_section_title),
+                    supportingText = stringResource(R.string.screen_create_room_room_address_section_footer),
+                )
+                Spacer(Modifier)
+            }
+        }
+    }
+
+    AvatarActionBottomSheet(
+        actions = state.avatarActions,
+        isVisible = isAvatarActionsSheetVisible.value,
+        onDismiss = { isAvatarActionsSheetVisible.value = false },
+        onSelectAction = { state.eventSink(ConfigureRoomEvents.HandleAvatarAction(it)) }
+    )
+
+    AsyncActionView(
+        async = state.createRoomAction,
+        progressDialog = {
+            AsyncActionViewDefaults.ProgressDialog(
+                progressText = stringResource(CommonStrings.common_creating_room),
+            )
+        },
+        onSuccess = { onCreateRoomSuccess(it) },
+        errorMessage = { stringResource(R.string.screen_create_room_error_creating_room) },
+        onRetry = { state.eventSink(ConfigureRoomEvents.CreateRoom) },
+        onErrorDismiss = { state.eventSink(ConfigureRoomEvents.CancelCreateRoom) },
+    )
+
+    PermissionsView(
+        state = state.cameraPermissionState,
+    )
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun ConfigureRoomToolbar(
+    isNextActionEnabled: Boolean,
+    onBackClick: () -> Unit,
+    onNextClick: () -> Unit,
+) {
+    TopAppBar(
+        titleStr = stringResource(R.string.screen_create_room_title),
+        navigationIcon = { BackButton(onClick = onBackClick) },
+        actions = {
+            TextButton(
+                text = stringResource(CommonStrings.action_create),
+                enabled = isNextActionEnabled,
+                onClick = onNextClick,
+            )
+        }
+    )
+}
+
+@Composable
+private fun RoomNameWithAvatar(
+    avatarUri: Uri?,
+    roomName: String,
+    onAvatarClick: () -> Unit,
+    onChangeRoomName: (String) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    Row(
+        modifier = modifier,
+        horizontalArrangement = Arrangement.spacedBy(16.dp),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        UnsavedAvatar(
+            avatarUri = avatarUri,
+            avatarSize = AvatarSize.EditRoomDetails,
+            avatarType = AvatarType.Room(),
+            modifier = Modifier.clickable(onClick = onAvatarClick),
+        )
+
+        TextField(
+            label = stringResource(R.string.screen_create_room_room_name_label),
+            value = roomName,
+            placeholder = stringResource(CommonStrings.common_room_name_placeholder),
+            singleLine = true,
+            onValueChange = onChangeRoomName,
+        )
+    }
+}
+
+@Composable
+private fun RoomTopic(
+    topic: String,
+    onTopicChange: (String) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    TextField(
+        modifier = modifier,
+        label = stringResource(R.string.screen_create_room_topic_label),
+        value = topic,
+        onValueChange = onTopicChange,
+        maxLines = 3,
+        supportingText = stringResource(CommonStrings.common_topic_placeholder),
+        keyboardOptions = KeyboardOptions(
+            capitalization = KeyboardCapitalization.Sentences,
+        ),
+    )
+}
+
+@Composable
+private fun ConfigureRoomOptions(
+    title: String,
+    modifier: Modifier = Modifier,
+    content: @Composable ColumnScope.() -> Unit,
+) {
+    Column(
+        modifier = modifier.selectableGroup()
+    ) {
+        Text(
+            text = title,
+            style = ElementTheme.typography.fontBodyLgMedium,
+            color = ElementTheme.colors.textPrimary,
+            modifier = Modifier.padding(horizontal = 16.dp),
+        )
+        content()
+    }
+}
+
+@Composable
+private fun RoomVisibilityOptions(
+    selected: RoomVisibilityItem,
+    onOptionClick: (RoomVisibilityItem) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    ConfigureRoomOptions(
+        title = stringResource(R.string.screen_create_room_room_visibility_section_title),
+        modifier = modifier,
+    ) {
+        RoomVisibilityItem.entries.forEach { item ->
+            val isSelected = item == selected
+            ListItem(
+                leadingContent = ListItemContent.Custom {
+                    RoundedIconAtom(
+                        size = RoundedIconAtomSize.Big,
+                        resourceId = item.icon,
+                        tint = if (isSelected) ElementTheme.colors.iconPrimary else ElementTheme.colors.iconSecondary,
+                    )
+                },
+                headlineContent = { Text(text = stringResource(item.title)) },
+                supportingContent = { Text(text = stringResource(item.description)) },
+                trailingContent = ListItemContent.RadioButton(selected = isSelected),
+                onClick = { onOptionClick(item) },
+            )
+        }
+    }
+}
+
+@Composable
+private fun RoomAccessOptions(
+    selected: RoomAccessItem,
+    onOptionClick: (RoomAccessItem) -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    ConfigureRoomOptions(
+        title = stringResource(R.string.screen_create_room_room_access_section_header),
+        modifier = modifier,
+    ) {
+        RoomAccessItem.entries.forEach { item ->
+            ListItem(
+                headlineContent = { Text(text = stringResource(item.title)) },
+                supportingContent = { Text(text = stringResource(item.description)) },
+                trailingContent = ListItemContent.RadioButton(selected = item == selected),
+                onClick = { onOptionClick(item) },
+            )
+        }
+    }
+}
+
+@PreviewWithLargeHeight
+@Composable
+internal fun ConfigureRoomViewLightPreview(@PreviewParameter(ConfigureRoomStateProvider::class) state: ConfigureRoomState) =
+    ElementPreviewLight { ContentToPreview(state) }
+
+@PreviewWithLargeHeight
+@Composable
+internal fun ConfigureRoomViewDarkPreview(@PreviewParameter(ConfigureRoomStateProvider::class) state: ConfigureRoomState) =
+    ElementPreviewDark { ContentToPreview(state) }
+
+@ExcludeFromCoverage
+@Composable
+private fun ContentToPreview(state: ConfigureRoomState) {
+    ConfigureRoomView(
+        state = state,
+        onBackClick = {},
+        onCreateRoomSuccess = {},
+    )
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/configureroom/RoomAccess.kt

@@ -0,0 +1,22 @@
+/*
+ * Copyright 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.
+ */
+
+package io.element.android.features.startchat.impl.configureroom
+
+import io.element.android.libraries.matrix.api.room.join.JoinRule
+
+enum class RoomAccess {
+    Anyone,
+    Knocking
+}
+
+fun RoomAccess.toJoinRule(): JoinRule? {
+    return when (this) {
+        RoomAccess.Anyone -> null
+        RoomAccess.Knocking -> JoinRule.Knock
+    }
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/configureroom/RoomAccessItem.kt

@@ -0,0 +1,25 @@
+/*
+ * 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.startchat.impl.configureroom
+
+import androidx.annotation.StringRes
+import io.element.android.features.startchat.impl.R
+
+enum class RoomAccessItem(
+    @StringRes val title: Int,
+    @StringRes val description: Int
+) {
+    Anyone(
+        title = R.string.screen_create_room_room_access_section_anyone_option_title,
+        description = R.string.screen_create_room_room_access_section_anyone_option_description,
+    ),
+    AskToJoin(
+        title = R.string.screen_create_room_room_access_section_knocking_option_title,
+        description = R.string.screen_create_room_room_access_section_knocking_option_description,
+    ),
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/configureroom/RoomAddress.kt

@@ -0,0 +1,13 @@
+/*
+ * Copyright 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.
+ */
+
+package io.element.android.features.startchat.impl.configureroom
+
+sealed class RoomAddress(open val value: String) {
+    data class AutoFilled(override val value: String) : RoomAddress(value)
+    data class Edited(override val value: String) : RoomAddress(value)
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/configureroom/RoomVisibilityItem.kt

@@ -0,0 +1,30 @@
+/*
+ * 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.startchat.impl.configureroom
+
+import androidx.annotation.DrawableRes
+import androidx.annotation.StringRes
+import io.element.android.features.startchat.impl.R
+import io.element.android.libraries.designsystem.icons.CompoundDrawables
+
+enum class RoomVisibilityItem(
+    @DrawableRes val icon: Int,
+    @StringRes val title: Int,
+    @StringRes val description: Int
+) {
+    Private(
+        icon = CompoundDrawables.ic_compound_lock,
+        title = R.string.screen_create_room_private_option_title,
+        description = R.string.screen_create_room_private_option_description,
+    ),
+    Public(
+        icon = CompoundDrawables.ic_compound_public,
+        title = R.string.screen_create_room_public_option_title,
+        description = R.string.screen_create_room_public_option_description,
+    )
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/configureroom/RoomVisibilityState.kt

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2023, 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.
+ */
+
+package io.element.android.features.startchat.impl.configureroom
+
+import java.util.Optional
+
+sealed interface RoomVisibilityState {
+    data object Private : RoomVisibilityState
+
+    data class Public(
+        val roomAddress: RoomAddress,
+        val roomAccess: RoomAccess,
+    ) : RoomVisibilityState
+
+    fun roomAddress(): Optional<String> {
+        return when (this) {
+            is Private -> Optional.empty()
+            is Public -> Optional.of(roomAddress.value)
+        }
+    }
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/di/CreateRoomComponent.kt

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2023, 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.
+ */
+
+package io.element.android.features.startchat.impl.di
+
+import com.squareup.anvil.annotations.ContributesTo
+import com.squareup.anvil.annotations.MergeSubcomponent
+import io.element.android.libraries.architecture.NodeFactoriesBindings
+import io.element.android.libraries.di.SessionScope
+import io.element.android.libraries.di.SingleIn
+
+@SingleIn(CreateRoomScope::class)
+@MergeSubcomponent(CreateRoomScope::class)
+interface CreateRoomComponent : NodeFactoriesBindings {
+    @MergeSubcomponent.Builder
+    interface Builder {
+        fun build(): CreateRoomComponent
+    }
+
+    @ContributesTo(SessionScope::class)
+    interface ParentBindings {
+        fun createRoomComponentBuilder(): Builder
+    }
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/di/CreateRoomScope.kt

@@ -0,0 +1,10 @@
+/*
+ * Copyright 2023, 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.
+ */
+
+package io.element.android.features.startchat.impl.di
+
+abstract class CreateRoomScope private constructor()

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/joinbyaddress/JoinRoomByAddressEvents.kt

@@ -0,0 +1,14 @@
+/*
+ * 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.startchat.impl.joinbyaddress
+
+sealed interface JoinRoomByAddressEvents {
+    data object Dismiss : JoinRoomByAddressEvents
+    data object Continue : JoinRoomByAddressEvents
+    data class UpdateAddress(val address: String) : JoinRoomByAddressEvents
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/joinbyaddress/JoinRoomByAddressNode.kt

@@ -0,0 +1,39 @@
+/*
+ * 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.startchat.impl.joinbyaddress
+
+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 com.bumble.appyx.core.plugin.plugins
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedInject
+import io.element.android.anvilannotations.ContributesNode
+import io.element.android.features.startchat.StartChatNavigator
+import io.element.android.libraries.di.SessionScope
+
+@ContributesNode(SessionScope::class)
+class JoinRoomByAddressNode @AssistedInject constructor(
+    @Assisted buildContext: BuildContext,
+    @Assisted plugins: List<Plugin>,
+    presenterFactory: JoinRoomByAddressPresenter.Factory,
+) : Node(buildContext, plugins = plugins) {
+    private val navigator = plugins<StartChatNavigator>().first()
+    private val presenter = presenterFactory.create(navigator)
+
+    @Composable
+    override fun View(modifier: Modifier) {
+        val state = presenter.present()
+        JoinRoomByAddressView(
+            state = state,
+            modifier = modifier
+        )
+    }
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/joinbyaddress/JoinRoomByAddressPresenter.kt

@@ -0,0 +1,138 @@
+/*
+ * 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.startchat.impl.joinbyaddress
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.derivedStateOf
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberUpdatedState
+import androidx.compose.runtime.setValue
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedFactory
+import dagger.assisted.AssistedInject
+import io.element.android.features.startchat.StartChatNavigator
+import io.element.android.libraries.architecture.Presenter
+import io.element.android.libraries.core.data.tryOrNull
+import io.element.android.libraries.matrix.api.MatrixClient
+import io.element.android.libraries.matrix.api.core.RoomAlias
+import io.element.android.libraries.matrix.api.core.toRoomIdOrAlias
+import io.element.android.libraries.matrix.api.room.alias.RoomAliasHelper
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.withTimeoutOrNull
+import kotlin.time.Duration.Companion.seconds
+
+private const val ADDRESS_RESOLVE_TIMEOUT_IN_SECONDS = 10
+
+class JoinRoomByAddressPresenter @AssistedInject constructor(
+    @Assisted private val navigator: StartChatNavigator,
+    private val client: MatrixClient,
+    private val roomAliasHelper: RoomAliasHelper,
+) : Presenter<JoinRoomByAddressState> {
+    @AssistedFactory
+    interface Factory {
+        fun create(navigator: StartChatNavigator): JoinRoomByAddressPresenter
+    }
+
+    @Composable
+    override fun present(): JoinRoomByAddressState {
+        var address by remember { mutableStateOf("") }
+        var internalAddressState by remember { mutableStateOf<RoomAddressState>(RoomAddressState.Unknown) }
+        var validateAddress: Boolean by remember { mutableStateOf(false) }
+
+        fun handleEvents(event: JoinRoomByAddressEvents) {
+            when (event) {
+                JoinRoomByAddressEvents.Continue -> {
+                    when (val currentState = internalAddressState) {
+                        is RoomAddressState.RoomFound -> onRoomFound(currentState)
+                        else -> validateAddress = true
+                    }
+                }
+                JoinRoomByAddressEvents.Dismiss -> navigator.onDismissJoinRoomByAddress()
+                is JoinRoomByAddressEvents.UpdateAddress -> {
+                    validateAddress = false
+                    address = event.address.trim()
+                }
+            }
+        }
+
+        RoomAddressStateEffect(
+            fullAddress = address,
+            onRoomAddressStateChange = { addressState ->
+                internalAddressState = addressState
+                if (addressState is RoomAddressState.RoomFound && validateAddress) {
+                    onRoomFound(addressState)
+                }
+            }
+        )
+
+        val addressState by remember {
+            derivedStateOf {
+                // We only want to show the "RoomFound" state as long as the user didn't validate the address.
+                if (validateAddress || internalAddressState is RoomAddressState.RoomFound) {
+                    internalAddressState
+                } else {
+                    RoomAddressState.Unknown
+                }
+            }
+        }
+
+        return JoinRoomByAddressState(
+            address = address,
+            addressState = addressState,
+            eventSink = ::handleEvents
+        )
+    }
+
+    private fun onRoomFound(state: RoomAddressState.RoomFound) {
+        navigator.onDismissJoinRoomByAddress()
+        navigator.onOpenRoom(
+            roomIdOrAlias = state.resolved.roomId.toRoomIdOrAlias(),
+            serverNames = state.resolved.servers
+        )
+    }
+
+    @Composable
+    private fun RoomAddressStateEffect(
+        fullAddress: String,
+        onRoomAddressStateChange: (RoomAddressState) -> Unit,
+    ) {
+        val onChange by rememberUpdatedState(onRoomAddressStateChange)
+        LaunchedEffect(fullAddress) {
+            // Whenever the address changes, reset the state to unknown
+            onChange(RoomAddressState.Unknown)
+            // debounce the room address resolution
+            delay(300)
+            val roomAlias = tryOrNull { RoomAlias(fullAddress) }
+            if (roomAlias != null && roomAliasHelper.isRoomAliasValid(roomAlias)) {
+                onChange(RoomAddressState.Resolving)
+                onChange(client.resolveRoomAddress(roomAlias))
+            } else {
+                onChange(RoomAddressState.Invalid)
+            }
+        }
+    }
+
+    private suspend fun MatrixClient.resolveRoomAddress(roomAlias: RoomAlias): RoomAddressState {
+        return withTimeoutOrNull(ADDRESS_RESOLVE_TIMEOUT_IN_SECONDS.seconds) {
+            resolveRoomAlias(roomAlias)
+                .fold(
+                    onSuccess = { resolved ->
+                        if (resolved.isPresent) {
+                            RoomAddressState.RoomFound(resolved.get())
+                        } else {
+                            RoomAddressState.RoomNotFound
+                        }
+                    },
+                    onFailure = { _ -> RoomAddressState.RoomNotFound }
+                )
+        } ?: RoomAddressState.RoomNotFound
+    }
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/joinbyaddress/JoinRoomByAddressState.kt

@@ -0,0 +1,26 @@
+/*
+ * 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.startchat.impl.joinbyaddress
+
+import androidx.compose.runtime.Immutable
+import io.element.android.libraries.matrix.api.room.alias.ResolvedRoomAlias
+
+data class JoinRoomByAddressState(
+    val address: String,
+    val addressState: RoomAddressState,
+    val eventSink: (JoinRoomByAddressEvents) -> Unit
+)
+
+@Immutable
+sealed interface RoomAddressState {
+    data object Unknown : RoomAddressState
+    data object Invalid : RoomAddressState
+    data object Resolving : RoomAddressState
+    data object RoomNotFound : RoomAddressState
+    data class RoomFound(val resolved: ResolvedRoomAlias) : RoomAddressState
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/joinbyaddress/JoinRoomByAddressStateProvider.kt

@@ -0,0 +1,37 @@
+/*
+ * 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.startchat.impl.joinbyaddress
+
+import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.api.room.alias.ResolvedRoomAlias
+
+open class JoinRoomByAddressStateProvider : PreviewParameterProvider<JoinRoomByAddressState> {
+    override val values: Sequence<JoinRoomByAddressState>
+        get() = sequenceOf(
+            aJoinRoomByAddressState(),
+            aJoinRoomByAddressState(address = "#room-"),
+            aJoinRoomByAddressState(address = "#room-", addressState = RoomAddressState.Invalid),
+            aJoinRoomByAddressState(address = "#room-name:matrix.org", addressState = RoomAddressState.Resolving),
+            aJoinRoomByAddressState(address = "#room-name-none:matrix.org", addressState = RoomAddressState.RoomNotFound),
+            aJoinRoomByAddressState(
+                address = "#room-name:matrix.org",
+                addressState = RoomAddressState.RoomFound(ResolvedRoomAlias(RoomId("!aRoom:id"), emptyList())),
+            ),
+        )
+}
+
+fun aJoinRoomByAddressState(
+    address: String = "",
+    addressState: RoomAddressState = RoomAddressState.Unknown,
+    eventSink: (JoinRoomByAddressEvents) -> Unit = {},
+) = JoinRoomByAddressState(
+    address = address,
+    addressState = addressState,
+    eventSink = eventSink
+)

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/joinbyaddress/JoinRoomByAddressView.kt

@@ -0,0 +1,134 @@
+/*
+ * 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.startchat.impl.joinbyaddress
+
+import androidx.compose.foundation.layout.Column
+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.text.KeyboardActions
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.rememberModalBottomSheetState
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.input.ImeAction
+import androidx.compose.ui.text.input.KeyboardCapitalization
+import androidx.compose.ui.text.input.KeyboardType
+import androidx.compose.ui.tooling.preview.PreviewParameter
+import androidx.compose.ui.unit.dp
+import io.element.android.features.startchat.impl.R
+import io.element.android.libraries.designsystem.preview.ElementPreview
+import io.element.android.libraries.designsystem.preview.PreviewsDayNight
+import io.element.android.libraries.designsystem.theme.components.Button
+import io.element.android.libraries.designsystem.theme.components.ModalBottomSheet
+import io.element.android.libraries.designsystem.theme.components.TextField
+import io.element.android.libraries.designsystem.theme.components.TextFieldValidity
+import io.element.android.libraries.ui.strings.CommonStrings
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun JoinRoomByAddressView(
+    state: JoinRoomByAddressState,
+    modifier: Modifier = Modifier,
+) {
+    val sheetState = rememberModalBottomSheetState(skipPartiallyExpanded = true)
+    ModalBottomSheet(
+        modifier = modifier,
+        sheetState = sheetState,
+        onDismissRequest = {
+            state.eventSink(JoinRoomByAddressEvents.Dismiss)
+        },
+    ) {
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(all = 16.dp),
+            horizontalAlignment = Alignment.CenterHorizontally,
+        ) {
+            RoomAddressField(
+                address = state.address,
+                addressState = state.addressState,
+                requestFocus = sheetState.isVisible,
+                onAddressChange = {
+                    state.eventSink(JoinRoomByAddressEvents.UpdateAddress(it))
+                },
+                onContinue = {
+                    state.eventSink(JoinRoomByAddressEvents.Continue)
+                },
+            )
+            Spacer(modifier = Modifier.height(24.dp))
+            Button(
+                text = stringResource(CommonStrings.action_continue),
+                modifier = Modifier.fillMaxWidth(),
+                showProgress = state.addressState is RoomAddressState.Resolving,
+                onClick = {
+                    state.eventSink(JoinRoomByAddressEvents.Continue)
+                }
+            )
+        }
+    }
+}
+
+@Composable
+private fun RoomAddressField(
+    address: String,
+    addressState: RoomAddressState,
+    requestFocus: Boolean,
+    onAddressChange: (String) -> Unit,
+    onContinue: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val focusRequester = remember { FocusRequester() }
+    if (requestFocus) {
+        LaunchedEffect(Unit) { focusRequester.requestFocus() }
+    }
+    TextField(
+        modifier = modifier.focusRequester(focusRequester),
+        value = address,
+        label = stringResource(R.string.screen_start_chat_join_room_by_address_action),
+        placeholder = stringResource(R.string.screen_start_chat_join_room_by_address_placeholder),
+        supportingText = when (addressState) {
+            RoomAddressState.Invalid -> stringResource(R.string.screen_start_chat_join_room_by_address_invalid_address)
+            is RoomAddressState.RoomFound -> stringResource(R.string.screen_start_chat_join_room_by_address_room_found)
+            RoomAddressState.RoomNotFound -> stringResource(R.string.screen_start_chat_join_room_by_address_room_not_found)
+            RoomAddressState.Unknown, RoomAddressState.Resolving -> stringResource(R.string.screen_start_chat_join_room_by_address_supporting_text)
+        },
+        validity = when (addressState) {
+            RoomAddressState.Unknown, RoomAddressState.Resolving -> TextFieldValidity.None
+            RoomAddressState.Invalid, RoomAddressState.RoomNotFound -> TextFieldValidity.Invalid
+            is RoomAddressState.RoomFound -> TextFieldValidity.Valid
+        },
+        onValueChange = onAddressChange,
+        singleLine = true,
+        keyboardOptions = KeyboardOptions(
+            capitalization = KeyboardCapitalization.None,
+            autoCorrectEnabled = false,
+            keyboardType = KeyboardType.Uri,
+            imeAction = ImeAction.Go
+        ),
+        keyboardActions = KeyboardActions(
+            onGo = { onContinue() }
+        )
+    )
+}
+
+@PreviewsDayNight
+@Composable
+internal fun JoinRoomByAddressViewPreview(
+    @PreviewParameter(JoinRoomByAddressStateProvider::class) state: JoinRoomByAddressState
+) = ElementPreview {
+    JoinRoomByAddressView(state = state)
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/root/StartChatEvents.kt

@@ -0,0 +1,15 @@
+/*
+ * 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.startchat.impl.root
+
+import io.element.android.libraries.matrix.api.user.MatrixUser
+
+sealed interface StartChatEvents {
+    data class StartDM(val matrixUser: MatrixUser) : StartChatEvents
+    data object CancelStartDM : StartChatEvents
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/root/StartChatNode.kt

@@ -0,0 +1,66 @@
+/*
+ * 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.startchat.impl.root
+
+import android.app.Activity
+import androidx.activity.compose.LocalActivity
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import com.bumble.appyx.core.lifecycle.subscribe
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.plugin.Plugin
+import com.bumble.appyx.core.plugin.plugins
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedInject
+import im.vector.app.features.analytics.plan.MobileScreen
+import io.element.android.anvilannotations.ContributesNode
+import io.element.android.features.startchat.StartChatNavigator
+import io.element.android.libraries.deeplink.usecase.InviteFriendsUseCase
+import io.element.android.libraries.di.SessionScope
+import io.element.android.libraries.matrix.api.core.toRoomIdOrAlias
+import io.element.android.services.analytics.api.AnalyticsService
+
+@ContributesNode(SessionScope::class)
+class StartChatNode @AssistedInject constructor(
+    @Assisted buildContext: BuildContext,
+    @Assisted plugins: List<Plugin>,
+    private val presenter: StartChatPresenter,
+    private val analyticsService: AnalyticsService,
+    private val inviteFriendsUseCase: InviteFriendsUseCase,
+) : Node(buildContext, plugins = plugins) {
+    private val navigator = plugins<StartChatNavigator>().first()
+
+    init {
+        lifecycle.subscribe(
+            onResume = { analyticsService.screen(MobileScreen(screenName = MobileScreen.ScreenName.StartChat)) }
+        )
+    }
+
+    @Composable
+    override fun View(modifier: Modifier) {
+        val state = presenter.present()
+        val activity = requireNotNull(LocalActivity.current)
+        CreateRoomRootView(
+            state = state,
+            modifier = modifier,
+            onCloseClick = this::navigateUp,
+            onNewRoomClick = navigator::onCreateNewRoom,
+            onOpenDM = {
+                navigator.onOpenRoom(roomIdOrAlias = it.toRoomIdOrAlias(), serverNames = emptyList())
+            },
+            onJoinByAddressClick = navigator::onShowJoinRoomByAddress,
+            onInviteFriendsClick = { invitePeople(activity) },
+            onRoomDirectorySearchClick = navigator::onOpenRoomDirectory
+        )
+    }
+
+    private fun invitePeople(activity: Activity) {
+        inviteFriendsUseCase.execute(activity)
+    }
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/root/StartChatPresenter.kt

@@ -0,0 +1,80 @@
+/*
+ * 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.startchat.impl.root
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import io.element.android.features.startchat.api.StartDMAction
+import io.element.android.features.startchat.impl.userlist.SelectionMode
+import io.element.android.features.startchat.impl.userlist.UserListDataStore
+import io.element.android.features.startchat.impl.userlist.UserListPresenter
+import io.element.android.features.startchat.impl.userlist.UserListPresenterArgs
+import io.element.android.libraries.architecture.AsyncAction
+import io.element.android.libraries.architecture.Presenter
+import io.element.android.libraries.core.meta.BuildMeta
+import io.element.android.libraries.featureflag.api.FeatureFlagService
+import io.element.android.libraries.featureflag.api.FeatureFlags
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.usersearch.api.UserRepository
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+
+class StartChatPresenter @Inject constructor(
+    presenterFactory: UserListPresenter.Factory,
+    userRepository: UserRepository,
+    userListDataStore: UserListDataStore,
+    private val startDMAction: StartDMAction,
+    private val buildMeta: BuildMeta,
+    private val featureFlagService: FeatureFlagService,
+) : Presenter<StartChatState> {
+    private val presenter = presenterFactory.create(
+        UserListPresenterArgs(
+            selectionMode = SelectionMode.Single,
+        ),
+        userRepository,
+        userListDataStore,
+    )
+
+    @Composable
+    override fun present(): StartChatState {
+        val userListState = presenter.present()
+
+        val localCoroutineScope = rememberCoroutineScope()
+        val startDmActionState: MutableState<AsyncAction<RoomId>> = remember { mutableStateOf(AsyncAction.Uninitialized) }
+
+        val isRoomDirectorySearchEnabled by remember {
+            featureFlagService.isFeatureEnabledFlow(FeatureFlags.RoomDirectorySearch)
+        }.collectAsState(initial = false)
+
+        fun handleEvents(event: StartChatEvents) {
+            when (event) {
+                is StartChatEvents.StartDM -> localCoroutineScope.launch {
+                    startDMAction.execute(
+                        matrixUser = event.matrixUser,
+                        createIfDmDoesNotExist = startDmActionState.value is AsyncAction.Confirming,
+                        actionState = startDmActionState,
+                    )
+                }
+                StartChatEvents.CancelStartDM -> startDmActionState.value = AsyncAction.Uninitialized
+            }
+        }
+
+        return StartChatState(
+            applicationName = buildMeta.applicationName,
+            userListState = userListState,
+            startDmAction = startDmActionState.value,
+            isRoomDirectorySearchEnabled = isRoomDirectorySearchEnabled,
+            eventSink = ::handleEvents,
+        )
+    }
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/root/StartChatState.kt

@@ -0,0 +1,20 @@
+/*
+ * 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.startchat.impl.root
+
+import io.element.android.features.startchat.impl.userlist.UserListState
+import io.element.android.libraries.architecture.AsyncAction
+import io.element.android.libraries.matrix.api.core.RoomId
+
+data class StartChatState(
+    val applicationName: String,
+    val userListState: UserListState,
+    val startDmAction: AsyncAction<RoomId>,
+    val isRoomDirectorySearchEnabled: Boolean,
+    val eventSink: (StartChatEvents) -> Unit,
+)

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/root/StartChatStateProvider.kt

@@ -0,0 +1,74 @@
+/*
+ * 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.startchat.impl.root
+
+import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+import io.element.android.features.startchat.api.ConfirmingStartDmWithMatrixUser
+import io.element.android.features.startchat.impl.userlist.UserListState
+import io.element.android.features.startchat.impl.userlist.aRecentDirectRoomList
+import io.element.android.features.startchat.impl.userlist.aUserListState
+import io.element.android.libraries.architecture.AsyncAction
+import io.element.android.libraries.designsystem.theme.components.SearchBarResultState
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.ui.components.aMatrixUser
+import io.element.android.libraries.usersearch.api.UserSearchResult
+import kotlinx.collections.immutable.persistentListOf
+
+open class CreateRoomRootStateProvider : PreviewParameterProvider<StartChatState> {
+    override val values: Sequence<StartChatState>
+        get() = sequenceOf(
+            aCreateRoomRootState(),
+            aCreateRoomRootState(
+                startDmAction = AsyncAction.Loading,
+                userListState = aMatrixUser().let {
+                    aUserListState().copy(
+                        searchQuery = it.userId.value,
+                        searchResults = SearchBarResultState.Results(persistentListOf(UserSearchResult(it, false))),
+                        selectedUsers = persistentListOf(it),
+                        isSearchActive = true,
+                    )
+                }
+            ),
+            aCreateRoomRootState(
+                startDmAction = AsyncAction.Failure(RuntimeException("error")),
+                userListState = aMatrixUser().let {
+                    aUserListState().copy(
+                        searchQuery = it.userId.value,
+                        searchResults = SearchBarResultState.Results(persistentListOf(UserSearchResult(it, false))),
+                        selectedUsers = persistentListOf(it),
+                        isSearchActive = true,
+                    )
+                }
+            ),
+            aCreateRoomRootState(
+                userListState = aUserListState(
+                    recentDirectRooms = aRecentDirectRoomList()
+                )
+            ),
+            aCreateRoomRootState(
+                startDmAction = ConfirmingStartDmWithMatrixUser(aMatrixUser()),
+            ),
+            aCreateRoomRootState(
+                isRoomDirectorySearchEnabled = true,
+            ),
+        )
+}
+
+fun aCreateRoomRootState(
+    applicationName: String = "Element X Preview",
+    userListState: UserListState = aUserListState(),
+    startDmAction: AsyncAction<RoomId> = AsyncAction.Uninitialized,
+    isRoomDirectorySearchEnabled: Boolean = false,
+    eventSink: (StartChatEvents) -> Unit = {},
+) = StartChatState(
+    applicationName = applicationName,
+    userListState = userListState,
+    startDmAction = startDmAction,
+    isRoomDirectorySearchEnabled = isRoomDirectorySearchEnabled,
+    eventSink = eventSink,
+)

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/root/StartChatView.kt

@@ -0,0 +1,253 @@
+/*
+ * 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.startchat.impl.root
+
+import androidx.annotation.DrawableRes
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.consumeWindowInsets
+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.lazy.LazyColumn
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+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.features.startchat.api.ConfirmingStartDmWithMatrixUser
+import io.element.android.features.startchat.impl.R
+import io.element.android.features.startchat.impl.components.UserListView
+import io.element.android.libraries.designsystem.components.async.AsyncActionView
+import io.element.android.libraries.designsystem.components.async.AsyncActionViewDefaults
+import io.element.android.libraries.designsystem.components.button.BackButton
+import io.element.android.libraries.designsystem.icons.CompoundDrawables
+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.ListSectionHeader
+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.ui.components.CreateDmConfirmationBottomSheet
+import io.element.android.libraries.matrix.ui.components.MatrixUserRow
+import io.element.android.libraries.ui.strings.CommonStrings
+import kotlinx.collections.immutable.persistentListOf
+
+@Composable
+fun CreateRoomRootView(
+    state: StartChatState,
+    onCloseClick: () -> Unit,
+    onNewRoomClick: () -> Unit,
+    onOpenDM: (RoomId) -> Unit,
+    onInviteFriendsClick: () -> Unit,
+    onJoinByAddressClick: () -> Unit,
+    onRoomDirectorySearchClick: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    Scaffold(
+        modifier = modifier.fillMaxWidth(),
+        topBar = {
+            if (!state.userListState.isSearchActive) {
+                CreateRoomRootViewTopBar(onCloseClick = onCloseClick)
+            }
+        }
+    ) { paddingValues ->
+        Column(
+            modifier = Modifier
+                .padding(paddingValues)
+                .consumeWindowInsets(paddingValues),
+            verticalArrangement = Arrangement.spacedBy(8.dp),
+        ) {
+            UserListView(
+                modifier = Modifier.fillMaxWidth(),
+                // Do not render suggestions in this case, the suggestion will be rendered
+                // by CreateRoomActionButtonsList
+                state = state.userListState.copy(
+                    recentDirectRooms = persistentListOf(),
+                ),
+                onSelectUser = {
+                    state.eventSink(StartChatEvents.StartDM(it))
+                },
+                onDeselectUser = { },
+            )
+
+            if (!state.userListState.isSearchActive) {
+                CreateRoomActionButtonsList(
+                    state = state,
+                    onNewRoomClick = onNewRoomClick,
+                    onInvitePeopleClick = onInviteFriendsClick,
+                    onJoinByAddressClick = onJoinByAddressClick,
+                    onRoomDirectorySearchClick = onRoomDirectorySearchClick,
+                    onDmClick = onOpenDM,
+                )
+            }
+        }
+    }
+
+    AsyncActionView(
+        async = state.startDmAction,
+        progressDialog = {
+            AsyncActionViewDefaults.ProgressDialog(
+                progressText = stringResource(CommonStrings.common_starting_chat),
+            )
+        },
+        onSuccess = { onOpenDM(it) },
+        errorMessage = { stringResource(R.string.screen_start_chat_error_starting_chat) },
+        onRetry = {
+            state.userListState.selectedUsers.firstOrNull()
+                ?.let { state.eventSink(StartChatEvents.StartDM(it)) }
+            // Cancel start DM if there is no more selected user (should not happen)
+                ?: state.eventSink(StartChatEvents.CancelStartDM)
+        },
+        onErrorDismiss = { state.eventSink(StartChatEvents.CancelStartDM) },
+        confirmationDialog = { data ->
+            if (data is ConfirmingStartDmWithMatrixUser) {
+                CreateDmConfirmationBottomSheet(
+                    matrixUser = data.matrixUser,
+                    onSendInvite = {
+                        state.eventSink(StartChatEvents.StartDM(data.matrixUser))
+                    },
+                    onDismiss = {
+                        state.eventSink(StartChatEvents.CancelStartDM)
+                    },
+                )
+            }
+        },
+    )
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+private fun CreateRoomRootViewTopBar(
+    onCloseClick: () -> Unit,
+) {
+    TopAppBar(
+        titleStr = stringResource(id = CommonStrings.action_start_chat),
+        navigationIcon = {
+            BackButton(
+                imageVector = CompoundIcons.Close(),
+                onClick = onCloseClick,
+            )
+        }
+    )
+}
+
+@Composable
+private fun CreateRoomActionButtonsList(
+    state: StartChatState,
+    onNewRoomClick: () -> Unit,
+    onInvitePeopleClick: () -> Unit,
+    onJoinByAddressClick: () -> Unit,
+    onRoomDirectorySearchClick: () -> Unit,
+    onDmClick: (RoomId) -> Unit,
+) {
+    LazyColumn {
+        item {
+            CreateRoomActionButton(
+                iconRes = CompoundDrawables.ic_compound_plus,
+                text = stringResource(id = R.string.screen_create_room_action_create_room),
+                onClick = onNewRoomClick,
+            )
+        }
+        if (state.isRoomDirectorySearchEnabled) {
+            item {
+                CreateRoomActionButton(
+                    iconRes = CompoundDrawables.ic_compound_list_bulleted,
+                    text = stringResource(id = R.string.screen_room_directory_search_title),
+                    onClick = onRoomDirectorySearchClick,
+                )
+            }
+        }
+        item {
+            CreateRoomActionButton(
+                iconRes = CompoundDrawables.ic_compound_share_android,
+                text = stringResource(id = CommonStrings.action_invite_friends_to_app, state.applicationName),
+                onClick = onInvitePeopleClick,
+            )
+        }
+        item {
+            CreateRoomActionButton(
+                iconRes = CompoundDrawables.ic_compound_room,
+                text = stringResource(R.string.screen_start_chat_join_room_by_address_action),
+                onClick = onJoinByAddressClick,
+            )
+        }
+        if (state.userListState.recentDirectRooms.isNotEmpty()) {
+            item {
+                ListSectionHeader(
+                    title = stringResource(id = CommonStrings.common_suggestions),
+                    hasDivider = false,
+                )
+            }
+            state.userListState.recentDirectRooms.forEach { recentDirectRoom ->
+                item {
+                    MatrixUserRow(
+                        modifier = Modifier.clickable(
+                            onClick = {
+                                onDmClick(recentDirectRoom.roomId)
+                            }
+                        ),
+                        matrixUser = recentDirectRoom.matrixUser,
+                    )
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun CreateRoomActionButton(
+    @DrawableRes iconRes: Int,
+    text: String,
+    onClick: () -> Unit,
+) {
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .height(56.dp)
+            .clickable { onClick() }
+            .padding(horizontal = 16.dp),
+        horizontalArrangement = Arrangement.spacedBy(16.dp),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Icon(
+            modifier = Modifier.size(24.dp),
+            tint = ElementTheme.colors.iconSecondary,
+            resourceId = iconRes,
+            contentDescription = null,
+        )
+        Text(
+            text = text,
+            style = ElementTheme.typography.fontBodyLgRegular,
+        )
+    }
+}
+
+@PreviewsDayNight
+@Composable
+internal fun CreateRoomRootViewPreview(@PreviewParameter(CreateRoomRootStateProvider::class) state: StartChatState) =
+    ElementPreview {
+        CreateRoomRootView(
+            state = state,
+            onCloseClick = {},
+            onNewRoomClick = {},
+            onOpenDM = {},
+            onJoinByAddressClick = {},
+            onInviteFriendsClick = {},
+            onRoomDirectorySearchClick = {},
+        )
+    }

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/userlist/DefaultUserListPresenter.kt

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2023, 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.
+ */
+
+package io.element.android.features.startchat.impl.userlist
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import com.squareup.anvil.annotations.ContributesBinding
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedFactory
+import dagger.assisted.AssistedInject
+import io.element.android.libraries.designsystem.theme.components.SearchBarResultState
+import io.element.android.libraries.di.SessionScope
+import io.element.android.libraries.matrix.api.MatrixClient
+import io.element.android.libraries.matrix.api.room.recent.RecentDirectRoom
+import io.element.android.libraries.matrix.api.room.recent.getRecentDirectRooms
+import io.element.android.libraries.usersearch.api.UserRepository
+import io.element.android.libraries.usersearch.api.UserSearchResult
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.toImmutableList
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+
+class DefaultUserListPresenter @AssistedInject constructor(
+    @Assisted val args: UserListPresenterArgs,
+    @Assisted val userRepository: UserRepository,
+    @Assisted val userListDataStore: UserListDataStore,
+    private val matrixClient: MatrixClient,
+) : UserListPresenter {
+    @AssistedFactory
+    @ContributesBinding(SessionScope::class)
+    interface DefaultUserListFactory : UserListPresenter.Factory {
+        override fun create(
+            args: UserListPresenterArgs,
+            userRepository: UserRepository,
+            userListDataStore: UserListDataStore,
+        ): DefaultUserListPresenter
+    }
+
+    @Composable
+    override fun present(): UserListState {
+        var recentDirectRooms by remember { mutableStateOf(emptyList<RecentDirectRoom>()) }
+        LaunchedEffect(Unit) {
+            recentDirectRooms = matrixClient.getRecentDirectRooms()
+        }
+        var isSearchActive by rememberSaveable { mutableStateOf(false) }
+        val selectedUsers by userListDataStore.selectedUsers.collectAsState(emptyList())
+        var searchQuery by rememberSaveable { mutableStateOf("") }
+        var searchResults: SearchBarResultState<ImmutableList<UserSearchResult>> by remember {
+            mutableStateOf(SearchBarResultState.Initial())
+        }
+        var showSearchLoader by remember { mutableStateOf(false) }
+
+        LaunchedEffect(searchQuery) {
+            searchResults = SearchBarResultState.Initial()
+            showSearchLoader = false
+            userRepository.search(searchQuery).onEach { state ->
+                showSearchLoader = state.isSearching
+                searchResults = when {
+                    state.results.isEmpty() && state.isSearching -> SearchBarResultState.Initial()
+                    state.results.isEmpty() && !state.isSearching -> SearchBarResultState.NoResultsFound()
+                    else -> SearchBarResultState.Results(state.results.toImmutableList())
+                }
+            }.launchIn(this)
+        }
+
+        return UserListState(
+            searchQuery = searchQuery,
+            searchResults = searchResults,
+            selectedUsers = selectedUsers.toImmutableList(),
+            isSearchActive = isSearchActive,
+            showSearchLoader = showSearchLoader,
+            selectionMode = args.selectionMode,
+            recentDirectRooms = recentDirectRooms.toImmutableList(),
+            eventSink = { event ->
+                when (event) {
+                    is UserListEvents.OnSearchActiveChanged -> isSearchActive = event.active
+                    is UserListEvents.UpdateSearchQuery -> searchQuery = event.query
+                    is UserListEvents.AddToSelection -> userListDataStore.selectUser(event.matrixUser)
+                    is UserListEvents.RemoveFromSelection -> userListDataStore.removeUserFromSelection(event.matrixUser)
+                }
+            },
+        )
+    }
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/userlist/UserListDataStore.kt

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2023, 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.
+ */
+
+package io.element.android.features.startchat.impl.userlist
+
+import io.element.android.libraries.matrix.api.user.MatrixUser
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import javax.inject.Inject
+
+class UserListDataStore @Inject constructor() {
+    private val _selectedUsers: MutableStateFlow<List<MatrixUser>> = MutableStateFlow(emptyList())
+
+    fun selectUser(user: MatrixUser) {
+        if (!_selectedUsers.value.contains(user)) {
+            _selectedUsers.tryEmit(_selectedUsers.value.plus(user))
+        }
+    }
+
+    fun removeUserFromSelection(user: MatrixUser) {
+        _selectedUsers.tryEmit(_selectedUsers.value.minus(user))
+    }
+
+    val selectedUsers = _selectedUsers.asStateFlow()
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/userlist/UserListEvents.kt

@@ -0,0 +1,17 @@
+/*
+ * Copyright 2023, 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.
+ */
+
+package io.element.android.features.startchat.impl.userlist
+
+import io.element.android.libraries.matrix.api.user.MatrixUser
+
+sealed interface UserListEvents {
+    data class UpdateSearchQuery(val query: String) : UserListEvents
+    data class AddToSelection(val matrixUser: MatrixUser) : UserListEvents
+    data class RemoveFromSelection(val matrixUser: MatrixUser) : UserListEvents
+    data class OnSearchActiveChanged(val active: Boolean) : UserListEvents
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/userlist/UserListPresenter.kt

@@ -0,0 +1,21 @@
+/*
+ * Copyright 2023, 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.
+ */
+
+package io.element.android.features.startchat.impl.userlist
+
+import io.element.android.libraries.architecture.Presenter
+import io.element.android.libraries.usersearch.api.UserRepository
+
+interface UserListPresenter : Presenter<UserListState> {
+    interface Factory {
+        fun create(
+            args: UserListPresenterArgs,
+            userRepository: UserRepository,
+            userListDataStore: UserListDataStore,
+        ): UserListPresenter
+    }
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/userlist/UserListPresenterArgs.kt

@@ -0,0 +1,17 @@
+/*
+ * Copyright 2023, 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.
+ */
+
+package io.element.android.features.startchat.impl.userlist
+
+data class UserListPresenterArgs(
+    val selectionMode: SelectionMode,
+)
+
+enum class SelectionMode {
+    Single,
+    Multiple,
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/userlist/UserListState.kt

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2023, 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.
+ */
+
+package io.element.android.features.startchat.impl.userlist
+
+import io.element.android.libraries.designsystem.theme.components.SearchBarResultState
+import io.element.android.libraries.matrix.api.room.recent.RecentDirectRoom
+import io.element.android.libraries.matrix.api.user.MatrixUser
+import io.element.android.libraries.usersearch.api.UserSearchResult
+import kotlinx.collections.immutable.ImmutableList
+
+data class UserListState(
+    val searchQuery: String,
+    val searchResults: SearchBarResultState<ImmutableList<UserSearchResult>>,
+    val showSearchLoader: Boolean,
+    val selectedUsers: ImmutableList<MatrixUser>,
+    val isSearchActive: Boolean,
+    val selectionMode: SelectionMode,
+    val recentDirectRooms: ImmutableList<RecentDirectRoom>,
+    val eventSink: (UserListEvents) -> Unit,
+) {
+    val isMultiSelectionEnabled = selectionMode == SelectionMode.Multiple
+}

features/startchat/impl/src/main/kotlin/io/element/android/features/startchat/impl/userlist/UserListStateProvider.kt

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2023, 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.
+ */
+
+package io.element.android.features.startchat.impl.userlist
+
+import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+import io.element.android.libraries.designsystem.theme.components.SearchBarResultState
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.api.room.recent.RecentDirectRoom
+import io.element.android.libraries.matrix.api.user.MatrixUser
+import io.element.android.libraries.matrix.ui.components.aMatrixUserList
+import io.element.android.libraries.usersearch.api.UserSearchResult
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.toImmutableList
+
+open class UserListStateProvider : PreviewParameterProvider<UserListState> {
+    override val values: Sequence<UserListState>
+        get() = sequenceOf(
+            aUserListState(),
+            aUserListState(
+                isSearchActive = false,
+                selectedUsers = aListOfSelectedUsers(),
+                selectionMode = SelectionMode.Multiple,
+            ),
+            aUserListState(isSearchActive = true),
+            aUserListState(isSearchActive = true, searchQuery = "someone"),
+            aUserListState(isSearchActive = true, searchQuery = "someone", selectionMode = SelectionMode.Multiple),
+            aUserListState(
+                isSearchActive = true,
+                searchQuery = "@someone:matrix.org",
+                selectedUsers = aMatrixUserList().toImmutableList(),
+                searchResults = SearchBarResultState.Results(aListOfUserSearchResults()),
+            ),
+            aUserListState(
+                isSearchActive = true,
+                searchQuery = "@someone:matrix.org",
+                selectionMode = SelectionMode.Multiple,
+                selectedUsers = aMatrixUserList().toImmutableList(),
+                searchResults = SearchBarResultState.Results(aListOfUserSearchResults()),
+            ),
+            aUserListState(
+                isSearchActive = true,
+                searchQuery = "something-with-no-results",
+                searchResults = SearchBarResultState.NoResultsFound()
+            ),
+            aUserListState(
+                isSearchActive = true,
+                searchQuery = "someone",
+                selectionMode = SelectionMode.Single,
+            ),
+            aUserListState(
+                recentDirectRooms = aRecentDirectRoomList(),
+            ),
+        )
+}
+
+fun aUserListState(
+    searchQuery: String = "",
+    isSearchActive: Boolean = false,
+    searchResults: SearchBarResultState<ImmutableList<UserSearchResult>> = SearchBarResultState.Initial(),
+    selectedUsers: List<MatrixUser> = emptyList(),
+    showSearchLoader: Boolean = false,
+    selectionMode: SelectionMode = SelectionMode.Single,
+    recentDirectRooms: List<RecentDirectRoom> = emptyList(),
+    eventSink: (UserListEvents) -> Unit = {},
+) = UserListState(
+    searchQuery = searchQuery,
+    isSearchActive = isSearchActive,
+    searchResults = searchResults,
+    selectedUsers = selectedUsers.toImmutableList(),
+    showSearchLoader = showSearchLoader,
+    selectionMode = selectionMode,
+    recentDirectRooms = recentDirectRooms.toImmutableList(),
+    eventSink = eventSink
+)
+
+fun aListOfSelectedUsers() = aMatrixUserList().take(6).toImmutableList()
+fun aListOfUserSearchResults() = aMatrixUserList().take(6).map { UserSearchResult(it) }.toImmutableList()
+
+fun aRecentDirectRoomList(
+    count: Int = 5
+): List<RecentDirectRoom> = aMatrixUserList()
+    .take(count)
+    .map {
+        RecentDirectRoom(RoomId("!aRoom:id"), it)
+    }

features/startchat/impl/src/main/res/values-be/translations.xml

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_create_room_action_create_room">"Новы пакой"</string>
+  <string name="screen_create_room_add_people_title">"Запрасіць карыстальнікаў"</string>
+  <string name="screen_create_room_error_creating_room">"Пры стварэнні пакоя адбылася памылка"</string>
+  <string name="screen_create_room_private_option_description">"Толькі запрошаныя людзі могуць атрымаць доступ да гэтага пакоя. Усе паведамленні абаронены end-to-end шыфраваннем."</string>
+  <string name="screen_create_room_private_option_title">"Прыватны пакой"</string>
+  <string name="screen_create_room_public_option_description">"Любы можа знайсці гэты пакой. 
+Вы можаце змяніць гэта ў любы час у наладах пакоя."</string>
+  <string name="screen_create_room_public_option_title">"Публічны пакой"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_title">"Хто заўгодна"</string>
+  <string name="screen_create_room_room_access_section_header">"Доступ у пакой"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_title">"Папрасіце далучыцца"</string>
+  <string name="screen_create_room_room_name_label">"Назва пакоя"</string>
+  <string name="screen_create_room_title">"Стварыце пакой"</string>
+  <string name="screen_create_room_topic_label">"Тэма (неабавязкова)"</string>
+  <string name="screen_room_directory_search_title">"Каталог пакояў"</string>
+  <string name="screen_start_chat_error_starting_chat">"Пры спробе пачаць чат адбылася памылка"</string>
+</resources>

features/startchat/impl/src/main/res/values-bg/translations.xml

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_create_room_action_create_room">"Нова стая"</string>
+  <string name="screen_create_room_add_people_title">"Поканване на хора"</string>
+  <string name="screen_create_room_error_creating_room">"Възникна грешка при създаването на стаята"</string>
+  <string name="screen_create_room_private_option_description">"Само поканени хора имат достъп до тази стая. Всички съобщения са шифровани от край до край."</string>
+  <string name="screen_create_room_private_option_title">"Частна стая"</string>
+  <string name="screen_create_room_public_option_description">"Всеки може да намери тази стая.
+Можете да промените това по всяко време в настройките на стаята."</string>
+  <string name="screen_create_room_public_option_title">"Общодостъпна стая"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_description">"Всеки може да се присъедини към тази стая"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_title">"Всеки"</string>
+  <string name="screen_create_room_room_address_section_footer">"За да бъде тази стая видима в директорията на общодостъпните стаи, ще ви е необходим адрес на стаята."</string>
+  <string name="screen_create_room_room_name_label">"Име на стаята"</string>
+  <string name="screen_create_room_room_visibility_section_title">"Видимост на стаята"</string>
+  <string name="screen_create_room_title">"Създаване на стая"</string>
+  <string name="screen_create_room_topic_label">"Тема за разговор (незадължително)"</string>
+  <string name="screen_start_chat_join_room_by_address_action">"Присъединяване към стая по адрес"</string>
+  <string name="screen_start_chat_join_room_by_address_invalid_address">"Не е валиден адрес"</string>
+  <string name="screen_start_chat_join_room_by_address_placeholder">"Въведете…"</string>
+  <string name="screen_start_chat_join_room_by_address_room_not_found">"Стаята не е намерена"</string>
+  <string name="screen_start_chat_join_room_by_address_supporting_text">"напр. #room-name:matrix.org"</string>
+</resources>

features/startchat/impl/src/main/res/values-cs/translations.xml

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_create_room_action_create_room">"Nová místnost"</string>
+  <string name="screen_create_room_add_people_title">"Pozvat přátele"</string>
+  <string name="screen_create_room_error_creating_room">"Při vytváření místnosti došlo k chybě"</string>
+  <string name="screen_create_room_private_option_description">"Do této místnosti mají přístup pouze pozvaní lidé. Všechny zprávy jsou koncově šifrovány."</string>
+  <string name="screen_create_room_private_option_title">"Soukromá místnost"</string>
+  <string name="screen_create_room_public_option_description">"Tuto místnost může najít kdokoli.
+To můžete kdykoli změnit v nastavení místnosti."</string>
+  <string name="screen_create_room_public_option_title">"Veřejná místnost"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_description">"Do této místnosti může vstoupit kdokoli"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_title">"Kdokoliv"</string>
+  <string name="screen_create_room_room_access_section_header">"Přístup do místnosti"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_description">"Kdokoli může požádat o vstup do místnosti, ale správce nebo moderátor bude muset žádost přijmout"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_title">"Požádat o připojení"</string>
+  <string name="screen_create_room_room_address_section_footer">"Aby byla tato místnost viditelná v adresáři veřejných místností, budete potřebovat adresu místnosti."</string>
+  <string name="screen_create_room_room_address_section_title">"Adresa místnosti"</string>
+  <string name="screen_create_room_room_name_label">"Název místnosti"</string>
+  <string name="screen_create_room_room_visibility_section_title">"Viditelnost místnosti"</string>
+  <string name="screen_create_room_title">"Vytvořit místnost"</string>
+  <string name="screen_create_room_topic_label">"Téma (nepovinné)"</string>
+  <string name="screen_room_directory_search_title">"Adresář místností"</string>
+  <string name="screen_start_chat_error_starting_chat">"Při pokusu o zahájení chatu došlo k chybě"</string>
+  <string name="screen_start_chat_join_room_by_address_action">"Vstoupit do místnosti pomocí adresy"</string>
+  <string name="screen_start_chat_join_room_by_address_invalid_address">"Neplatná adresa"</string>
+  <string name="screen_start_chat_join_room_by_address_placeholder">"Zadejte…"</string>
+  <string name="screen_start_chat_join_room_by_address_room_found">"Odpovídající místnost nalezena"</string>
+  <string name="screen_start_chat_join_room_by_address_room_not_found">"Místnost nebyla nalezena"</string>
+  <string name="screen_start_chat_join_room_by_address_supporting_text">"např. #room-name:matrix.org"</string>
+</resources>

features/startchat/impl/src/main/res/values-cy/translations.xml

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_create_room_action_create_room">"Ystafell newydd"</string>
+  <string name="screen_create_room_add_people_title">"Gwahodd pobl"</string>
+  <string name="screen_create_room_error_creating_room">"Bu gwall wrth greu\'r ystafell"</string>
+  <string name="screen_create_room_private_option_description">"Dim ond pobl wahoddwyd all gael mynediad i\'r ystafell hon. Mae pob neges wedi\'i hamgryptio o\'r dechrau i\'r diwedd."</string>
+  <string name="screen_create_room_private_option_title">"Ystafell breifat"</string>
+  <string name="screen_create_room_public_option_description">"Gall unrhyw un ddod o hyd i\'r ystafell hon.
+Gallwch newid hyn unrhyw bryd yng ngosodiadau ystafell."</string>
+  <string name="screen_create_room_public_option_title">"Ystafell gyhoeddus"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_description">"Gall unrhyw un ymuno â\'r ystafell hon"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_title">"Unrhyw un"</string>
+  <string name="screen_create_room_room_access_section_header">"Mynediad i\'r Ystafell"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_description">"Gall unrhyw un ofyn am gael ymuno â\'r ystafell ond bydd rhaid i weinyddwr neu gymedrolwr dderbyn y cais"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_title">"Gofyn i gael ymuno"</string>
+  <string name="screen_create_room_room_address_section_footer">"Er mwyn i\'r ystafell hon fod yn weladwy yn y cyfeiriadur ystafelloedd cyhoeddus, bydd angen cyfeiriad ystafell arnoch."</string>
+  <string name="screen_create_room_room_address_section_title">"Cyfeiriad yr ystafell"</string>
+  <string name="screen_create_room_room_name_label">"Enw\'r ystafell"</string>
+  <string name="screen_create_room_room_visibility_section_title">"Gwelededd yr ystafell"</string>
+  <string name="screen_create_room_title">"Creu ystafell"</string>
+  <string name="screen_create_room_topic_label">"Pwnc (dewisol)"</string>
+  <string name="screen_room_directory_search_title">"Cyfeiriadur ystafelloedd"</string>
+  <string name="screen_start_chat_error_starting_chat">"Digwyddodd gwall wrth geisio cychwyn sgwrs"</string>
+  <string name="screen_start_chat_join_room_by_address_action">"Ymuno â\'r ystafell yn ôl cyfeiriad"</string>
+  <string name="screen_start_chat_join_room_by_address_invalid_address">"Ddim yn gyfeiriad dilys"</string>
+  <string name="screen_start_chat_join_room_by_address_placeholder">"Ewch i mewn…"</string>
+  <string name="screen_start_chat_join_room_by_address_room_found">"Cafwyd hyd i ystafell gyfatebol"</string>
+  <string name="screen_start_chat_join_room_by_address_room_not_found">"Heb ganfod yr ystafell"</string>
+  <string name="screen_start_chat_join_room_by_address_supporting_text">"e.e. #enw-ystafell:matrix.org"</string>
+</resources>

features/startchat/impl/src/main/res/values-da/translations.xml

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_create_room_action_create_room">"Nyt rum"</string>
+  <string name="screen_create_room_add_people_title">"Invitér folk"</string>
+  <string name="screen_create_room_error_creating_room">"Der opstod en fejl ved oprettelsen af rummet"</string>
+  <string name="screen_create_room_private_option_description">"Kun inviterede personer kan få adgang til dette rum. Alle meddelelser er ende-til-ende krypteret."</string>
+  <string name="screen_create_room_private_option_title">"Privat rum"</string>
+  <string name="screen_create_room_public_option_description">"Alle kan finde dette rum.
+Du kan ændre dette når som helst i rummets indstillinger."</string>
+  <string name="screen_create_room_public_option_title">"Offentligt rum"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_description">"Alle kan deltage i dette rum"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_title">"Enhver"</string>
+  <string name="screen_create_room_room_access_section_header">"Adgang til rummet"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_description">"Alle kan bede om at deltage i rummet, men en administrator eller en moderator skal acceptere anmodningen"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_title">"Spørg om at deltage"</string>
+  <string name="screen_create_room_room_address_section_footer">"Hvis dette rum skal være synligt i det offentlige register, skal du bruge en rum-adresse."</string>
+  <string name="screen_create_room_room_address_section_title">"Rummets adresse"</string>
+  <string name="screen_create_room_room_name_label">"Navn på rum"</string>
+  <string name="screen_create_room_room_visibility_section_title">"Rummets synlighed"</string>
+  <string name="screen_create_room_title">"Opret et rum"</string>
+  <string name="screen_create_room_topic_label">"Emne (valgfrit)"</string>
+  <string name="screen_room_directory_search_title">"Register over rum"</string>
+  <string name="screen_start_chat_error_starting_chat">"Der opstod en fejl under forsøget på at starte en samtale"</string>
+  <string name="screen_start_chat_join_room_by_address_action">"Tilslut dig rummet med adressen"</string>
+  <string name="screen_start_chat_join_room_by_address_invalid_address">"Ikke en gyldig adresse"</string>
+  <string name="screen_start_chat_join_room_by_address_placeholder">"Indtast…"</string>
+  <string name="screen_start_chat_join_room_by_address_room_found">"Matchende rum fundet"</string>
+  <string name="screen_start_chat_join_room_by_address_room_not_found">"Rum ikke fundet"</string>
+  <string name="screen_start_chat_join_room_by_address_supporting_text">"f.eks. #rummets-navn:matrix.org"</string>
+</resources>

features/startchat/impl/src/main/res/values-de/translations.xml

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_create_room_action_create_room">"Neuer Raum"</string>
+  <string name="screen_create_room_add_people_title">"Nutzer einladen"</string>
+  <string name="screen_create_room_error_creating_room">"Beim Erstellen des Chats ist ein Fehler aufgetreten"</string>
+  <string name="screen_create_room_private_option_description">"Nur eingeladene Personen haben Zutritt zu diesem Chatroom. Alle Nachrichten sind Ende-zu-Ende verschlüsselt."</string>
+  <string name="screen_create_room_private_option_title">"Privater Chatroom"</string>
+  <string name="screen_create_room_public_option_description">"Alle können diesen Chatroom finden.
+Sie können dies aber jederzeit in den Chatroomeinstellungen ändern."</string>
+  <string name="screen_create_room_public_option_title">"Öffentlicher Raum"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_description">"Jeder darf diesen Raum betreten"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_title">"Jeder"</string>
+  <string name="screen_create_room_room_access_section_header">"Chatroomzugang"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_description">"Jeder kann den Zutritt zum Raum beantragen, aber ein Moderator muss die Anfrage akzeptieren."</string>
+  <string name="screen_create_room_room_access_section_knocking_option_title">"Beitritt beantragen"</string>
+  <string name="screen_create_room_room_address_section_footer">"Damit dieser Chatroom im öffentlichen Chatroomverzeichnis sichtbar ist, benötigen Sie eine Chatroomadresse."</string>
+  <string name="screen_create_room_room_address_section_title">"Chatroomadresse"</string>
+  <string name="screen_create_room_room_name_label">"Raumname"</string>
+  <string name="screen_create_room_room_visibility_section_title">" Sichtbarkeit des Chatrooms"</string>
+  <string name="screen_create_room_title">"Raum erstellen"</string>
+  <string name="screen_create_room_topic_label">"Thema (optional)"</string>
+  <string name="screen_room_directory_search_title">"Raum-Verzeichnis"</string>
+  <string name="screen_start_chat_error_starting_chat">"Beim Versuch, einen Chat zu starten, ist ein Fehler aufgetreten"</string>
+  <string name="screen_start_chat_join_room_by_address_action">"Raum per Adresse betreten"</string>
+  <string name="screen_start_chat_join_room_by_address_invalid_address">"Keine gültige Adresse"</string>
+  <string name="screen_start_chat_join_room_by_address_placeholder">"Eintreten…"</string>
+  <string name="screen_start_chat_join_room_by_address_room_found">"Passender Raum gefunden"</string>
+  <string name="screen_start_chat_join_room_by_address_room_not_found">"Raum nicht gefunden"</string>
+  <string name="screen_start_chat_join_room_by_address_supporting_text">"z. B. #room -name:matrix.org"</string>
+</resources>

features/startchat/impl/src/main/res/values-el/translations.xml

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_create_room_action_create_room">"Νέα αίθουσα"</string>
+  <string name="screen_create_room_add_people_title">"Πρόσκληση ατόμων"</string>
+  <string name="screen_create_room_error_creating_room">"Προέκυψε σφάλμα κατά τη δημιουργία της αίθουσας"</string>
+  <string name="screen_create_room_private_option_description">"Μόνο τα άτομα που έχουν προσκληθεί μπορούν να έχουν πρόσβαση σε αυτή την αίθουσα. Όλα τα μηνύματα είναι κρυπτογραφημένα από άκρο σε άκρο."</string>
+  <string name="screen_create_room_private_option_title">"Ιδιωτική αίθουσα"</string>
+  <string name="screen_create_room_public_option_description">"Ο καθένας μπορεί να βρει αυτή την αίθουσα.
+Αυτό μπορείτε να το αλλάξετε ανά πάσα στιγμή στις ρυθμίσεις της αίθουσας."</string>
+  <string name="screen_create_room_public_option_title">"Δημόσια αίθουσα"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_description">"Οποιοσδήποτε μπορεί να συμμετάσχει σε αυτή την αίθουσα"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_title">"Οποιοσδήποτε"</string>
+  <string name="screen_create_room_room_access_section_header">"Πρόσβαση στην Αίθουσα"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_description">"Οποιοσδήποτε μπορεί να ζητήσει να συμμετάσχει στην αίθουσα, αλλά ένας διαχειριστής ή ένας συντονιστής θα πρέπει να αποδεχτεί το αίτημα"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_title">"Αίτημα συμμετοχής"</string>
+  <string name="screen_create_room_room_address_section_footer">"Για να είναι ορατή αυτή η αίθουσα στον δημόσιο κατάλογο αιθουσών, θα χρειαστείτε μια διεύθυνση αίθουσας."</string>
+  <string name="screen_create_room_room_address_section_title">"Διεύθυνση αίθουσας"</string>
+  <string name="screen_create_room_room_name_label">"Όνομα αίθουσας"</string>
+  <string name="screen_create_room_room_visibility_section_title">"Ορατότητα αίθουσας"</string>
+  <string name="screen_create_room_title">"Δημιουργία αίθουσας"</string>
+  <string name="screen_create_room_topic_label">"Θέμα (προαιρετικό)"</string>
+  <string name="screen_room_directory_search_title">"Κατάλογος αιθουσών"</string>
+  <string name="screen_start_chat_error_starting_chat">"Παρουσιάστηκε σφάλμα κατά την προσπάθεια έναρξης μιας συνομιλίας"</string>
+  <string name="screen_start_chat_join_room_by_address_action">"Συμμετοχή σε αίθουσα μέσω διεύθυνσης"</string>
+  <string name="screen_start_chat_join_room_by_address_invalid_address">"Μη έγκυρη διεύθυνση"</string>
+  <string name="screen_start_chat_join_room_by_address_placeholder">"Εισάγετε…"</string>
+  <string name="screen_start_chat_join_room_by_address_room_found">"Βρέθηκε η αντίστοιχη αίθουσα"</string>
+  <string name="screen_start_chat_join_room_by_address_room_not_found">"Η αίθουσα δεν βρέθηκε"</string>
+  <string name="screen_start_chat_join_room_by_address_supporting_text">"π.χ. #όνομα-αίθουσας:matrix.org"</string>
+</resources>

features/startchat/impl/src/main/res/values-es/translations.xml

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_create_room_action_create_room">"Nueva sala"</string>
+  <string name="screen_create_room_add_people_title">"Invitar personas"</string>
+  <string name="screen_create_room_error_creating_room">"Se ha producido un error al crear la sala"</string>
+  <string name="screen_create_room_private_option_description">"Solo las personas invitadas pueden acceder a esta sala. Todos los mensajes están cifrados de extremo a extremo."</string>
+  <string name="screen_create_room_private_option_title">"Sala privada"</string>
+  <string name="screen_create_room_public_option_description">"Cualquiera puede encontrar esta sala.
+Puedes cambiar esto en cualquier momento en los ajustes de la sala."</string>
+  <string name="screen_create_room_public_option_title">"Sala pública"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_description">"Cualquiera puede unirse a esta sala"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_title">"Cualquiera"</string>
+  <string name="screen_create_room_room_access_section_header">"Acceso a la sala"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_description">"Cualquiera puede solicitar unirse a la sala, pero un administrador o un moderador tendrá que aceptar la solicitud"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_title">"Solicitud para unirse"</string>
+  <string name="screen_create_room_room_address_section_footer">"Para que esta sala sea visible en el directorio de salas públicas, necesitarás una dirección de sala."</string>
+  <string name="screen_create_room_room_address_section_title">"Dirección de la sala"</string>
+  <string name="screen_create_room_room_name_label">"Nombre de la sala"</string>
+  <string name="screen_create_room_room_visibility_section_title">"Visibilidad de la sala"</string>
+  <string name="screen_create_room_title">"Crear una sala"</string>
+  <string name="screen_create_room_topic_label">"Tema (opcional)"</string>
+  <string name="screen_room_directory_search_title">"Directorio de salas"</string>
+  <string name="screen_start_chat_error_starting_chat">"Se ha producido un error al intentar iniciar un chat"</string>
+  <string name="screen_start_chat_join_room_by_address_action">"Unirse a una sala por su dirección"</string>
+  <string name="screen_start_chat_join_room_by_address_invalid_address">"Dirección no válida"</string>
+  <string name="screen_start_chat_join_room_by_address_placeholder">"Introducir…"</string>
+  <string name="screen_start_chat_join_room_by_address_room_found">"Sala encontrada"</string>
+  <string name="screen_start_chat_join_room_by_address_room_not_found">"No se encontró la sala"</string>
+  <string name="screen_start_chat_join_room_by_address_supporting_text">"p. ej., #nombre-de-la-sala:matrix.org"</string>
+</resources>

features/startchat/impl/src/main/res/values-et/translations.xml

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_create_room_action_create_room">"Uus jututuba"</string>
+  <string name="screen_create_room_add_people_title">"Kutsu osalejaid"</string>
+  <string name="screen_create_room_error_creating_room">"Jututoa loomisel tekkis viga"</string>
+  <string name="screen_create_room_private_option_description">"Ligipääs siia jututuppa on vaid kutse alusel. Kõik sõnumid siin jututoas on läbivalt krüptitud."</string>
+  <string name="screen_create_room_private_option_title">"Privaatne jututuba"</string>
+  <string name="screen_create_room_public_option_description">"Kõik saavad seda jututuba leida.
+Sa võid seda jututoa seadistustest alati muuta."</string>
+  <string name="screen_create_room_public_option_title">"Avalik jututuba"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_description">"Kõik võivad selle jututoaga liituda"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_title">"Kõik"</string>
+  <string name="screen_create_room_room_access_section_header">"Ligipääs jututoale"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_description">"Kõik võivad paluda selle jututoaga liitumist, kuid peakasutaja või moderaator peavad selle kinnitama"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_title">"Küsi võimalust liitumiseks"</string>
+  <string name="screen_create_room_room_address_section_footer">"Selleks, et see jututuba oleks nähtav jututubade avalikus kataloogis, sa vajad jututoa aadressi."</string>
+  <string name="screen_create_room_room_address_section_title">"Jututoa aadress"</string>
+  <string name="screen_create_room_room_name_label">"Jututoa nimi"</string>
+  <string name="screen_create_room_room_visibility_section_title">"Jututoa nähtavus"</string>
+  <string name="screen_create_room_title">"Loo jututuba"</string>
+  <string name="screen_create_room_topic_label">"Teema (kui soovid lisada)"</string>
+  <string name="screen_room_directory_search_title">"Jututubade kataloog"</string>
+  <string name="screen_start_chat_error_starting_chat">"Vestluse alustamisel tekkis viga"</string>
+  <string name="screen_start_chat_join_room_by_address_action">"Liitu jututoaga aadressi alusel"</string>
+  <string name="screen_start_chat_join_room_by_address_invalid_address">"See pole kehtiv aadress"</string>
+  <string name="screen_start_chat_join_room_by_address_placeholder">"Sisene…"</string>
+  <string name="screen_start_chat_join_room_by_address_room_found">"Leidsime vastava jututoa"</string>
+  <string name="screen_start_chat_join_room_by_address_room_not_found">"Jututuba ei leidu"</string>
+  <string name="screen_start_chat_join_room_by_address_supporting_text">"nt. #jututoa-nimi:matrix.org"</string>
+</resources>

features/startchat/impl/src/main/res/values-eu/translations.xml

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_create_room_action_create_room">"Gela berria"</string>
+  <string name="screen_create_room_add_people_title">"Gonbidatu jendea"</string>
+  <string name="screen_create_room_error_creating_room">"Errorea gertatu da gela sortzean"</string>
+  <string name="screen_create_room_private_option_description">"Gonbidatutako jendea soilik sar daiteke gelara. Mezu guztiak daude ertzetik ertzera zifratuta."</string>
+  <string name="screen_create_room_private_option_title">"Gela pribatua"</string>
+  <string name="screen_create_room_public_option_description">"Edonork aurki dezake gela hau.
+Gelaren ezarpenetan aldatu dezakezu hobespena."</string>
+  <string name="screen_create_room_public_option_title">"Gela publikoa"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_description">"Edonor sar daiteke gela honetara"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_title">"Edonork"</string>
+  <string name="screen_create_room_room_access_section_header">"Gelarako sarbidea"</string>
+  <string name="screen_create_room_room_address_section_title">"Gelaren helbidea"</string>
+  <string name="screen_create_room_room_name_label">"Gelaren izena"</string>
+  <string name="screen_create_room_room_visibility_section_title">"Gelaren ikusgarritasuna"</string>
+  <string name="screen_create_room_title">"Sortu gela"</string>
+  <string name="screen_create_room_topic_label">"Mintzagaia (aukerakoa)"</string>
+  <string name="screen_room_directory_search_title">"Gelen direktorioa"</string>
+  <string name="screen_start_chat_error_starting_chat">"Errorea gertatu da txata hasten saiatzean"</string>
+  <string name="screen_start_chat_join_room_by_address_placeholder">"Sartu…"</string>
+  <string name="screen_start_chat_join_room_by_address_room_not_found">"Ez da gela aurkitu"</string>
+</resources>

features/startchat/impl/src/main/res/values-fa/translations.xml

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_create_room_action_create_room">"اتاق جدید"</string>
+  <string name="screen_create_room_add_people_title">"دعوت افراد"</string>
+  <string name="screen_create_room_error_creating_room">"هنگام ایجاد اتاق خطایی رخ داد"</string>
+  <string name="screen_create_room_private_option_description">"تنها افراد دعوت شده می‌توانند به این اتاق دسترسی داشته باشند. همهٔ پیام‌ها رمزنگاری سرتاسری شده‌اند."</string>
+  <string name="screen_create_room_private_option_title">"اتاق خصوصی"</string>
+  <string name="screen_create_room_public_option_description">"هرکسی می‌تواند اتاق را بیابد.
+می‌توانید بعداً در تظیمات اتاق عوضش کنید."</string>
+  <string name="screen_create_room_public_option_title">"اتاق عمومی"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_description">"هرکسی می‌تواند به این اتاق بپیوندد"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_title">"هرکسی"</string>
+  <string name="screen_create_room_room_access_section_header">"دسترسی اتاق"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_title">"درخواست دعوت"</string>
+  <string name="screen_create_room_room_address_section_title">"نشانی اتاق"</string>
+  <string name="screen_create_room_room_name_label">"نام اتاق"</string>
+  <string name="screen_create_room_room_visibility_section_title">"نمایانی اتاق"</string>
+  <string name="screen_create_room_title">"ایجاد اتاق"</string>
+  <string name="screen_create_room_topic_label">"موضوع (اختیاری)"</string>
+  <string name="screen_room_directory_search_title">"فهرست اتاق‌ها"</string>
+  <string name="screen_start_chat_error_starting_chat">"هنگام تلاش برای شروع چت خطایی روی داد"</string>
+  <string name="screen_start_chat_join_room_by_address_action">"پیوستن به اتاق با نشانی"</string>
+  <string name="screen_start_chat_join_room_by_address_invalid_address">"نشانی معتبری نیست"</string>
+  <string name="screen_start_chat_join_room_by_address_placeholder">"ورود…"</string>
+  <string name="screen_start_chat_join_room_by_address_room_found">"اتاق مطابق پیدا شد"</string>
+  <string name="screen_start_chat_join_room_by_address_room_not_found">"اتاق پیدا نشد"</string>
+  <string name="screen_start_chat_join_room_by_address_supporting_text">"نمونه: ‪#room-name:matrix.org"</string>
+</resources>

features/startchat/impl/src/main/res/values-fi/translations.xml

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_create_room_action_create_room">"Uusi huone"</string>
+  <string name="screen_create_room_add_people_title">"Kutsu ihmisiä"</string>
+  <string name="screen_create_room_error_creating_room">"Huoneen luomisessa tapahtui virhe"</string>
+  <string name="screen_create_room_private_option_description">"Vain kutsutut henkilöt pääsevät tähän huoneeseen. Kaikki viestit ovat päästä päähän salattuja."</string>
+  <string name="screen_create_room_private_option_title">"Yksityinen huone"</string>
+  <string name="screen_create_room_public_option_description">"Kuka tahansa voi löytää tämän huoneen.
+Voit muuttaa tämän milloin tahansa huoneen asetuksista."</string>
+  <string name="screen_create_room_public_option_title">"Julkinen huone"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_description">"Kuka tahansa voi liittyä tähän huoneeseen"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_title">"Kuka tahansa"</string>
+  <string name="screen_create_room_room_access_section_header">"Huoneeseen Pääsy"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_description">"Kuka tahansa voi pyytää saada liittyä huoneeseen, mutta ylläpitäjän tai valvojan on hyväksyttävä pyyntö"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_title">"Pyydä liittymistä"</string>
+  <string name="screen_create_room_room_address_section_footer">"Jotta tämä huone näkyisi julkisessa huonehakemistossa, tarvitset huoneen osoitteen."</string>
+  <string name="screen_create_room_room_address_section_title">"Huoneen osoite"</string>
+  <string name="screen_create_room_room_name_label">"Huoneen nimi"</string>
+  <string name="screen_create_room_room_visibility_section_title">"Huoneen näkyvyys"</string>
+  <string name="screen_create_room_title">"Luo huone"</string>
+  <string name="screen_create_room_topic_label">"Aihe (valinnainen)"</string>
+  <string name="screen_room_directory_search_title">"Huoneluettelo"</string>
+  <string name="screen_start_chat_error_starting_chat">"Keskustelun aloituksessa tapahtui virhe"</string>
+  <string name="screen_start_chat_join_room_by_address_action">"Liity huoneeseen osoitteella"</string>
+  <string name="screen_start_chat_join_room_by_address_invalid_address">"Osoite ei ole kelvollinen"</string>
+  <string name="screen_start_chat_join_room_by_address_placeholder">"Syötä…"</string>
+  <string name="screen_start_chat_join_room_by_address_room_found">"Täsmäävä huone löytyi"</string>
+  <string name="screen_start_chat_join_room_by_address_room_not_found">"Huonetta ei löytynyt"</string>
+  <string name="screen_start_chat_join_room_by_address_supporting_text">"esim. #huoneen-nimi:matrix.org"</string>
+</resources>

features/startchat/impl/src/main/res/values-fr/translations.xml

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_create_room_action_create_room">"Nouveau salon"</string>
+  <string name="screen_create_room_add_people_title">"Inviter des amis"</string>
+  <string name="screen_create_room_error_creating_room">"Une erreur s’est produite lors de la création du salon"</string>
+  <string name="screen_create_room_private_option_description">"Seules les personnes invitées peuvent accéder à ce salon. Tous les messages sont chiffrés de bout en bout."</string>
+  <string name="screen_create_room_private_option_title">"Salon privé"</string>
+  <string name="screen_create_room_public_option_description">"N’importe qui peut trouver ce salon.
+Vous pouvez modifier cela à tout moment dans les paramètres du salon."</string>
+  <string name="screen_create_room_public_option_title">"Salon public"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_description">"Tout le monde peut rejoindre ce salon"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_title">"Tout le monde"</string>
+  <string name="screen_create_room_room_access_section_header">"Accès au salon"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_description">"Tout le monde peut demander à rejoindre le salon, mais un administrateur ou un modérateur devra accepter la demande"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_title">"Demander à rejoindre"</string>
+  <string name="screen_create_room_room_address_section_footer">"Pour que ce salon soit visible dans le répertoire des salons publics, vous aurez besoin d’une adresse de salon."</string>
+  <string name="screen_create_room_room_address_section_title">"Adresse du salon"</string>
+  <string name="screen_create_room_room_name_label">"Nom du salon"</string>
+  <string name="screen_create_room_room_visibility_section_title">"Visibilité du salon"</string>
+  <string name="screen_create_room_title">"Créer un salon"</string>
+  <string name="screen_create_room_topic_label">"Sujet (facultatif)"</string>
+  <string name="screen_room_directory_search_title">"Annuaire des salons"</string>
+  <string name="screen_start_chat_error_starting_chat">"Une erreur s’est produite lors de la tentative de création de la discussion"</string>
+  <string name="screen_start_chat_join_room_by_address_action">"Saisir une adresse de salon"</string>
+  <string name="screen_start_chat_join_room_by_address_invalid_address">"Ce n’est pas une adresse valide"</string>
+  <string name="screen_start_chat_join_room_by_address_placeholder">"Saisir…"</string>
+  <string name="screen_start_chat_join_room_by_address_room_found">"Ce salon existe"</string>
+  <string name="screen_start_chat_join_room_by_address_room_not_found">"Salon non trouvé"</string>
+  <string name="screen_start_chat_join_room_by_address_supporting_text">"ex: #nom-du-salon:matrix.org"</string>
+</resources>

features/startchat/impl/src/main/res/values-hu/translations.xml

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_create_room_action_create_room">"Új szoba"</string>
+  <string name="screen_create_room_add_people_title">"Ismerősök meghívása"</string>
+  <string name="screen_create_room_error_creating_room">"Hiba történt a szoba létrehozásakor"</string>
+  <string name="screen_create_room_private_option_description">"Csak a meghívottak léphetnek be ebbe a szobába. Az összes üzenet végpontok közti titkosítással van védve."</string>
+  <string name="screen_create_room_private_option_title">"Privát szoba"</string>
+  <string name="screen_create_room_public_option_description">"Bárki megtalálhatja ezt a szobát.
+Ezt bármikor módosíthatja a szobabeállításokban."</string>
+  <string name="screen_create_room_public_option_title">"Nyilvános szoba"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_description">"Bárki csatlakozhat ehhez a szobához"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_title">"Bárki"</string>
+  <string name="screen_create_room_room_access_section_header">"Szobahozzáférés"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_description">"Bárki kérheti, hogy csatlakozzon a szobához, de egy adminisztrátornak vagy moderátornak el kell fogadnia a kérést"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_title">"Csatlakozás kérése"</string>
+  <string name="screen_create_room_room_address_section_footer">"Ahhoz, hogy ez a szoba látható legyen a nyilvános szobák címtárában, meg kell adnia a szoba címét."</string>
+  <string name="screen_create_room_room_address_section_title">"A szoba címe"</string>
+  <string name="screen_create_room_room_name_label">"Szoba neve"</string>
+  <string name="screen_create_room_room_visibility_section_title">"Szoba láthatósága"</string>
+  <string name="screen_create_room_title">"Szoba létrehozása"</string>
+  <string name="screen_create_room_topic_label">"Téma (nem kötelező)"</string>
+  <string name="screen_room_directory_search_title">"Szobakatalógus"</string>
+  <string name="screen_start_chat_error_starting_chat">"Hiba történt a csevegés indításakor"</string>
+  <string name="screen_start_chat_join_room_by_address_action">"Csatlakozás a szobához cím szerint"</string>
+  <string name="screen_start_chat_join_room_by_address_invalid_address">"Nem érvényes cím"</string>
+  <string name="screen_start_chat_join_room_by_address_placeholder">"Írja be…"</string>
+  <string name="screen_start_chat_join_room_by_address_room_found">"Megfelelő szoba található"</string>
+  <string name="screen_start_chat_join_room_by_address_room_not_found">"Szoba nem található"</string>
+  <string name="screen_start_chat_join_room_by_address_supporting_text">"pl. #szoba-neve:matrix.org"</string>
+</resources>

features/startchat/impl/src/main/res/values-in/translations.xml

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_create_room_action_create_room">"Ruangan baru"</string>
+  <string name="screen_create_room_add_people_title">"Undang orang-orang"</string>
+  <string name="screen_create_room_error_creating_room">"Terjadi kesalahan saat membuat ruangan"</string>
+  <string name="screen_create_room_private_option_description">"Hanya orang-orang yang diundang dapat mengakses ruangan ini. Semua pesan terenkripsi secara ujung ke ujung."</string>
+  <string name="screen_create_room_private_option_title">"Ruangan pribadi"</string>
+  <string name="screen_create_room_public_option_description">"Siapa pun dapat mencari ruangan ini.
+Anda dapat mengubah ini kapan pun dalam pengaturan ruangan."</string>
+  <string name="screen_create_room_public_option_title">"Ruangan publik"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_description">"Siapa pun dapat bergabung dengan ruangan ini"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_title">"Siapa pun"</string>
+  <string name="screen_create_room_room_access_section_header">"Akses Ruangan"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_description">"Siapa pun dapat meminta untuk bergabung dengan ruangan tetapi administrator atau moderator harus menerima permintaan tersebut"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_title">"Minta untuk bergabung"</string>
+  <string name="screen_create_room_room_address_section_footer">"Supaya ruangan ini terlihat di direktori ruangan publik, Anda memerlukan alamat ruangan."</string>
+  <string name="screen_create_room_room_address_section_title">"Alamat ruangan"</string>
+  <string name="screen_create_room_room_name_label">"Nama ruangan"</string>
+  <string name="screen_create_room_room_visibility_section_title">"Keterlihatan ruangan"</string>
+  <string name="screen_create_room_title">"Buat ruangan"</string>
+  <string name="screen_create_room_topic_label">"Topik (opsional)"</string>
+  <string name="screen_room_directory_search_title">"Direktori ruangan"</string>
+  <string name="screen_start_chat_error_starting_chat">"Terjadi kesalahan saat mencoba memulai obrolan"</string>
+  <string name="screen_start_chat_join_room_by_address_action">"Bergabung dalam ruangan berdasarkan alamat"</string>
+  <string name="screen_start_chat_join_room_by_address_invalid_address">"Bukan alamat yang valid"</string>
+  <string name="screen_start_chat_join_room_by_address_placeholder">"Masuk…"</string>
+  <string name="screen_start_chat_join_room_by_address_room_found">"Ruangan yang cocok ditemukan"</string>
+  <string name="screen_start_chat_join_room_by_address_room_not_found">"Ruangan tidak ditemukan"</string>
+  <string name="screen_start_chat_join_room_by_address_supporting_text">"mis. #nama-ruangan:matrix.org"</string>
+</resources>

features/startchat/impl/src/main/res/values-it/translations.xml

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_create_room_action_create_room">"Nuova stanza"</string>
+  <string name="screen_create_room_add_people_title">"Invita persone"</string>
+  <string name="screen_create_room_error_creating_room">"Si è verificato un errore durante la creazione della stanza"</string>
+  <string name="screen_create_room_private_option_description">"Solo le persone invitate possono accedere a questa stanza. Tutti i messaggi sono cifrati end-to-end."</string>
+  <string name="screen_create_room_private_option_title">"Stanza privata"</string>
+  <string name="screen_create_room_public_option_description">"Chiunque può trovare questa stanza.
+Puoi modificarlo in qualsiasi momento nelle impostazioni della stanza."</string>
+  <string name="screen_create_room_public_option_title">"Stanza pubblica"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_description">"Chiunque può entrare in questa stanza"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_title">"Chiunque"</string>
+  <string name="screen_create_room_room_access_section_header">"Accesso alla stanza"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_description">"Chiunque può chiedere di entrare nella stanza, ma un amministratore o un moderatore dovrà accettare la richiesta"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_title">"Chiedi di entrare"</string>
+  <string name="screen_create_room_room_address_section_footer">"Affinché questa stanza sia visibile nell\'elenco delle stanze pubbliche, è necessario un indirizzo della stanza."</string>
+  <string name="screen_create_room_room_address_section_title">"Indirizzo della stanza"</string>
+  <string name="screen_create_room_room_name_label">"Nome stanza"</string>
+  <string name="screen_create_room_room_visibility_section_title">"Visibilità della stanza"</string>
+  <string name="screen_create_room_title">"Crea una stanza"</string>
+  <string name="screen_create_room_topic_label">"Argomento (facoltativo)"</string>
+  <string name="screen_room_directory_search_title">"Elenco delle stanze"</string>
+  <string name="screen_start_chat_error_starting_chat">"Si è verificato un errore durante il tentativo di avviare una chat"</string>
+  <string name="screen_start_chat_join_room_by_address_action">"Accedi alla stanza tramite indirizzo"</string>
+  <string name="screen_start_chat_join_room_by_address_invalid_address">"Indirizzo non valido"</string>
+  <string name="screen_start_chat_join_room_by_address_placeholder">"Inserisci…"</string>
+  <string name="screen_start_chat_join_room_by_address_room_found">"Stanza trovata"</string>
+  <string name="screen_start_chat_join_room_by_address_room_not_found">"Stanza non trovata"</string>
+  <string name="screen_start_chat_join_room_by_address_supporting_text">"ad esempio #room -name:matrix.org"</string>
+</resources>

features/startchat/impl/src/main/res/values-ka/translations.xml

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_create_room_action_create_room">"ახალი ოთახი"</string>
+  <string name="screen_create_room_add_people_title">"ხალხის მოწვევა"</string>
+  <string name="screen_create_room_error_creating_room">"ოთახის შექმნისას შეცდომა მოხდა"</string>
+  <string name="screen_create_room_private_option_description">"ამ ოთახში შეტყობინებები დაშიფრულია. შემდგომ დაშიფვრის გამორთვა შეუძლებელია."</string>
+  <string name="screen_create_room_private_option_title">"კერძო ოთახი"</string>
+  <string name="screen_create_room_public_option_description">"ყველას ამ ოთახის მოძებნა შეუძლია.
+თქვენ ნებისმიერ დროს შეგიძლიათ ამის შეცვლა ოთახის პარამეტრებში."</string>
+  <string name="screen_create_room_room_name_label">"ოთახის სახელი"</string>
+  <string name="screen_create_room_title">"ოთახის შექმნა"</string>
+  <string name="screen_create_room_topic_label">"თემა (სურვილისამებრ)"</string>
+  <string name="screen_room_directory_search_title">"ოთახის კატალოგი"</string>
+  <string name="screen_start_chat_error_starting_chat">"ჩატის დაწყების მცდელობისას შეცდომა მოხდა"</string>
+</resources>

features/startchat/impl/src/main/res/values-lt/translations.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_create_room_action_create_room">"Naujas kambarys"</string>
+  <string name="screen_create_room_add_people_title">"Pakviesti žmonių"</string>
+  <string name="screen_create_room_error_creating_room">"Kuriant kambarį įvyko klaida"</string>
+  <string name="screen_create_room_private_option_description">"Į šį kambarį gali patekti tik pakviesti žmonės. Visi pranešimai yra užšifruoti nuo pradžios iki galo."</string>
+  <string name="screen_create_room_private_option_title">"Privatus kambarys"</string>
+  <string name="screen_create_room_public_option_description">"Bet kas gali rasti šį kambarį.
+Tai galite bet kada pakeisti kambario nustatymuose."</string>
+  <string name="screen_create_room_room_name_label">"Kambario pavadinimas"</string>
+  <string name="screen_create_room_title">"Kurti kambarį"</string>
+  <string name="screen_create_room_topic_label">"Tema (nebūtina)"</string>
+  <string name="screen_start_chat_error_starting_chat">"Bandant pradėti pokalbį įvyko klaida"</string>
+</resources>

features/startchat/impl/src/main/res/values-nb/translations.xml

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_create_room_action_create_room">"Nytt rom"</string>
+  <string name="screen_create_room_add_people_title">"Inviter folk"</string>
+  <string name="screen_create_room_error_creating_room">"Det oppsto en feil under opprettelsen av rommet"</string>
+  <string name="screen_create_room_private_option_description">"Bare inviterte personer har tilgang til dette rommet. Alle meldinger er ende-til-ende-kryptert."</string>
+  <string name="screen_create_room_private_option_title">"Privat rom"</string>
+  <string name="screen_create_room_public_option_description">"Alle kan finne dette rommet.
+Du kan endre dette når som helst i rominnstillingene."</string>
+  <string name="screen_create_room_public_option_title">"Offentlig rom"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_description">"Alle kan bli med i dette rommet"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_title">"Alle"</string>
+  <string name="screen_create_room_room_access_section_header">"Tilgang til rom"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_description">"Alle kan be om å få bli med i rommet, men en administrator eller moderator må godta forespørselen"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_title">"Be om å bli med"</string>
+  <string name="screen_create_room_room_address_section_footer">"For at dette rommet skal være synlig i den offentlige romkatalogen, trenger du en romadresse."</string>
+  <string name="screen_create_room_room_address_section_title">"Romadresse"</string>
+  <string name="screen_create_room_room_name_label">"Romnavn"</string>
+  <string name="screen_create_room_room_visibility_section_title">"Romsynlighet"</string>
+  <string name="screen_create_room_title">"Opprett et rom"</string>
+  <string name="screen_create_room_topic_label">"Emne (valgfritt)"</string>
+  <string name="screen_room_directory_search_title">"Romkatalog"</string>
+  <string name="screen_start_chat_error_starting_chat">"Det oppstod en feil når du prøvde å starte en chat"</string>
+  <string name="screen_start_chat_join_room_by_address_action">"Bli med i rommet med adresse"</string>
+  <string name="screen_start_chat_join_room_by_address_invalid_address">"Ikke en gyldig adresse"</string>
+  <string name="screen_start_chat_join_room_by_address_placeholder">"Gå inn…"</string>
+  <string name="screen_start_chat_join_room_by_address_room_found">"Matchende rom funnet"</string>
+  <string name="screen_start_chat_join_room_by_address_room_not_found">"Rom ikke funnet"</string>
+  <string name="screen_start_chat_join_room_by_address_supporting_text">"f.eks. #rom-navn:matrix.org"</string>
+</resources>

features/startchat/impl/src/main/res/values-nl/translations.xml

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_create_room_action_create_room">"Nieuwe kamer"</string>
+  <string name="screen_create_room_add_people_title">"Mensen uitnodigen"</string>
+  <string name="screen_create_room_error_creating_room">"Er is een fout opgetreden bij het aanmaken van de kamer"</string>
+  <string name="screen_create_room_private_option_description">"Alleen uitgenodigde personen hebben toegang tot deze kamer. Alle berichten zijn end-to-end versleuteld."</string>
+  <string name="screen_create_room_private_option_title">"Privé kamer"</string>
+  <string name="screen_create_room_public_option_description">"Iedereen kan deze kamer vinden.
+Je kunt dit op elk gewenst moment wijzigen in de kamerinstellingen."</string>
+  <string name="screen_create_room_public_option_title">"Openbare kamer"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_description">"Iedereen kan toetreden tot deze kamer"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_title">"Iedereen"</string>
+  <string name="screen_create_room_room_access_section_header">"Toegang tot de kamer"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_description">"Iedereen kan vragen om toe te treden tot de kamer, maar een beheerder of moderator moet het verzoek accepteren"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_title">"Vraag om toe te treden"</string>
+  <string name="screen_create_room_room_name_label">"Naam van de kamer"</string>
+  <string name="screen_create_room_title">"Creëer een kamer"</string>
+  <string name="screen_create_room_topic_label">"Onderwerp (optioneel)"</string>
+  <string name="screen_room_directory_search_title">"Kamergids"</string>
+  <string name="screen_start_chat_error_starting_chat">"Er is een fout opgetreden bij het starten van een chat"</string>
+</resources>

features/startchat/impl/src/main/res/values-pl/translations.xml

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_create_room_action_create_room">"Nowy pokój"</string>
+  <string name="screen_create_room_add_people_title">"Zaproś znajomych"</string>
+  <string name="screen_create_room_error_creating_room">"Wystąpił błąd w trakcie tworzenia pokoju"</string>
+  <string name="screen_create_room_private_option_description">"Tylko zaproszone osoby mogą dołączyć do tego pokoju. Wszystkie wiadomości są szyfrowane end-to-end."</string>
+  <string name="screen_create_room_private_option_title">"Pokój prywatny"</string>
+  <string name="screen_create_room_public_option_description">"Każdy może znaleźć ten pokój.
+Możesz to zmienić w ustawieniach pokoju."</string>
+  <string name="screen_create_room_public_option_title">"Pokój publiczny"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_description">"Każdy może dołączyć do tego pokoju"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_title">"Wszyscy"</string>
+  <string name="screen_create_room_room_access_section_header">"Dostęp do pokoju"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_description">"Każdy może poprosić o dołączenie do pokoju, ale administrator lub moderator będzie musiał zatwierdzić prośbę"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_title">"Poproś o dołączenie"</string>
+  <string name="screen_create_room_room_address_section_footer">"Aby ten pokój był widoczny w katalogu pomieszczeń publicznych, będziesz potrzebował adres pokoju."</string>
+  <string name="screen_create_room_room_address_section_title">"Adres pokoju"</string>
+  <string name="screen_create_room_room_name_label">"Nazwa pokoju"</string>
+  <string name="screen_create_room_room_visibility_section_title">"Widoczność pomieszczenia"</string>
+  <string name="screen_create_room_title">"Utwórz pokój"</string>
+  <string name="screen_create_room_topic_label">"Temat (opcjonalnie)"</string>
+  <string name="screen_room_directory_search_title">"Katalog pokoi"</string>
+  <string name="screen_start_chat_error_starting_chat">"Wystąpił błąd podczas próby rozpoczęcia czatu"</string>
+  <string name="screen_start_chat_join_room_by_address_action">"Dołącz do pokoju za pomocą adresu"</string>
+  <string name="screen_start_chat_join_room_by_address_invalid_address">"Nieprawidłowy adres"</string>
+  <string name="screen_start_chat_join_room_by_address_placeholder">"Wprowadź…"</string>
+  <string name="screen_start_chat_join_room_by_address_room_found">"Znaleziono pasujący pokój"</string>
+  <string name="screen_start_chat_join_room_by_address_room_not_found">"Nie znaleziono pokoju"</string>
+  <string name="screen_start_chat_join_room_by_address_supporting_text">"np. #room-name:matrix.org"</string>
+</resources>

features/startchat/impl/src/main/res/values-pt-rBR/translations.xml

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_create_room_action_create_room">"Nova sala"</string>
+  <string name="screen_create_room_add_people_title">"Convidar pessoas"</string>
+  <string name="screen_create_room_error_creating_room">"Ocorreu um erro ao criar a sala"</string>
+  <string name="screen_create_room_private_option_description">"Apenas as pessoas convidadas podem aceder a esta sala. Todas as mensagens são criptografadas de ponta a ponta."</string>
+  <string name="screen_create_room_private_option_title">"Sala privada"</string>
+  <string name="screen_create_room_public_option_description">"Qualquer um pode encontrar esta sala.
+Você pode mudar isso a qualquer momento nas configurações da sala."</string>
+  <string name="screen_create_room_public_option_title">"Sala pública"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_description">"Qualquer pessoa pode entrar nesta sala"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_title">"Qualquer pessoa"</string>
+  <string name="screen_create_room_room_access_section_header">"Acesso à sala"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_description">"Qualquer pessoa pode pedir para entrar na sala, mas um administrador ou moderador terá de aceitar a solicitação"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_title">"Pedir para entrar"</string>
+  <string name="screen_create_room_room_address_section_footer">"Para que esta sala fique visível no diretório público de salas, você precisará de um endereço de sala."</string>
+  <string name="screen_create_room_room_address_section_title">"Endereço da sala"</string>
+  <string name="screen_create_room_room_name_label">"Nome da sala"</string>
+  <string name="screen_create_room_room_visibility_section_title">"Visibilidade da sala"</string>
+  <string name="screen_create_room_title">"Criar uma sala"</string>
+  <string name="screen_create_room_topic_label">"Tópico (opcional)"</string>
+  <string name="screen_room_directory_search_title">"Diretório de salas"</string>
+  <string name="screen_start_chat_error_starting_chat">"Ocorreu um erro ao tentar iniciar um chat"</string>
+  <string name="screen_start_chat_join_room_by_address_action">"Entrar na sala pelo endereço"</string>
+  <string name="screen_start_chat_join_room_by_address_invalid_address">"Não é um endereço válido"</string>
+  <string name="screen_start_chat_join_room_by_address_placeholder">"Entrar…"</string>
+  <string name="screen_start_chat_join_room_by_address_room_found">"Foi encontrada uma sala correspondente"</string>
+  <string name="screen_start_chat_join_room_by_address_room_not_found">"Sala não encontrada"</string>
+  <string name="screen_start_chat_join_room_by_address_supporting_text">"Por exemplo, #nome-da-sala:matrix.org"</string>
+</resources>

features/startchat/impl/src/main/res/values-pt/translations.xml

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_create_room_action_create_room">"Nova sala"</string>
+  <string name="screen_create_room_add_people_title">"Convidar pessoas"</string>
+  <string name="screen_create_room_error_creating_room">"Ocorreu um erro ao criar a sala"</string>
+  <string name="screen_create_room_private_option_description">"Apenas as pessoas convidadas podem aceder a esta sala. Todas as mensagens são cifradas ponta-a-ponta."</string>
+  <string name="screen_create_room_private_option_title">"Sala privada"</string>
+  <string name="screen_create_room_public_option_description">"Qualquer um pode encontrar esta sala. 
+Pode alterar esta opção nas definições da sala."</string>
+  <string name="screen_create_room_public_option_title">"Sala pública"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_description">"Qualquer pessoa pode entrar nesta sala"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_title">"Qualquer pessoa"</string>
+  <string name="screen_create_room_room_access_section_header">"Acesso à sala"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_description">"Qualquer pessoa pode pedir para entrar na sala, mas um administrador ou um moderador terá de aceitar o pedido"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_title">"Pedir para participar"</string>
+  <string name="screen_create_room_room_address_section_footer">"Para que esta sala seja visível no diretório público de salas, precisas de um endereço de sala."</string>
+  <string name="screen_create_room_room_address_section_title">"Endereço da sala"</string>
+  <string name="screen_create_room_room_name_label">"Nome da sala"</string>
+  <string name="screen_create_room_room_visibility_section_title">"Visibilidade da sala"</string>
+  <string name="screen_create_room_title">"Criar uma sala"</string>
+  <string name="screen_create_room_topic_label">"Descrição (opcional)"</string>
+  <string name="screen_room_directory_search_title">"Diretório de salas"</string>
+  <string name="screen_start_chat_error_starting_chat">"Ocorreu um erro ao tentar iniciar uma conversa"</string>
+  <string name="screen_start_chat_join_room_by_address_action">"Entrar na sala pelo endereço"</string>
+  <string name="screen_start_chat_join_room_by_address_invalid_address">"Não é um endereço válido"</string>
+  <string name="screen_start_chat_join_room_by_address_placeholder">"Entrar…"</string>
+  <string name="screen_start_chat_join_room_by_address_room_found">"Sala correspondente encontrado"</string>
+  <string name="screen_start_chat_join_room_by_address_room_not_found">"Sala não encontrada"</string>
+  <string name="screen_start_chat_join_room_by_address_supporting_text">"por exemplo, #sala:matrix.org"</string>
+</resources>

features/startchat/impl/src/main/res/values-ro/translations.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_create_room_action_create_room">"Cameră nouă"</string>
+  <string name="screen_create_room_add_people_title">"Invitați prieteni"</string>
+  <string name="screen_create_room_error_creating_room">"A apărut o eroare la crearea camerei"</string>
+  <string name="screen_create_room_private_option_description">"Doar persoanele invitate pot accesa această cameră. Toate mesajele sunt criptate end-to-end."</string>
+  <string name="screen_create_room_private_option_title">"Cameră privată"</string>
+  <string name="screen_create_room_public_option_description">"Oricine poate găsi această cameră.
+Puteți modifica acest lucru oricând în setări."</string>
+  <string name="screen_create_room_public_option_title">"Cameră publică"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_description">"Oricine se poate alătura acestei camere"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_title">"Oricine"</string>
+  <string name="screen_create_room_room_access_section_header">"Acces la cameră"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_description">"Oricine poate cere să se alăture camerei, dar un administrator sau un moderator va trebui să accepte solicitarea"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_title">"Cereți să vă alăturați"</string>
+  <string name="screen_create_room_room_address_section_footer">"Pentru ca această cameră să fie vizibilă în directorul de camere publice, veți avea nevoie de o adresă de cameră."</string>
+  <string name="screen_create_room_room_name_label">"Numele camerei"</string>
+  <string name="screen_create_room_title">"Creați o cameră"</string>
+  <string name="screen_create_room_topic_label">"Subiect (opțional)"</string>
+  <string name="screen_room_directory_search_title">"Director de camere"</string>
+  <string name="screen_start_chat_error_starting_chat">"A apărut o eroare la încercarea începerii conversației"</string>
+</resources>

features/startchat/impl/src/main/res/values-ru/translations.xml

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_create_room_action_create_room">"Создать новую комнату"</string>
+  <string name="screen_create_room_add_people_title">"Пригласить в комнату"</string>
+  <string name="screen_create_room_error_creating_room">"Произошла ошибка при создании комнаты"</string>
+  <string name="screen_create_room_private_option_description">"Доступ в эту комнату имеют только приглашенные пользователи. Все сообщения защищены сквозным шифрованием."</string>
+  <string name="screen_create_room_private_option_title">"Частная комната"</string>
+  <string name="screen_create_room_public_option_description">"Любой желающий может найти эту комнату.
+Вы можете изменить это в любое время в настройках комнаты."</string>
+  <string name="screen_create_room_public_option_title">"Общедоступная комната"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_description">"Любой желающий может присоединиться к этой комнате"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_title">"Любой"</string>
+  <string name="screen_create_room_room_access_section_header">"Доступ в комнату"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_description">"Любой желающий может подать заявку на присоединение к комнате, но администратор или модератор должен будет принять запрос."</string>
+  <string name="screen_create_room_room_access_section_knocking_option_title">"Попросить присоединиться"</string>
+  <string name="screen_create_room_room_address_section_footer">"Чтобы эта комната была видна в каталоге общедоступных, вам необходим ее адрес"</string>
+  <string name="screen_create_room_room_address_section_title">"Адрес комнаты"</string>
+  <string name="screen_create_room_room_name_label">"Название комнаты"</string>
+  <string name="screen_create_room_room_visibility_section_title">"Видимость комнаты"</string>
+  <string name="screen_create_room_title">"Создать комнату"</string>
+  <string name="screen_create_room_topic_label">"Тема (необязательно)"</string>
+  <string name="screen_room_directory_search_title">"Каталог комнат"</string>
+  <string name="screen_start_chat_error_starting_chat">"Произошла ошибка при запуске чата"</string>
+  <string name="screen_start_chat_join_room_by_address_action">"Присоединиться к комнате по адресу"</string>
+  <string name="screen_start_chat_join_room_by_address_invalid_address">"Недействительный адрес"</string>
+  <string name="screen_start_chat_join_room_by_address_placeholder">"Ввести…"</string>
+  <string name="screen_start_chat_join_room_by_address_room_found">"Соответствующая комната найдена"</string>
+  <string name="screen_start_chat_join_room_by_address_room_not_found">"Комната не найдена"</string>
+  <string name="screen_start_chat_join_room_by_address_supporting_text">"прим. #room-name:matrix.org"</string>
+</resources>

features/startchat/impl/src/main/res/values-sk/translations.xml

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_create_room_action_create_room">"Nová miestnosť"</string>
+  <string name="screen_create_room_add_people_title">"Pozvať ľudí"</string>
+  <string name="screen_create_room_error_creating_room">"Pri vytváraní miestnosti došlo k chybe"</string>
+  <string name="screen_create_room_private_option_description">"Do tejto miestnosti majú prístup iba pozvaní ľudia. Všetky správy sú end-to-end šifrované."</string>
+  <string name="screen_create_room_private_option_title">"Súkromná miestnosť"</string>
+  <string name="screen_create_room_public_option_description">"Túto miestnosť môže nájsť ktokoľvek.
+Môžete to kedykoľvek zmeniť v nastaveniach miestnosti."</string>
+  <string name="screen_create_room_public_option_title">"Verejná miestnosť"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_description">"Do tejto miestnosti sa môže pripojiť ktokoľvek"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_title">"Ktokoľvek"</string>
+  <string name="screen_create_room_room_access_section_header">"Prístup do miestnosti"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_description">"Ktokoľvek môže požiadať o pripojenie sa k miestnosti, ale administrátor alebo moderátor bude musieť žiadosť schváliť"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_title">"Požiadať o pripojenie"</string>
+  <string name="screen_create_room_room_address_section_footer">"Aby bola táto miestnosť viditeľná v adresári verejných miestností, budete potrebovať adresu miestnosti."</string>
+  <string name="screen_create_room_room_address_section_title">"Adresa miestnosti"</string>
+  <string name="screen_create_room_room_name_label">"Názov miestnosti"</string>
+  <string name="screen_create_room_room_visibility_section_title">"Viditeľnosť miestnosti"</string>
+  <string name="screen_create_room_title">"Vytvoriť miestnosť"</string>
+  <string name="screen_create_room_topic_label">"Téma (voliteľné)"</string>
+  <string name="screen_room_directory_search_title">"Adresár miestností"</string>
+  <string name="screen_start_chat_error_starting_chat">"Pri pokuse o spustenie konverzácie sa vyskytla chyba"</string>
+  <string name="screen_start_chat_join_room_by_address_action">"Pripojte sa do miestnosti podľa adresy"</string>
+  <string name="screen_start_chat_join_room_by_address_invalid_address">"Neplatná adresa"</string>
+  <string name="screen_start_chat_join_room_by_address_placeholder">"Zadajte…"</string>
+  <string name="screen_start_chat_join_room_by_address_room_found">"Nájdená zodpovedajúca miestnosť"</string>
+  <string name="screen_start_chat_join_room_by_address_room_not_found">"Miestnosť sa nenašla"</string>
+  <string name="screen_start_chat_join_room_by_address_supporting_text">"napr. #nazov-miestnosti:matrix.org"</string>
+</resources>

features/startchat/impl/src/main/res/values-sv/translations.xml

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_create_room_action_create_room">"Nytt rum"</string>
+  <string name="screen_create_room_add_people_title">"Bjud in personer"</string>
+  <string name="screen_create_room_error_creating_room">"Ett fel uppstod när rummet skapades"</string>
+  <string name="screen_create_room_private_option_description">"Endast inbjudna personer har tillgång till detta rum. Alla meddelanden är totalsträckskrypterade."</string>
+  <string name="screen_create_room_private_option_title">"Privat rum"</string>
+  <string name="screen_create_room_public_option_description">"Vem som helst kan hitta det här rummet.
+Du kan ändra detta när som helst i rumsinställningarna."</string>
+  <string name="screen_create_room_public_option_title">"Offentligt rum"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_description">"Vem som helst kan gå med i det här rummet"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_title">"Vem som helst"</string>
+  <string name="screen_create_room_room_access_section_header">"Rumsåtkomst"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_description">"Vem som helst kan be om att gå med i rummet men en administratör eller en moderator måste acceptera begäran"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_title">"Be om att gå med"</string>
+  <string name="screen_create_room_room_address_section_footer">"För att detta rum ska vara synligt i den allmänna rumskatalogen behöver du en rumsadress."</string>
+  <string name="screen_create_room_room_address_section_title">"Rumsadress"</string>
+  <string name="screen_create_room_room_name_label">"Rumsnamn"</string>
+  <string name="screen_create_room_room_visibility_section_title">"Rumssynlighet"</string>
+  <string name="screen_create_room_title">"Skapa ett rum"</string>
+  <string name="screen_create_room_topic_label">"Ämne (valfritt)"</string>
+  <string name="screen_room_directory_search_title">"Rumskatalog"</string>
+  <string name="screen_start_chat_error_starting_chat">"Ett fel uppstod när du försökte starta en chatt"</string>
+  <string name="screen_start_chat_join_room_by_address_action">"Gå med i rum med adress"</string>
+  <string name="screen_start_chat_join_room_by_address_invalid_address">"Inte en giltig adress"</string>
+  <string name="screen_start_chat_join_room_by_address_placeholder">"Ange …"</string>
+  <string name="screen_start_chat_join_room_by_address_room_found">"Matchande rum hittades"</string>
+  <string name="screen_start_chat_join_room_by_address_room_not_found">"Rummet hittades inte"</string>
+  <string name="screen_start_chat_join_room_by_address_supporting_text">"t.ex. #rumsnamn:matrix.org"</string>
+</resources>

features/startchat/impl/src/main/res/values-tr/translations.xml

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_create_room_action_create_room">"Yeni oda"</string>
+  <string name="screen_create_room_add_people_title">"İnsanları davet et"</string>
+  <string name="screen_create_room_error_creating_room">"Oda oluşturulurken bir hata oluştu"</string>
+  <string name="screen_create_room_private_option_description">"Bu odaya yalnızca davet edilen kişiler erişebilir. Tüm mesajlar uçtan uca şifrelenir."</string>
+  <string name="screen_create_room_private_option_title">"Özel oda"</string>
+  <string name="screen_create_room_public_option_description">"Bu odayı herkes bulabilir.
+Bunu istediğiniz zaman oda ayarlarından değiştirebilirsiniz."</string>
+  <string name="screen_create_room_public_option_title">"Herkese açık oda"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_description">"Bu odaya herkes katılabilir"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_title">"Herkes"</string>
+  <string name="screen_create_room_room_access_section_header">"Oda Erişimi"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_description">"Herkes odaya katılmayı isteyebilir ancak bir yönetici veya moderatörün isteği kabul etmesi gerekecektir"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_title">"Katılmak için sor"</string>
+  <string name="screen_create_room_room_address_section_footer">"Bu odanın genel oda dizininde görünür olması için bir oda adresine ihtiyacınız olacaktır."</string>
+  <string name="screen_create_room_room_address_section_title">"Oda adresi"</string>
+  <string name="screen_create_room_room_name_label">"Oda adı"</string>
+  <string name="screen_create_room_room_visibility_section_title">"Oda görünürlüğü"</string>
+  <string name="screen_create_room_title">"Bir oda oluştur"</string>
+  <string name="screen_create_room_topic_label">"Konu (isteğe bağlı)"</string>
+  <string name="screen_room_directory_search_title">"Oda dizini"</string>
+  <string name="screen_start_chat_error_starting_chat">"Sohbet başlatmaya çalışırken bir hata oluştu"</string>
+</resources>

features/startchat/impl/src/main/res/values-uk/translations.xml

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_create_room_action_create_room">"Нова кімната"</string>
+  <string name="screen_create_room_add_people_title">"Запросити людей"</string>
+  <string name="screen_create_room_error_creating_room">"Під час створення кімнати сталася помилка"</string>
+  <string name="screen_create_room_private_option_description">"Лише запрошені люди мають доступ до цієї кімнати. Усі повідомлення захищені наскрізним шифруванням."</string>
+  <string name="screen_create_room_private_option_title">"Приватна кімната (тільки за запрошенням)"</string>
+  <string name="screen_create_room_public_option_description">"Будь-хто може знайти цю кімнату. 
+Ви можете змінити це в будь-який час у налаштуваннях кімнати."</string>
+  <string name="screen_create_room_public_option_title">"Загальнодоступна кімната"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_description">"Будь-хто може приєднатися до цієї кімнати"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_title">"Кожний"</string>
+  <string name="screen_create_room_room_access_section_header">"Доступ до кімнати"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_description">"Будь-хто може попросити приєднатися до кімнати, але адміністратор або модератор повинен буде прийняти запит"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_title">"Запросити приєднатися"</string>
+  <string name="screen_create_room_room_address_section_footer">"Щоб цю кімнату було видно в каталозі загальнодоступних кімнат, вам знадобиться її адреса."</string>
+  <string name="screen_create_room_room_address_section_title">"Адреса кімнати"</string>
+  <string name="screen_create_room_room_name_label">"Назва кімнати"</string>
+  <string name="screen_create_room_room_visibility_section_title">"Видимість кімнати"</string>
+  <string name="screen_create_room_title">"Створити кімнату"</string>
+  <string name="screen_create_room_topic_label">"Тема (необов\'язково)"</string>
+  <string name="screen_room_directory_search_title">"Каталог кімнат"</string>
+  <string name="screen_start_chat_error_starting_chat">"Під час спроби почати бесіду сталася помилка"</string>
+  <string name="screen_start_chat_join_room_by_address_action">"Приєднатися до кімнати за адресою"</string>
+  <string name="screen_start_chat_join_room_by_address_invalid_address">"Недійсна адреса"</string>
+  <string name="screen_start_chat_join_room_by_address_placeholder">"Введіть…"</string>
+  <string name="screen_start_chat_join_room_by_address_room_found">"Знайдено відповідну кімнату"</string>
+  <string name="screen_start_chat_join_room_by_address_room_not_found">"Кімната не знайдена"</string>
+  <string name="screen_start_chat_join_room_by_address_supporting_text">"наприклад, #room-name:matrix.org"</string>
+</resources>

features/startchat/impl/src/main/res/values-ur/translations.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_create_room_action_create_room">"نیا کمرہ"</string>
+  <string name="screen_create_room_add_people_title">"لوگوں کو مدعو کریں"</string>
+  <string name="screen_create_room_error_creating_room">"کمرہ تخلیق کرتے ہوئے ایک نقص واقع ہوا"</string>
+  <string name="screen_create_room_private_option_description">"صرف مدعو لوگ ہی اس کمرے تک رسائی حاصل کر سکتے ہیں۔ تمام پیغامات آخر تا آخر مرموز کردہ ہیں۔"</string>
+  <string name="screen_create_room_private_option_title">"نجی کمرہ"</string>
+  <string name="screen_create_room_public_option_description">"کوئی بھی یہ کمرہ ڈھونڈ سکتا ہے۔
+آپ اسے کمرے کی ترتیبات میں کسی بھی وقت تبدیل کرسکتے ہیں۔"</string>
+  <string name="screen_create_room_public_option_title">"عوامی کمرہ"</string>
+  <string name="screen_create_room_room_name_label">"کمرے کا نام"</string>
+  <string name="screen_create_room_title">"ایک کمرہ بنائیں"</string>
+  <string name="screen_create_room_topic_label">"موضوع (اختیاری)"</string>
+  <string name="screen_room_directory_search_title">"کمرے کا راہنامچہ"</string>
+  <string name="screen_start_chat_error_starting_chat">"گفتگو شروع کرنے کی کوشش کرتے وقت ایک خرابی واقع ہوگئی"</string>
+</resources>

features/startchat/impl/src/main/res/values-uz/translations.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_create_room_action_create_room">"Yangi xona"</string>
+  <string name="screen_create_room_add_people_title">"Odamlarni taklif qiling"</string>
+  <string name="screen_create_room_error_creating_room">"Xonani yaratishda xatolik yuz berdi"</string>
+  <string name="screen_create_room_private_option_description">"Bu xonadagi xabarlar shifrlangan. Keyinchalik shifrlashni o‘chirib bo‘lmaydi."</string>
+  <string name="screen_create_room_private_option_title">"Shaxsiy xona (faqat taklif)"</string>
+  <string name="screen_create_room_public_option_description">"Xabarlar shifrlanmagan va har kim ularni o\'qiy oladi. Keyinchalik shifrlashni yoqishingiz mumkin."</string>
+  <string name="screen_create_room_room_name_label">"Xona nomi"</string>
+  <string name="screen_create_room_title">"Xonani yaratish"</string>
+  <string name="screen_create_room_topic_label">"Mavzu (ixtiyoriy)"</string>
+  <string name="screen_start_chat_error_starting_chat">"Suhbatni boshlashda xatolik yuz berdi"</string>
+</resources>

features/startchat/impl/src/main/res/values-zh-rTW/translations.xml

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_create_room_action_create_room">"建立聊天室"</string>
+  <string name="screen_create_room_add_people_title">"邀請夥伴"</string>
+  <string name="screen_create_room_error_creating_room">"建立聊天室時發生錯誤"</string>
+  <string name="screen_create_room_private_option_description">"僅被邀請的人才能存取此聊天室。所有訊息均會端到端加密。"</string>
+  <string name="screen_create_room_private_option_title">"私密聊天室"</string>
+  <string name="screen_create_room_public_option_description">"任何人都可以找到此聊天室。
+您隨時都可以在聊天室設定中變更此設定。"</string>
+  <string name="screen_create_room_public_option_title">"公開的聊天室"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_description">"任何人都可以加入此聊天室"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_title">"任何人"</string>
+  <string name="screen_create_room_room_access_section_header">"聊天室存取權"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_description">"任何人都可以要求加入聊天室，但管理員或版主必須接受該請求"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_title">"要求加入"</string>
+  <string name="screen_create_room_room_address_section_footer">"為了讓此聊天室在公開聊天室目錄中可見，您需要聊天室地址。"</string>
+  <string name="screen_create_room_room_address_section_title">"聊天室地址"</string>
+  <string name="screen_create_room_room_name_label">"聊天室名稱"</string>
+  <string name="screen_create_room_room_visibility_section_title">"聊天室能見度"</string>
+  <string name="screen_create_room_title">"建立聊天室"</string>
+  <string name="screen_create_room_topic_label">"主題（非必填）"</string>
+  <string name="screen_room_directory_search_title">"聊天室目錄"</string>
+  <string name="screen_start_chat_error_starting_chat">"嘗試開始聊天時發生錯誤"</string>
+  <string name="screen_start_chat_join_room_by_address_action">"按地址加入聊天室"</string>
+  <string name="screen_start_chat_join_room_by_address_invalid_address">"不是有效的位址"</string>
+  <string name="screen_start_chat_join_room_by_address_placeholder">"輸入……"</string>
+  <string name="screen_start_chat_join_room_by_address_room_found">"找到相符的聊天室"</string>
+  <string name="screen_start_chat_join_room_by_address_room_not_found">"找不到聊天室"</string>
+  <string name="screen_start_chat_join_room_by_address_supporting_text">"例如 #room-name:matrix.org"</string>
+</resources>

features/startchat/impl/src/main/res/values-zh/translations.xml

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_create_room_action_create_room">"新聊天室"</string>
+  <string name="screen_create_room_add_people_title">"邀请朋友"</string>
+  <string name="screen_create_room_error_creating_room">"创建聊天室时出错"</string>
+  <string name="screen_create_room_private_option_description">"只有受邀用户才能访问此聊天室。所有消息均经过端到端加密。"</string>
+  <string name="screen_create_room_private_option_title">"私有聊天室"</string>
+  <string name="screen_create_room_public_option_description">"任何人都能找到此聊天室。
+你可以随时在聊天室设置中更改。"</string>
+  <string name="screen_create_room_public_option_title">"公共聊天室"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_description">"任何人都可以加入此房间"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_title">"任何人"</string>
+  <string name="screen_create_room_room_access_section_header">"房间访问权限"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_description">"任何人都可以请求加入房间，但必须由管理员或审核人接受"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_title">"请求加入"</string>
+  <string name="screen_create_room_room_address_section_footer">"要使该房间在公开房间目录中可见，您需要一个房间地址。"</string>
+  <string name="screen_create_room_room_address_section_title">"房间地址"</string>
+  <string name="screen_create_room_room_name_label">"聊天室名称"</string>
+  <string name="screen_create_room_room_visibility_section_title">"房间可见性"</string>
+  <string name="screen_create_room_title">"创建聊天室"</string>
+  <string name="screen_create_room_topic_label">"主题（可选）"</string>
+  <string name="screen_room_directory_search_title">"聊天室目录"</string>
+  <string name="screen_start_chat_error_starting_chat">"在开始聊天时发生了错误"</string>
+</resources>

features/startchat/impl/src/main/res/values/localazy.xml

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="screen_create_room_action_create_room">"New room"</string>
+  <string name="screen_create_room_add_people_title">"Invite people"</string>
+  <string name="screen_create_room_error_creating_room">"An error occurred when creating the room"</string>
+  <string name="screen_create_room_private_option_description">"Only people invited can access this room. All messages are end-to-end encrypted."</string>
+  <string name="screen_create_room_private_option_title">"Private room"</string>
+  <string name="screen_create_room_public_option_description">"Anyone can find this room.
+You can change this anytime in room settings."</string>
+  <string name="screen_create_room_public_option_title">"Public room"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_description">"Anyone can join this room"</string>
+  <string name="screen_create_room_room_access_section_anyone_option_title">"Anyone"</string>
+  <string name="screen_create_room_room_access_section_header">"Room Access"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_description">"Anyone can ask to join the room but an administrator or a moderator will have to accept the request"</string>
+  <string name="screen_create_room_room_access_section_knocking_option_title">"Ask to join"</string>
+  <string name="screen_create_room_room_address_section_footer">"In order for this room to be visible in the public room directory, you will need a room address."</string>
+  <string name="screen_create_room_room_address_section_title">"Room address"</string>
+  <string name="screen_create_room_room_name_label">"Room name"</string>
+  <string name="screen_create_room_room_visibility_section_title">"Room visibility"</string>
+  <string name="screen_create_room_title">"Create a room"</string>
+  <string name="screen_create_room_topic_label">"Topic (optional)"</string>
+  <string name="screen_room_directory_search_title">"Room directory"</string>
+  <string name="screen_start_chat_error_starting_chat">"An error occurred when trying to start a chat"</string>
+  <string name="screen_start_chat_join_room_by_address_action">"Join room by address"</string>
+  <string name="screen_start_chat_join_room_by_address_invalid_address">"Not a valid address"</string>
+  <string name="screen_start_chat_join_room_by_address_placeholder">"Enter…"</string>
+  <string name="screen_start_chat_join_room_by_address_room_found">"Matching room found"</string>
+  <string name="screen_start_chat_join_room_by_address_room_not_found">"Room not found"</string>
+  <string name="screen_start_chat_join_room_by_address_supporting_text">"e.g. #room-name:matrix.org"</string>
+</resources>

features/startchat/impl/src/test/kotlin/io/element/android/features/startchat/impl/DefaultStartDMActionTest.kt

@@ -0,0 +1,105 @@
+/*
+ * Copyright 2023, 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.
+ */
+
+package io.element.android.features.startchat.impl
+
+import androidx.compose.runtime.mutableStateOf
+import com.google.common.truth.Truth.assertThat
+import im.vector.app.features.analytics.plan.CreatedRoom
+import io.element.android.features.startchat.api.ConfirmingStartDmWithMatrixUser
+import io.element.android.libraries.architecture.AsyncAction
+import io.element.android.libraries.matrix.api.MatrixClient
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.test.AN_EXCEPTION
+import io.element.android.libraries.matrix.test.A_ROOM_ID
+import io.element.android.libraries.matrix.test.FakeMatrixClient
+import io.element.android.libraries.matrix.ui.components.aMatrixUser
+import io.element.android.services.analytics.api.AnalyticsService
+import io.element.android.services.analytics.test.FakeAnalyticsService
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+class DefaultStartDMActionTest {
+    @Test
+    fun `when dm is found, assert state is updated with given room id`() = runTest {
+        val matrixClient = FakeMatrixClient().apply {
+            givenFindDmResult(Result.success(A_ROOM_ID))
+        }
+        val analyticsService = FakeAnalyticsService()
+        val action = createStartDMAction(matrixClient, analyticsService)
+        val state = mutableStateOf<AsyncAction<RoomId>>(AsyncAction.Uninitialized)
+        action.execute(aMatrixUser(), true, state)
+        assertThat(state.value).isEqualTo(AsyncAction.Success(A_ROOM_ID))
+        assertThat(analyticsService.capturedEvents).isEmpty()
+    }
+
+    @Test
+    fun `when finding the dm fails, assert state is updated with given error`() = runTest {
+        val matrixClient = FakeMatrixClient().apply {
+            givenFindDmResult(Result.failure(AN_EXCEPTION))
+        }
+        val analyticsService = FakeAnalyticsService()
+        val action = createStartDMAction(matrixClient, analyticsService)
+        val state = mutableStateOf<AsyncAction<RoomId>>(AsyncAction.Uninitialized)
+        action.execute(aMatrixUser(), true, state)
+        assertThat(state.value).isEqualTo(AsyncAction.Failure(AN_EXCEPTION))
+        assertThat(analyticsService.capturedEvents).isEmpty()
+    }
+
+    @Test
+    fun `when dm is not found, assert dm is created, state is updated with given room id and analytics get called`() = runTest {
+        val matrixClient = FakeMatrixClient().apply {
+            givenFindDmResult(Result.success(null))
+            givenCreateDmResult(Result.success(A_ROOM_ID))
+        }
+        val analyticsService = FakeAnalyticsService()
+        val action = createStartDMAction(matrixClient, analyticsService)
+        val state = mutableStateOf<AsyncAction<RoomId>>(AsyncAction.Uninitialized)
+        action.execute(aMatrixUser(), true, state)
+        assertThat(state.value).isEqualTo(AsyncAction.Success(A_ROOM_ID))
+        assertThat(analyticsService.capturedEvents).containsExactly(CreatedRoom(isDM = true))
+    }
+
+    @Test
+    fun `when dm is not found, and createIfDmDoesNotExist is false, assert dm is not created and state is updated to confirmation state`() = runTest {
+        val matrixClient = FakeMatrixClient().apply {
+            givenFindDmResult(Result.success(null))
+            givenCreateDmResult(Result.success(A_ROOM_ID))
+        }
+        val analyticsService = FakeAnalyticsService()
+        val action = createStartDMAction(matrixClient, analyticsService)
+        val state = mutableStateOf<AsyncAction<RoomId>>(AsyncAction.Uninitialized)
+        val matrixUser = aMatrixUser()
+        action.execute(matrixUser, false, state)
+        assertThat(state.value).isEqualTo(ConfirmingStartDmWithMatrixUser(matrixUser))
+        assertThat(analyticsService.capturedEvents).isEmpty()
+    }
+
+    @Test
+    fun `when dm creation fails, assert state is updated with given error`() = runTest {
+        val matrixClient = FakeMatrixClient().apply {
+            givenFindDmResult(Result.success(null))
+            givenCreateDmResult(Result.failure(AN_EXCEPTION))
+        }
+        val analyticsService = FakeAnalyticsService()
+        val action = createStartDMAction(matrixClient, analyticsService)
+        val state = mutableStateOf<AsyncAction<RoomId>>(AsyncAction.Uninitialized)
+        action.execute(aMatrixUser(), true, state)
+        assertThat(state.value).isEqualTo(AsyncAction.Failure(AN_EXCEPTION))
+        assertThat(analyticsService.capturedEvents).isEmpty()
+    }
+
+    private fun createStartDMAction(
+        matrixClient: MatrixClient = FakeMatrixClient(),
+        analyticsService: AnalyticsService = FakeAnalyticsService(),
+    ): DefaultStartDMAction {
+        return DefaultStartDMAction(
+            matrixClient = matrixClient,
+            analyticsService = analyticsService,
+        )
+    }
+}

features/startchat/impl/src/test/kotlin/io/element/android/features/startchat/impl/FakeStartChatNavigator.kt

@@ -0,0 +1,39 @@
+/*
+ * 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.startchat.impl
+
+import io.element.android.features.invitepeople.StartChatNavigator
+import io.element.android.libraries.matrix.api.core.RoomIdOrAlias
+
+class FakeStartChatNavigator(
+    private val openRoomLambda: (roomIdOrAlias: RoomIdOrAlias, serverNames: List<String>) -> Unit = { _, _ -> },
+    private val createNewRoomLambda: () -> Unit = {},
+    private val showJoinRoomByAddressLambda: () -> Unit = {},
+    private val dismissJoinRoomByAddressLambda: () -> Unit = {},
+    private val openRoomDirectoryLambda: () -> Unit = {},
+) : StartChatNavigator {
+    override fun onOpenRoom(roomIdOrAlias: RoomIdOrAlias, serverNames: List<String>) {
+        openRoomLambda(roomIdOrAlias, serverNames)
+    }
+
+    override fun onCreateNewRoom() {
+        createNewRoomLambda()
+    }
+
+    override fun onShowJoinRoomByAddress() {
+        showJoinRoomByAddressLambda()
+    }
+
+    override fun onDismissJoinRoomByAddress() {
+        dismissJoinRoomByAddressLambda()
+    }
+
+    override fun onOpenRoomDirectory() {
+        openRoomDirectoryLambda()
+    }
+}

features/startchat/impl/src/test/kotlin/io/element/android/features/startchat/impl/addpeople/AddPeoplePresenterTest.kt

@@ -0,0 +1,50 @@
+/*
+ * 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.startchat.impl.addpeople
+
+import app.cash.molecule.RecompositionMode
+import app.cash.molecule.moleculeFlow
+import app.cash.turbine.test
+import com.google.common.truth.Truth.assertThat
+import io.element.android.features.invitepeople.impl.CreateRoomDataStore
+import io.element.android.features.startchat.impl.userlist.FakeUserListPresenterFactory
+import io.element.android.features.invitepeople.impl.userlist.UserListDataStore
+import io.element.android.libraries.matrix.test.room.alias.FakeRoomAliasHelper
+import io.element.android.libraries.usersearch.test.FakeUserRepository
+import io.element.android.tests.testutils.WarmUpRule
+import kotlinx.coroutines.test.runTest
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+
+class AddPeoplePresenterTest {
+    @get:Rule
+    val warmUpRule = WarmUpRule()
+
+    private lateinit var presenter: AddPeoplePresenter
+
+    @Before
+    fun setup() {
+        presenter = AddPeoplePresenter(
+            FakeUserListPresenterFactory(),
+            FakeUserRepository(),
+            CreateRoomDataStore(UserListDataStore(), FakeRoomAliasHelper())
+        )
+    }
+
+    @Test
+    fun `present - initial state`() = runTest {
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            // TODO This doesn't actually test anything...
+            val initialState = awaitItem()
+            assertThat(initialState)
+        }
+    }
+}

features/startchat/impl/src/test/kotlin/io/element/android/features/startchat/impl/addpeople/AddPeopleViewTest.kt

@@ -0,0 +1,89 @@
+/*
+ * Copyright 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.
+ */
+
+package io.element.android.features.startchat.impl.addpeople
+
+import androidx.activity.ComponentActivity
+import androidx.compose.ui.test.junit4.AndroidComposeTestRule
+import androidx.compose.ui.test.junit4.createAndroidComposeRule
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import io.element.android.features.invitepeople.impl.userlist.UserListEvents
+import io.element.android.features.invitepeople.impl.userlist.UserListState
+import io.element.android.features.invitepeople.impl.userlist.aUserListState
+import io.element.android.libraries.ui.strings.CommonStrings
+import io.element.android.tests.testutils.EnsureNeverCalled
+import io.element.android.tests.testutils.EventsRecorder
+import io.element.android.tests.testutils.clickOn
+import io.element.android.tests.testutils.ensureCalledOnce
+import io.element.android.tests.testutils.pressBack
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TestRule
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class AddPeopleViewTest {
+    @get:Rule
+    val rule = createAndroidComposeRule<ComponentActivity>()
+
+    @Test
+    fun `clicking on back invokes the expected callback`() {
+        val eventsRecorder = EventsRecorder<UserListEvents>()
+        ensureCalledOnce {
+            rule.setAddPeopleView(
+                aUserListState(
+                    eventSink = eventsRecorder,
+                ),
+                onBackClick = it
+            )
+            rule.pressBack()
+        }
+        eventsRecorder.assertSingle(UserListEvents.UpdateSearchQuery(""))
+    }
+
+    @Test
+    fun `clicking on back during search emits the expected Event`() {
+        val eventsRecorder = EventsRecorder<UserListEvents>()
+        rule.setAddPeopleView(
+            aUserListState(
+                isSearchActive = true,
+                eventSink = eventsRecorder,
+            ),
+        )
+        rule.pressBack()
+        eventsRecorder.assertSingle(UserListEvents.OnSearchActiveChanged(false))
+    }
+
+    @Test
+    fun `clicking on skip invokes the expected callback`() {
+        val eventsRecorder = EventsRecorder<UserListEvents>()
+        ensureCalledOnce {
+            rule.setAddPeopleView(
+                aUserListState(
+                    eventSink = eventsRecorder,
+                ),
+                onNextClick = it
+            )
+            rule.clickOn(CommonStrings.action_skip)
+        }
+        eventsRecorder.assertSingle(UserListEvents.UpdateSearchQuery(""))
+    }
+}
+
+private fun <R : TestRule> AndroidComposeTestRule<R, ComponentActivity>.setAddPeopleView(
+    state: UserListState,
+    onBackClick: () -> Unit = EnsureNeverCalled(),
+    onNextClick: () -> Unit = EnsureNeverCalled(),
+) {
+    setContent {
+        AddPeopleView(
+            state = state,
+            onBackClick = onBackClick,
+            onSkipClick = onNextClick,
+        )
+    }
+}

features/startchat/impl/src/test/kotlin/io/element/android/features/startchat/impl/configureroom/ConfigureBaseRoomPresenterTest.kt

@@ -0,0 +1,429 @@
+/*
+ * Copyright 2023, 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.
+ */
+
+package io.element.android.features.startchat.impl.configureroom
+
+import android.net.Uri
+import app.cash.turbine.TurbineTestContext
+import com.google.common.truth.Truth.assertThat
+import im.vector.app.features.analytics.plan.CreatedRoom
+import io.element.android.features.invitepeople.impl.CreateRoomConfig
+import io.element.android.features.invitepeople.impl.CreateRoomDataStore
+import io.element.android.features.invitepeople.impl.userlist.UserListDataStore
+import io.element.android.libraries.architecture.AsyncAction
+import io.element.android.libraries.featureflag.api.FeatureFlags
+import io.element.android.libraries.featureflag.test.FakeFeatureFlagService
+import io.element.android.libraries.matrix.api.MatrixClient
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.api.room.alias.ResolvedRoomAlias
+import io.element.android.libraries.matrix.api.room.alias.RoomAliasHelper
+import io.element.android.libraries.matrix.test.AN_AVATAR_URL
+import io.element.android.libraries.matrix.test.AN_EXCEPTION
+import io.element.android.libraries.matrix.test.A_MESSAGE
+import io.element.android.libraries.matrix.test.A_ROOM_ID
+import io.element.android.libraries.matrix.test.A_ROOM_NAME
+import io.element.android.libraries.matrix.test.FakeMatrixClient
+import io.element.android.libraries.matrix.test.room.alias.FakeRoomAliasHelper
+import io.element.android.libraries.matrix.ui.components.aMatrixUser
+import io.element.android.libraries.matrix.ui.media.AvatarAction
+import io.element.android.libraries.matrix.ui.room.address.RoomAddressValidity
+import io.element.android.libraries.mediapickers.api.PickerProvider
+import io.element.android.libraries.mediapickers.test.FakePickerProvider
+import io.element.android.libraries.mediaupload.api.MediaPreProcessor
+import io.element.android.libraries.mediaupload.api.MediaUploadInfo
+import io.element.android.libraries.mediaupload.test.FakeMediaOptimizationConfigProvider
+import io.element.android.libraries.mediaupload.test.FakeMediaPreProcessor
+import io.element.android.libraries.permissions.api.PermissionsPresenter
+import io.element.android.libraries.permissions.test.FakePermissionsPresenter
+import io.element.android.libraries.permissions.test.FakePermissionsPresenterFactory
+import io.element.android.services.analytics.api.AnalyticsService
+import io.element.android.services.analytics.test.FakeAnalyticsService
+import io.element.android.tests.testutils.WarmUpRule
+import io.element.android.tests.testutils.test
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.mockkStatic
+import io.mockk.unmockkAll
+import kotlinx.collections.immutable.persistentListOf
+import kotlinx.collections.immutable.toImmutableList
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.advanceUntilIdle
+import kotlinx.coroutines.test.runTest
+import org.junit.After
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import java.io.File
+import java.util.Optional
+
+private const val AN_URI_FROM_CAMERA = "content://uri_from_camera"
+private const val AN_URI_FROM_CAMERA_2 = "content://uri_from_camera_2"
+private const val AN_URI_FROM_GALLERY = "content://uri_from_gallery"
+
+@RunWith(RobolectricTestRunner::class)
+class ConfigureBaseRoomPresenterTest {
+    @get:Rule
+    val warmUpRule = WarmUpRule()
+
+    @Before
+    fun setup() {
+        mockkStatic(File::readBytes)
+        every { any<File>().readBytes() } returns byteArrayOf()
+    }
+
+    @After
+    fun tearDown() {
+        unmockkAll()
+    }
+
+    @Test
+    fun `present - initial state`() = runTest {
+        val presenter = createConfigureRoomPresenter()
+        presenter.test {
+            val initialState = initialState()
+            assertThat(initialState.config).isEqualTo(CreateRoomConfig())
+            assertThat(initialState.config.roomName).isNull()
+            assertThat(initialState.config.topic).isNull()
+            assertThat(initialState.config.invites).isEmpty()
+            assertThat(initialState.config.avatarUri).isNull()
+            assertThat(initialState.config.roomVisibility).isEqualTo(RoomVisibilityState.Private)
+            assertThat(initialState.createRoomAction).isInstanceOf(AsyncAction.Uninitialized::class.java)
+            assertThat(initialState.homeserverName).isEqualTo("matrix.org")
+        }
+    }
+
+    @Test
+    fun `present - create room button is enabled only if the required fields are completed`() = runTest {
+        val presenter = createConfigureRoomPresenter()
+        presenter.test {
+            val initialState = initialState()
+            var config = initialState.config
+            assertThat(initialState.isValid).isFalse()
+
+            // Room name not empty
+            initialState.eventSink(ConfigureRoomEvents.RoomNameChanged(A_ROOM_NAME))
+            var newState: ConfigureRoomState = awaitItem()
+            config = config.copy(roomName = A_ROOM_NAME)
+            assertThat(newState.config).isEqualTo(config)
+            assertThat(newState.isValid).isTrue()
+
+            // Clear room name
+            newState.eventSink(ConfigureRoomEvents.RoomNameChanged(""))
+            newState = awaitItem()
+            config = config.copy(roomName = null)
+            assertThat(newState.config).isEqualTo(config)
+            assertThat(newState.isValid).isFalse()
+        }
+    }
+
+    @Test
+    fun `present - state is updated when fields are changed`() = runTest {
+        val userListDataStore = UserListDataStore()
+        val pickerProvider = FakePickerProvider()
+        val permissionsPresenter = FakePermissionsPresenter()
+        val roomAliasHelper = FakeRoomAliasHelper()
+        val presenter = createConfigureRoomPresenter(
+            createRoomDataStore = CreateRoomDataStore(userListDataStore, roomAliasHelper),
+            pickerProvider = pickerProvider,
+            permissionsPresenter = permissionsPresenter,
+        )
+        presenter.test {
+            val initialState = initialState()
+            var expectedConfig = CreateRoomConfig()
+            assertThat(initialState.config).isEqualTo(expectedConfig)
+
+            // Select User
+            val selectedUser1 = aMatrixUser()
+            val selectedUser2 = aMatrixUser("@id_of_bob:server.org", "Bob")
+            userListDataStore.selectUser(selectedUser1)
+            skipItems(1)
+            userListDataStore.selectUser(selectedUser2)
+            var newState = awaitItem()
+            expectedConfig = expectedConfig.copy(invites = persistentListOf(selectedUser1, selectedUser2))
+            assertThat(newState.config).isEqualTo(expectedConfig)
+
+            // Room name
+            initialState.eventSink(ConfigureRoomEvents.RoomNameChanged(A_ROOM_NAME))
+            newState = awaitItem()
+            expectedConfig = expectedConfig.copy(roomName = A_ROOM_NAME)
+            assertThat(newState.config).isEqualTo(expectedConfig)
+
+            // Room topic
+            newState.eventSink(ConfigureRoomEvents.TopicChanged(A_MESSAGE))
+            newState = awaitItem()
+            expectedConfig = expectedConfig.copy(topic = A_MESSAGE)
+            assertThat(newState.config).isEqualTo(expectedConfig)
+
+            // Room avatar
+            // Pick avatar
+            pickerProvider.givenResult(null)
+            // From gallery
+            val uriFromGallery = Uri.parse(AN_URI_FROM_GALLERY)
+            pickerProvider.givenResult(uriFromGallery)
+            newState.eventSink(ConfigureRoomEvents.HandleAvatarAction(AvatarAction.ChoosePhoto))
+            newState = awaitItem()
+            expectedConfig = expectedConfig.copy(avatarUri = uriFromGallery)
+            assertThat(newState.config).isEqualTo(expectedConfig)
+            // From camera
+            val uriFromCamera = Uri.parse(AN_URI_FROM_CAMERA)
+            pickerProvider.givenResult(uriFromCamera)
+            assertThat(newState.cameraPermissionState.permissionGranted).isFalse()
+            newState.eventSink(ConfigureRoomEvents.HandleAvatarAction(AvatarAction.TakePhoto))
+            newState = awaitItem()
+            assertThat(newState.cameraPermissionState.showDialog).isTrue()
+            permissionsPresenter.setPermissionGranted()
+            newState = awaitItem()
+            assertThat(newState.cameraPermissionState.permissionGranted).isTrue()
+            newState = awaitItem()
+            expectedConfig = expectedConfig.copy(avatarUri = uriFromCamera)
+            assertThat(newState.config).isEqualTo(expectedConfig)
+            // Do it again, no permission is requested
+            val uriFromCamera2 = Uri.parse(AN_URI_FROM_CAMERA_2)
+            pickerProvider.givenResult(uriFromCamera2)
+            newState.eventSink(ConfigureRoomEvents.HandleAvatarAction(AvatarAction.TakePhoto))
+            newState = awaitItem()
+            expectedConfig = expectedConfig.copy(avatarUri = uriFromCamera2)
+            assertThat(newState.config).isEqualTo(expectedConfig)
+            // Remove
+            newState.eventSink(ConfigureRoomEvents.HandleAvatarAction(AvatarAction.Remove))
+            newState = awaitItem()
+            expectedConfig = expectedConfig.copy(avatarUri = null)
+            assertThat(newState.config).isEqualTo(expectedConfig)
+
+            // Room privacy
+            newState.eventSink(ConfigureRoomEvents.RoomVisibilityChanged(RoomVisibilityItem.Public))
+            newState = awaitItem()
+            expectedConfig = expectedConfig.copy(
+                roomVisibility = RoomVisibilityState.Public(
+                    roomAddress = RoomAddress.AutoFilled(roomAliasHelper.roomAliasNameFromRoomDisplayName(expectedConfig.roomName ?: "")),
+                    roomAccess = RoomAccess.Anyone,
+                )
+            )
+            assertThat(newState.config).isEqualTo(expectedConfig)
+
+            // Remove user
+            newState.eventSink(ConfigureRoomEvents.RemoveUserFromSelection(selectedUser1))
+            newState = awaitItem()
+            expectedConfig = expectedConfig.copy(invites = expectedConfig.invites.minus(selectedUser1).toImmutableList())
+            assertThat(newState.config).isEqualTo(expectedConfig)
+        }
+    }
+
+    @Test
+    fun `present - trigger create room action`() = runTest {
+        val matrixClient = createMatrixClient()
+        val presenter = createConfigureRoomPresenter(
+            matrixClient = matrixClient
+        )
+        presenter.test {
+            val initialState = initialState()
+            val createRoomResult = Result.success(RoomId("!createRoomResult:domain"))
+
+            matrixClient.givenCreateRoomResult(createRoomResult)
+
+            initialState.eventSink(ConfigureRoomEvents.CreateRoom)
+            assertThat(awaitItem().createRoomAction).isInstanceOf(AsyncAction.Loading::class.java)
+            val stateAfterCreateRoom = awaitItem()
+            assertThat(stateAfterCreateRoom.createRoomAction).isInstanceOf(AsyncAction.Success::class.java)
+            assertThat(stateAfterCreateRoom.createRoomAction.dataOrNull()).isEqualTo(createRoomResult.getOrNull())
+        }
+    }
+
+    @Test
+    fun `present - record analytics when creating room`() = runTest {
+        val matrixClient = createMatrixClient()
+        val analyticsService = FakeAnalyticsService()
+        val presenter = createConfigureRoomPresenter(
+            matrixClient = matrixClient,
+            analyticsService = analyticsService
+        )
+        presenter.test {
+            val initialState = initialState()
+            val createRoomResult = Result.success(RoomId("!createRoomResult:domain"))
+
+            matrixClient.givenCreateRoomResult(createRoomResult)
+
+            initialState.eventSink(ConfigureRoomEvents.CreateRoom)
+            skipItems(2)
+
+            val analyticsEvent = analyticsService.capturedEvents.filterIsInstance<CreatedRoom>().firstOrNull()
+            assertThat(analyticsEvent).isNotNull()
+            assertThat(analyticsEvent?.isDM).isFalse()
+        }
+    }
+
+    @Test
+    fun `present - trigger create room with upload error and retry`() = runTest {
+        val matrixClient = createMatrixClient()
+        val analyticsService = FakeAnalyticsService()
+        val mediaPreProcessor = FakeMediaPreProcessor()
+        val createRoomDataStore = CreateRoomDataStore(UserListDataStore(), FakeRoomAliasHelper())
+        val presenter = createConfigureRoomPresenter(
+            createRoomDataStore = createRoomDataStore,
+            mediaPreProcessor = mediaPreProcessor,
+            matrixClient = matrixClient,
+            analyticsService = analyticsService
+        )
+        presenter.test {
+            val initialState = initialState()
+            createRoomDataStore.setAvatarUri(Uri.parse(AN_URI_FROM_GALLERY))
+            skipItems(1)
+            mediaPreProcessor.givenResult(Result.success(MediaUploadInfo.Image(mockk(), mockk(), mockk())))
+            matrixClient.givenUploadMediaResult(Result.failure(AN_EXCEPTION))
+
+            initialState.eventSink(ConfigureRoomEvents.CreateRoom)
+            assertThat(awaitItem().createRoomAction).isInstanceOf(AsyncAction.Loading::class.java)
+            val stateAfterCreateRoom = awaitItem()
+            assertThat(stateAfterCreateRoom.createRoomAction).isInstanceOf(AsyncAction.Failure::class.java)
+            assertThat(analyticsService.capturedEvents.filterIsInstance<CreatedRoom>()).isEmpty()
+
+            matrixClient.givenUploadMediaResult(Result.success(AN_AVATAR_URL))
+            stateAfterCreateRoom.eventSink(ConfigureRoomEvents.CreateRoom)
+            assertThat(awaitItem().createRoomAction).isInstanceOf(AsyncAction.Uninitialized::class.java)
+            assertThat(awaitItem().createRoomAction).isInstanceOf(AsyncAction.Loading::class.java)
+            assertThat(awaitItem().createRoomAction).isInstanceOf(AsyncAction.Success::class.java)
+        }
+    }
+
+    @Test
+    fun `present - trigger retry and cancel actions`() = runTest {
+        val fakeMatrixClient = createMatrixClient()
+        val presenter = createConfigureRoomPresenter(
+            matrixClient = fakeMatrixClient
+        )
+        presenter.test {
+            val initialState = initialState()
+            val createRoomResult = Result.failure<RoomId>(AN_EXCEPTION)
+
+            fakeMatrixClient.givenCreateRoomResult(createRoomResult)
+
+            // Create
+            initialState.eventSink(ConfigureRoomEvents.CreateRoom)
+            assertThat(awaitItem().createRoomAction).isInstanceOf(AsyncAction.Loading::class.java)
+            val stateAfterCreateRoom = awaitItem()
+            assertThat(stateAfterCreateRoom.createRoomAction).isInstanceOf(AsyncAction.Failure::class.java)
+            assertThat((stateAfterCreateRoom.createRoomAction as? AsyncAction.Failure)?.error).isEqualTo(createRoomResult.exceptionOrNull())
+
+            // Retry
+            stateAfterCreateRoom.eventSink(ConfigureRoomEvents.CreateRoom)
+            assertThat(awaitItem().createRoomAction).isInstanceOf(AsyncAction.Uninitialized::class.java)
+            assertThat(awaitItem().createRoomAction).isInstanceOf(AsyncAction.Loading::class.java)
+            val stateAfterRetry = awaitItem()
+            assertThat(stateAfterRetry.createRoomAction).isInstanceOf(AsyncAction.Failure::class.java)
+            assertThat((stateAfterRetry.createRoomAction as? AsyncAction.Failure)?.error).isEqualTo(createRoomResult.exceptionOrNull())
+
+            // Cancel
+            stateAfterRetry.eventSink(ConfigureRoomEvents.CancelCreateRoom)
+            assertThat(awaitItem().createRoomAction).isInstanceOf(AsyncAction.Uninitialized::class.java)
+        }
+    }
+
+    @OptIn(ExperimentalCoroutinesApi::class)
+    @Test
+    fun `present - address is invalid when format is invalid`() = runTest {
+        val aliasHelper = FakeRoomAliasHelper(
+            isRoomAliasValidLambda = { false }
+        )
+        val presenter = createConfigureRoomPresenter(
+            roomAliasHelper = aliasHelper
+        )
+        presenter.test {
+            val initialState = initialState()
+            initialState.eventSink(ConfigureRoomEvents.RoomVisibilityChanged(RoomVisibilityItem.Public))
+            skipItems(1)
+            initialState.eventSink(ConfigureRoomEvents.RoomAddressChanged("invalid address"))
+            skipItems(1)
+            advanceUntilIdle()
+            awaitItem().also { state ->
+                assertThat(state.roomAddressValidity).isEqualTo(RoomAddressValidity.InvalidSymbols)
+            }
+        }
+    }
+
+    @OptIn(ExperimentalCoroutinesApi::class)
+    @Test
+    fun `present - address is not available when alias is not available`() = runTest {
+        val fakeMatrixClient = createMatrixClient(isAliasAvailable = false)
+        val presenter = createConfigureRoomPresenter(
+            matrixClient = fakeMatrixClient,
+        )
+        presenter.test {
+            val initialState = initialState()
+            initialState.eventSink(ConfigureRoomEvents.RoomVisibilityChanged(RoomVisibilityItem.Public))
+            skipItems(1)
+            initialState.eventSink(ConfigureRoomEvents.RoomAddressChanged("address"))
+            skipItems(1)
+            advanceUntilIdle()
+            awaitItem().also { state ->
+                assertThat(state.roomAddressValidity).isEqualTo(RoomAddressValidity.NotAvailable)
+            }
+        }
+    }
+
+    @OptIn(ExperimentalCoroutinesApi::class)
+    @Test
+    fun `present - address is valid when alias is available and format is valid`() = runTest {
+        val fakeMatrixClient = createMatrixClient(isAliasAvailable = true)
+        val presenter = createConfigureRoomPresenter(
+            matrixClient = fakeMatrixClient,
+        )
+        presenter.test {
+            val initialState = initialState()
+            initialState.eventSink(ConfigureRoomEvents.RoomVisibilityChanged(RoomVisibilityItem.Public))
+            skipItems(1)
+            initialState.eventSink(ConfigureRoomEvents.RoomAddressChanged("address"))
+            skipItems(1)
+            advanceUntilIdle()
+            awaitItem().also { state ->
+                assertThat(state.roomAddressValidity).isEqualTo(RoomAddressValidity.Valid)
+            }
+        }
+    }
+
+    private suspend fun TurbineTestContext<ConfigureRoomState>.initialState(): ConfigureRoomState {
+        skipItems(1)
+        return awaitItem()
+    }
+
+    private fun createMatrixClient(isAliasAvailable: Boolean = true) = FakeMatrixClient(
+        userIdServerNameLambda = { "matrix.org" },
+        resolveRoomAliasResult = {
+            val resolvedRoomAlias = if (isAliasAvailable) {
+                Optional.empty()
+            } else {
+                Optional.of(ResolvedRoomAlias(A_ROOM_ID, emptyList()))
+            }
+            Result.success(resolvedRoomAlias)
+        }
+    )
+
+    private fun createConfigureRoomPresenter(
+        roomAliasHelper: RoomAliasHelper = FakeRoomAliasHelper(),
+        createRoomDataStore: CreateRoomDataStore = CreateRoomDataStore(UserListDataStore(), roomAliasHelper),
+        matrixClient: MatrixClient = createMatrixClient(),
+        pickerProvider: PickerProvider = FakePickerProvider(),
+        mediaPreProcessor: MediaPreProcessor = FakeMediaPreProcessor(),
+        analyticsService: AnalyticsService = FakeAnalyticsService(),
+        permissionsPresenter: PermissionsPresenter = FakePermissionsPresenter(),
+        isKnockFeatureEnabled: Boolean = true,
+        mediaOptimizationConfigProvider: FakeMediaOptimizationConfigProvider = FakeMediaOptimizationConfigProvider(),
+    ) = ConfigureRoomPresenter(
+        dataStore = createRoomDataStore,
+        matrixClient = matrixClient,
+        mediaPickerProvider = pickerProvider,
+        mediaPreProcessor = mediaPreProcessor,
+        analyticsService = analyticsService,
+        permissionsPresenterFactory = FakePermissionsPresenterFactory(permissionsPresenter),
+        roomAliasHelper = roomAliasHelper,
+        featureFlagService = FakeFeatureFlagService(
+            mapOf(FeatureFlags.Knock.key to isKnockFeatureEnabled)
+        ),
+        mediaOptimizationConfigProvider = mediaOptimizationConfigProvider,
+    )
+}

features/startchat/impl/src/test/kotlin/io/element/android/features/startchat/impl/joinbyaddress/JoinBaseRoomByAddressPresenterTest.kt

@@ -0,0 +1,140 @@
+/*
+ * 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.startchat.impl.joinbyaddress
+
+import com.google.common.truth.Truth.assertThat
+import io.element.android.features.invitepeople.StartChatNavigator
+import io.element.android.features.startchat.impl.FakeStartChatNavigator
+import io.element.android.libraries.matrix.api.MatrixClient
+import io.element.android.libraries.matrix.api.core.RoomIdOrAlias
+import io.element.android.libraries.matrix.api.room.alias.RoomAliasHelper
+import io.element.android.libraries.matrix.test.FakeMatrixClient
+import io.element.android.libraries.matrix.test.room.alias.FakeRoomAliasHelper
+import io.element.android.tests.testutils.lambda.assert
+import io.element.android.tests.testutils.lambda.lambdaRecorder
+import io.element.android.tests.testutils.test
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+class JoinBaseRoomByAddressPresenterTest {
+    @Test
+    fun `present - initial state`() = runTest {
+        val presenter = createJoinRoomByAddressPresenter()
+        presenter.test {
+            with(awaitItem()) {
+                assertThat(address).isEmpty()
+                assertThat(addressState).isEqualTo(RoomAddressState.Unknown)
+            }
+        }
+    }
+
+    @Test
+    fun `present - invalid address`() = runTest {
+        val presenter = createJoinRoomByAddressPresenter(
+            roomAliasHelper = FakeRoomAliasHelper(
+                isRoomAliasValidLambda = { false }
+            )
+        )
+        presenter.test {
+            with(awaitItem()) {
+                eventSink(JoinRoomByAddressEvents.UpdateAddress("invalid_address"))
+            }
+            with(awaitItem()) {
+                assertThat(address).isEqualTo("invalid_address")
+                assertThat(addressState).isEqualTo(RoomAddressState.Unknown)
+                eventSink(JoinRoomByAddressEvents.Continue)
+            }
+            // The address should be marked as invalid only after the user tries to continue
+            with(awaitItem()) {
+                assertThat(address).isEqualTo("invalid_address")
+                assertThat(addressState).isEqualTo(RoomAddressState.Invalid)
+            }
+        }
+    }
+
+    @Test
+    fun `present - room found`() = runTest {
+        val openRoomLambda = lambdaRecorder<RoomIdOrAlias, List<String>, Unit> { _, _ -> }
+        val dismissJoinRoomByAddressLambda = lambdaRecorder<Unit> { }
+        val navigator = FakeStartChatNavigator(
+            openRoomLambda = openRoomLambda,
+            dismissJoinRoomByAddressLambda = dismissJoinRoomByAddressLambda
+        )
+        val presenter = createJoinRoomByAddressPresenter(navigator = navigator)
+        presenter.test {
+            with(awaitItem()) {
+                eventSink(JoinRoomByAddressEvents.UpdateAddress("#room_found:matrix.org"))
+            }
+            with(awaitItem()) {
+                assertThat(address).isEqualTo("#room_found:matrix.org")
+                assertThat(addressState).isEqualTo(RoomAddressState.Unknown)
+            }
+            with(awaitItem()) {
+                assertThat(address).isEqualTo("#room_found:matrix.org")
+                assertThat(addressState).isInstanceOf(RoomAddressState.RoomFound::class.java)
+                eventSink(JoinRoomByAddressEvents.Continue)
+            }
+            assert(openRoomLambda).isCalledOnce()
+            assert(dismissJoinRoomByAddressLambda).isCalledOnce()
+        }
+    }
+
+    @Test
+    fun `present - room not found`() = runTest {
+        val presenter = createJoinRoomByAddressPresenter(
+            matrixClient = FakeMatrixClient(
+                resolveRoomAliasResult = { Result.failure(RuntimeException()) }
+            )
+        )
+        presenter.test {
+            with(awaitItem()) {
+                eventSink(JoinRoomByAddressEvents.UpdateAddress("#room_not_found:matrix.org"))
+            }
+            with(awaitItem()) {
+                assertThat(address).isEqualTo("#room_not_found:matrix.org")
+                assertThat(addressState).isEqualTo(RoomAddressState.Unknown)
+                eventSink(JoinRoomByAddressEvents.Continue)
+            }
+            with(awaitItem()) {
+                assertThat(address).isEqualTo("#room_not_found:matrix.org")
+                assertThat(addressState).isEqualTo(RoomAddressState.Resolving)
+            }
+            with(awaitItem()) {
+                assertThat(address).isEqualTo("#room_not_found:matrix.org")
+                assertThat(addressState).isEqualTo(RoomAddressState.RoomNotFound)
+            }
+        }
+    }
+
+    @Test
+    fun `present - dismiss`() = runTest {
+        val dismissJoinRoomByAddressLambda = lambdaRecorder<Unit> { }
+        val navigator = FakeStartChatNavigator(
+            dismissJoinRoomByAddressLambda = dismissJoinRoomByAddressLambda
+        )
+        val presenter = createJoinRoomByAddressPresenter(navigator = navigator)
+        presenter.test {
+            with(awaitItem()) {
+                eventSink(JoinRoomByAddressEvents.Dismiss)
+            }
+            assert(dismissJoinRoomByAddressLambda).isCalledOnce()
+        }
+    }
+
+    private fun createJoinRoomByAddressPresenter(
+        navigator: StartChatNavigator = FakeStartChatNavigator(),
+        matrixClient: MatrixClient = FakeMatrixClient(),
+        roomAliasHelper: RoomAliasHelper = FakeRoomAliasHelper(),
+    ): JoinRoomByAddressPresenter {
+        return JoinRoomByAddressPresenter(
+            navigator = navigator,
+            client = matrixClient,
+            roomAliasHelper = roomAliasHelper,
+        )
+    }
+}

features/startchat/impl/src/test/kotlin/io/element/android/features/startchat/impl/joinbyaddress/JoinBaseRoomByAddressViewTest.kt

@@ -0,0 +1,63 @@
+/*
+ * 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.startchat.impl.joinbyaddress
+
+import androidx.activity.ComponentActivity
+import androidx.compose.ui.test.junit4.AndroidComposeTestRule
+import androidx.compose.ui.test.junit4.createAndroidComposeRule
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performTextInput
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import io.element.android.features.invitepeople.impl.R
+import io.element.android.libraries.ui.strings.CommonStrings
+import io.element.android.tests.testutils.EventsRecorder
+import io.element.android.tests.testutils.clickOn
+import io.element.android.tests.testutils.setSafeContent
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TestRule
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class JoinBaseRoomByAddressViewTest {
+    @get:Rule
+    val rule = createAndroidComposeRule<ComponentActivity>()
+
+    @Test
+    fun `entering text emits the expected event`() {
+        val eventsRecorder = EventsRecorder<JoinRoomByAddressEvents>()
+        rule.setJoinRoomByAddressView(
+            aJoinRoomByAddressState(
+                eventSink = eventsRecorder,
+            )
+        )
+        val text = rule.activity.getString(R.string.screen_start_chat_join_room_by_address_action)
+        rule.onNodeWithText(text).performTextInput("#address:matrix.org")
+        eventsRecorder.assertSingle(JoinRoomByAddressEvents.UpdateAddress("#address:matrix.org"))
+    }
+
+    @Test
+    fun `clicking on continue emits the expected event`() {
+        val eventsRecorder = EventsRecorder<JoinRoomByAddressEvents>()
+        rule.setJoinRoomByAddressView(
+            aJoinRoomByAddressState(
+                eventSink = eventsRecorder,
+            )
+        )
+        rule.clickOn(CommonStrings.action_continue)
+        eventsRecorder.assertSingle(JoinRoomByAddressEvents.Continue)
+    }
+}
+
+private fun <R : TestRule> AndroidComposeTestRule<R, ComponentActivity>.setJoinRoomByAddressView(
+    state: JoinRoomByAddressState,
+) {
+    setSafeContent {
+        JoinRoomByAddressView(state = state)
+    }
+}

features/startchat/impl/src/test/kotlin/io/element/android/features/startchat/impl/root/CreateBaseRoomRootPresenterTest.kt

@@ -0,0 +1,199 @@
+/*
+ * 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.startchat.impl.root
+
+import androidx.compose.runtime.MutableState
+import app.cash.molecule.RecompositionMode
+import app.cash.molecule.moleculeFlow
+import app.cash.turbine.test
+import com.google.common.truth.Truth.assertThat
+import io.element.android.features.startchat.api.ConfirmingStartDmWithMatrixUser
+import io.element.android.features.startchat.api.StartDMAction
+import io.element.android.features.startchat.impl.userlist.FakeUserListPresenter
+import io.element.android.features.startchat.impl.userlist.FakeUserListPresenterFactory
+import io.element.android.features.invitepeople.impl.userlist.UserListDataStore
+import io.element.android.features.invitepeople.test.FakeStartDMAction
+import io.element.android.libraries.architecture.AsyncAction
+import io.element.android.libraries.featureflag.api.FeatureFlags
+import io.element.android.libraries.featureflag.test.FakeFeatureFlagService
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.api.core.UserId
+import io.element.android.libraries.matrix.api.user.MatrixUser
+import io.element.android.libraries.matrix.test.AN_EXCEPTION
+import io.element.android.libraries.matrix.test.A_ROOM_ID
+import io.element.android.libraries.matrix.test.core.aBuildMeta
+import io.element.android.libraries.usersearch.test.FakeUserRepository
+import io.element.android.tests.testutils.WarmUpRule
+import io.element.android.tests.testutils.lambda.any
+import io.element.android.tests.testutils.lambda.lambdaRecorder
+import io.element.android.tests.testutils.lambda.value
+import kotlinx.coroutines.test.runTest
+import org.junit.Rule
+import org.junit.Test
+
+class CreateBaseRoomRootPresenterTest {
+    @get:Rule
+    val warmUpRule = WarmUpRule()
+
+    @Test
+    fun `present - start DM action failure scenario`() = runTest {
+        val startDMFailureResult = AsyncAction.Failure(AN_EXCEPTION)
+        val executeResult = lambdaRecorder<MatrixUser, Boolean, MutableState<AsyncAction<RoomId>>, Unit> { _, _, actionState ->
+            actionState.value = startDMFailureResult
+        }
+        val startDMAction = FakeStartDMAction(executeResult = executeResult)
+        val presenter = createCreateRoomRootPresenter(startDMAction)
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            assertThat(initialState.startDmAction).isInstanceOf(AsyncAction.Uninitialized::class.java)
+            assertThat(initialState.applicationName).isEqualTo(aBuildMeta().applicationName)
+            assertThat(initialState.userListState.selectedUsers).isEmpty()
+            assertThat(initialState.userListState.isSearchActive).isFalse()
+            assertThat(initialState.userListState.isMultiSelectionEnabled).isFalse()
+            val matrixUser = MatrixUser(UserId("@name:domain"))
+            initialState.eventSink(StartChatEvents.StartDM(matrixUser))
+            awaitItem().also { state ->
+                assertThat(state.startDmAction).isEqualTo(startDMFailureResult)
+                executeResult.assertions().isCalledOnce().with(
+                    value(matrixUser),
+                    value(false),
+                    any(),
+                )
+                state.eventSink(StartChatEvents.CancelStartDM)
+            }
+            awaitItem().also { state ->
+                assertThat(state.startDmAction.isUninitialized()).isTrue()
+            }
+        }
+    }
+
+    @Test
+    fun `present - start DM action success scenario`() = runTest {
+        val startDMSuccessResult = AsyncAction.Success(A_ROOM_ID)
+        val executeResult = lambdaRecorder<MatrixUser, Boolean, MutableState<AsyncAction<RoomId>>, Unit> { _, _, actionState ->
+            actionState.value = startDMSuccessResult
+        }
+        val startDMAction = FakeStartDMAction(executeResult = executeResult)
+        val presenter = createCreateRoomRootPresenter(startDMAction)
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            assertThat(initialState.startDmAction).isInstanceOf(AsyncAction.Uninitialized::class.java)
+            assertThat(initialState.applicationName).isEqualTo(aBuildMeta().applicationName)
+            assertThat(initialState.userListState.selectedUsers).isEmpty()
+            assertThat(initialState.userListState.isSearchActive).isFalse()
+            assertThat(initialState.userListState.isMultiSelectionEnabled).isFalse()
+            val matrixUser = MatrixUser(UserId("@name:domain"))
+            initialState.eventSink(StartChatEvents.StartDM(matrixUser))
+            awaitItem().also { state ->
+                assertThat(state.startDmAction).isEqualTo(startDMSuccessResult)
+                executeResult.assertions().isCalledOnce().with(
+                    value(matrixUser),
+                    value(false),
+                    any(),
+                )
+            }
+        }
+    }
+
+    @Test
+    fun `present - start DM action confirmation scenario - cancel`() = runTest {
+        val matrixUser = MatrixUser(UserId("@name:domain"))
+        val startDMConfirmationResult = ConfirmingStartDmWithMatrixUser(matrixUser)
+        val executeResult = lambdaRecorder<MatrixUser, Boolean, MutableState<AsyncAction<RoomId>>, Unit> { _, _, actionState ->
+            actionState.value = startDMConfirmationResult
+        }
+        val startDMAction = FakeStartDMAction(executeResult = executeResult)
+        val presenter = createCreateRoomRootPresenter(startDMAction)
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            assertThat(initialState.startDmAction).isInstanceOf(AsyncAction.Uninitialized::class.java)
+            initialState.eventSink(StartChatEvents.StartDM(matrixUser))
+            val confirmingState = awaitItem()
+            assertThat(confirmingState.startDmAction).isEqualTo(startDMConfirmationResult)
+            executeResult.assertions().isCalledOnce().with(
+                value(matrixUser),
+                value(false),
+                any(),
+            )
+            // Cancelling should not create the DM
+            confirmingState.eventSink(StartChatEvents.CancelStartDM)
+            val finalState = awaitItem()
+            assertThat(finalState.startDmAction.isUninitialized()).isTrue()
+            executeResult.assertions().isCalledExactly(1)
+        }
+    }
+
+    @Test
+    fun `present - start DM action confirmation scenario - confirm`() = runTest {
+        val matrixUser = MatrixUser(UserId("@name:domain"))
+        val startDMConfirmationResult = ConfirmingStartDmWithMatrixUser(matrixUser)
+        val executeResult = lambdaRecorder<MatrixUser, Boolean, MutableState<AsyncAction<RoomId>>, Unit> { _, _, actionState ->
+            actionState.value = startDMConfirmationResult
+        }
+        val startDMAction = FakeStartDMAction(executeResult = executeResult)
+        val presenter = createCreateRoomRootPresenter(startDMAction)
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            assertThat(initialState.startDmAction).isInstanceOf(AsyncAction.Uninitialized::class.java)
+            initialState.eventSink(StartChatEvents.StartDM(matrixUser))
+            val confirmingState = awaitItem()
+            assertThat(confirmingState.startDmAction).isEqualTo(startDMConfirmationResult)
+            executeResult.assertions().isCalledOnce().with(
+                value(matrixUser),
+                value(false),
+                any(),
+            )
+            // Start DM again should invoke the action with createIfDmDoesNotExist = true
+            confirmingState.eventSink(StartChatEvents.StartDM(matrixUser))
+            executeResult.assertions().isCalledExactly(2).withSequence(
+                listOf(value(matrixUser), value(false), any()),
+                listOf(value(matrixUser), value(true), any()),
+            )
+        }
+    }
+
+    @Test
+    fun `present - room directory search`() = runTest {
+        val presenter = createCreateRoomRootPresenter(isRoomDirectorySearchEnabled = true)
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            skipItems(1)
+            awaitItem().let { state ->
+                assertThat(state.isRoomDirectorySearchEnabled).isTrue()
+            }
+        }
+    }
+
+    private fun createCreateRoomRootPresenter(
+        startDMAction: StartDMAction = FakeStartDMAction(),
+        isRoomDirectorySearchEnabled: Boolean = false,
+    ): StartChatPresenter {
+        val featureFlagService = FakeFeatureFlagService(
+            initialState = mapOf(
+                FeatureFlags.RoomDirectorySearch.key to isRoomDirectorySearchEnabled,
+            ),
+        )
+        return StartChatPresenter(
+            presenterFactory = FakeUserListPresenterFactory(FakeUserListPresenter()),
+            userRepository = FakeUserRepository(),
+            userListDataStore = UserListDataStore(),
+            startDMAction = startDMAction,
+            featureFlagService = featureFlagService,
+            buildMeta = aBuildMeta(),
+        )
+    }
+}

features/startchat/impl/src/test/kotlin/io/element/android/features/startchat/impl/root/CreateBaseRoomRootViewTest.kt

@@ -0,0 +1,157 @@
+/*
+ * 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.startchat.impl.root
+
+import androidx.activity.ComponentActivity
+import androidx.compose.ui.test.junit4.AndroidComposeTestRule
+import androidx.compose.ui.test.junit4.createAndroidComposeRule
+import androidx.compose.ui.test.onNodeWithText
+import androidx.compose.ui.test.performClick
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import io.element.android.features.invitepeople.impl.R
+import io.element.android.features.invitepeople.impl.userlist.aRecentDirectRoomList
+import io.element.android.features.invitepeople.impl.userlist.aUserListState
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.ui.model.getBestName
+import io.element.android.libraries.ui.strings.CommonStrings
+import io.element.android.tests.testutils.EnsureNeverCalled
+import io.element.android.tests.testutils.EnsureNeverCalledWithParam
+import io.element.android.tests.testutils.EventsRecorder
+import io.element.android.tests.testutils.clickOn
+import io.element.android.tests.testutils.ensureCalledOnce
+import io.element.android.tests.testutils.ensureCalledOnceWithParam
+import io.element.android.tests.testutils.pressBack
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.TestRule
+import org.junit.runner.RunWith
+import org.robolectric.annotation.Config
+import kotlin.collections.get
+
+@RunWith(AndroidJUnit4::class)
+class CreateBaseRoomRootViewTest {
+    @get:Rule
+    val rule = createAndroidComposeRule<ComponentActivity>()
+
+    @Test
+    fun `clicking on back invokes the expected callback`() {
+        val eventsRecorder = EventsRecorder<StartChatEvents>(expectEvents = false)
+        ensureCalledOnce {
+            rule.setCreateRoomRootView(
+                aCreateRoomRootState(
+                    eventSink = eventsRecorder,
+                ),
+                onCloseClick = it
+            )
+            rule.pressBack()
+        }
+    }
+
+    @Test
+    fun `clicking on New room invokes the expected callback`() {
+        val eventsRecorder = EventsRecorder<StartChatEvents>(expectEvents = false)
+        ensureCalledOnce {
+            rule.setCreateRoomRootView(
+                aCreateRoomRootState(
+                    eventSink = eventsRecorder,
+                ),
+                onNewRoomClick = it
+            )
+            rule.clickOn(R.string.screen_create_room_action_create_room)
+        }
+    }
+
+    @Config(qualifiers = "h1024dp")
+    @Test
+    fun `clicking on Invite people invokes the expected callback`() {
+        val eventsRecorder = EventsRecorder<StartChatEvents>(expectEvents = false)
+        ensureCalledOnce {
+            rule.setCreateRoomRootView(
+                aCreateRoomRootState(
+                    applicationName = "test",
+                    eventSink = eventsRecorder,
+                ),
+                onInviteFriendsClick = it
+            )
+            val text = rule.activity.getString(CommonStrings.action_invite_friends_to_app, "test")
+            rule.onNodeWithText(text).performClick()
+        }
+    }
+
+    @Config(qualifiers = "h1024dp")
+    @Test
+    fun `clicking on a user suggestion invokes the expected callback`() {
+        val recentDirectRoomList = aRecentDirectRoomList()
+        val firstRoom = recentDirectRoomList[0]
+        val eventsRecorder = EventsRecorder<StartChatEvents>(expectEvents = false)
+        ensureCalledOnceWithParam(firstRoom.roomId) {
+            rule.setCreateRoomRootView(
+                aCreateRoomRootState(
+                    userListState = aUserListState(
+                        recentDirectRooms = recentDirectRoomList
+                    ),
+                    eventSink = eventsRecorder,
+                ),
+                onOpenDM = it
+            )
+            rule.onNodeWithText(firstRoom.matrixUser.getBestName()).performClick()
+        }
+    }
+
+    @Config(qualifiers = "h1024dp")
+    @Test
+    fun `clicking on Join room by address invokes the expected callback`() {
+        val eventsRecorder = EventsRecorder<StartChatEvents>(expectEvents = false)
+        ensureCalledOnce {
+            rule.setCreateRoomRootView(
+                aCreateRoomRootState(
+                    eventSink = eventsRecorder,
+                ),
+                onJoinRoomByAddressClick = it
+            )
+            rule.clickOn(R.string.screen_start_chat_join_room_by_address_action)
+        }
+    }
+
+    @Test
+    fun `clicking on room directory invokes the expected callback`() {
+        val eventsRecorder = EventsRecorder<StartChatEvents>(expectEvents = false)
+        ensureCalledOnce {
+            rule.setCreateRoomRootView(
+                aCreateRoomRootState(
+                    eventSink = eventsRecorder,
+                    isRoomDirectorySearchEnabled = true
+                ),
+                onRoomDirectorySearchClick = it
+            )
+            rule.clickOn(R.string.screen_room_directory_search_title)
+        }
+    }
+}
+
+private fun <R : TestRule> AndroidComposeTestRule<R, ComponentActivity>.setCreateRoomRootView(
+    state: StartChatState,
+    onCloseClick: () -> Unit = EnsureNeverCalled(),
+    onNewRoomClick: () -> Unit = EnsureNeverCalled(),
+    onOpenDM: (RoomId) -> Unit = EnsureNeverCalledWithParam(),
+    onInviteFriendsClick: () -> Unit = EnsureNeverCalled(),
+    onJoinRoomByAddressClick: () -> Unit = EnsureNeverCalled(),
+    onRoomDirectorySearchClick: () -> Unit = EnsureNeverCalled(),
+) {
+    setContent {
+        CreateRoomRootView(
+            state = state,
+            onCloseClick = onCloseClick,
+            onNewRoomClick = onNewRoomClick,
+            onOpenDM = onOpenDM,
+            onInviteFriendsClick = onInviteFriendsClick,
+            onJoinByAddressClick = onJoinRoomByAddressClick,
+            onRoomDirectorySearchClick = onRoomDirectorySearchClick,
+        )
+    }
+}

features/startchat/impl/src/test/kotlin/io/element/android/features/startchat/impl/userlist/DefaultUserListPresenterTest.kt

@@ -0,0 +1,232 @@
+/*
+ * Copyright 2023, 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.
+ */
+
+package io.element.android.features.startchat.impl.userlist
+
+import app.cash.molecule.RecompositionMode
+import app.cash.molecule.moleculeFlow
+import app.cash.turbine.test
+import com.google.common.truth.Truth.assertThat
+import io.element.android.libraries.designsystem.theme.components.SearchBarResultState
+import io.element.android.libraries.matrix.test.FakeMatrixClient
+import io.element.android.libraries.matrix.ui.components.aMatrixUser
+import io.element.android.libraries.matrix.ui.components.aMatrixUserList
+import io.element.android.libraries.usersearch.api.UserSearchResult
+import io.element.android.libraries.usersearch.api.UserSearchResultState
+import io.element.android.libraries.usersearch.test.FakeUserRepository
+import io.element.android.tests.testutils.WarmUpRule
+import kotlinx.collections.immutable.persistentListOf
+import kotlinx.coroutines.test.runTest
+import org.junit.Rule
+import org.junit.Test
+
+class DefaultUserListPresenterTest {
+    @get:Rule
+    val warmUpRule = WarmUpRule()
+
+    private val userRepository = FakeUserRepository()
+
+    @Test
+    fun `present - initial state for single selection`() = runTest {
+        val presenter =
+            DefaultUserListPresenter(
+                UserListPresenterArgs(selectionMode = SelectionMode.Single),
+                userRepository,
+                UserListDataStore(),
+                FakeMatrixClient(),
+            )
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            skipItems(1)
+            val initialState = awaitItem()
+            assertThat(initialState.searchQuery).isEmpty()
+            assertThat(initialState.isMultiSelectionEnabled).isFalse()
+            assertThat(initialState.isSearchActive).isFalse()
+            assertThat(initialState.selectedUsers).isEmpty()
+            assertThat(initialState.searchResults).isInstanceOf(SearchBarResultState.Initial::class.java)
+        }
+    }
+
+    @Test
+    fun `present - initial state for multiple selection`() = runTest {
+        val presenter =
+            DefaultUserListPresenter(
+                UserListPresenterArgs(selectionMode = SelectionMode.Multiple),
+                userRepository,
+                UserListDataStore(),
+                FakeMatrixClient(),
+            )
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            skipItems(1)
+            val initialState = awaitItem()
+            assertThat(initialState.searchQuery).isEmpty()
+            assertThat(initialState.isMultiSelectionEnabled).isTrue()
+            assertThat(initialState.isSearchActive).isFalse()
+            assertThat(initialState.selectedUsers).isEmpty()
+            assertThat(initialState.searchResults).isInstanceOf(SearchBarResultState.Initial::class.java)
+        }
+    }
+
+    @Test
+    fun `present - update search query`() = runTest {
+        val presenter =
+            DefaultUserListPresenter(
+                UserListPresenterArgs(selectionMode = SelectionMode.Single),
+                userRepository,
+                UserListDataStore(),
+                FakeMatrixClient(),
+            )
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            skipItems(1)
+            val initialState = awaitItem()
+
+            initialState.eventSink(UserListEvents.OnSearchActiveChanged(true))
+            assertThat(awaitItem().isSearchActive).isTrue()
+
+            val matrixIdQuery = "@name:matrix.org"
+            initialState.eventSink(UserListEvents.UpdateSearchQuery(matrixIdQuery))
+            assertThat(awaitItem().searchQuery).isEqualTo(matrixIdQuery)
+            assertThat(userRepository.providedQuery).isEqualTo(matrixIdQuery)
+            skipItems(1)
+
+            val notMatrixIdQuery = "name"
+            initialState.eventSink(UserListEvents.UpdateSearchQuery(notMatrixIdQuery))
+            assertThat(awaitItem().searchQuery).isEqualTo(notMatrixIdQuery)
+            assertThat(userRepository.providedQuery).isEqualTo(notMatrixIdQuery)
+            skipItems(1)
+
+            initialState.eventSink(UserListEvents.OnSearchActiveChanged(false))
+            assertThat(awaitItem().isSearchActive).isFalse()
+        }
+    }
+
+    @Test
+    fun `present - presents search results`() = runTest {
+        val presenter =
+            DefaultUserListPresenter(
+                UserListPresenterArgs(
+                    selectionMode = SelectionMode.Single,
+                ),
+                userRepository,
+                UserListDataStore(),
+                FakeMatrixClient(),
+            )
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            skipItems(1)
+            val initialState = awaitItem()
+
+            initialState.eventSink(UserListEvents.UpdateSearchQuery("alice"))
+            assertThat(initialState.searchResults).isInstanceOf(SearchBarResultState.Initial::class.java)
+            assertThat(userRepository.providedQuery).isEqualTo("alice")
+            skipItems(2)
+
+            // When the user repository emits a result, it's copied to the state
+            val result = UserSearchResultState(
+                results = listOf(UserSearchResult(aMatrixUser())),
+                isSearching = false,
+            )
+            userRepository.emitState(result)
+            awaitItem().also { state ->
+                assertThat(state.searchResults).isEqualTo(
+                    SearchBarResultState.Results(
+                        persistentListOf(UserSearchResult(aMatrixUser()))
+                    )
+                )
+                assertThat(state.showSearchLoader).isFalse()
+            }
+            // When the user repository emits another result, it replaces the previous value
+            val newResult = UserSearchResultState(
+                results = aMatrixUserList().map { UserSearchResult(it) },
+                isSearching = false,
+            )
+            userRepository.emitState(newResult)
+            awaitItem().also { state ->
+                assertThat(state.searchResults).isEqualTo(
+                    SearchBarResultState.Results(
+                        aMatrixUserList().map { UserSearchResult(it) }
+                    )
+                )
+                assertThat(state.showSearchLoader).isFalse()
+            }
+        }
+    }
+
+    @Test
+    fun `present - presents search results when not found`() = runTest {
+        val presenter =
+            DefaultUserListPresenter(
+                UserListPresenterArgs(
+                    selectionMode = SelectionMode.Single,
+                ),
+                userRepository,
+                UserListDataStore(),
+                FakeMatrixClient(),
+            )
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            skipItems(1)
+            val initialState = awaitItem()
+
+            initialState.eventSink(UserListEvents.UpdateSearchQuery("alice"))
+            assertThat(initialState.searchResults).isInstanceOf(SearchBarResultState.Initial::class.java)
+            assertThat(userRepository.providedQuery).isEqualTo("alice")
+            skipItems(2)
+
+            // When the results list is empty, the state is set to NoResults
+            userRepository.emitState(UserSearchResultState(results = emptyList(), isSearching = false))
+            assertThat(awaitItem().searchResults).isInstanceOf(SearchBarResultState.NoResultsFound::class.java)
+        }
+    }
+
+    @Test
+    fun `present - select a user`() = runTest {
+        val presenter =
+            DefaultUserListPresenter(
+                UserListPresenterArgs(selectionMode = SelectionMode.Single),
+                userRepository,
+                UserListDataStore(),
+                FakeMatrixClient(),
+            )
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            skipItems(1)
+            val initialState = awaitItem()
+
+            val userA = aMatrixUser("@userA:domain", "A")
+            val userB = aMatrixUser("@userB:domain", "B")
+            val userABis = aMatrixUser("@userA:domain", "A")
+            val userC = aMatrixUser("@userC:domain", "C")
+
+            initialState.eventSink(UserListEvents.AddToSelection(userA))
+            assertThat(awaitItem().selectedUsers).containsExactly(userA)
+
+            initialState.eventSink(UserListEvents.AddToSelection(userB))
+            assertThat(awaitItem().selectedUsers).containsExactly(userA, userB)
+
+            initialState.eventSink(UserListEvents.AddToSelection(userABis))
+            initialState.eventSink(UserListEvents.AddToSelection(userC))
+            // duplicated users should be ignored
+            assertThat(awaitItem().selectedUsers).containsExactly(userA, userB, userC)
+
+            initialState.eventSink(UserListEvents.RemoveFromSelection(userB))
+            assertThat(awaitItem().selectedUsers).containsExactly(userA, userC)
+            initialState.eventSink(UserListEvents.RemoveFromSelection(userA))
+            assertThat(awaitItem().selectedUsers).containsExactly(userC)
+            initialState.eventSink(UserListEvents.RemoveFromSelection(userC))
+            assertThat(awaitItem().selectedUsers).isEmpty()
+        }
+    }
+}

features/startchat/impl/src/test/kotlin/io/element/android/features/startchat/impl/userlist/FakeUserListPresenter.kt

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2023, 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.
+ */
+
+package io.element.android.features.startchat.impl.userlist
+
+import androidx.compose.runtime.Composable
+
+class FakeUserListPresenter : UserListPresenter {
+    private var state = aUserListState()
+
+    fun givenState(state: UserListState) {
+        this.state = state
+    }
+
+    @Composable
+    override fun present(): UserListState {
+        return state
+    }
+}

features/startchat/impl/src/test/kotlin/io/element/android/features/startchat/impl/userlist/FakeUserListPresenterFactory.kt

@@ -0,0 +1,20 @@
+/*
+ * Copyright 2023, 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.
+ */
+
+package io.element.android.features.startchat.impl.userlist
+
+import io.element.android.libraries.usersearch.api.UserRepository
+
+class FakeUserListPresenterFactory(
+    private val fakeUserListPresenter: FakeUserListPresenter = FakeUserListPresenter()
+) : UserListPresenter.Factory {
+    override fun create(
+        args: UserListPresenterArgs,
+        userRepository: UserRepository,
+        userListDataStore: UserListDataStore,
+    ): UserListPresenter = fakeUserListPresenter
+}

features/startchat/test/build.gradle.kts

@@ -0,0 +1,23 @@
+/*
+ * 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-compose-library")
+}
+
+android {
+    namespace = "io.element.android.features.invitepeople.test"
+}
+
+dependencies {
+    implementation(libs.coroutines.core)
+    implementation(projects.libraries.matrix.api)
+    implementation(projects.libraries.matrix.test)
+    implementation(projects.libraries.architecture)
+    implementation(projects.tests.testutils)
+    api(projects.features.startchat.api)
+}