Room setting: update join rules and guest access (#2442)

CHANGES.md

@@ -32,6 +32,7 @@ Features ✨:
  - Create DMs with users by scanning their QR code (#2025)
  - Add Invite friends quick invite actions (#2348)
  - Add friend by scanning QR code, show your code to friends (#2025)
+ - Room setting: update join rules and guest access (#2442)
 
 Improvements 🙌:
  - New room creation tile with quick action (#2346)

matrix-sdk-android-rx/src/main/java/org/matrix/android/sdk/rx/RxRoom.kt

@@ -35,6 +35,8 @@ import org.matrix.android.sdk.api.util.toOptional
 import io.reactivex.Completable
 import io.reactivex.Observable
 import io.reactivex.Single
+import org.matrix.android.sdk.api.session.room.model.GuestAccess
+import org.matrix.android.sdk.api.session.room.model.RoomJoinRules
 
 class RxRoom(private val room: Room) {
 
@@ -131,6 +133,10 @@ class RxRoom(private val room: Room) {
         room.updateHistoryReadability(readability, it)
     }
 
+    fun updateJoinRule(joinRules: RoomJoinRules?, guestAccess: GuestAccess?): Completable = completableBuilder<Unit> {
+        room.updateJoinRule(joinRules, guestAccess, it)
+    }
+
     fun updateAvatar(avatarUri: Uri, fileName: String): Completable = completableBuilder<Unit> {
         room.updateAvatar(avatarUri, fileName, it)
     }

matrix-sdk-android/src/main/java/org/matrix/android/sdk/api/session/room/state/StateService.kt

@@ -21,7 +21,9 @@ import androidx.lifecycle.LiveData
 import org.matrix.android.sdk.api.MatrixCallback
 import org.matrix.android.sdk.api.query.QueryStringValue
 import org.matrix.android.sdk.api.session.events.model.Event
+import org.matrix.android.sdk.api.session.room.model.GuestAccess
 import org.matrix.android.sdk.api.session.room.model.RoomHistoryVisibility
+import org.matrix.android.sdk.api.session.room.model.RoomJoinRules
 import org.matrix.android.sdk.api.util.Cancelable
 import org.matrix.android.sdk.api.util.JsonDict
 import org.matrix.android.sdk.api.util.Optional
@@ -50,6 +52,11 @@ interface StateService {
      */
     fun updateHistoryReadability(readability: RoomHistoryVisibility, callback: MatrixCallback<Unit>): Cancelable
 
+    /**
+     * Update the join rule and/or the guest access
+     */
+    fun updateJoinRule(joinRules: RoomJoinRules?, guestAccess: GuestAccess?, callback: MatrixCallback<Unit>): Cancelable
+
     /**
      * Update the avatar of the room
      */

matrix-sdk-android/src/main/java/org/matrix/android/sdk/internal/session/room/state/DefaultStateService.kt

@@ -25,8 +25,12 @@ import org.matrix.android.sdk.api.query.QueryStringValue
 import org.matrix.android.sdk.api.session.events.model.Event
 import org.matrix.android.sdk.api.session.events.model.EventType
 import org.matrix.android.sdk.api.session.events.model.toContent
+import org.matrix.android.sdk.api.session.room.model.GuestAccess
 import org.matrix.android.sdk.api.session.room.model.RoomCanonicalAliasContent
+import org.matrix.android.sdk.api.session.room.model.RoomGuestAccessContent
 import org.matrix.android.sdk.api.session.room.model.RoomHistoryVisibility
+import org.matrix.android.sdk.api.session.room.model.RoomJoinRules
+import org.matrix.android.sdk.api.session.room.model.RoomJoinRulesContent
 import org.matrix.android.sdk.api.session.room.state.StateService
 import org.matrix.android.sdk.api.util.Cancelable
 import org.matrix.android.sdk.api.util.JsonDict
@@ -133,6 +137,31 @@ internal class DefaultStateService @AssistedInject constructor(@Assisted private
         )
     }
 
+    override fun updateJoinRule(joinRules: RoomJoinRules?, guestAccess: GuestAccess?, callback: MatrixCallback<Unit>): Cancelable {
+        return taskExecutor.executorScope.launchToCallback(coroutineDispatchers.main, callback) {
+            if (joinRules != null) {
+                awaitCallback<Unit> {
+                    sendStateEvent(
+                            eventType = EventType.STATE_ROOM_JOIN_RULES,
+                            body = RoomJoinRulesContent(joinRules).toContent(),
+                            callback = it,
+                            stateKey = null
+                    )
+                }
+            }
+            if (guestAccess != null) {
+                awaitCallback<Unit> {
+                    sendStateEvent(
+                            eventType = EventType.STATE_ROOM_GUEST_ACCESS,
+                            body = RoomGuestAccessContent(guestAccess).toContent(),
+                            callback = it,
+                            stateKey = null
+                    )
+                }
+            }
+        }
+    }
+
     override fun updateAvatar(avatarUri: Uri, fileName: String, callback: MatrixCallback<Unit>): Cancelable {
         return taskExecutor.executorScope.launchToCallback(coroutineDispatchers.main, callback) {
             val response = fileUploader.uploadFromUri(avatarUri, fileName, "image/jpeg")

vector/src/main/java/im/vector/app/core/di/ScreenComponent.kt

@@ -69,6 +69,7 @@ import im.vector.app.features.roommemberprofile.devices.DeviceListBottomSheet
 import im.vector.app.features.roomprofile.RoomProfileActivity
 import im.vector.app.features.roomprofile.alias.detail.RoomAliasBottomSheet
 import im.vector.app.features.roomprofile.settings.historyvisibility.RoomHistoryVisibilityBottomSheet
+import im.vector.app.features.roomprofile.settings.joinrule.RoomJoinRuleBottomSheet
 import im.vector.app.features.settings.VectorSettingsActivity
 import im.vector.app.features.settings.devices.DeviceVerificationInfoBottomSheet
 import im.vector.app.features.share.IncomingShareActivity
@@ -157,6 +158,7 @@ interface ScreenComponent {
     fun inject(bottomSheet: RoomListQuickActionsBottomSheet)
     fun inject(bottomSheet: RoomAliasBottomSheet)
     fun inject(bottomSheet: RoomHistoryVisibilityBottomSheet)
+    fun inject(bottomSheet: RoomJoinRuleBottomSheet)
     fun inject(bottomSheet: VerificationBottomSheet)
     fun inject(bottomSheet: DeviceVerificationInfoBottomSheet)
     fun inject(bottomSheet: DeviceListBottomSheet)

vector/src/main/java/im/vector/app/core/di/ViewModelModule.kt

@@ -37,6 +37,7 @@ import im.vector.app.features.roomdirectory.RoomDirectorySharedActionViewModel
 import im.vector.app.features.roomprofile.RoomProfileSharedActionViewModel
 import im.vector.app.features.roomprofile.alias.detail.RoomAliasBottomSheetSharedActionViewModel
 import im.vector.app.features.roomprofile.settings.historyvisibility.RoomHistoryVisibilitySharedActionViewModel
+import im.vector.app.features.roomprofile.settings.joinrule.RoomJoinRuleSharedActionViewModel
 import im.vector.app.features.userdirectory.UserListSharedActionViewModel
 
 @Module
@@ -117,6 +118,11 @@ interface ViewModelModule {
     @ViewModelKey(RoomHistoryVisibilitySharedActionViewModel::class)
     fun bindRoomHistoryVisibilitySharedActionViewModel(viewModel: RoomHistoryVisibilitySharedActionViewModel): ViewModel
 
+    @Binds
+    @IntoMap
+    @ViewModelKey(RoomJoinRuleSharedActionViewModel::class)
+    fun bindRoomJoinRuleSharedActionViewModel(viewModel: RoomJoinRuleSharedActionViewModel): ViewModel
+
     @Binds
     @IntoMap
     @ViewModelKey(RoomDirectorySharedActionViewModel::class)

vector/src/main/java/im/vector/app/features/roomprofile/settings/RoomSettingsAction.kt

@@ -17,13 +17,17 @@
 package im.vector.app.features.roomprofile.settings
 
 import im.vector.app.core.platform.VectorViewModelAction
+import org.matrix.android.sdk.api.session.room.model.GuestAccess
 import org.matrix.android.sdk.api.session.room.model.RoomHistoryVisibility
+import org.matrix.android.sdk.api.session.room.model.RoomJoinRules
 
 sealed class RoomSettingsAction : VectorViewModelAction {
     data class SetAvatarAction(val avatarAction: RoomSettingsViewState.AvatarAction) : RoomSettingsAction()
     data class SetRoomName(val newName: String) : RoomSettingsAction()
     data class SetRoomTopic(val newTopic: String) : RoomSettingsAction()
     data class SetRoomHistoryVisibility(val visibility: RoomHistoryVisibility) : RoomSettingsAction()
+    data class SetRoomJoinRule(val roomJoinRule: RoomJoinRules?, val roomGuestAccess: GuestAccess?) : RoomSettingsAction()
+
     object Save : RoomSettingsAction()
     object Cancel : RoomSettingsAction()
 }

vector/src/main/java/im/vector/app/features/roomprofile/settings/RoomSettingsController.kt

@@ -26,6 +26,8 @@ import im.vector.app.features.form.formEditTextItem
 import im.vector.app.features.form.formEditableAvatarItem
 import im.vector.app.features.home.AvatarRenderer
 import im.vector.app.features.home.room.detail.timeline.format.RoomHistoryVisibilityFormatter
+import org.matrix.android.sdk.api.session.room.model.GuestAccess
+import org.matrix.android.sdk.api.session.room.model.RoomJoinRules
 import org.matrix.android.sdk.api.util.toMatrixItem
 import javax.inject.Inject
 
@@ -44,6 +46,7 @@ class RoomSettingsController @Inject constructor(
         fun onTopicChanged(topic: String)
         fun onHistoryVisibilityClicked()
         fun onRoomAliasesClicked()
+        fun onJoinRuleClicked()
     }
 
     private val dividerColor = colorProvider.getColorFromAttribute(R.attr.vctr_list_divider_color)
@@ -117,9 +120,33 @@ class RoomSettingsController @Inject constructor(
                 title = stringProvider.getString(R.string.room_settings_room_read_history_rules_pref_title),
                 subtitle = roomHistoryVisibilityFormatter.getSetting(data.newHistoryVisibility ?: data.currentHistoryVisibility),
                 dividerColor = dividerColor,
-                divider = false,
+                divider = true,
                 editable = data.actionPermissions.canChangeHistoryVisibility,
                 action = { if (data.actionPermissions.canChangeHistoryVisibility) callback?.onHistoryVisibilityClicked() }
         )
+
+        buildProfileAction(
+                id = "joinRule",
+                title = stringProvider.getString(R.string.room_settings_room_access_title),
+                subtitle = data.getJoinRuleWording(),
+                dividerColor = dividerColor,
+                divider = false,
+                editable = data.actionPermissions.canChangeJoinRule,
+                action = { if (data.actionPermissions.canChangeJoinRule) callback?.onJoinRuleClicked() }
+        )
+    }
+
+    private fun RoomSettingsViewState.getJoinRuleWording(): String {
+        val joinRule = newRoomJoinRules.newJoinRules ?: currentRoomJoinRules
+        val guestAccess = newRoomJoinRules.newGuestAccess ?: currentGuestAccess
+        return stringProvider.getString(if (joinRule == RoomJoinRules.INVITE) {
+            R.string.room_settings_room_access_entry_only_invited
+        } else {
+            if (guestAccess == GuestAccess.CanJoin) {
+                R.string.room_settings_room_access_entry_anyone_with_link_including_guest
+            } else {
+                R.string.room_settings_room_access_entry_anyone_with_link_apart_guest
+            }
+        })
     }
 }

vector/src/main/java/im/vector/app/features/roomprofile/settings/RoomSettingsFragment.kt

@@ -42,6 +42,8 @@ import im.vector.app.features.roomprofile.RoomProfileSharedAction
 import im.vector.app.features.roomprofile.RoomProfileSharedActionViewModel
 import im.vector.app.features.roomprofile.settings.historyvisibility.RoomHistoryVisibilitySharedActionViewModel
 import im.vector.app.features.roomprofile.settings.historyvisibility.RoomHistoryVisibilityBottomSheet
+import im.vector.app.features.roomprofile.settings.joinrule.RoomJoinRuleBottomSheet
+import im.vector.app.features.roomprofile.settings.joinrule.RoomJoinRuleSharedActionViewModel
 import kotlinx.android.synthetic.main.fragment_room_setting_generic.*
 import kotlinx.android.synthetic.main.merge_overlay_waiting_view.*
 import org.matrix.android.sdk.api.util.toMatrixItem
@@ -62,6 +64,8 @@ class RoomSettingsFragment @Inject constructor(
     private val viewModel: RoomSettingsViewModel by fragmentViewModel()
     private lateinit var roomProfileSharedActionViewModel: RoomProfileSharedActionViewModel
     private lateinit var roomHistoryVisibilitySharedActionViewModel: RoomHistoryVisibilitySharedActionViewModel
+    private lateinit var roomJoinRuleSharedActionViewModel: RoomJoinRuleSharedActionViewModel
+
     private val roomProfileArgs: RoomProfileArgs by args()
     private val galleryOrCameraDialogHelper = GalleryOrCameraDialogHelper(this, colorProvider)
 
@@ -73,6 +77,7 @@ class RoomSettingsFragment @Inject constructor(
         super.onViewCreated(view, savedInstanceState)
         roomProfileSharedActionViewModel = activityViewModelProvider.get(RoomProfileSharedActionViewModel::class.java)
         setupRoomHistoryVisibilitySharedActionViewModel()
+        setupRoomJoinRuleSharedActionViewModel()
         controller.callback = this
         setupToolbar(roomSettingsToolbar)
         roomSettingsRecyclerView.configureWith(controller, hasFixedSize = true)
@@ -91,6 +96,16 @@ class RoomSettingsFragment @Inject constructor(
         }
     }
 
+    private fun setupRoomJoinRuleSharedActionViewModel() {
+        roomJoinRuleSharedActionViewModel = activityViewModelProvider.get(RoomJoinRuleSharedActionViewModel::class.java)
+        roomJoinRuleSharedActionViewModel
+                .observe()
+                .subscribe { action ->
+                    viewModel.handle(RoomSettingsAction.SetRoomJoinRule(action.roomJoinRule, action.roomGuestAccess))
+                }
+                .disposeOnDestroyView()
+    }
+
     private fun setupRoomHistoryVisibilitySharedActionViewModel() {
         roomHistoryVisibilitySharedActionViewModel = activityViewModelProvider.get(RoomHistoryVisibilitySharedActionViewModel::class.java)
         roomHistoryVisibilitySharedActionViewModel
@@ -159,6 +174,13 @@ class RoomSettingsFragment @Inject constructor(
         roomProfileSharedActionViewModel.post(RoomProfileSharedAction.OpenRoomAliasesSettings)
     }
 
+    override fun onJoinRuleClicked()  = withState(viewModel) { state ->
+        val currentJoinRule = state.newRoomJoinRules.newJoinRules ?: state.currentRoomJoinRules
+        val currentGuestAccess = state.newRoomJoinRules.newGuestAccess ?: state.currentGuestAccess
+        RoomJoinRuleBottomSheet.newInstance(currentJoinRule, currentGuestAccess)
+                .show(childFragmentManager, "RoomJoinRuleBottomSheet")
+    }
+
     override fun onImageReady(uri: Uri?) {
         uri ?: return
         viewModel.handle(

vector/src/main/java/im/vector/app/features/roomprofile/settings/RoomSettingsViewModel.kt

@@ -33,7 +33,9 @@ import org.matrix.android.sdk.api.session.Session
 import org.matrix.android.sdk.api.session.events.model.EventType
 import org.matrix.android.sdk.api.session.events.model.toModel
 import org.matrix.android.sdk.api.session.room.model.RoomAvatarContent
+import org.matrix.android.sdk.api.session.room.model.RoomGuestAccessContent
 import org.matrix.android.sdk.api.session.room.model.RoomHistoryVisibilityContent
+import org.matrix.android.sdk.api.session.room.model.RoomJoinRulesContent
 import org.matrix.android.sdk.api.session.room.powerlevels.PowerLevelsHelper
 import org.matrix.android.sdk.rx.mapOptional
 import org.matrix.android.sdk.rx.rx
@@ -62,6 +64,8 @@ class RoomSettingsViewModel @AssistedInject constructor(@Assisted initialState:
     init {
         observeRoomSummary()
         observeRoomHistoryVisibility()
+        observeJoinRule()
+        observeGuestAccess()
         observeRoomAvatar()
         observeState()
     }
@@ -72,10 +76,12 @@ class RoomSettingsViewModel @AssistedInject constructor(@Assisted initialState:
                 RoomSettingsViewState::newName,
                 RoomSettingsViewState::newTopic,
                 RoomSettingsViewState::newHistoryVisibility,
+                RoomSettingsViewState::newRoomJoinRules,
                 RoomSettingsViewState::roomSummary) { avatarAction,
                                                       newName,
                                                       newTopic,
                                                       newHistoryVisibility,
+                                                      newJoinRule,
                                                       asyncSummary ->
             val summary = asyncSummary()
             setState {
@@ -84,6 +90,7 @@ class RoomSettingsViewModel @AssistedInject constructor(@Assisted initialState:
                                 || summary?.name != newName
                                 || summary?.topic != newTopic
                                 || (newHistoryVisibility != null && newHistoryVisibility != currentHistoryVisibility)
+                                || newJoinRule.hasChanged()
                 )
             }
         }
@@ -111,7 +118,11 @@ class RoomSettingsViewModel @AssistedInject constructor(@Assisted initialState:
                             canChangeName = powerLevelsHelper.isUserAllowedToSend(session.myUserId, true, EventType.STATE_ROOM_NAME),
                             canChangeTopic = powerLevelsHelper.isUserAllowedToSend(session.myUserId, true, EventType.STATE_ROOM_TOPIC),
                             canChangeHistoryVisibility = powerLevelsHelper.isUserAllowedToSend(session.myUserId, true,
-                                    EventType.STATE_ROOM_HISTORY_VISIBILITY)
+                                    EventType.STATE_ROOM_HISTORY_VISIBILITY),
+                            canChangeJoinRule = powerLevelsHelper.isUserAllowedToSend(session.myUserId, true,
+                                    EventType.STATE_ROOM_JOIN_RULES)
+                                    && powerLevelsHelper.isUserAllowedToSend(session.myUserId, true,
+                                    EventType.STATE_ROOM_GUEST_ACCESS)
                     )
                     setState { copy(actionPermissions = permissions) }
                 }
@@ -131,6 +142,32 @@ class RoomSettingsViewModel @AssistedInject constructor(@Assisted initialState:
                 .disposeOnClear()
     }
 
+    private fun observeGuestAccess() {
+        room.rx()
+                .liveStateEvent(EventType.STATE_ROOM_JOIN_RULES, QueryStringValue.NoCondition)
+                .mapOptional { it.content.toModel<RoomJoinRulesContent>() }
+                .unwrap()
+                .subscribe {
+                    it.joinRules?.let {
+                        setState { copy(currentRoomJoinRules = it) }
+                    }
+                }
+                .disposeOnClear()
+    }
+
+    private fun observeJoinRule() {
+        room.rx()
+                .liveStateEvent(EventType.STATE_ROOM_GUEST_ACCESS, QueryStringValue.NoCondition)
+                .mapOptional { it.content.toModel<RoomGuestAccessContent>() }
+                .unwrap()
+                .subscribe {
+                    it.guestAccess?.let {
+                        setState { copy(currentGuestAccess = it) }
+                    }
+                }
+                .disposeOnClear()
+    }
+
     /**
      * We do not want to use the fallback avatar url, which can be the other user avatar, or the current user avatar.
      */
@@ -151,11 +188,21 @@ class RoomSettingsViewModel @AssistedInject constructor(@Assisted initialState:
             is RoomSettingsAction.SetRoomName              -> setState { copy(newName = action.newName) }
             is RoomSettingsAction.SetRoomTopic             -> setState { copy(newTopic = action.newTopic) }
             is RoomSettingsAction.SetRoomHistoryVisibility -> setState { copy(newHistoryVisibility = action.visibility) }
+            is RoomSettingsAction.SetRoomJoinRule          -> handleSetRoomJoinRule(action)
             is RoomSettingsAction.Save                     -> saveSettings()
             is RoomSettingsAction.Cancel                   -> cancel()
         }.exhaustive
     }
 
+    private fun handleSetRoomJoinRule(action: RoomSettingsAction.SetRoomJoinRule) = withState { state ->
+        setState {
+            copy(newRoomJoinRules = RoomSettingsViewState.NewJoinRule(
+                    action.roomJoinRule.takeIf { it != state.currentRoomJoinRules },
+                    action.roomGuestAccess.takeIf { it != state.currentGuestAccess }
+            ))
+        }
+    }
+
     private fun handleSetAvatarAction(action: RoomSettingsAction.SetAvatarAction) {
         setState {
             deletePendingAvatar(this)
@@ -202,6 +249,10 @@ class RoomSettingsViewModel @AssistedInject constructor(@Assisted initialState:
             operationList.add(room.rx().updateHistoryReadability(state.newHistoryVisibility))
         }
 
+        if (state.newRoomJoinRules.hasChanged()) {
+            operationList.add(room.rx().updateJoinRule(state.newRoomJoinRules.newJoinRules, state.newRoomJoinRules.newGuestAccess))
+        }
+
         Observable
                 .fromIterable(operationList)
                 .concatMapCompletable { it }
@@ -212,7 +263,8 @@ class RoomSettingsViewModel @AssistedInject constructor(@Assisted initialState:
                                 deletePendingAvatar(this)
                                 copy(
                                         avatarAction = RoomSettingsViewState.AvatarAction.None,
-                                        newHistoryVisibility = null
+                                        newHistoryVisibility = null,
+                                        newRoomJoinRules = RoomSettingsViewState.NewJoinRule()
                                 )
                             }
                             _viewEvents.post(RoomSettingsViewEvents.Success)

vector/src/main/java/im/vector/app/features/roomprofile/settings/RoomSettingsViewState.kt

@@ -21,13 +21,17 @@ import com.airbnb.mvrx.Async
 import com.airbnb.mvrx.MvRxState
 import com.airbnb.mvrx.Uninitialized
 import im.vector.app.features.roomprofile.RoomProfileArgs
+import org.matrix.android.sdk.api.session.room.model.GuestAccess
 import org.matrix.android.sdk.api.session.room.model.RoomHistoryVisibility
+import org.matrix.android.sdk.api.session.room.model.RoomJoinRules
 import org.matrix.android.sdk.api.session.room.model.RoomSummary
 
 data class RoomSettingsViewState(
         val roomId: String,
         // Default value: https://matrix.org/docs/spec/client_server/r0.6.1#id88
         val currentHistoryVisibility: RoomHistoryVisibility = RoomHistoryVisibility.SHARED,
+        val currentRoomJoinRules: RoomJoinRules = RoomJoinRules.INVITE,
+        val currentGuestAccess: GuestAccess? = null,
         val roomSummary: Async<RoomSummary> = Uninitialized,
         val isLoading: Boolean = false,
         val currentRoomAvatarUrl: String? = null,
@@ -35,6 +39,7 @@ data class RoomSettingsViewState(
         val newName: String? = null,
         val newTopic: String? = null,
         val newHistoryVisibility: RoomHistoryVisibility? = null,
+        val newRoomJoinRules: NewJoinRule = NewJoinRule(),
         val showSaveAction: Boolean = false,
         val actionPermissions: ActionPermissions = ActionPermissions()
 ) : MvRxState {
@@ -45,7 +50,8 @@ data class RoomSettingsViewState(
             val canChangeAvatar: Boolean = false,
             val canChangeName: Boolean = false,
             val canChangeTopic: Boolean = false,
-            val canChangeHistoryVisibility: Boolean = false
+            val canChangeHistoryVisibility: Boolean = false,
+            val canChangeJoinRule: Boolean = false
     )
 
     sealed class AvatarAction {
@@ -54,4 +60,11 @@ data class RoomSettingsViewState(
         data class UpdateAvatar(val newAvatarUri: Uri,
                                 val newAvatarFileName: String) : AvatarAction()
     }
+
+    data class NewJoinRule(
+            val newJoinRules: RoomJoinRules? = null,
+            val newGuestAccess: GuestAccess? = null
+    ) {
+        fun hasChanged() = newJoinRules != null || newGuestAccess != null
+    }
 }

vector/src/main/java/im/vector/app/features/roomprofile/settings/joinrule/RoomJoinRuleAction.kt

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.app.features.roomprofile.settings.joinrule
+
+import androidx.annotation.DrawableRes
+import im.vector.app.core.ui.bottomsheet.BottomSheetGenericAction
+import org.matrix.android.sdk.api.session.room.model.GuestAccess
+import org.matrix.android.sdk.api.session.room.model.RoomJoinRules
+
+class RoomJoinRuleAction(
+        val roomJoinRule: RoomJoinRules,
+        val roomGuestAccess: GuestAccess?,
+        title: String,
+        @DrawableRes iconResId: Int,
+        isSelected: Boolean,
+        destructive: Boolean
+) : BottomSheetGenericAction(
+        title = title,
+        iconResId = iconResId,
+        isSelected = isSelected,
+        destructive = destructive
+)

vector/src/main/java/im/vector/app/features/roomprofile/settings/joinrule/RoomJoinRuleBottomSheet.kt

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.app.features.roomprofile.settings.joinrule
+
+import android.os.Bundle
+import android.os.Parcelable
+import android.view.View
+import com.airbnb.mvrx.fragmentViewModel
+import com.airbnb.mvrx.withState
+import im.vector.app.core.di.ScreenComponent
+import im.vector.app.core.ui.bottomsheet.BottomSheetGeneric
+import im.vector.app.core.ui.bottomsheet.BottomSheetGenericController
+import kotlinx.android.parcel.Parcelize
+import org.matrix.android.sdk.api.session.room.model.GuestAccess
+import org.matrix.android.sdk.api.session.room.model.RoomJoinRules
+import javax.inject.Inject
+
+@Parcelize
+data class RoomJoinRuleBottomSheetArgs(
+        val currentRoomJoinRule: RoomJoinRules,
+        val currentGuestAccess: GuestAccess?
+) : Parcelable
+
+class RoomJoinRuleBottomSheet : BottomSheetGeneric<RoomJoinRuleState, RoomJoinRuleAction>() {
+
+    private lateinit var roomJoinRuleSharedActionViewModel: RoomJoinRuleSharedActionViewModel
+    @Inject lateinit var controller: RoomJoinRuleController
+    @Inject lateinit var roomJoinRuleViewModelFactory: RoomJoinRuleViewModel.Factory
+    private val viewModel: RoomJoinRuleViewModel by fragmentViewModel(RoomJoinRuleViewModel::class)
+
+    override fun injectWith(injector: ScreenComponent) {
+        injector.inject(this)
+    }
+
+    override fun getController(): BottomSheetGenericController<RoomJoinRuleState, RoomJoinRuleAction> = controller
+
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        super.onViewCreated(view, savedInstanceState)
+        roomJoinRuleSharedActionViewModel = activityViewModelProvider.get(RoomJoinRuleSharedActionViewModel::class.java)
+    }
+
+    override fun didSelectAction(action: RoomJoinRuleAction) {
+        roomJoinRuleSharedActionViewModel.post(action)
+        dismiss()
+    }
+
+    override fun invalidate() = withState(viewModel) {
+        controller.setData(it)
+        super.invalidate()
+    }
+
+    companion object {
+        fun newInstance(currentRoomJoinRule: RoomJoinRules, currentGuestAccess: GuestAccess?): RoomJoinRuleBottomSheet {
+            return RoomJoinRuleBottomSheet().apply {
+                setArguments(RoomJoinRuleBottomSheetArgs(currentRoomJoinRule, currentGuestAccess))
+            }
+        }
+    }
+}

vector/src/main/java/im/vector/app/features/roomprofile/settings/joinrule/RoomJoinRuleController.kt

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.app.features.roomprofile.settings.joinrule
+
+import im.vector.app.R
+import im.vector.app.core.resources.StringProvider
+import im.vector.app.core.ui.bottomsheet.BottomSheetGenericController
+import org.matrix.android.sdk.api.session.room.model.GuestAccess
+import org.matrix.android.sdk.api.session.room.model.RoomJoinRules
+import javax.inject.Inject
+
+class RoomJoinRuleController @Inject constructor(
+        private val stringProvider: StringProvider
+) : BottomSheetGenericController<RoomJoinRuleState, RoomJoinRuleAction>() {
+
+    override fun getActions(state: RoomJoinRuleState): List<RoomJoinRuleAction> {
+        return listOf(
+                RoomJoinRuleAction(
+                        roomJoinRule = RoomJoinRules.INVITE,
+                        roomGuestAccess = null,
+                        title = stringProvider.getString(R.string.room_settings_room_access_entry_only_invited),
+                        iconResId = 0,
+                        isSelected = state.currentRoomJoinRule == RoomJoinRules.INVITE,
+                        destructive = false
+                ),
+                RoomJoinRuleAction(
+                        roomJoinRule = RoomJoinRules.PUBLIC,
+                        roomGuestAccess = GuestAccess.Forbidden,
+                        title = stringProvider.getString(R.string.room_settings_room_access_entry_anyone_with_link_apart_guest),
+                        iconResId = 0,
+                        isSelected = state.currentRoomJoinRule == RoomJoinRules.PUBLIC && state.currentGuestAccess == GuestAccess.Forbidden,
+                        destructive = false
+                ),
+                RoomJoinRuleAction(
+                        roomJoinRule = RoomJoinRules.PUBLIC,
+                        roomGuestAccess = GuestAccess.CanJoin,
+                        title = stringProvider.getString(R.string.room_settings_room_access_entry_anyone_with_link_including_guest),
+                        iconResId = 0,
+                        isSelected = state.currentRoomJoinRule == RoomJoinRules.PUBLIC && state.currentGuestAccess == GuestAccess.CanJoin,
+                        destructive = false
+                )
+        )
+    }
+}

vector/src/main/java/im/vector/app/features/roomprofile/settings/joinrule/RoomJoinRuleSharedActionViewModel.kt

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2019 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+package im.vector.app.features.roomprofile.settings.joinrule
+
+import im.vector.app.core.platform.VectorSharedActionViewModel
+import javax.inject.Inject
+
+class RoomJoinRuleSharedActionViewModel @Inject constructor()
+    : VectorSharedActionViewModel<RoomJoinRuleAction>()

vector/src/main/java/im/vector/app/features/roomprofile/settings/joinrule/RoomJoinRuleState.kt

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.app.features.roomprofile.settings.joinrule
+
+import im.vector.app.core.ui.bottomsheet.BottomSheetGenericState
+import org.matrix.android.sdk.api.session.room.model.GuestAccess
+import org.matrix.android.sdk.api.session.room.model.RoomJoinRules
+
+data class RoomJoinRuleState(
+        val currentRoomJoinRule: RoomJoinRules = RoomJoinRules.INVITE,
+        val currentGuestAccess: GuestAccess? = null
+) : BottomSheetGenericState() {
+
+    constructor(args: RoomJoinRuleBottomSheetArgs) : this(
+            currentRoomJoinRule = args.currentRoomJoinRule,
+            currentGuestAccess = args.currentGuestAccess
+    )
+}

vector/src/main/java/im/vector/app/features/roomprofile/settings/joinrule/RoomJoinRuleViewModel.kt

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2020 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package im.vector.app.features.roomprofile.settings.joinrule
+
+import com.airbnb.mvrx.FragmentViewModelContext
+import com.airbnb.mvrx.MvRxViewModelFactory
+import com.airbnb.mvrx.ViewModelContext
+import com.squareup.inject.assisted.Assisted
+import com.squareup.inject.assisted.AssistedInject
+import im.vector.app.core.platform.EmptyAction
+import im.vector.app.core.platform.EmptyViewEvents
+import im.vector.app.core.platform.VectorViewModel
+
+class RoomJoinRuleViewModel @AssistedInject constructor(@Assisted initialState: RoomJoinRuleState)
+    : VectorViewModel<RoomJoinRuleState, EmptyAction, EmptyViewEvents>(initialState) {
+
+    @AssistedInject.Factory
+    interface Factory {
+        fun create(initialState: RoomJoinRuleState): RoomJoinRuleViewModel
+    }
+
+    companion object : MvRxViewModelFactory<RoomJoinRuleViewModel, RoomJoinRuleState> {
+        @JvmStatic
+        override fun create(viewModelContext: ViewModelContext, state: RoomJoinRuleState): RoomJoinRuleViewModel? {
+            val fragment: RoomJoinRuleBottomSheet = (viewModelContext as FragmentViewModelContext).fragment()
+            return fragment.roomJoinRuleViewModelFactory.create(state)
+        }
+    }
+
+    override fun handle(action: EmptyAction) {
+        // No op
+    }
+}

vector/src/main/res/values/strings.xml

@@ -1023,6 +1023,7 @@
     <string name="room_settings_room_read_history_rules_pref_title">Room History Readability</string>
     <string name="room_settings_room_read_history_rules_pref_dialog_title">Who can read history?</string>
     <string name="room_settings_room_access_rules_pref_dialog_title">Who can access this room?</string>
+    <string name="room_settings_room_access_title">Room access</string>
 
     <!-- room settings : alias -->
     <string name="room_settings_alias_title">Room addresses</string>