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

2026-11-04 10:33:45 +00:00 · 2025-08-07 10:40:14 +02:00
parent be525e6a60
commit 5ab6f90863
67 changed files with 691 additions and 363 deletions
@@ -24,6 +24,7 @@ enum HomeScreenCoordinatorAction {
    case presentReportRoom(roomIdentifier: String)
    case presentDeclineAndBlock(userID: String, roomID: String)
    case roomLeft(roomIdentifier: String)
+    case transferOwnership(roomIdentifier: String)
    case presentSettingsScreen
    case presentFeedbackScreen
    case presentSecureBackupSettings
@@ -86,6 +87,8 @@ final class HomeScreenCoordinator: CoordinatorProtocol {
                    actionsSubject.send(.logout)
                case .presentDeclineAndBlock(let userID, let roomID):
                    actionsSubject.send(.presentDeclineAndBlock(userID: userID, roomID: roomID))
+                case .transferOwnership(let roomIdentifier):
+                    actionsSubject.send(.transferOwnership(roomIdentifier: roomIdentifier))
                }
            }
            .store(in: &cancellables)
@@ -15,6 +15,7 @@ enum HomeScreenViewModelAction: Equatable {
    case presentReportRoom(roomIdentifier: String)
    case presentDeclineAndBlock(userID: String, roomID: String)
    case roomLeft(roomIdentifier: String)
+    case transferOwnership(roomIdentifier: String)
    case presentSecureBackupSettings
    case presentRecoveryKeyScreen
    case presentEncryptionResetScreen
@@ -342,15 +342,37 @@ class HomeScreenViewModel: HomeScreenViewModelType, HomeScreenViewModelProtocol
                return
            }
            
-            if !(roomProxy.infoPublisher.value.isPrivate ?? true) {
-                state.bindings.leaveRoomAlertItem = LeaveRoomAlertItem(roomID: roomID, isDM: roomProxy.isDirectOneToOneRoom, state: .public)
-            } else {
-                state.bindings.leaveRoomAlertItem = if roomProxy.infoPublisher.value.joinedMembersCount > 1 {
-                    LeaveRoomAlertItem(roomID: roomID, isDM: roomProxy.isDirectOneToOneRoom, state: .private)
-                } else {
-                    LeaveRoomAlertItem(roomID: roomID, isDM: roomProxy.isDirectOneToOneRoom, state: .empty)
+            guard roomProxy.infoPublisher.value.joinedMembersCount > 1 else {
+                state.bindings.leaveRoomAlertItem = LeaveRoomAlertItem(roomID: roomID,
+                                                                       isDM: roomProxy.isDirectOneToOneRoom,
+                                                                       state: roomProxy.infoPublisher.value.isPrivate ?? true ? .empty : .public)
+                return
+            }
+            
+            if !roomProxy.isDirectOneToOneRoom {
+                if case let .success(ownMember) = await roomProxy.getMember(userID: roomProxy.ownUserID),
+                   ownMember.role.isOwner {
+                    await roomProxy.updateMembers()
+                    var isLastOwner = true
+                    for member in roomProxy.membersPublisher.value where member.userID != roomProxy.ownUserID {
+                        if member.role.isOwner {
+                            isLastOwner = false
+                            break
+                        }
+                    }
+                    
+                    if isLastOwner {
+                        state.bindings.alertInfo = .init(id: UUID(),
+                                                         title: L10n.leaveRoomAlertSelectNewOwnerTitle,
+                                                         message: L10n.leaveRoomAlertSelectNewOwnerSubtitle,
+                                                         primaryButton: .init(title: L10n.actionCancel, role: .cancel, action: nil),
+                                                         secondaryButton: .init(title: L10n.leaveRoomAlertSelectNewOwnerAction, role: .destructive, action: { [weak self] in self?.actionsSubject.send(.transferOwnership(roomIdentifier: roomID)) }))
+                        return
+                    }
                }
            }
+            
+            state.bindings.leaveRoomAlertItem = LeaveRoomAlertItem(roomID: roomID, isDM: roomProxy.isDirectOneToOneRoom, state: roomProxy.infoPublisher.value.isPrivate ?? true ? .private : .public)
        }
    }
    
@@ -9,7 +9,7 @@ import Combine
 import SwiftUI

 struct RoomChangeRolesScreenCoordinatorParameters {
-    let mode: RoomMemberDetails.Role
+    let mode: RoomRole
    let roomProxy: JoinedRoomProxyProtocol
    let mediaProvider: MediaProviderProtocol
    let userIndicatorController: UserIndicatorControllerProtocol
@@ -14,15 +14,19 @@ enum RoomChangeRolesScreenViewModelAction {

 struct RoomChangeRolesScreenViewState: BindableState {
    /// The screen's current mode (which role we are promoting/demoting users to/from.
-    let mode: RoomMemberDetails.Role
+    let mode: RoomRole
+    /// The current user's role.
+    var ownRole: RoomRole
+    /// All of the room's members who are currently owners or creators.
+    var owners: [RoomMemberDetails] = []
    /// All of the room's members who are currently admins.
-    var administrators: [RoomMemberDetails]
+    var administrators: [RoomMemberDetails] = []
    /// All of the room's members who are currently moderators.
-    var moderators: [RoomMemberDetails]
+    var moderators: [RoomMemberDetails] = []
    /// All of the room's members who are currently neither an admin or moderator.
-    var users: [RoomMemberDetails]
+    var users: [RoomMemberDetails] = []
    
-    var bindings: RoomChangeRolesScreenViewStateBindings
+    var bindings = RoomChangeRolesScreenViewStateBindings()
    
    /// The members selected for promotion to the current role.
    var membersToPromote: Set<RoomMemberDetails> = []
@@ -35,9 +39,17 @@ struct RoomChangeRolesScreenViewState: BindableState {
    /// The screen's title.
    var title: String {
        switch mode {
-        case .creator, .owner, .administrator:
-            // TODO: Handle the creator permissions change
-            L10n.screenRoomChangeRoleAdministratorsTitle
+        case .creator:
+            "" // The screen can't be configured with this role.
+        case .owner:
+            L10n.screenRoomChangeRoleOwnersTitle
+        case .administrator:
+            switch ownRole {
+            case .creator:
+                L10n.screenRoomChangeRoleAdministratorsOrOwnersTitle
+            default:
+                L10n.screenRoomChangeRoleAdministratorsTitle
+            }
        case .moderator:
            L10n.screenRoomChangeRoleModeratorsTitle
        case .user:
@@ -45,6 +57,10 @@ struct RoomChangeRolesScreenViewState: BindableState {
        }
    }
    
+    var visibleOwners: [RoomMemberDetails] {
+        owners.filter { $0.matches(searchQuery: bindings.searchQuery) }
+    }
+    
    /// The visible admins in the screen (after searching).
    var visibleAdministrators: [RoomMemberDetails] {
        administrators.filter { $0.matches(searchQuery: bindings.searchQuery) }
@@ -62,7 +78,8 @@ struct RoomChangeRolesScreenViewState: BindableState {
    
    /// All of the members who will gain/keep this screen's role after saving any changes.
    var membersWithRole: [RoomMemberDetails] {
-        administrators.filter(isMemberSelected) + moderators.filter(isMemberSelected) + users.filter(isMemberSelected)
+        let members = owners + administrators + moderators + users
+        return members.filter(isMemberSelected)
    }
    
    /// Whether or not any changes have been made to the members.
@@ -78,7 +95,31 @@ struct RoomChangeRolesScreenViewState: BindableState {
    /// Whether or not a specific member has this screen's role.
    func isMemberSelected(_ member: RoomMemberDetails) -> Bool {
        guard !membersToDemote.contains(member) else { return false }
-        return member.role == mode || membersToPromote.contains(member)
+        return member.role >= mode || membersToPromote.contains(member)
+    }
+    
+    func isMemberDisabled(_ member: RoomMemberDetails) -> Bool {
+        member.role > maxDemotableRole
+    }
+    
+    var maxDemotableRole: RoomRole {
+        switch mode {
+        case .owner:
+            return .owner
+        case .administrator:
+            switch ownRole {
+            case .owner:
+                return .administrator
+            case .creator:
+                return .owner
+            default:
+                return .moderator
+            }
+        case .moderator:
+            return .moderator
+        default:
+            return .user
+        }
    }
 }

@@ -91,6 +132,8 @@ struct RoomChangeRolesScreenViewStateBindings {
 enum RoomChangeRolesScreenAlertType {
    /// A warning that a particular promotion can't be undone.
    case promotionWarning
+    /// A warning that ownership transfer is final when the room is left.
+    case transferOwnershipWarning
    /// A confirmation that the user would like to discard any unsaved changes.
    case discardChanges
    /// The generic error message.
@@ -20,22 +20,19 @@ class RoomChangeRolesScreenViewModel: RoomChangeRolesScreenViewModelType, RoomCh
        actionsSubject.eraseToAnyPublisher()
    }

-    init(mode: RoomMemberDetails.Role,
+    init(mode: RoomRole,
         roomProxy: JoinedRoomProxyProtocol,
         mediaProvider: MediaProviderProtocol,
         userIndicatorController: UserIndicatorControllerProtocol,
         analytics: AnalyticsService) {
-        guard mode != .user else { fatalError("Invalid screen configuration: \(mode)") }
-        
+        guard mode != .user || mode != .creator else { fatalError("Invalid screen configuration: \(mode)") }
+
        self.roomProxy = roomProxy
        self.userIndicatorController = userIndicatorController
        self.analytics = analytics
        
        super.init(initialViewState: RoomChangeRolesScreenViewState(mode: mode,
-                                                                    administrators: [],
-                                                                    moderators: [],
-                                                                    users: [],
-                                                                    bindings: .init()),
+                                                                    ownRole: roomProxy.membersPublisher.value.first { $0.userID == roomProxy.id }?.role ?? .administrator),
                   mediaProvider: mediaProvider)
        
        roomProxy.membersPublisher
@@ -64,11 +61,16 @@ class RoomChangeRolesScreenViewModel: RoomChangeRolesScreenViewModelType, RoomCh
        case .demoteMember(let member):
            demoteMember(member)
        case .save:
-            if state.mode.isAdminOrHigher, !state.membersToPromote.isEmpty {
-                showPromotionWarning()
-            } else {
-                Task { await save() }
+            if !state.membersToPromote.isEmpty {
+                if state.mode == .administrator, state.ownRole == .administrator {
+                    showPromotionWarning()
+                    return
+                } else if state.mode == .owner {
+                    showTransferOwnershipWarning()
+                    return
+                }
            }
+            Task { await save() }
        case .cancel:
            confirmDiscardChanges()
        }
@@ -77,17 +79,23 @@ class RoomChangeRolesScreenViewModel: RoomChangeRolesScreenViewModelType, RoomCh
    // MARK: - Private
    
    private func updateMembers(_ members: [RoomMemberProxyProtocol]) {
+        var owners = [RoomMemberDetails]()
        var administrators = [RoomMemberDetails]()
        var moderators = [RoomMemberDetails]()
        var users = [RoomMemberDetails]()
        
        for member in members.sorted() {
+            if member.userID == roomProxy.ownUserID {
+                state.ownRole = member.role
+            }
+            
            guard member.isActive else { continue }
            let memberDetails = RoomMemberDetails(withProxy: member)
            
-            switch member.role {
-            // TODO: Create a owner list
-            case .administrator, .creator:
+            switch memberDetails.role {
+            case .creator, .owner:
+                owners.append(memberDetails)
+            case .administrator:
                administrators.append(memberDetails)
            case .moderator:
                moderators.append(memberDetails)
@@ -96,6 +104,7 @@ class RoomChangeRolesScreenViewModel: RoomChangeRolesScreenViewModelType, RoomCh
            }
        }
        
+        state.owners = owners
        state.administrators = administrators
        state.moderators = moderators
        state.users = users
@@ -107,9 +116,9 @@ class RoomChangeRolesScreenViewModel: RoomChangeRolesScreenViewModelType, RoomCh
        } else if state.membersToDemote.contains(member) {
            state.membersToDemote.remove(member)
            state.lastPromotedMember = member
-        } else if member.role == state.mode {
+        } else if member.role >= state.mode, member.role <= state.maxDemotableRole {
            state.membersToDemote.insert(member)
-        } else {
+        } else if member.role < state.mode {
            state.membersToPromote.insert(member)
            state.lastPromotedMember = member
        }
@@ -133,6 +142,16 @@ class RoomChangeRolesScreenViewModel: RoomChangeRolesScreenViewModelType, RoomCh
                                      secondaryButton: .init(title: L10n.actionCancel, role: .cancel, action: nil))
    }
    
+    private func showTransferOwnershipWarning() {
+        context.alertInfo = AlertInfo(id: .transferOwnershipWarning,
+                                      title: L10n.screenRoomChangeRoleConfirmChangeOwnersTitle,
+                                      message: L10n.screenRoomChangeRoleConfirmChangeOwnersDescription,
+                                      primaryButton: .init(title: L10n.actionContinue, role: .destructive) {
+                                          Task { await self.save() }
+                                      },
+                                      secondaryButton: .init(title: L10n.actionCancel, role: .cancel, action: nil))
+    }
+    
    private func save() async {
        showSavingIndicator()
        
@@ -45,15 +45,18 @@ struct RoomChangeRolesScreen: View {
                    }
                }
                
+                RoomChangeRolesScreenSection(members: context.viewState.visibleOwners,
+                                             role: .owner,
+                                             context: context)
+                
                RoomChangeRolesScreenSection(members: context.viewState.visibleAdministrators,
-                                             title: L10n.screenRoomChangeRoleSectionAdministrators,
-                                             isAdministratorsSection: true,
+                                             role: .administrator,
                                             context: context)
                RoomChangeRolesScreenSection(members: context.viewState.visibleModerators,
-                                             title: L10n.screenRoomChangeRoleSectionModerators,
+                                             role: .moderator,
                                             context: context)
                RoomChangeRolesScreenSection(members: context.viewState.visibleUsers,
-                                             title: L10n.screenRoomChangeRoleSectionUsers,
+                                             role: .user,
                                             context: context)
            }
        }
@@ -65,10 +68,12 @@ struct RoomChangeRolesScreen: View {
            ScrollViewReader { scrollView in
                HStack(spacing: 16) {
                    ForEach(context.viewState.membersWithRole, id: \.id) { member in
-                        RoomChangeRolesScreenSelectedItem(member: member, mediaProvider: context.mediaProvider) {
+                        let dismissAction = context.viewState.isMemberDisabled(member) ? nil : {
                            context.send(viewAction: .demoteMember(member))
                        }
-                        .frame(width: cellWidth)
+                        RoomChangeRolesScreenSelectedItem(member: member, mediaProvider: context.mediaProvider,
+                                                          dismissAction: dismissAction)
+                            .frame(width: cellWidth)
                    }
                }
                .onChange(of: context.viewState.lastPromotedMember) { _, newValue in
@@ -104,10 +109,22 @@ struct RoomChangeRolesScreen: View {
 // MARK: - Previews

 struct RoomChangeRolesScreen_Previews: PreviewProvider, TestablePreview {
-    static let administratorViewModel = makeViewModel(mode: .administrator)
-    static let moderatorViewModel = makeViewModel(mode: .moderator)
+    static let ownerViewModel = makeViewModel(mode: .owner, ownRole: .creator)
+    static let administratorOrOwnerViewModel = makeViewModel(mode: .administrator, ownRole: .creator)
+    static let administratorViewModel = makeViewModel(mode: .administrator, ownRole: .administrator)
+    static let moderatorViewModel = makeViewModel(mode: .moderator, ownRole: .administrator)
    
    static var previews: some View {
+        NavigationStack {
+            RoomChangeRolesScreen(context: ownerViewModel.context)
+        }
+        .previewDisplayName("Owners")
+        
+        NavigationStack {
+            RoomChangeRolesScreen(context: administratorOrOwnerViewModel.context)
+        }
+        .previewDisplayName("Administrator or Owners")
+        
        NavigationStack {
            RoomChangeRolesScreen(context: administratorViewModel.context)
        }
@@ -119,11 +136,18 @@ struct RoomChangeRolesScreen_Previews: PreviewProvider, TestablePreview {
        .previewDisplayName("Moderators")
    }
    
-    static func makeViewModel(mode: RoomMemberDetails.Role) -> RoomChangeRolesScreenViewModel {
-        RoomChangeRolesScreenViewModel(mode: mode,
-                                       roomProxy: JoinedRoomProxyMock(.init(members: .allMembersAsAdmin)),
-                                       mediaProvider: MediaProviderMock(configuration: .init()),
-                                       userIndicatorController: UserIndicatorControllerMock(),
-                                       analytics: ServiceLocator.shared.analytics)
+    static func makeViewModel(mode: RoomRole, ownRole: RoomRole) -> RoomChangeRolesScreenViewModel {
+        let members: [RoomMemberProxyMock] = switch ownRole {
+        case .creator:
+            .allMembersAsCreator
+        default:
+            .allMembersAsAdminV2
+        }
+        
+        return RoomChangeRolesScreenViewModel(mode: mode,
+                                              roomProxy: JoinedRoomProxyMock(.init(members: members)),
+                                              mediaProvider: MediaProviderMock(configuration: .init()),
+                                              userIndicatorController: UserIndicatorControllerMock(),
+                                              analytics: ServiceLocator.shared.analytics)
    }
 }
@@ -10,36 +10,46 @@ import SwiftUI

 struct RoomChangeRolesScreenSection: View {
    let members: [RoomMemberDetails]
-    let title: String
-    var isAdministratorsSection = false
+    let role: RoomRole
    
    let context: RoomChangeRolesScreenViewModel.Context
    
+    var title: String {
+        switch role {
+        case .creator, .owner:
+            L10n.screenRoomRolesAndPermissionsOwners
+        case .administrator:
+            L10n.screenRoomChangeRoleSectionAdministrators
+        case .moderator:
+            L10n.screenRoomChangeRoleSectionModerators
+        case .user:
+            L10n.screenRoomChangeRoleSectionUsers
+        }
+    }
+    
    var body: some View {
        if !members.isEmpty {
            Section {
                ForEach(members, id: \.id) { member in
                    RoomChangeRolesScreenRow(member: member,
                                             mediaProvider: context.mediaProvider,
-                                             isSelected: isMemberSelected(member)) {
+                                             isSelected: context.viewState.isMemberSelected(member)) {
                        context.send(viewAction: .toggleMember(member))
                    }
-                    .disabled(member.role.isAdminOrHigher)
+                    .disabled(context.viewState.isMemberDisabled(member))
                }
            } header: {
                Text(title)
                    .compoundListSectionHeader()
            } footer: {
-                if isAdministratorsSection, context.viewState.mode == .moderator {
+                if role == .administrator, context.viewState.mode == .moderator {
                    Text(L10n.screenRoomChangeRoleModeratorsAdminSectionFooter)
                        .compoundListSectionFooter()
+                } else if role.isOwner, context.viewState.mode != .owner {
+                    Text(L10n.screenRoomChangeRoleModeratorsOwnerSectionFooter)
+                        .compoundListSectionFooter()
                }
            }
        }
    }
-    
-    private func isMemberSelected(_ member: RoomMemberDetails) -> Bool {
-        // We always show administrators as selected, even on the moderators screen.
-        member.role.isAdminOrHigher || context.viewState.isMemberSelected(member)
-    }
 }
@@ -10,9 +10,22 @@ import SwiftUI
 struct RoomChangeRolesScreenSelectedItem: View {
    let member: RoomMemberDetails
    let mediaProvider: MediaProviderProtocol?
-    let dismissAction: () -> Void
+    let dismissAction: (() -> Void)?
    
    var body: some View {
+        mainContent
+            .accessibilityActions {
+                if let dismissAction {
+                    Button(L10n.actionDismiss) {
+                        dismissAction()
+                    }
+                }
+            }
+    }
+    
+    // MARK: - Private
+    
+    private var mainContent: some View {
        VStack(spacing: 4) {
            avatar
            
@@ -22,13 +35,8 @@ struct RoomChangeRolesScreenSelectedItem: View {
                .lineLimit(1)
        }
        .accessibilityElement(children: .combine)
-        .accessibilityAction(named: L10n.actionDismiss) {
-            dismissAction()
-        }
    }
    
-    // MARK: - Private
-    
    var avatar: some View {
        LoadableAvatarImage(url: member.avatarURL,
                            name: member.name,
@@ -37,7 +45,7 @@ struct RoomChangeRolesScreenSelectedItem: View {
                            mediaProvider: mediaProvider)
            .accessibilityHidden(true)
            .overlay(alignment: .topTrailing) {
-                if member.role != .administrator {
+                if let dismissAction {
                    Button(action: dismissAction) {
                        Image(systemName: "xmark.circle.fill")
                            .resizable()
@@ -34,6 +34,7 @@ enum RoomDetailsScreenCoordinatorAction {
    case presentKnockingRequestsListScreen
    case presentSecurityAndPrivacyScreen
    case presentReportRoomScreen
+    case transferOwnership
 }

 final class RoomDetailsScreenCoordinator: CoordinatorProtocol {
@@ -94,6 +95,8 @@ final class RoomDetailsScreenCoordinator: CoordinatorProtocol {
                    actionsSubject.send(.presentRecipientDetails(userID: userID))
                case .displayReportRoom:
                    actionsSubject.send(.presentReportRoomScreen)
+                case .transferOwnership:
+                    actionsSubject.send(.transferOwnership)
                }
            }
            .store(in: &cancellables)
@@ -27,6 +27,7 @@ enum RoomDetailsScreenViewModelAction: Equatable {
    case displayKnockingRequests
    case displaySecurityAndPrivacy
    case displayReportRoom
+    case transferOwnership
 }

 // MARK: View
@@ -288,6 +289,8 @@ enum RoomDetailsScreenErrorType: Hashable {
    case alert
    /// Leaving room has failed..
    case unknown
+    /// Last owner
+    case lastOwner
 }

 enum RoomDetailsScreenPinnedEventsActionState {
@@ -119,13 +119,7 @@ class RoomDetailsScreenViewModel: RoomDetailsScreenViewModelType, RoomDetailsScr
        case .processTapInvite:
            actionsSubject.send(.requestInvitePeoplePresentation)
        case .processTapLeave:
-            guard state.joinedMembersCount > 1 else {
-                state.bindings.leaveRoomAlertItem = LeaveRoomAlertItem(roomID: roomProxy.id, isDM: roomProxy.isDirectOneToOneRoom, state: .empty)
-                return
-            }
-            state.bindings.leaveRoomAlertItem = LeaveRoomAlertItem(roomID: roomProxy.id,
-                                                                   isDM: roomProxy.isDirectOneToOneRoom,
-                                                                   state: roomProxy.infoPublisher.value.isPrivate ?? true ? .private : .public)
+            processTapToLeave()
        case .confirmLeave:
            Task { await leaveRoom() }
        case .processTapIgnore:
@@ -177,6 +171,38 @@ class RoomDetailsScreenViewModel: RoomDetailsScreenViewModelType, RoomDetailsScr
    
    // MARK: - Private
    
+    private func processTapToLeave() {
+        guard state.joinedMembersCount > 1 else {
+            state.bindings.leaveRoomAlertItem = LeaveRoomAlertItem(roomID: roomProxy.id,
+                                                                   isDM: roomProxy.isDirectOneToOneRoom,
+                                                                   state: roomProxy.infoPublisher.value.isPrivate ?? true ? .empty : .public)
+            return
+        }
+        
+        if !roomProxy.isDirectOneToOneRoom, state.accountOwner?.role.isOwner == true {
+            var isLastOwner = true
+            for member in roomProxy.membersPublisher.value where member.userID != roomProxy.ownUserID {
+                if member.role.isOwner {
+                    isLastOwner = false
+                    break
+                }
+            }
+            
+            if isLastOwner {
+                state.bindings.alertInfo = .init(id: .lastOwner,
+                                                 title: L10n.leaveRoomAlertSelectNewOwnerTitle,
+                                                 message: L10n.leaveRoomAlertSelectNewOwnerSubtitle,
+                                                 primaryButton: .init(title: L10n.actionCancel, role: .cancel, action: nil),
+                                                 secondaryButton: .init(title: L10n.leaveRoomAlertSelectNewOwnerAction, role: .destructive, action: { [weak self] in self?.actionsSubject.send(.transferOwnership) }))
+                return
+            }
+        }
+        
+        state.bindings.leaveRoomAlertItem = LeaveRoomAlertItem(roomID: roomProxy.id,
+                                                               isDM: roomProxy.isDirectOneToOneRoom,
+                                                               state: roomProxy.infoPublisher.value.isPrivate ?? true ? .private : .public)
+    }
+    
    private func setupRoomSubscription() {
        roomProxy.infoPublisher
            .receive(on: DispatchQueue.main)
@@ -237,11 +263,6 @@ class RoomDetailsScreenViewModel: RoomDetailsScreenViewModelType, RoomDetailsScr
    }
    
    private func fetchMembersIfNeeded() async {
-        // We need to fetch members just in 1-to-1 chat to get the member object for the other person
-        guard roomProxy.isDirectOneToOneRoom else {
-            return
-        }
-        
        roomProxy.membersPublisher
            .receive(on: DispatchQueue.main)
            .sink { [weak self, ownUserID = roomProxy.ownUserID] members in
@@ -251,6 +272,10 @@ class RoomDetailsScreenViewModel: RoomDetailsScreenViewModelType, RoomDetailsScr
                    self.state.accountOwner = .init(withProxy: accountOwner)
                }
                
+                guard roomProxy.isDirectOneToOneRoom else {
+                    return
+                }
+                
                if let dmRecipient = members.first(where: { $0.userID != ownUserID }) {
                    self.state.dmRecipientInfo = .init(member: .init(withProxy: dmRecipient))
                    
@@ -17,12 +17,16 @@ enum RoomRolesAndPermissionsScreenViewModelAction {
 }

 struct RoomRolesAndPermissionsScreenViewState: BindableState {
+    var ownRole: RoomRole
+    
+    var administratorsAndOwnersCount: Int?
    /// The number of administrators in the room.
    var administratorCount: Int?
    /// The number of moderators in the room.
    var moderatorCount: Int?
    /// The permissions of the room when loaded.
    var permissions: RoomPermissions?
+        
    var bindings = RoomRolesAndPermissionsScreenViewStateBindings()
 }

@@ -46,7 +50,7 @@ enum RoomRolesAndPermissionsScreenViewAction {
    case reset
 }

-enum RoomRolesAndPermissionsScreenRole {
+enum RoomRolesAndPermissionsScreenRole: Hashable {
    case administrators
    case moderators
 }
@@ -14,6 +14,7 @@ class RoomRolesAndPermissionsScreenViewModel: RoomRolesAndPermissionsScreenViewM
    private let roomProxy: JoinedRoomProxyProtocol
    private let userIndicatorController: UserIndicatorControllerProtocol
    private let analytics: AnalyticsService
+    private var ownUser: RoomMemberDetails?
    
    private var actionsSubject: PassthroughSubject<RoomRolesAndPermissionsScreenViewModelAction, Never> = .init()
    var actionsPublisher: AnyPublisher<RoomRolesAndPermissionsScreenViewModelAction, Never> {
@@ -24,7 +25,8 @@ class RoomRolesAndPermissionsScreenViewModel: RoomRolesAndPermissionsScreenViewM
        self.roomProxy = roomProxy
        self.userIndicatorController = userIndicatorController
        self.analytics = analytics
-        super.init(initialViewState: RoomRolesAndPermissionsScreenViewState(permissions: initialPermissions))
+        super.init(initialViewState: RoomRolesAndPermissionsScreenViewState(ownRole: roomProxy.membersPublisher.value.first(where: { $0.userID == roomProxy.ownUserID })?.role ?? .administrator,
+                                                                            permissions: initialPermissions))
        
        // Automatically update the admin/moderator counts.
        roomProxy.membersPublisher
@@ -80,16 +82,19 @@ class RoomRolesAndPermissionsScreenViewModel: RoomRolesAndPermissionsScreenViewM
                                                 secondaryButton: .init(title: L10n.actionCancel, role: .cancel) { })
        }
    }
-    
+
    // MARK: - Members
    
    private func updateMembers(_ members: [RoomMemberProxyProtocol]) {
-        // TODO: Will probably be changed when we implement the owners list
-        state.administratorCount = members.filter { $0.role.isAdminOrHigher && $0.isActive }.count
+        state.administratorsAndOwnersCount = members.filter { $0.role.isAdminOrHigher && $0.isActive }.count
+        state.administratorCount = members.filter { $0.role == .administrator && $0.isActive }.count
        state.moderatorCount = members.filter { $0.role == .moderator && $0.isActive }.count
+        if let ownUser = members.first(where: { $0.userID == roomProxy.ownUserID }) {
+            state.ownRole = ownUser.role
+        }
    }
    
-    private func updateOwnRole(_ role: RoomMemberDetails.Role) async {
+    private func updateOwnRole(_ role: RoomRole) async {
        showSavingIndicator()
        
        // A task we can await until the room's info gets modified with the new power levels.
@@ -142,7 +147,7 @@ class RoomRolesAndPermissionsScreenViewModel: RoomRolesAndPermissionsScreenViewM
        
        hideSavingIndicator()
    }
-    
+        
    // MARK: Loading indicator
    
    private static let savingIndicatorID = "RolesAndPermissionsSaving"
@@ -26,13 +26,23 @@ struct RoomRolesAndPermissionsScreen: View {
    
    private var rolesSection: some View {
        Section {
-            ListRow(label: .default(title: L10n.screenRoomRolesAndPermissionsAdmins,
-                                    icon: \.admin),
-                    details: administratorDetails,
-                    kind: .navigationLink {
-                        context.send(viewAction: .editRoles(.administrators))
-                    })
-                    .accessibilityIdentifier(A11yIdentifiers.roomRolesAndPermissionsScreen.administrators)
+            if context.viewState.ownRole == .creator {
+                ListRow(label: .default(title: L10n.screenRoomRolesAndPermissionsAdminsAndOwners,
+                                        icon: \.admin),
+                        details: administratorOrOwnersDetails,
+                        kind: .navigationLink {
+                            context.send(viewAction: .editRoles(.administrators))
+                        })
+                        .accessibilityIdentifier(A11yIdentifiers.roomRolesAndPermissionsScreen.administrators)
+            } else {
+                ListRow(label: .default(title: L10n.screenRoomRolesAndPermissionsAdmins,
+                                        icon: \.admin),
+                        details: administratorDetails,
+                        kind: .navigationLink {
+                            context.send(viewAction: .editRoles(.administrators))
+                        })
+                        .accessibilityIdentifier(A11yIdentifiers.roomRolesAndPermissionsScreen.administrators)
+            }
            
            ListRow(label: .default(title: L10n.screenRoomRolesAndPermissionsModerators,
                                    icon: \.chatProblem),
@@ -42,17 +52,27 @@ struct RoomRolesAndPermissionsScreen: View {
                    })
                    .accessibilityIdentifier(A11yIdentifiers.roomRolesAndPermissionsScreen.moderators)
            
-            ListRow(label: .default(title: L10n.screenRoomRolesAndPermissionsChangeMyRole,
-                                    icon: \.edit),
-                    kind: .button {
-                        context.send(viewAction: .editOwnUserRole)
-                    })
+            if context.viewState.ownRole != .creator {
+                ListRow(label: .default(title: L10n.screenRoomRolesAndPermissionsChangeMyRole,
+                                        icon: \.edit),
+                        kind: .button {
+                            context.send(viewAction: .editOwnUserRole)
+                        })
+            }
        } header: {
            Text(L10n.screenRoomRolesAndPermissionsRolesHeader)
                .compoundListSectionHeader()
        }
    }
    
+    private var administratorOrOwnersDetails: ListRowDetails<Image> {
+        if let administratorCount = context.viewState.administratorsAndOwnersCount {
+            .title("\(administratorCount)")
+        } else {
+            .isWaiting(true)
+        }
+    }
+    
    private var administratorDetails: ListRowDetails<Image> {
        if let administratorCount = context.viewState.administratorCount {
            .title("\(administratorCount)")
@@ -121,9 +141,20 @@ struct RoomRolesAndPermissionsScreen_Previews: PreviewProvider, TestablePreview
                                                                  roomProxy: JoinedRoomProxyMock(.init(members: .allMembersAsAdmin)),
                                                                  userIndicatorController: UserIndicatorControllerMock(),
                                                                  analytics: ServiceLocator.shared.analytics)
+    
+    static let creatorViewModel = RoomRolesAndPermissionsScreenViewModel(initialPermissions: RoomPermissions(powerLevels: .mock),
+                                                                         roomProxy: JoinedRoomProxyMock(.init(members: .allMembersAsCreator)),
+                                                                         userIndicatorController: UserIndicatorControllerMock(),
+                                                                         analytics: ServiceLocator.shared.analytics)
    static var previews: some View {
        NavigationStack {
            RoomRolesAndPermissionsScreen(context: viewModel.context)
        }
+        .previewDisplayName("Admin")
+        
+        NavigationStack {
+            RoomRolesAndPermissionsScreen(context: creatorViewModel.context)
+        }
+        .previewDisplayName("Creator")
    }
 }