Merge remote-tracking branch 'upstream/develop' into develop

features/createroom/impl/build.gradle.kts

@@ -40,6 +40,7 @@ dependencies {
     implementation(projects.libraries.usersearch.impl)
     implementation(projects.services.analytics.api)
     implementation(libs.coil.compose)
+    implementation(projects.libraries.featureflag.api)
     api(projects.features.createroom.api)
 
     testImplementation(libs.test.junit)
@@ -56,6 +57,7 @@ dependencies {
     testImplementation(projects.libraries.permissions.test)
     testImplementation(projects.libraries.usersearch.test)
     testImplementation(projects.features.createroom.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/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/CreateRoomConfig.kt

@@ -8,7 +8,7 @@
 package io.element.android.features.createroom.impl
 
 import android.net.Uri
-import io.element.android.features.createroom.impl.configureroom.RoomPrivacy
+import io.element.android.features.createroom.impl.configureroom.RoomVisibilityState
 import io.element.android.libraries.matrix.api.user.MatrixUser
 import kotlinx.collections.immutable.ImmutableList
 import kotlinx.collections.immutable.persistentListOf
@@ -18,5 +18,7 @@ data class CreateRoomConfig(
     val topic: String? = null,
     val avatarUri: Uri? = null,
     val invites: ImmutableList<MatrixUser> = persistentListOf(),
-    val privacy: RoomPrivacy = RoomPrivacy.Private,
-)
+    val roomVisibility: RoomVisibilityState = RoomVisibilityState.Private,
+) {
+    val isValid = roomName.isNullOrEmpty().not() && roomVisibility.isValid()
+}

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

@@ -8,7 +8,12 @@
 package io.element.android.features.createroom.impl
 
 import android.net.Uri
-import io.element.android.features.createroom.impl.configureroom.RoomPrivacy
+import io.element.android.features.createroom.impl.configureroom.RoomAccess
+import io.element.android.features.createroom.impl.configureroom.RoomAccessItem
+import io.element.android.features.createroom.impl.configureroom.RoomAddress
+import io.element.android.features.createroom.impl.configureroom.RoomAddressErrorState
+import io.element.android.features.createroom.impl.configureroom.RoomVisibilityItem
+import io.element.android.features.createroom.impl.configureroom.RoomVisibilityState
 import io.element.android.features.createroom.impl.di.CreateRoomScope
 import io.element.android.features.createroom.impl.userlist.UserListDataStore
 import io.element.android.libraries.androidutils.file.safeDelete
@@ -17,6 +22,7 @@ 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
 
@@ -31,28 +37,89 @@ class CreateRoomDataStore @Inject constructor(
             field = value
         }
 
-    fun getCreateRoomConfig(): Flow<CreateRoomConfig> = combine(
+    val createRoomConfigWithInvites: Flow<CreateRoomConfig> = combine(
         selectedUserListDataStore.selectedUsers(),
         createRoomConfigFlow,
     ) { selectedUsers, config ->
         config.copy(invites = selectedUsers.toImmutableList())
     }
 
-    fun setRoomName(roomName: String?) {
-        createRoomConfigFlow.tryEmit(createRoomConfigFlow.value.copy(roomName = roomName?.takeIf { it.isNotEmpty() }))
+    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()) {
+                        config.roomVisibility.copy(
+                            roomAddress = RoomAddress.AutoFilled(roomName),
+                        )
+                    } else {
+                        config.roomVisibility
+                    }
+                }
+                else -> config.roomVisibility
+            }
+             */
+            config.copy(
+                roomName = roomName.takeIf { it.isNotEmpty() },
+            )
+        }
     }
 
-    fun setTopic(topic: String?) {
-        createRoomConfigFlow.tryEmit(createRoomConfigFlow.value.copy(topic = topic?.takeIf { it.isNotEmpty() }))
+    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.tryEmit(createRoomConfigFlow.value.copy(avatarUri = uri))
+        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 -> RoomVisibilityState.Public(
+                        roomAddress = RoomAddress.AutoFilled(config.roomName.orEmpty()),
+                        roomAddressErrorState = RoomAddressErrorState.None,
+                        roomAccess = RoomAccess.Anyone,
+                    )
+                }
+            )
+        }
     }
 
-    fun setPrivacy(privacy: RoomPrivacy) {
-        createRoomConfigFlow.tryEmit(createRoomConfigFlow.value.copy(privacy = privacy))
+    fun setRoomAddress(address: String) {
+        createRoomConfigFlow.getAndUpdate { config ->
+            config.copy(
+                roomVisibility = when (config.roomVisibility) {
+                    is RoomVisibilityState.Public -> config.roomVisibility.copy(roomAddress = RoomAddress.Edited(address))
+                    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() {

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

@@ -7,16 +7,17 @@
 
 package io.element.android.features.createroom.impl.configureroom
 
-import io.element.android.features.createroom.impl.CreateRoomConfig
 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 RoomPrivacyChanged(val privacy: RoomPrivacy) : ConfigureRoomEvents
-    data class RemoveFromSelection(val matrixUser: MatrixUser) : ConfigureRoomEvents
-    data class CreateRoom(val config: CreateRoomConfig) : 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/createroom/impl/src/main/kotlin/io/element/android/features/createroom/impl/configureroom/ConfigureRoomPresenter.kt

@@ -24,6 +24,8 @@ 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
@@ -38,6 +40,7 @@ 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
 
 class ConfigureRoomPresenter @Inject constructor(
@@ -47,14 +50,17 @@ class ConfigureRoomPresenter @Inject constructor(
     private val mediaPreProcessor: MediaPreProcessor,
     private val analyticsService: AnalyticsService,
     permissionsPresenterFactory: PermissionsPresenter.Factory,
+    private val featureFlagService: FeatureFlagService,
 ) : 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 = dataStore.getCreateRoomConfig().collectAsState(CreateRoomConfig())
+        val createRoomConfig = dataStore.createRoomConfigWithInvites.collectAsState(CreateRoomConfig())
+        val homeserverName = remember { matrixClient.userIdServerName() }
+        val isKnockFeatureEnabled by featureFlagService.isFeatureEnabledFlow(FeatureFlags.Knock).collectAsState(initial = false)
 
         val cameraPhotoPicker = mediaPickerProvider.registerCameraPhotoPicker(
             onResult = { uri -> if (uri != null) dataStore.setAvatarUri(uri = uri, cached = true) },
@@ -92,9 +98,11 @@ class ConfigureRoomPresenter @Inject constructor(
             when (event) {
                 is ConfigureRoomEvents.RoomNameChanged -> dataStore.setRoomName(event.name)
                 is ConfigureRoomEvents.TopicChanged -> dataStore.setTopic(event.topic)
-                is ConfigureRoomEvents.RoomPrivacyChanged -> dataStore.setPrivacy(event.privacy)
-                is ConfigureRoomEvents.RemoveFromSelection -> dataStore.selectedUserListDataStore.removeUserFromSelection(event.matrixUser)
-                is ConfigureRoomEvents.CreateRoom -> createRoom(event.config)
+                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.value)
                 is ConfigureRoomEvents.HandleAvatarAction -> {
                     when (event.action) {
                         AvatarAction.ChoosePhoto -> galleryImagePicker.launch()
@@ -113,10 +121,12 @@ class ConfigureRoomPresenter @Inject constructor(
         }
 
         return ConfigureRoomState(
+            isKnockFeatureEnabled = isKnockFeatureEnabled,
             config = createRoomConfig.value,
             avatarActions = avatarActions,
             createRoomAction = createRoomAction.value,
             cameraPermissionState = cameraPermissionState,
+            homeserverName = homeserverName,
             eventSink = ::handleEvents,
         )
     }
@@ -127,21 +137,40 @@ class ConfigureRoomPresenter @Inject constructor(
     ) = launch {
         suspend {
             val avatarUrl = config.avatarUri?.let { uploadAvatar(it) }
-            val params = CreateRoomParameters(
-                name = config.roomName,
-                topic = config.topic,
-                isEncrypted = config.privacy == RoomPrivacy.Private,
-                isDirect = false,
-                visibility = if (config.privacy == RoomPrivacy.Public) RoomVisibility.PUBLIC else RoomVisibility.PRIVATE,
-                preset = if (config.privacy == RoomPrivacy.Public) RoomPreset.PUBLIC_CHAT else RoomPreset.PRIVATE_CHAT,
-                invite = config.invites.map { it.userId },
-                avatar = avatarUrl,
-            )
-            matrixClient.createRoom(params).getOrThrow()
-                .also {
+            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,
+                    canonicalAlias = config.roomVisibility.roomAddress()
+                )
+            } else {
+                CreateRoomParameters(
+                    name = config.roomName,
+                    topic = config.topic,
+                    isEncrypted = config.roomVisibility is RoomVisibilityState.Private,
+                    isDirect = false,
+                    visibility = RoomVisibility.PRIVATE,
+                    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)
     }