Adapt 'change roles' screens to the new creator/owner role (#5076)

* Replace `RoomMember.Role.CREATOR` with `RoomMember.Role.Owner` - Make `RoomMember.Role` a sealed interface instead

* Adapt room member role mapping to include the power level to distinguish between admins and owners

* Use new `RoomMember.Role` sealed interface through the app

* Change how `MembersByRole` groups members to add owners to the admins section

* Adapt the `ChangeRoles` screen to the new roles:
    - Owners can't modify other owner's roles.
    - They can modify the roles of any other user, without confirmation.

* Adapt 'roles and permissions' screen:
    - Owners can't demote themselves.
    - The admin count also counts owners.

* Add more tests and screenshots

* Add owners to its own section in the 'change roles' screen

* Update screenshots

---------

Co-authored-by: ElementBot <android@element.io>

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/RustMatrixClient.kt

@@ -343,7 +343,7 @@ class RustMatrixClient(
                 powerLevelContentOverride = defaultRoomCreationPowerLevels.copy(
                     invite = if (createRoomParams.joinRuleOverride == JoinRule.Knock) {
                         // override the invite power level so it's the same as kick.
-                        RoomMember.Role.MODERATOR.powerLevel.toInt()
+                        RoomMember.Role.Moderator.powerLevel.toInt()
                     } else {
                         null
                     }

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/room/RustBaseRoom.kt

@@ -128,7 +128,11 @@ class RustBaseRoom(
 
     override suspend fun userRole(userId: UserId): Result<RoomMember.Role> = withContext(roomDispatcher) {
         runCatchingExceptions {
-            RoomMemberMapper.mapRole(innerRoom.suggestedRoleForUser(userId.value))
+            val powerLevel = roomInfoFlow.value.roomPowerLevels?.powerLevelOf(userId) ?: 0L
+            RoomMemberMapper.mapRole(
+                role = innerRoom.suggestedRoleForUser(userId.value),
+                powerLevel = powerLevel,
+            )
         }
     }
 

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/room/member/RoomMemberMapper.kt

@@ -16,25 +16,36 @@ import org.matrix.rustcomponents.sdk.MembershipState as RustMembershipState
 import org.matrix.rustcomponents.sdk.RoomMember as RustRoomMember
 
 object RoomMemberMapper {
-    fun map(roomMember: RustRoomMember): RoomMember = RoomMember(
-        userId = UserId(roomMember.userId),
-        displayName = roomMember.displayName,
-        avatarUrl = roomMember.avatarUrl,
-        membership = mapMembership(roomMember.membership),
-        isNameAmbiguous = roomMember.isNameAmbiguous,
-        powerLevel = roomMember.powerLevel.into(),
-        normalizedPowerLevel = roomMember.normalizedPowerLevel.into(),
-        isIgnored = roomMember.isIgnored,
-        role = mapRole(roomMember.suggestedRoleForPowerLevel),
-        membershipChangeReason = roomMember.membershipChangeReason
-    )
+    fun map(roomMember: RustRoomMember): RoomMember {
+        val powerLevel = roomMember.powerLevel.into()
+        return RoomMember(
+            userId = UserId(roomMember.userId),
+            displayName = roomMember.displayName,
+            avatarUrl = roomMember.avatarUrl,
+            membership = mapMembership(roomMember.membership),
+            isNameAmbiguous = roomMember.isNameAmbiguous,
+            powerLevel = powerLevel,
+            normalizedPowerLevel = roomMember.normalizedPowerLevel.into(),
+            isIgnored = roomMember.isIgnored,
+            role = mapRole(roomMember.suggestedRoleForPowerLevel, powerLevel),
+            membershipChangeReason = roomMember.membershipChangeReason
+        )
+    }
 
-    fun mapRole(role: RoomMemberRole): RoomMember.Role =
+    fun mapRole(role: RoomMemberRole, powerLevel: Long?): RoomMember.Role =
         when (role) {
-            RoomMemberRole.CREATOR -> RoomMember.Role.CREATOR
-            RoomMemberRole.ADMINISTRATOR -> RoomMember.Role.ADMIN
-            RoomMemberRole.MODERATOR -> RoomMember.Role.MODERATOR
-            RoomMemberRole.USER -> RoomMember.Role.USER
+            RoomMemberRole.CREATOR -> RoomMember.Role.Owner(isCreator = true)
+            RoomMemberRole.ADMINISTRATOR -> {
+                val superAdmin = RoomMember.Role.Owner(isCreator = false)
+                val powerLevelOrDefault = powerLevel ?: 0L
+                if (powerLevelOrDefault >= superAdmin.powerLevel) {
+                    superAdmin
+                } else {
+                    RoomMember.Role.Admin
+                }
+            }
+            RoomMemberRole.MODERATOR -> RoomMember.Role.Moderator
+            RoomMemberRole.USER -> RoomMember.Role.User
         }
 
     fun mapMembership(membershipState: RustMembershipState): RoomMembershipState =

libraries/matrix/impl/src/main/kotlin/io/element/android/libraries/matrix/impl/room/powerlevels/RoomPowerLevelsValuesMapper.kt

@@ -28,6 +28,6 @@ object RoomPowerLevelsValuesMapper {
 }
 
 fun PowerLevel.into(): Long = when (this) {
-    PowerLevel.Infinite -> RoomMember.Role.CREATOR.powerLevel
+    PowerLevel.Infinite -> RoomMember.Role.Owner(isCreator = true).powerLevel
     is PowerLevel.Value -> this.value
 }