Last Owner should edit admins, and not leave when is last (#4372)

ElementX/Sources/FlowCoordinators/ChatsFlowCoordinator.swift

@@ -202,6 +202,12 @@ class ChatsFlowCoordinator: FlowCoordinatorProtocol {
             }
         case .accountProvisioningLink:
             break // We always ignore this flow when logged in.
+        case .transferOwnership(let roomID):
+            if stateMachine.state.roomListSelectedRoomID == roomID {
+                roomFlowCoordinator?.handleAppRoute(appRoute, animated: animated)
+            } else {
+                stateMachine.processEvent(.selectRoom(roomID: roomID, via: [], entryPoint: .transferOwnership))
+            }
         }
     }
     
@@ -232,6 +238,7 @@ class ChatsFlowCoordinator: FlowCoordinatorProtocol {
                     case .roomDetails: .roomDetails(roomID: roomID)
                     case .eventID(let eventID): .event(eventID: eventID, roomID: roomID, via: via) // ignored.
                     case .share(let payload): .share(payload)
+                    case .transferOwnership: .transferOwnership(roomID: roomID)
                     }
                     roomFlowCoordinator.handleAppRoute(route, animated: animated)
                 } else {
@@ -449,6 +456,8 @@ class ChatsFlowCoordinator: FlowCoordinatorProtocol {
                     actionsSubject.send(.logout)
                 case .presentDeclineAndBlock(let userID, let roomID):
                     stateMachine.processEvent(.presentDeclineAndBlockScreen(userID: userID, roomID: roomID))
+                case .transferOwnership(let roomIdentifier):
+                    handleAppRoute(.transferOwnership(roomID: roomIdentifier), animated: true)
                 }
             }
             .store(in: &cancellables)
@@ -555,6 +564,8 @@ class ChatsFlowCoordinator: FlowCoordinatorProtocol {
             coordinator.handleAppRoute(.roomDetails(roomID: roomID), animated: animated)
         case .share(let payload):
             coordinator.handleAppRoute(.share(payload), animated: animated)
+        case .transferOwnership:
+            coordinator.handleAppRoute(.transferOwnership(roomID: roomID), animated: animated)
         }
                 
         Task {

ElementX/Sources/FlowCoordinators/EncryptionSettingsFlowCoordinator.swift

@@ -82,7 +82,7 @@ class EncryptionSettingsFlowCoordinator: FlowCoordinatorProtocol {
         case .roomList, .room, .roomAlias, .childRoom, .childRoomAlias,
              .roomDetails, .roomMemberDetails, .userProfile,
              .event, .eventOnRoomAlias, .childEvent, .childEventOnRoomAlias,
-             .call, .genericCallLink, .settings, .share:
+             .call, .genericCallLink, .settings, .share, .transferOwnership:
             // These routes aren't in this flow so clear the entire stack.
             clearRoute(animated: animated)
         case .chatBackupSettings:

ElementX/Sources/FlowCoordinators/RoomFlowCoordinator.swift

@@ -37,6 +37,8 @@ enum RoomFlowCoordinatorEntryPoint: Hashable {
     case roomDetails
     /// An external media share request
     case share(ShareExtensionPayload)
+    /// The flow to change the the owner of the room
+    case transferOwnership
     
     var isEventID: Bool {
         guard case .eventID = self else { return false }
@@ -196,9 +198,44 @@ class RoomFlowCoordinator: FlowCoordinatorProtocol {
             break // These are converted to a room ID route one level above.
         case .accountProvisioningLink, .roomList, .userProfile, .call, .genericCallLink, .settings, .chatBackupSettings:
             break // These routes can't be handled.
+        case .transferOwnership(let roomID):
+            guard self.roomID == roomID else { fatalError("Navigation route doesn't belong to this room flow.") }
+            
+            Task {
+                if roomProxy == nil {
+                    guard case let .joined(roomProxy) = await userSession.clientProxy.roomForIdentifier(roomID) else {
+                        return
+                    }
+                    
+                    await storeAndSubscribeToRoomProxy(roomProxy)
+                }
+                
+                presentTransferOwnershipScreen()
+            }
         }
     }
     
+    private func presentTransferOwnershipScreen() {
+        let parameters = RoomChangeRolesScreenCoordinatorParameters(mode: .owner,
+                                                                    roomProxy: roomProxy,
+                                                                    mediaProvider: userSession.mediaProvider,
+                                                                    userIndicatorController: userIndicatorController,
+                                                                    analytics: analytics)
+        let stackCoordinator = NavigationStackCoordinator()
+        let coordinator = RoomChangeRolesScreenCoordinator(parameters: parameters)
+        coordinator.actionsPublisher.sink { [weak self] action in
+            guard let self else { return }
+            switch action {
+            case .complete:
+                navigationStackCoordinator.setSheetCoordinator(nil)
+            }
+        }
+        .store(in: &cancellables)
+        
+        stackCoordinator.setRootCoordinator(coordinator)
+        navigationStackCoordinator.setSheetCoordinator(stackCoordinator, animated: true)
+    }
+    
     private func presentCallScreen(roomID: String) async {
         guard case let .joined(roomProxy) = await userSession.clientProxy.roomForIdentifier(roomID) else {
             return
@@ -798,6 +835,8 @@ class RoomFlowCoordinator: FlowCoordinatorProtocol {
                 stateMachine.tryEvent(.presentRoomMemberDetails(userID: userID))
             case .presentReportRoomScreen:
                 stateMachine.tryEvent(.presentReportRoomScreen)
+            case .transferOwnership:
+                presentTransferOwnershipScreen()
             }
         }
         .store(in: &cancellables)
@@ -1555,6 +1594,8 @@ class RoomFlowCoordinator: FlowCoordinatorProtocol {
             coordinator.handleAppRoute(.roomDetails(roomID: roomID), animated: true)
         case .share(let payload):
             coordinator.handleAppRoute(.share(payload), animated: true)
+        case .transferOwnership:
+            coordinator.handleAppRoute(.transferOwnership(roomID: roomID), animated: true)
         }
     }
     

ElementX/Sources/FlowCoordinators/RoomRolesAndPermissionsFlowCoordinator.swift

@@ -107,7 +107,13 @@ class RoomRolesAndPermissionsFlowCoordinator: FlowCoordinatorProtocol {
         
         stateMachine.addRoutes(event: .changeRoles, transitions: [.rolesAndPermissionsScreen => .changingRoles]) { [weak self] context in
             guard let role = context.userInfo as? RoomRolesAndPermissionsScreenRole else { fatalError("Expected a role") }
-            self?.presentChangeRolesScreen(role: role)
+            let mode: RoomRole = switch role {
+            case .administrators:
+                .administrator
+            case .moderators:
+                .moderator
+            }
+            self?.presentChangeRolesScreen(mode: mode)
         }
         stateMachine.addRoutes(event: .finishedChangingRoles, transitions: [.changingRoles => .rolesAndPermissionsScreen])
         
@@ -150,12 +156,7 @@ class RoomRolesAndPermissionsFlowCoordinator: FlowCoordinatorProtocol {
         }
     }
     
-    private func presentChangeRolesScreen(role: RoomRolesAndPermissionsScreenRole) {
-        let mode = switch role {
-        case .administrators: RoomMemberDetails.Role.administrator
-        case .moderators: RoomMemberDetails.Role.moderator
-        }
-        
+    private func presentChangeRolesScreen(mode: RoomRole) {
         let parameters = RoomChangeRolesScreenCoordinatorParameters(mode: mode,
                                                                     roomProxy: roomProxy,
                                                                     mediaProvider: mediaProvider,