Refactor the JoinRoom screen to take advantage of newer APIs and support more joinRule/membership combinations (i.e. invite required, restricted, banned) (#3685)

- expose the full RoomPreview and RoomMembershipDetails through their own proxies
- implement standard mocks for all the different combinations
- converge on a single room info provider
- rebuild all the previews
- prioritise the preview data over the room one.
This commit is contained in:
Stefan Ceriu
2025-01-20 19:07:11 +02:00
committed by GitHub
parent f20847f62b
commit 8577f53613
48 changed files with 504 additions and 248 deletions
@@ -27,7 +27,7 @@ struct JoinRoomScreen: View {
mainContent
}
} bottomContent: {
buttons
bottomContent
}
.alert(item: $context.alertInfo)
.background()
@@ -86,7 +86,7 @@ struct JoinRoomScreen: View {
.lineLimit(3)
}
if context.viewState.mode == .knock {
if context.viewState.mode == .knockable {
knockMessage
.padding(.top, 19)
}
@@ -148,27 +148,76 @@ struct JoinRoomScreen: View {
}
@ViewBuilder
var buttons: some View {
var bottomContent: some View {
switch context.viewState.mode {
case .loading, .unknown:
case .loading:
EmptyView()
case .knock:
case .joinable:
joinButton
case .unknown, .restricted: // If unknown, do our best.
VStack(spacing: 24) {
bottomNoticeMessage(L10n.screenJoinRoomJoinRestrictedMessage)
joinButton
}
case .knockable:
Button(L10n.screenJoinRoomKnockAction) { context.send(viewAction: .knock) }
.buttonStyle(.compound(.super))
case .knocked:
Button(L10n.screenJoinRoomCancelKnockAction) { context.send(viewAction: .cancelKnock) }
.buttonStyle(.compound(.secondary))
case .join:
Button(L10n.screenJoinRoomJoinAction) { context.send(viewAction: .join) }
.buttonStyle(.compound(.super))
case .inviteRequired:
bottomNoticeMessage(L10n.screenJoinRoomInviteRequiredMessage)
case .invited:
ViewThatFits {
HStack(spacing: 8) { inviteButtons }
VStack(spacing: 16) { inviteButtons }
}
case .banned(let sender, let reason):
if let sender, let reason {
bottomErrorMessage(title: L10n.screenJoinRoomBanByMessage(sender),
subtitle: L10n.screenJoinRoomBanReason(reason))
} else {
bottomErrorMessage(title: L10n.screenJoinRoomBanMessage, subtitle: nil)
}
}
}
func bottomNoticeMessage(_ notice: String) -> some View {
Label(notice, icon: \.info)
.labelStyle(.custom(spacing: 12, alignment: .top))
.font(.compound.bodyLGSemibold)
.foregroundStyle(.compound.textPrimary)
.frame(maxWidth: .infinity, alignment: .leading)
.padding()
.background(.compound.bgSubtleSecondary)
.cornerRadius(14, corners: .allCorners)
}
func bottomErrorMessage(title: String, subtitle: String?) -> some View {
Label {
VStack(alignment: .leading, spacing: 4) {
Text(title)
.font(.compound.bodyLGSemibold)
.foregroundStyle(.compound.textCriticalPrimary)
if let subtitle {
Text(subtitle)
.font(.compound.bodyMD)
.foregroundStyle(.compound.textSecondary)
}
}
} icon: {
CompoundIcon(\.error)
.foregroundStyle(.compound.iconCriticalPrimary)
}
.labelStyle(.custom(spacing: 12, alignment: .top))
.frame(maxWidth: .infinity, alignment: .leading)
.padding()
.background(.compound.bgSubtleSecondary)
.cornerRadius(14, corners: .allCorners)
}
@ViewBuilder
var inviteButtons: some View {
Button(L10n.actionDecline) { context.send(viewAction: .declineInvite) }
@@ -177,6 +226,11 @@ struct JoinRoomScreen: View {
.buttonStyle(.compound(.primary))
}
var joinButton: some View {
Button(L10n.screenJoinRoomJoinAction) { context.send(viewAction: .join) }
.buttonStyle(.compound(.super))
}
@ToolbarContentBuilder
private var toolbar: some ToolbarContent {
if context.viewState.mode == .knocked {
@@ -193,101 +247,75 @@ struct JoinRoomScreen: View {
struct JoinRoomScreen_Previews: PreviewProvider, TestablePreview {
static let unknownViewModel = makeViewModel(mode: .unknown)
static let knockViewModel = makeViewModel(mode: .knock)
static let joinViewModel = makeViewModel(mode: .join)
static let inviteViewModel = makeViewModel(mode: .invited)
static let joinableViewModel = makeViewModel(mode: .joinable)
static let restrictedViewModel = makeViewModel(mode: .restricted)
static let inviteRequiredViewModel = makeViewModel(mode: .inviteRequired)
static let invitedViewModel = makeViewModel(mode: .invited)
static let knockableViewModel = makeViewModel(mode: .knockable)
static let knockedViewModel = makeViewModel(mode: .knocked)
static let bannedViewModel = makeViewModel(mode: .banned(sender: "Bob", reason: "Spamming"))
static var previews: some View {
NavigationStack {
JoinRoomScreen(context: unknownViewModel.context)
}
.snapshotPreferences(expect: unknownViewModel.context.$viewState.map { state in
state.roomDetails != nil
})
.previewDisplayName("Unknown")
NavigationStack {
JoinRoomScreen(context: knockViewModel.context)
}
.snapshotPreferences(expect: knockViewModel.context.$viewState.map { state in
state.roomDetails != nil
})
.previewDisplayName("Knock")
NavigationStack {
JoinRoomScreen(context: joinViewModel.context)
}
.snapshotPreferences(expect: joinViewModel.context.$viewState.map { state in
state.roomDetails != nil
})
.previewDisplayName("Join")
NavigationStack {
JoinRoomScreen(context: inviteViewModel.context)
}
.snapshotPreferences(expect: inviteViewModel.context.$viewState.map { state in
state.roomDetails != nil
})
.previewDisplayName("Invite")
NavigationStack {
JoinRoomScreen(context: knockedViewModel.context)
}
.snapshotPreferences(expect: knockedViewModel.context.$viewState.map { state in
state.roomDetails != nil
})
.previewDisplayName("Knocked")
makePreview(viewModel: unknownViewModel, previewDisplayName: "Unknown")
makePreview(viewModel: joinableViewModel, previewDisplayName: "Joinable")
makePreview(viewModel: restrictedViewModel, previewDisplayName: "Restricted")
makePreview(viewModel: inviteRequiredViewModel, previewDisplayName: "InviteRequired")
makePreview(viewModel: invitedViewModel, previewDisplayName: "Invited")
makePreview(viewModel: knockableViewModel, previewDisplayName: "Knockable")
makePreview(viewModel: knockedViewModel, previewDisplayName: "Knocked")
makePreview(viewModel: bannedViewModel, previewDisplayName: "Banned")
}
static func makeViewModel(mode: JoinRoomScreenInteractionMode) -> JoinRoomScreenViewModel {
static func makePreview(viewModel: JoinRoomScreenViewModel, previewDisplayName: String) -> some View {
NavigationStack {
JoinRoomScreen(context: viewModel.context)
}
.snapshotPreferences(expect: viewModel.context.$viewState.map { state in
state.roomDetails != nil
})
.previewDisplayName(previewDisplayName)
}
static func makeViewModel(mode: JoinRoomScreenMode) -> JoinRoomScreenViewModel {
ServiceLocator.shared.settings.knockingEnabled = true
let clientProxy = ClientProxyMock(.init())
// swiftlint:disable:next large_tuple
let membership: (isJoined: Bool, isInvited: Bool, isPublic: Bool, canKnock: Bool) = switch mode {
case .loading, .unknown:
(false, false, false, false)
case .invited:
(false, true, false, false)
case .join:
(false, false, true, false)
case .knock:
(false, false, false, true)
case .knocked:
(false, false, false, false)
}
if mode == .unknown {
switch mode {
case .unknown:
clientProxy.roomPreviewForIdentifierViaReturnValue = .failure(.sdkError(ClientProxyMockError.generic))
} else {
switch mode {
case .knocked:
clientProxy.roomForIdentifierClosure = { _ in
.knocked(KnockedRoomProxyMock(.init(avatarURL: .mockMXCAvatar)))
}
case .invited:
clientProxy.roomForIdentifierClosure = { _ in
.invited(InvitedRoomProxyMock(.init(avatarURL: .mockMXCAvatar)))
}
default:
break
clientProxy.roomForIdentifierReturnValue = nil
case .joinable:
clientProxy.roomPreviewForIdentifierViaReturnValue = .success(RoomPreviewProxyMock.joinable)
clientProxy.roomForIdentifierReturnValue = nil
case .restricted:
clientProxy.roomPreviewForIdentifierViaReturnValue = .success(RoomPreviewProxyMock.restricted)
clientProxy.roomForIdentifierReturnValue = nil
case .inviteRequired:
clientProxy.roomPreviewForIdentifierViaReturnValue = .success(RoomPreviewProxyMock.inviteRequired)
clientProxy.roomForIdentifierReturnValue = nil
case .invited:
clientProxy.roomPreviewForIdentifierViaReturnValue = .success(RoomPreviewProxyMock.invited())
clientProxy.roomForIdentifierClosure = { _ in
.invited(InvitedRoomProxyMock(.init(avatarURL: .mockMXCAvatar)))
}
clientProxy.roomPreviewForIdentifierViaReturnValue = .success(.init(roomID: "1",
name: "The Three-Body Problem - 三体",
canonicalAlias: "#3🌞problem:matrix.org",
// swiftlint:disable:next line_length
topic: "“Science and technology were the only keys to opening the door to the future, and people approached science with the faith and sincerity of elementary school students.”",
avatarURL: .mockMXCAvatar,
memberCount: UInt(100),
isHistoryWorldReadable: nil,
isJoined: membership.isJoined,
isInvited: membership.isInvited,
isPublic: membership.isPublic,
canKnock: membership.canKnock))
case .knockable:
clientProxy.roomPreviewForIdentifierViaReturnValue = .success(RoomPreviewProxyMock.knockable)
clientProxy.roomForIdentifierReturnValue = nil
case .knocked:
clientProxy.roomPreviewForIdentifierViaReturnValue = .success(RoomPreviewProxyMock.knocked)
clientProxy.roomForIdentifierClosure = { _ in
.knocked(KnockedRoomProxyMock(.init(avatarURL: .mockMXCAvatar)))
}
case .banned:
clientProxy.roomPreviewForIdentifierViaReturnValue = .success(RoomPreviewProxyMock.banned)
clientProxy.roomForIdentifierClosure = { _ in
.banned
}
default:
break
}
ServiceLocator.shared.settings.knockingEnabled = true
return JoinRoomScreenViewModel(roomID: "1",
via: [],
appSettings: ServiceLocator.shared.settings,