mobile/element-android
mobile/element-android
1
0
Fork 0
mirror of https://github.com/element-hq/element-android synced 2024-10-07 00:31:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse source
This commit is contained in:
Benoit Marty 2020-11-26 22:23:25 +01:00 committed by Benoit Marty
parent 41dd67f1c1
commit a813610c04
18 changed files with 443 additions and 4 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
CHANGES.md
View file

@ -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)

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

@ -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)
}

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

@ -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
*/

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

@ -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")

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

@ -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)

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

@ -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)

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

@ -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()
}

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

@ -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
}
})
}
}

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

@ -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(

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

@ -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)

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

@ -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
}
}

36
vector/src/main/java/im/vector/app/features/roomprofile/settings/joinrule/RoomJoinRuleAction.kt Normal file
View file

@ -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
)

73
vector/src/main/java/im/vector/app/features/roomprofile/settings/joinrule/RoomJoinRuleBottomSheet.kt Normal file
View file

@ -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))
}
}
}
}

58
vector/src/main/java/im/vector/app/features/roomprofile/settings/joinrule/RoomJoinRuleController.kt Normal file
View file

@ -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
)
)
}
}

23
vector/src/main/java/im/vector/app/features/roomprofile/settings/joinrule/RoomJoinRuleSharedActionViewModel.kt Normal file
View file

@ -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>()

32
vector/src/main/java/im/vector/app/features/roomprofile/settings/joinrule/RoomJoinRuleState.kt Normal file
View file

@ -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
)
}

47
vector/src/main/java/im/vector/app/features/roomprofile/settings/joinrule/RoomJoinRuleViewModel.kt Normal file
View file

@ -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
}
}

1
vector/src/main/res/values/strings.xml
View file

@ -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>