Iterate on Space related UI

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

@@ -82,10 +82,6 @@ class ConfigureRoomPresenter(
     private val cameraPermissionPresenter: PermissionsPresenter = permissionsPresenterFactory.create(android.Manifest.permission.CAMERA)
     private var pendingPermissionRequest = false
 
-    init {
-        dataStore.setIsSpace(isSpace)
-    }
-
     @Composable
     override fun present(): ConfigureRoomState {
         val canAddRoomToSpace by featureFlagService.isFeatureEnabledFlow(FeatureFlags.CreateSpaces).collectAsState(false)
@@ -123,9 +119,10 @@ class ConfigureRoomPresenter(
             } else {
                 persistentListOf()
             }
-
             val parentSpace = spaces.find { it.roomId == initialParentSpaceId }
-            parentSpace?.let { dataStore.setParentSpace(it) }
+            parentSpace?.let {
+                dataStore.setParentSpace(parentSpace = parentSpace, updateVisibility = true)
+            }
         }
 
         LaunchedEffect(cameraPermissionState.permissionGranted) {
@@ -152,21 +149,42 @@ class ConfigureRoomPresenter(
         // 2. If it has a parent space.
         // 3. If knocking is enabled.
         val parentSpace = createRoomConfig.parentSpace
-        val availableJoinRules = remember(createRoomConfig.parentSpace, isSpace, isKnockFeatureEnabled) {
+        val availableJoinRules = remember(parentSpace, isSpace, isKnockFeatureEnabled) {
             when {
                 isSpace && parentSpace != null -> TODO("Adding a space to a parent space is not supported yet! How did you get here?")
                 parentSpace == null || parentSpace.joinRule == JoinRule.Public -> listOfNotNull(
                     JoinRuleItem.PublicVisibility.Public,
                     JoinRuleItem.PublicVisibility.AskToJoin.takeIf { !isSpace && isKnockFeatureEnabled },
-                    JoinRuleItem.Private,
+                    JoinRuleItem.PrivateVisibility.Private,
                 ).toImmutableList()
                 else -> listOfNotNull(
-                    JoinRuleItem.PublicVisibility.Restricted(parentSpace.roomId),
-                    JoinRuleItem.PublicVisibility.AskToJoinRestricted(parentSpace.roomId).takeIf { !isSpace && isKnockFeatureEnabled },
-                    JoinRuleItem.Private,
+                    JoinRuleItem.PrivateVisibility.Restricted(parentSpace.roomId),
+                    JoinRuleItem.PrivateVisibility.AskToJoinRestricted(parentSpace.roomId).takeIf { isKnockFeatureEnabled },
+                    JoinRuleItem.PrivateVisibility.Private,
                 ).toImmutableList()
             }
         }
+        val currentJoinRule = createRoomConfig.visibilityState.joinRuleItem
+        LaunchedEffect(availableJoinRules, currentJoinRule) {
+            // Find matching rule by type (ignoring parentSpaceId parameter for Restricted types)
+            val matchingRule = when (currentJoinRule) {
+                is JoinRuleItem.PrivateVisibility.Restricted ->
+                    availableJoinRules.filterIsInstance<JoinRuleItem.PrivateVisibility.Restricted>().firstOrNull()
+                is JoinRuleItem.PrivateVisibility.AskToJoinRestricted ->
+                    availableJoinRules.filterIsInstance<JoinRuleItem.PrivateVisibility.AskToJoinRestricted>().firstOrNull()
+                else -> availableJoinRules.find { it == currentJoinRule }
+            }
+            when {
+                matchingRule == null -> {
+                    // No matching type fallback to Private (always available)
+                    dataStore.setJoinRule(JoinRuleItem.PrivateVisibility.Private)
+                }
+                matchingRule != currentJoinRule -> {
+                    // Same type but different params (e.g., different parentSpaceId), update
+                    dataStore.setJoinRule(matchingRule)
+                }
+            }
+        }
 
         fun createRoom(config: CreateRoomConfig) {
             createRoomAction.value = AsyncAction.Uninitialized
@@ -193,7 +211,7 @@ class ConfigureRoomPresenter(
                     }
                 }
                 is ConfigureRoomEvents.SetParentSpace -> {
-                    dataStore.setParentSpace(event.space)
+                    dataStore.setParentSpace(event.space, false)
                 }
                 ConfigureRoomEvents.CancelCreateRoom -> {
                     createRoomAction.value = AsyncAction.Uninitialized
@@ -210,6 +228,7 @@ class ConfigureRoomPresenter(
             roomAddressValidity = roomAddressValidity.value,
             availableJoinRules = availableJoinRules,
             spaces = spaces,
+            isSpace = isSpace,
             eventSink = ::handleEvent,
         )
     }
@@ -220,35 +239,41 @@ class ConfigureRoomPresenter(
     ) = launch {
         suspend {
             val avatarUrl = config.avatarUri?.let { uploadAvatar(it.toUri()) }
-            val params = if (config.visibilityState is RoomVisibilityState.Public) {
-                CreateRoomParameters(
-                    name = config.roomName,
-                    topic = config.topic,
-                    isEncrypted = false,
-                    isDirect = false,
-                    visibility = RoomVisibility.Public,
-                    joinRuleOverride = config.visibilityState.joinRuleItem.toJoinRule()
-                        // No need to specify the public join rule override, since the preset is already PUBLIC_CHAT
-                        .takeIf { it != JoinRule.Public },
-                    preset = RoomPreset.PUBLIC_CHAT,
-                    invite = config.invites.map { it.userId },
-                    avatar = avatarUrl,
-                    roomAliasName = config.visibilityState.roomAddress(),
-                    isSpace = isSpace,
-                )
-            } else {
-                CreateRoomParameters(
-                    name = config.roomName,
-                    topic = config.topic,
-                    isEncrypted = config.visibilityState is RoomVisibilityState.Private,
-                    isDirect = false,
-                    visibility = RoomVisibility.Private,
-                    historyVisibilityOverride = RoomHistoryVisibility.Invited,
-                    preset = RoomPreset.PRIVATE_CHAT,
-                    invite = config.invites.map { it.userId },
-                    avatar = avatarUrl,
-                    isSpace = isSpace,
-                )
+            val params = when (config.visibilityState) {
+                is RoomVisibilityState.Public -> {
+                    CreateRoomParameters(
+                        name = config.roomName,
+                        topic = config.topic,
+                        isEncrypted = false,
+                        isDirect = false,
+                        visibility = RoomVisibility.Public,
+                        joinRuleOverride = config.visibilityState.joinRuleItem.toJoinRule()
+                            // No need to specify the public join rule override, since the preset is already PUBLIC_CHAT
+                            .takeIf { it != JoinRule.Public },
+                        preset = RoomPreset.PUBLIC_CHAT,
+                        invite = config.invites.map { it.userId },
+                        avatar = avatarUrl,
+                        roomAliasName = config.visibilityState.roomAddress(),
+                        isSpace = isSpace,
+                    )
+                }
+                is RoomVisibilityState.Private -> {
+                    CreateRoomParameters(
+                        name = config.roomName,
+                        topic = config.topic,
+                        isEncrypted = true,
+                        isDirect = false,
+                        visibility = RoomVisibility.Private,
+                        historyVisibilityOverride = RoomHistoryVisibility.Invited,
+                        joinRuleOverride = config.visibilityState.joinRuleItem.toJoinRule()
+                            // No need to specify the Invite join rule override, since the preset is already PRIVATE_CHAT
+                            .takeIf { it != JoinRule.Invite },
+                        preset = RoomPreset.PRIVATE_CHAT,
+                        invite = config.invites.map { it.userId },
+                        avatar = avatarUrl,
+                        isSpace = isSpace,
+                    )
+                }
             }
             val roomId = matrixClient.createRoom(params)
                 .onFailure { failure ->

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

@@ -17,6 +17,7 @@ import io.element.android.libraries.permissions.api.PermissionsState
 import kotlinx.collections.immutable.ImmutableList
 
 data class ConfigureRoomState(
+    val isSpace: Boolean,
     val config: CreateRoomConfig,
     val avatarActions: ImmutableList<AvatarAction>,
     val createRoomAction: AsyncAction<RoomId>,
@@ -28,5 +29,6 @@ data class ConfigureRoomState(
     val eventSink: (ConfigureRoomEvents) -> Unit
 ) {
     val isValid: Boolean = config.roomName?.isNotEmpty() == true &&
-        (config.visibilityState is RoomVisibilityState.Private || roomAddressValidity == RoomAddressValidity.Valid)
+        (config.visibilityState is RoomVisibilityState.Private || roomAddressValidity == RoomAddressValidity.Valid) &&
+        config.visibilityState.joinRuleItem in availableJoinRules
 }

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

@@ -82,8 +82,8 @@ open class ConfigureRoomStateProvider : PreviewParameterProvider<ConfigureRoomSt
                 roomAddressValidity = RoomAddressValidity.Valid,
             ),
             aConfigureRoomState(
+                isSpace = true,
                 config = CreateRoomConfig(
-                    isSpace = true,
                     roomName = "Space 101",
                     topic = "Space topic for this space when the text goes onto multiple lines and is really long, there shouldn’t be more than 3 lines",
                     visibilityState = RoomVisibilityState.Public(
@@ -95,27 +95,23 @@ open class ConfigureRoomStateProvider : PreviewParameterProvider<ConfigureRoomSt
             ),
             aConfigureRoomState(
                 config = CreateRoomConfig(
-                    isSpace = false,
                     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",
                     parentSpace = null,
-                    visibilityState = RoomVisibilityState.Public(
-                        roomAddress = RoomAddress.AutoFilled("Space-101"),
-                        joinRuleItem = JoinRuleItem.PublicVisibility.Restricted(aSpaceRoom().roomId),
+                    visibilityState = RoomVisibilityState.Private(
+                        joinRuleItem = JoinRuleItem.PrivateVisibility.Restricted(aSpaceRoom().roomId),
                     ),
                 ),
                 spaces = listOf(aSpaceRoom()),
                 roomAddressValidity = RoomAddressValidity.Valid,
             ),
             aConfigureRoomState(
                 config = CreateRoomConfig(
-                    isSpace = false,
                     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",
                     parentSpace = aSpaceRoom(canonicalAlias = RoomAlias("#a-space-room:example.org")),
-                    visibilityState = RoomVisibilityState.Public(
-                        roomAddress = RoomAddress.AutoFilled("Space-101"),
-                        joinRuleItem = JoinRuleItem.PublicVisibility.Restricted(aSpaceRoom().roomId),
+                    visibilityState = RoomVisibilityState.Private(
+                        joinRuleItem = JoinRuleItem.PrivateVisibility.Restricted(aSpaceRoom().roomId),
                     ),
                 ),
                 spaces = listOf(aSpaceRoom()),
@@ -126,6 +122,7 @@ open class ConfigureRoomStateProvider : PreviewParameterProvider<ConfigureRoomSt
 
 fun aConfigureRoomState(
     config: CreateRoomConfig = CreateRoomConfig(),
+    isSpace: Boolean = false,
     isKnockFeatureEnabled: Boolean = true,
     avatarActions: List<AvatarAction> = emptyList(),
     createRoomAction: AsyncAction<RoomId> = AsyncAction.Uninitialized,
@@ -134,21 +131,22 @@ fun aConfigureRoomState(
     roomAddressValidity: RoomAddressValidity = RoomAddressValidity.Valid,
     availableVisibilityOptions: List<JoinRuleItem> = if (config.parentSpace != null) {
         listOfNotNull(
-            JoinRuleItem.PublicVisibility.Restricted(config.parentSpace.roomId),
-            JoinRuleItem.PublicVisibility.AskToJoinRestricted(config.parentSpace.roomId).takeIf { isKnockFeatureEnabled },
-            JoinRuleItem.Private,
+            JoinRuleItem.PrivateVisibility.Restricted(config.parentSpace.roomId),
+            JoinRuleItem.PrivateVisibility.AskToJoinRestricted(config.parentSpace.roomId).takeIf { isKnockFeatureEnabled },
+            JoinRuleItem.PrivateVisibility.Private,
         )
     } else {
         listOfNotNull(
             JoinRuleItem.PublicVisibility.Public,
             JoinRuleItem.PublicVisibility.AskToJoin.takeIf { isKnockFeatureEnabled },
-            JoinRuleItem.Private,
+            JoinRuleItem.PrivateVisibility.Private,
         )
     },
     spaces: List<SpaceRoom> = emptyList(),
     eventSink: (ConfigureRoomEvents) -> Unit = { },
 ) = ConfigureRoomState(
     config = config,
+    isSpace = isSpace,
     avatarActions = avatarActions.toImmutableList(),
     createRoomAction = createRoomAction,
     cameraPermissionState = cameraPermissionState,