implemented the ask to join restricted rule join UI, and added tests and previews for it.

ElementX/Resources/Localizations/en-US.lproj/Localizable.strings

@@ -230,6 +230,7 @@
 "common_light" = "Light";
 "common_line_copied_to_clipboard" = "Line copied to clipboard";
 "common_link_copied_to_clipboard" = "Link copied to clipboard";
+"common_link_new_device" = "Link new device";
 "common_loading" = "Loading…";
 "common_loading_more" = "Loading more…";
 "common_message" = "Message";
@@ -586,6 +587,9 @@
 "screen_leave_space_subtitle_only_last_admin" = "You will not be removed from the following room(s) because you're the only administrator:";
 "screen_leave_space_title" = "Leave %1$@?";
 "screen_leave_space_title_last_admin" = "You are the only admin for %1$@";
+"screen_link_new_device_desktop_computer" = "Desktop computer";
+"screen_link_new_device_mobile_device" = "Mobile device";
+"screen_link_new_device_title" = "What type of device do you want to link?";
 "screen_manage_authorized_spaces_header" = "Spaces where members can join the room without an invitation.";
 "screen_manage_authorized_spaces_title" = "Manage spaces";
 "screen_manage_authorized_spaces_unknown_space" = "(Unknown space)";
@@ -652,7 +656,9 @@
 "screen_roomlist_clear_filters" = "Clear filters";
 "screen_roomlist_tombstoned_room_description" = "This room has been upgraded";
 "screen_security_and_privacy_add_room_address_action" = "Add address";
+"screen_security_and_privacy_ask_to_join_multiple_spaces_members_option_description" = "Anyone in authorized spaces can join, but everyone else must request access.";
 "screen_security_and_privacy_ask_to_join_option_description" = "Everyone must request access.";
+"screen_security_and_privacy_ask_to_join_single_space_members_option_description" = "Anyone in %1$@ can join, but everyone else must request access.";
 "screen_security_and_privacy_enable_encryption_alert_confirm_button_title" = "Yes, enable encryption";
 "screen_security_and_privacy_enable_encryption_alert_description" = "Once enabled, encryption for a room cannot be disabled, Message history will only be visible for room members since they were invited or since they joined the room.\nNo one besides the room members will be able to read messages. This may prevent bots and bridges to work correctly.\nWe do not recommend enabling encryption for rooms that anyone can find and join.";
 "screen_security_and_privacy_enable_encryption_alert_title" = "Enable encryption?";

ElementX/Resources/Localizations/en.lproj/Localizable.strings

@@ -230,6 +230,7 @@
 "common_light" = "Light";
 "common_line_copied_to_clipboard" = "Line copied to clipboard";
 "common_link_copied_to_clipboard" = "Link copied to clipboard";
+"common_link_new_device" = "Link new device";
 "common_loading" = "Loading…";
 "common_loading_more" = "Loading more…";
 "common_message" = "Message";
@@ -586,6 +587,9 @@
 "screen_leave_space_subtitle_only_last_admin" = "You will not be removed from the following room(s) because you're the only administrator:";
 "screen_leave_space_title" = "Leave %1$@?";
 "screen_leave_space_title_last_admin" = "You are the only admin for %1$@";
+"screen_link_new_device_desktop_computer" = "Desktop computer";
+"screen_link_new_device_mobile_device" = "Mobile device";
+"screen_link_new_device_title" = "What type of device do you want to link?";
 "screen_manage_authorized_spaces_header" = "Spaces where members can join the room without an invitation.";
 "screen_manage_authorized_spaces_title" = "Manage spaces";
 "screen_manage_authorized_spaces_unknown_space" = "(Unknown space)";
@@ -652,7 +656,9 @@
 "screen_roomlist_clear_filters" = "Clear filters";
 "screen_roomlist_tombstoned_room_description" = "This room has been upgraded";
 "screen_security_and_privacy_add_room_address_action" = "Add address";
+"screen_security_and_privacy_ask_to_join_multiple_spaces_members_option_description" = "Anyone in authorized spaces can join, but everyone else must request access.";
 "screen_security_and_privacy_ask_to_join_option_description" = "Everyone must request access.";
+"screen_security_and_privacy_ask_to_join_single_space_members_option_description" = "Anyone in %1$@ can join, but everyone else must request access.";
 "screen_security_and_privacy_enable_encryption_alert_confirm_button_title" = "Yes, enable encryption";
 "screen_security_and_privacy_enable_encryption_alert_description" = "Once enabled, encryption for a room cannot be disabled, Message history will only be visible for room members since they were invited or since they joined the room.\nNo one besides the room members will be able to read messages. This may prevent bots and bridges to work correctly.\nWe do not recommend enabling encryption for rooms that anyone can find and join.";
 "screen_security_and_privacy_enable_encryption_alert_title" = "Enable encryption?";

ElementX/Sources/Generated/Strings.swift

@@ -508,6 +508,8 @@ internal enum L10n {
   internal static var commonLineCopiedToClipboard: String { return L10n.tr("Localizable", "common_line_copied_to_clipboard") }
   /// Link copied to clipboard
   internal static var commonLinkCopiedToClipboard: String { return L10n.tr("Localizable", "common_link_copied_to_clipboard") }
+  /// Link new device
+  internal static var commonLinkNewDevice: String { return L10n.tr("Localizable", "common_link_new_device") }
   /// Loading…
   internal static var commonLoading: String { return L10n.tr("Localizable", "common_loading") }
   /// Loading more…
@@ -1882,6 +1884,12 @@ internal enum L10n {
   internal static func screenLeaveSpaceTitleLastAdmin(_ p1: Any) -> String {
     return L10n.tr("Localizable", "screen_leave_space_title_last_admin", String(describing: p1))
   }
+  /// Desktop computer
+  internal static var screenLinkNewDeviceDesktopComputer: String { return L10n.tr("Localizable", "screen_link_new_device_desktop_computer") }
+  /// Mobile device
+  internal static var screenLinkNewDeviceMobileDevice: String { return L10n.tr("Localizable", "screen_link_new_device_mobile_device") }
+  /// What type of device do you want to link?
+  internal static var screenLinkNewDeviceTitle: String { return L10n.tr("Localizable", "screen_link_new_device_title") }
   /// This account has been deactivated.
   internal static var screenLoginErrorDeactivatedAccount: String { return L10n.tr("Localizable", "screen_login_error_deactivated_account") }
   /// Incorrect username and/or password
@@ -2770,10 +2778,16 @@ internal enum L10n {
   internal static var screenRoomlistTombstonedRoomDescription: String { return L10n.tr("Localizable", "screen_roomlist_tombstoned_room_description") }
   /// Add address
   internal static var screenSecurityAndPrivacyAddRoomAddressAction: String { return L10n.tr("Localizable", "screen_security_and_privacy_add_room_address_action") }
+  /// Anyone in authorized spaces can join, but everyone else must request access.
+  internal static var screenSecurityAndPrivacyAskToJoinMultipleSpacesMembersOptionDescription: String { return L10n.tr("Localizable", "screen_security_and_privacy_ask_to_join_multiple_spaces_members_option_description") }
   /// Everyone must request access.
   internal static var screenSecurityAndPrivacyAskToJoinOptionDescription: String { return L10n.tr("Localizable", "screen_security_and_privacy_ask_to_join_option_description") }
   /// Ask to join
   internal static var screenSecurityAndPrivacyAskToJoinOptionTitle: String { return L10n.tr("Localizable", "screen_security_and_privacy_ask_to_join_option_title") }
+  /// Anyone in %1$@ can join, but everyone else must request access.
+  internal static func screenSecurityAndPrivacyAskToJoinSingleSpaceMembersOptionDescription(_ p1: Any) -> String {
+    return L10n.tr("Localizable", "screen_security_and_privacy_ask_to_join_single_space_members_option_description", String(describing: p1))
+  }
   /// Yes, enable encryption
   internal static var screenSecurityAndPrivacyEnableEncryptionAlertConfirmButtonTitle: String { return L10n.tr("Localizable", "screen_security_and_privacy_enable_encryption_alert_confirm_button_title") }
   /// Once enabled, encryption for a room cannot be disabled, Message history will only be visible for room members since they were invited or since they joined the room.

ElementX/Sources/Screens/SecurityAndPrivacyScreen/SecurityAndPrivacyScreenModels.swift

@@ -74,6 +74,14 @@ struct SecurityAndPrivacyScreenViewState: BindableState {
         isSpaceSettingsEnabled && selectableSpacesCount > 0
     }
     
+    var isAskToJoinWithSpaceMembersOptionAvailable: Bool {
+        currentSettings.accessType.isAskToJoinWithSpaceUsers || isAskToJoinWithSpaceMembersOptionSelectable
+    }
+    
+    var isAskToJoinWithSpaceMembersOptionSelectable: Bool {
+        isSpaceMembersOptionSelectable && isKnockingEnabled
+    }
+    
     var spaceMembersDescription: String {
         if isSpaceMembersOptionSelectable {
             switch spaceSelection {
@@ -89,10 +97,27 @@ struct SecurityAndPrivacyScreenViewState: BindableState {
         }
     }
     
+    var askToJoinWithSpaceMembersDescription: String {
+        if isAskToJoinWithSpaceMembersOptionSelectable {
+            switch spaceSelection {
+            case .singleJoined(let joinedParentSpace):
+                L10n.screenSecurityAndPrivacyAskToJoinSingleSpaceMembersOptionDescription(joinedParentSpace.name)
+            case .singleUnknown(let id):
+                L10n.screenSecurityAndPrivacyAskToJoinSingleSpaceMembersOptionDescription(id)
+            case .multiple, .empty:
+                L10n.screenSecurityAndPrivacyAskToJoinMultipleSpacesMembersOptionDescription
+            }
+        } else {
+            L10n.screenSecurityAndPrivacyRoomAccessSpaceMembersOptionUnavailableDescription
+        }
+    }
+    
     var accessSectionFooter: AttributedString? {
-        if bindings.desiredSettings.accessType.isSpaceUsers,
+        if (bindings.desiredSettings.accessType.isSpaceUsers &&
-           isSpaceMembersOptionSelectable,
+            isSpaceMembersOptionSelectable) ||
-           case .multiple = spaceSelection {
+            (bindings.desiredSettings.accessType.isAskToJoinWithSpaceUsers &&
+                isAskToJoinWithSpaceMembersOptionSelectable),
+            case .multiple = spaceSelection {
             Self.accessSectionFooterAttributedString
         } else {
             nil
@@ -116,8 +141,8 @@ struct SecurityAndPrivacyScreenViewState: BindableState {
         } else if selectableSpacesCount > 1 {
             .multiple
         } else if let joinedParent = joinedParentSpaces.first {
-            if case let .spaceUsers(ids) = currentSettings.accessType {
+            if currentSettings.accessType.isSpaceUsers || currentSettings.accessType.isAskToJoinWithSpaceUsers {
-                if ids.isEmpty {
+                if currentSettings.accessType.spaceIDs.isEmpty {
                     // Edge case where the access type is already space members, but it does not contain any id
                     // So if the user wants to add their own parent they need to do it from the selection menu
                     .multiple
@@ -185,6 +210,15 @@ enum SecurityAndPrivacyRoomAccessType: Equatable {
         }
     }
     
+    var isAskToJoinWithSpaceUsers: Bool {
+        switch self {
+        case .askToJoinWithSpaceUsers:
+            true
+        default:
+            false
+        }
+    }
+    
     var isAddressRequired: Bool {
         switch self {
         case .inviteOnly, .spaceUsers:
@@ -215,6 +249,7 @@ enum SecurityAndPrivacyScreenViewAction {
     case tryUpdatingEncryption(Bool)
     case editAddress
     case selectedSpaceMembersAccess
+    case selectedAskToJoinWithSpaceMembersAccess
     case manageSpaces
 }
 

ElementX/Sources/Screens/SecurityAndPrivacyScreen/SecurityAndPrivacyScreenViewModel.swift

@@ -81,7 +81,9 @@ class SecurityAndPrivacyScreenViewModel: SecurityAndPrivacyScreenViewModelType,
         case .selectedSpaceMembersAccess:
             handleSelectedSpaceMembersAccess()
         case .manageSpaces:
-            displayManageAuthorizedSpacesScreen()
+            displayManageAuthorizedSpacesScreen(isAskToJoin: state.bindings.desiredSettings.accessType.isAskToJoinWithSpaceUsers)
+        case .selectedAskToJoinWithSpaceMembersAccess:
+            handleSelectedAskToJoinWithSpaceMembersAccess()
         }
     }
     
@@ -248,11 +250,29 @@ class SecurityAndPrivacyScreenViewModel: SecurityAndPrivacyScreenViewModelType,
         case .empty:
             break // Very edge case. We do nothing in this case.
         case .multiple:
-            displayManageAuthorizedSpacesScreen()
+            displayManageAuthorizedSpacesScreen(isAskToJoin: false)
         }
     }
     
-    private func displayManageAuthorizedSpacesScreen() {
+    private func handleSelectedAskToJoinWithSpaceMembersAccess() {
+        guard !state.bindings.desiredSettings.accessType.isAskToJoinWithSpaceUsers else {
+            // If the user is tapping the ask to join with space members access again we do nothing
+            return
+        }
+        
+        switch state.spaceSelection {
+        case .singleJoined(let joinedParent):
+            state.bindings.desiredSettings.accessType = .askToJoinWithSpaceUsers(spaceIDs: [joinedParent.id])
+        case .singleUnknown(let id):
+            state.bindings.desiredSettings.accessType = .askToJoinWithSpaceUsers(spaceIDs: [id])
+        case .empty:
+            break // Very edge case. We do nothing in this case.
+        case .multiple:
+            displayManageAuthorizedSpacesScreen(isAskToJoin: true)
+        }
+    }
+
+    private func displayManageAuthorizedSpacesScreen(isAskToJoin: Bool) {
         let joinedParentSpaces = state.joinedParentSpaces
         let unknownSpaceIDs = state.currentSettings.accessType.spaceIDs.filter { id in
             !joinedParentSpaces.contains { $0.id == id }
@@ -263,7 +283,8 @@ class SecurityAndPrivacyScreenViewModel: SecurityAndPrivacyScreenViewModelType,
                                                                   initialSelectedIDs: selectedIDs)
         authorizedSpacesSelection.selectedIDs
             .sink { [weak self] desiredSelectedIDs in
-                self?.state.bindings.desiredSettings.accessType = .spaceUsers(spaceIDs: desiredSelectedIDs.sorted())
+                let sortedIDs = desiredSelectedIDs.sorted()
+                self?.state.bindings.desiredSettings.accessType = isAskToJoin ? .askToJoinWithSpaceUsers(spaceIDs: sortedIDs) : .spaceUsers(spaceIDs: sortedIDs)
             }
             .store(in: &cancellables)
         
@@ -334,20 +355,24 @@ private extension Optional where Wrapped == JoinRule {
             return .anyone
         case .invite:
             return .inviteOnly
-        case .knock, .knockRestricted:
+        case .knock:
-            // TODO: Handle knock restricted with rules
             return .askToJoin
+        case .knockRestricted(let rules):
+            return .askToJoinWithSpaceUsers(spaceIDs: Self.spaceIDs(from: rules))
         case .restricted(let rules):
-            let spaceIDs = rules.compactMap { rule in
+            return .spaceUsers(spaceIDs: Self.spaceIDs(from: rules))
-                if case let .roomMembership(id) = rule {
-                    id
-                } else {
-                    nil
-                }
-            }
-            return .spaceUsers(spaceIDs: spaceIDs)
         default:
             return .inviteOnly
         }
     }
+    
+    private static func spaceIDs(from rules: [AllowRule]) -> [String] {
+        rules.compactMap { rule in
+            if case let .roomMembership(id) = rule {
+                id
+            } else {
+                nil
+            }
+        }
+    }
 }

ElementX/Sources/Screens/SecurityAndPrivacyScreen/View/SecurityAndPrivacyScreen.swift

@@ -50,13 +50,6 @@ struct SecurityAndPrivacyScreen: View {
                                     description: L10n.screenSecurityAndPrivacyRoomAccessAnyoneOptionDescription,
                                     icon: \.public),
                     kind: .selection(isSelected: context.desiredSettings.accessType == .anyone) { context.desiredSettings.accessType = .anyone })
-            if context.viewState.isKnockingEnabled || context.viewState.currentSettings.accessType == .askToJoin {
-                ListRow(label: .default(title: L10n.screenSecurityAndPrivacyAskToJoinOptionTitle,
-                                        description: L10n.screenSecurityAndPrivacyAskToJoinOptionDescription,
-                                        icon: \.userAdd),
-                        kind: .selection(isSelected: context.desiredSettings.accessType == .askToJoin) { context.desiredSettings.accessType = .askToJoin })
-                    .disabled(!context.viewState.isKnockingEnabled)
-            }
             
             if context.viewState.isSpaceMembersOptionAvailable {
                 ListRow(label: .default(title: L10n.screenSecurityAndPrivacyRoomAccessSpaceMembersOptionTitle,
@@ -68,6 +61,17 @@ struct SecurityAndPrivacyScreen: View {
                         .disabled(!context.viewState.isSpaceMembersOptionSelectable)
             }
             
+            if context.viewState.currentSettings.accessType == .askToJoin {
+                askToJoinOption
+            }
+            
+            // Ask to join and askToJoin with space members can coexist if the initial setting is ask to join but the space members option is available otherwise it's either one or the other.
+            if context.viewState.isAskToJoinWithSpaceMembersOptionAvailable {
+                askToJoinWithSpaceMembersOption
+            } else if context.viewState.isKnockingEnabled, context.viewState.currentSettings.accessType != .askToJoin {
+                askToJoinOption
+            }
+            
             ListRow(label: .default(title: L10n.screenSecurityAndPrivacyRoomAccessInviteOnlyOptionTitle,
                                     description: L10n.screenSecurityAndPrivacyRoomAccessInviteOnlyOptionDescription,
                                     icon: \.lock),
@@ -87,6 +91,22 @@ struct SecurityAndPrivacyScreen: View {
         }
     }
     
+    private var askToJoinOption: some View {
+        ListRow(label: .default(title: L10n.screenSecurityAndPrivacyAskToJoinOptionTitle,
+                                description: L10n.screenSecurityAndPrivacyAskToJoinOptionDescription,
+                                icon: \.userAdd),
+                kind: .selection(isSelected: context.desiredSettings.accessType == .askToJoin) { context.desiredSettings.accessType = .askToJoin })
+            .disabled(!context.viewState.isKnockingEnabled)
+    }
+    
+    private var askToJoinWithSpaceMembersOption: some View {
+        ListRow(label: .default(title: L10n.screenSecurityAndPrivacyAskToJoinOptionTitle,
+                                description: context.viewState.askToJoinWithSpaceMembersDescription,
+                                icon: \.userAdd),
+                kind: .selection(isSelected: context.desiredSettings.accessType.isAskToJoinWithSpaceUsers) { context.send(viewAction: .selectedAskToJoinWithSpaceMembersAccess) })
+            .disabled(!context.viewState.isAskToJoinWithSpaceMembersOptionSelectable)
+    }
+    
     @ViewBuilder
     private var encryptionSection: some View {
         let binding = Binding<Bool>(get: {
@@ -286,6 +306,42 @@ struct SecurityAndPrivacyScreen_Previews: PreviewProvider, TestablePreview {
                                                  appSettings: appSettings)
     }()
     
+    static let singleAskToJoinSpaceMembersViewModel = {
+        AppSettings.resetAllSettings()
+        let appSettings = AppSettings()
+        appSettings.spaceSettingsEnabled = true
+        appSettings.knockingEnabled = true
+        let space = [SpaceRoomProxyProtocol].mockSingleRoom[0]
+        
+        return SecurityAndPrivacyScreenViewModel(roomProxy: JoinedRoomProxyMock(.init(isEncrypted: false,
+                                                                                      canonicalAlias: "#room:matrix.org",
+                                                                                      members: .allMembersAsCreator,
+                                                                                      joinRule: .knockRestricted(rules: [.roomMembership(roomId: space.id)]),
+                                                                                      isVisibleInPublicDirectory: true)),
+                                                 clientProxy: ClientProxyMock(.init(userIDServerName: "matrix.org",
+                                                                                    spaceServiceConfiguration: .init(joinedParentSpaces: [space]))),
+                                                 userIndicatorController: UserIndicatorControllerMock(),
+                                                 appSettings: appSettings)
+    }()
+    
+    static let multipleAskToJoinSpacesMembersViewModel = {
+        AppSettings.resetAllSettings()
+        let appSettings = AppSettings()
+        appSettings.spaceSettingsEnabled = true
+        appSettings.knockingEnabled = true
+        let spaces = [SpaceRoomProxyProtocol].mockJoinedSpaces
+        
+        return SecurityAndPrivacyScreenViewModel(roomProxy: JoinedRoomProxyMock(.init(isEncrypted: false,
+                                                                                      canonicalAlias: "#room:matrix.org",
+                                                                                      members: .allMembersAsCreator,
+                                                                                      joinRule: .knockRestricted(rules: spaces.map { .roomMembership(roomId: $0.id) }),
+                                                                                      isVisibleInPublicDirectory: true)),
+                                                 clientProxy: ClientProxyMock(.init(userIDServerName: "matrix.org",
+                                                                                    spaceServiceConfiguration: .init(joinedParentSpaces: spaces))),
+                                                 userIndicatorController: UserIndicatorControllerMock(),
+                                                 appSettings: appSettings)
+    }()
+    
     static let publicSpaceViewModel = {
         AppSettings.resetAllSettings()
         return SecurityAndPrivacyScreenViewModel(roomProxy: JoinedRoomProxyMock(.init(isSpace: true,
@@ -342,6 +398,22 @@ struct SecurityAndPrivacyScreen_Previews: PreviewProvider, TestablePreview {
         })
         .previewDisplayName("Ask to join room")
         
+        NavigationStack {
+            SecurityAndPrivacyScreen(context: singleAskToJoinSpaceMembersViewModel.context)
+        }
+        .snapshotPreferences(expect: singleAskToJoinSpaceMembersViewModel.context.$viewState.map { state in
+            state.currentSettings.isVisibileInRoomDirectory == true
+        })
+        .previewDisplayName("Ask to join with single space members room")
+        
+        NavigationStack {
+            SecurityAndPrivacyScreen(context: multipleAskToJoinSpacesMembersViewModel.context)
+        }
+        .snapshotPreferences(expect: multipleAskToJoinSpacesMembersViewModel.context.$viewState.map { state in
+            state.currentSettings.isVisibileInRoomDirectory == true
+        })
+        .previewDisplayName("Ask to join with multiple spaces members room")
+        
         NavigationStack {
             SecurityAndPrivacyScreen(context: publicSpaceViewModel.context)
         }

PreviewTests/Sources/__Snapshots__/PreviewTests/securityAndPrivacyScreen.Ask-to-join-with-multiple-spaces-members-room-iPad-en-GB.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:beb3917bac09663e50dc7759681e4c74f737789cc52edc08087a41db0e103a1a
+size 211544

PreviewTests/Sources/__Snapshots__/PreviewTests/securityAndPrivacyScreen.Ask-to-join-with-multiple-spaces-members-room-iPad-pseudo.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6dea2512291fb291cb74cddf5acaead1776d7286e0fbd51d65d811ef3abe7f3d
+size 262252

PreviewTests/Sources/__Snapshots__/PreviewTests/securityAndPrivacyScreen.Ask-to-join-with-multiple-spaces-members-room-iPhone-en-GB.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7c20f5acdf0bea460a75100551817860ab7f3db7d6049b179088bf695dc99c64
+size 147525

PreviewTests/Sources/__Snapshots__/PreviewTests/securityAndPrivacyScreen.Ask-to-join-with-multiple-spaces-members-room-iPhone-pseudo.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:befced025b5ae7210f72dfa9ec01b514ced1a64e20c22120ecde4636fd4f89d4
+size 179658

PreviewTests/Sources/__Snapshots__/PreviewTests/securityAndPrivacyScreen.Ask-to-join-with-single-space-members-room-iPad-en-GB.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bf83cc61198e77aa658cc17d57dbc1019569b2552bb341b90034f7345939e588
+size 198334

PreviewTests/Sources/__Snapshots__/PreviewTests/securityAndPrivacyScreen.Ask-to-join-with-single-space-members-room-iPad-pseudo.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:afd52028661858843b63bc99f715bd91fc10d5fb22b8eee3117875afee29722b
+size 248058

PreviewTests/Sources/__Snapshots__/PreviewTests/securityAndPrivacyScreen.Ask-to-join-with-single-space-members-room-iPhone-en-GB.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cf7256d898a8329af1c1153250d1492e377021de91aacd23544fe83cbf16edb2
+size 136320

PreviewTests/Sources/__Snapshots__/PreviewTests/securityAndPrivacyScreen.Ask-to-join-with-single-space-members-room-iPhone-pseudo.png

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1a48162c23078a6eac6e3afdbe16b8045bb558247ce956a18f8b8a84eb73ad9e
+size 170604

UnitTests/Sources/SecurityAndPrivacyScreenViewModelTests.swift

@@ -30,7 +30,7 @@ class SecurityAndPrivacyScreenViewModelTests: XCTestCase {
     func testSetSingleJoinedSpaceMembersAccess() async throws {
         let singleRoom = [SpaceRoomProxyProtocol].mockSingleRoom
         let space = singleRoom[0]
-        setupViewModel(isSpaceSettingsEnabled: true, joinedParentSpaces: singleRoom, joinRule: .public)
+        setupViewModel(joinedParentSpaces: singleRoom, joinRule: .public)
         
         let deferred = deferFulfillment(context.$viewState) { $0.joinedParentSpaces.count == 1 }
         try await deferred.fulfill()
@@ -58,10 +58,41 @@ class SecurityAndPrivacyScreenViewModelTests: XCTestCase {
         await fulfillment(of: [expectation])
     }
     
+    func testSetSingleJoinedAskToJoinWithSpaceMembersAccess() async throws {
+        let singleRoom = [SpaceRoomProxyProtocol].mockSingleRoom
+        let space = singleRoom[0]
+        setupViewModel(joinedParentSpaces: singleRoom, joinRule: .public)
+        
+        let deferred = deferFulfillment(context.$viewState) { $0.joinedParentSpaces.count == 1 }
+        try await deferred.fulfill()
+        
+        XCTAssertEqual(context.viewState.currentSettings.accessType, .anyone)
+        XCTAssertTrue(context.viewState.isSaveDisabled)
+        XCTAssertTrue(context.viewState.isAskToJoinWithSpaceMembersOptionSelectable)
+        guard case .singleJoined = context.viewState.spaceSelection else {
+            XCTFail("Expected spaceSelection to be .singleJoined")
+            return
+        }
+        
+        context.send(viewAction: .selectedAskToJoinWithSpaceMembersAccess)
+        XCTAssertEqual(context.desiredSettings.accessType, .askToJoinWithSpaceUsers(spaceIDs: [space.id]))
+        XCTAssertNil(context.viewState.accessSectionFooter)
+        XCTAssertFalse(context.viewState.isSaveDisabled)
+        
+        let expectation = expectation(description: "Join rule has updated")
+        roomProxy.updateJoinRuleClosure = { value in
+            XCTAssertEqual(value, .knockRestricted(rules: [.roomMembership(roomId: space.id)]))
+            expectation.fulfill()
+            return .success(())
+        }
+        context.send(viewAction: .save)
+        await fulfillment(of: [expectation])
+    }
+    
     func testSingleUnknownSpaceMembersAccessCanBeReselected() async throws {
         let singleRoom = [SpaceRoomProxyProtocol].mockSingleRoom
         let space = singleRoom[0]
-        setupViewModel(isSpaceSettingsEnabled: true, joinedParentSpaces: [], joinRule: .restricted(rules: [.roomMembership(roomId: space.id)]))
+        setupViewModel(joinedParentSpaces: [], joinRule: .restricted(rules: [.roomMembership(roomId: space.id)]))
         
         let deferred = deferFulfillment(context.$viewState) { $0.joinedParentSpaces.count == 0 }
         try await deferred.fulfill()
@@ -91,7 +122,7 @@ class SecurityAndPrivacyScreenViewModelTests: XCTestCase {
     
     func testMultipleKnownSpacesMembersSelection() async throws {
         let spaces = [SpaceRoomProxyProtocol].mockJoinedSpaces2
-        setupViewModel(isSpaceSettingsEnabled: true, joinedParentSpaces: spaces, joinRule: .public)
+        setupViewModel(joinedParentSpaces: spaces, joinRule: .public)
         
         let deferred = deferFulfillment(context.$viewState) { $0.joinedParentSpaces.count == 3 }
         try await deferred.fulfill()
@@ -133,10 +164,53 @@ class SecurityAndPrivacyScreenViewModelTests: XCTestCase {
         await fulfillment(of: [expectation])
     }
     
+    func testMultipleKnownAskToJoinSpacesMembersSelection() async throws {
+        let spaces = [SpaceRoomProxyProtocol].mockJoinedSpaces2
+        setupViewModel(joinedParentSpaces: spaces, joinRule: .public)
+        
+        let deferred = deferFulfillment(context.$viewState) { $0.joinedParentSpaces.count == 3 }
+        try await deferred.fulfill()
+        
+        XCTAssertEqual(context.viewState.currentSettings.accessType, .anyone)
+        XCTAssertTrue(context.viewState.isSaveDisabled)
+        XCTAssertTrue(context.viewState.isAskToJoinWithSpaceMembersOptionSelectable)
+        guard case .multiple = context.viewState.spaceSelection else {
+            XCTFail("Expected spaceSelection to be .multiple")
+            return
+        }
+        
+        var selectedIDs: PassthroughSubject<Set<String>, Never>!
+        let deferredAction = deferFulfillment(viewModel.actionsPublisher) { action in
+            switch action {
+            case .displayManageAuthorizedSpacesScreen(let authorizedSpacesSelection):
+                defer { selectedIDs = authorizedSpacesSelection.selectedIDs }
+                return authorizedSpacesSelection.joinedParentSpaces.map(\.id) == spaces.map(\.id) &&
+                    authorizedSpacesSelection.unknownSpacesIDs.isEmpty &&
+                    authorizedSpacesSelection.initialSelectedIDs.isEmpty
+            default:
+                return false
+            }
+        }
+        context.send(viewAction: .selectedAskToJoinWithSpaceMembersAccess)
+        try await deferredAction.fulfill()
+        selectedIDs.send([spaces[0].id])
+        XCTAssertEqual(context.desiredSettings.accessType, .askToJoinWithSpaceUsers(spaceIDs: [spaces[0].id]))
+        XCTAssertNotNil(context.viewState.accessSectionFooter)
+        XCTAssertFalse(context.viewState.isSaveDisabled)
+
+        let expectation = expectation(description: "Join rule has updated")
+        roomProxy.updateJoinRuleClosure = { value in
+            XCTAssertEqual(value, .knockRestricted(rules: [.roomMembership(roomId: spaces[0].id)]))
+            expectation.fulfill()
+            return .success(())
+        }
+        context.send(viewAction: .save)
+        await fulfillment(of: [expectation])
+    }
+    
     func testMultipleSpacesMembersSelection() async throws {
         let spaces = [SpaceRoomProxyProtocol].mockJoinedSpaces2
-        setupViewModel(isSpaceSettingsEnabled: true,
+        setupViewModel(joinedParentSpaces: spaces,
-                       joinedParentSpaces: spaces,
                        joinRule: .restricted(rules: [.roomMembership(roomId: "unknownSpaceID")]))
         
         let deferred = deferFulfillment(context.$viewState) { $0.selectableSpacesCount == 4 }
@@ -183,8 +257,7 @@ class SecurityAndPrivacyScreenViewModelTests: XCTestCase {
     func testEmptySpaceMembersSelectionEdgeCase() async throws {
         // Edge case where there is no available joined parents and the room has a restricted join rule.
         // With no space ids in it
-        setupViewModel(isSpaceSettingsEnabled: true,
+        setupViewModel(joinedParentSpaces: [],
-                       joinedParentSpaces: [],
                        joinRule: .restricted(rules: []))
         
         let deferred = deferFulfillment(context.$viewState) { $0.selectableSpacesCount == 0 }
@@ -204,8 +277,7 @@ class SecurityAndPrivacyScreenViewModelTests: XCTestCase {
         // Edge case where there is one available joined parent but the room has a restricted join rule.
         // With no space ids in it
         let singleRoom = [SpaceRoomProxyProtocol].mockSingleRoom
-        setupViewModel(isSpaceSettingsEnabled: true,
+        setupViewModel(joinedParentSpaces: singleRoom,
-                       joinedParentSpaces: singleRoom,
                        joinRule: .restricted(rules: []))
         
         let deferred = deferFulfillment(context.$viewState) { $0.selectableSpacesCount == 1 }
@@ -235,7 +307,7 @@ class SecurityAndPrivacyScreenViewModelTests: XCTestCase {
     }
     
     func testSave() async throws {
-        setupViewModel(isSpaceSettingsEnabled: false, joinedParentSpaces: [], joinRule: .public)
+        setupViewModel(joinedParentSpaces: [], joinRule: .public)
         
         // Saving shouldn't dismiss this screen (or trigger any other action).
         let deferred = deferFailure(viewModel.actionsPublisher, timeout: 1) { _ in true }
@@ -247,7 +319,7 @@ class SecurityAndPrivacyScreenViewModelTests: XCTestCase {
     }
     
     func testCancelWithChangesAndDiscard() async throws {
-        setupViewModel(isSpaceSettingsEnabled: false, joinedParentSpaces: [], joinRule: .public)
+        setupViewModel(joinedParentSpaces: [], joinRule: .public)
         context.desiredSettings.accessType = .inviteOnly
         XCTAssertFalse(context.viewState.isSaveDisabled)
         XCTAssertNil(context.alertInfo)
@@ -269,7 +341,7 @@ class SecurityAndPrivacyScreenViewModelTests: XCTestCase {
     }
     
     func testCancelWithChangesAndSave() async throws {
-        setupViewModel(isSpaceSettingsEnabled: false, joinedParentSpaces: [], joinRule: .public)
+        setupViewModel(joinedParentSpaces: [], joinRule: .public)
         context.desiredSettings.accessType = .inviteOnly
         XCTAssertFalse(context.viewState.isSaveDisabled)
         XCTAssertNil(context.alertInfo)
@@ -291,7 +363,7 @@ class SecurityAndPrivacyScreenViewModelTests: XCTestCase {
     }
     
     func testCancelWithChangesAndSaveWithFailure() async throws {
-        setupViewModel(isSpaceSettingsEnabled: false, joinedParentSpaces: [], joinRule: .public)
+        setupViewModel(joinedParentSpaces: [], joinRule: .public)
         roomProxy.updateJoinRuleReturnValue = .failure(.sdkError(RoomProxyMockError.generic))
         context.desiredSettings.accessType = .inviteOnly
         XCTAssertFalse(context.viewState.isSaveDisabled)
@@ -309,11 +381,11 @@ class SecurityAndPrivacyScreenViewModelTests: XCTestCase {
     
     // MARK: - Helpers
     
-    private func setupViewModel(isSpaceSettingsEnabled: Bool,
+    private func setupViewModel(joinedParentSpaces: [SpaceRoomProxyProtocol],
-                                joinedParentSpaces: [SpaceRoomProxyProtocol],
                                 joinRule: JoinRule) {
         let appSettings = AppSettings()
-        appSettings.spaceSettingsEnabled = isSpaceSettingsEnabled
+        appSettings.spaceSettingsEnabled = true
+        appSettings.knockingEnabled = true
         roomProxy = JoinedRoomProxyMock(.init(isEncrypted: false,
                                               canonicalAlias: "#room:matrix.org",
                                               members: .allMembersAsCreator,