refactor: Adapt to changes in power levels

Signed-off-by: Kévin Commaille <[email protected]>

Author: zecakeh

bindings/matrix-sdk-ffi/src/client.rs

@@ -78,6 +78,7 @@ use ruma::{
         RoomAccountDataEvent as RumaRoomAccountDataEvent,
     },
     push::{HttpPusherData as RumaHttpPusherData, PushFormat as RumaPushFormat},
+    room_version_rules::AuthorizationRules,
     OwnedDeviceId, OwnedServerName, RoomAliasId, RoomOrAliasId, ServerName,
 };
 use serde::{Deserialize, Serialize};
@@ -1898,7 +1899,7 @@ pub struct PowerLevels {
 
 impl From<PowerLevels> for RoomPowerLevelsEventContent {
     fn from(value: PowerLevels) -> Self {
-        let mut power_levels = RoomPowerLevelsEventContent::new();
+        let mut power_levels = RoomPowerLevelsEventContent::new(&AuthorizationRules::V1);
 
         if let Some(users_default) = value.users_default {
             power_levels.users_default = users_default.into();

bindings/matrix-sdk-ffi/src/room_member.rs

@@ -1,5 +1,5 @@
 use matrix_sdk::room::{RoomMember as SdkRoomMember, RoomMemberRole};
-use ruma::UserId;
+use ruma::{events::room::power_levels::UserPowerLevel, UserId};
 
 use crate::error::{ClientError, NotYetImplemented};
 
@@ -57,16 +57,22 @@ impl TryFrom<matrix_sdk::ruma::events::room::member::MembershipState> for Member
     }
 }
 
+/// Get the suggested role for the given power level.
+///
+/// Returns an error if the value of the power level is out of range for numbers
+/// accepted in canonical JSON.
 #[matrix_sdk_ffi_macros::export]
-pub fn suggested_role_for_power_level(power_level: i64) -> RoomMemberRole {
+pub fn suggested_role_for_power_level(
+    power_level: PowerLevel,
+) -> Result<RoomMemberRole, ClientError> {
     // It's not possible to expose the constructor on the Enum through Uniffi ☹️
-    RoomMemberRole::suggested_role_for_power_level(power_level)
+    Ok(RoomMemberRole::suggested_role_for_power_level(power_level.try_into()?))
 }
 
 #[matrix_sdk_ffi_macros::export]
-pub fn suggested_power_level_for_role(role: RoomMemberRole) -> i64 {
+pub fn suggested_power_level_for_role(role: RoomMemberRole) -> PowerLevel {
     // It's not possible to expose methods on an Enum through Uniffi ☹️
-    role.suggested_power_level()
+    role.suggested_power_level().into()
 }
 
 /// Generates a `matrix.to` permalink to the given userID.
@@ -83,8 +89,8 @@ pub struct RoomMember {
     pub avatar_url: Option<String>,
     pub membership: MembershipState,
     pub is_name_ambiguous: bool,
-    pub power_level: i64,
-    pub normalized_power_level: i64,
+    pub power_level: PowerLevel,
+    pub normalized_power_level: PowerLevel,
     pub is_ignored: bool,
     pub suggested_role_for_power_level: RoomMemberRole,
     pub membership_change_reason: Option<String>,
@@ -100,8 +106,8 @@ impl TryFrom<SdkRoomMember> for RoomMember {
             avatar_url: m.avatar_url().map(|a| a.to_string()),
             membership: m.membership().clone().try_into()?,
             is_name_ambiguous: m.name_ambiguous(),
-            power_level: m.power_level(),
-            normalized_power_level: m.normalized_power_level(),
+            power_level: m.power_level().into(),
+            normalized_power_level: m.normalized_power_level().into(),
             is_ignored: m.is_ignored(),
             suggested_role_for_power_level: m.suggested_role_for_power_level(),
             membership_change_reason: m.event().reason().map(|s| s.to_owned()),
@@ -130,3 +136,40 @@ impl TryFrom<matrix_sdk::room::RoomMemberWithSenderInfo> for RoomMemberWithSende
         })
     }
 }
+
+#[derive(Clone, uniffi::Enum)]
+pub enum PowerLevel {
+    /// The user is a room creator and has infinite power level.
+    ///
+    /// This power level was introduced in room version 12.
+    Infinite,
+
+    /// The user has the given power level.
+    Value { value: i64 },
+}
+
+impl From<UserPowerLevel> for PowerLevel {
+    fn from(value: UserPowerLevel) -> Self {
+        match value {
+            UserPowerLevel::Infinite => Self::Infinite,
+            UserPowerLevel::Int(value) => Self::Value { value: value.into() },
+            _ => unimplemented!(),
+        }
+    }
+}
+
+impl TryFrom<PowerLevel> for UserPowerLevel {
+    type Error = ClientError;
+
+    fn try_from(value: PowerLevel) -> Result<Self, Self::Error> {
+        Ok(match value {
+            PowerLevel::Infinite => Self::Infinite,
+            PowerLevel::Value { value } => {
+                Self::Int(value.try_into().map_err(|err| ClientError::Generic {
+                    msg: "Power level is out of range".to_owned(),
+                    details: Some(format!("{err:?}")),
+                })?)
+            }
+        })
+    }
+}

crates/matrix-sdk-base/src/deserialized_responses.rs

@@ -29,6 +29,7 @@ use ruma::{
         PossiblyRedactedStateEventContent, RedactContent, RedactedStateEventContent,
         StateEventContent, StaticStateEventContent, StrippedStateEvent, SyncStateEvent,
     },
+    room_version_rules::AuthorizationRules,
     serde::Raw,
     EventId, MilliSecondsSinceUnixEpoch, OwnedEventId, OwnedRoomId, OwnedUserId, UInt, UserId,
 };
@@ -517,10 +518,14 @@ impl MemberEvent {
 
 impl SyncOrStrippedState<RoomPowerLevelsEventContent> {
     /// The power levels of the event.
-    pub fn power_levels(&self) -> RoomPowerLevels {
+    pub fn power_levels(
+        &self,
+        rules: &AuthorizationRules,
+        creators: Vec<OwnedUserId>,
+    ) -> RoomPowerLevels {
         match self {
-            Self::Sync(e) => e.power_levels(),
-            Self::Stripped(e) => e.power_levels(),
+            Self::Sync(e) => e.power_levels(rules, creators),
+            Self::Stripped(e) => e.power_levels(rules, creators),
         }
     }
 }

crates/matrix-sdk-base/src/response_processors/state_events.rs

@@ -1080,6 +1080,7 @@ mod tests {
             .add_joined_room(
                 JoinedRoomBuilder::new(&DEFAULT_TEST_ROOM_ID)
                     .add_timeline_event(room_name)
+                    .add_state_event(StateTestEvent::Create)
                     .add_state_event(StateTestEvent::PowerLevels),
             )
             .build_sync_response();

crates/matrix-sdk-base/src/room/members.rs

@@ -25,7 +25,7 @@ use ruma::{
         presence::PresenceEvent,
         room::{
             member::{MembershipState, RoomMemberEventContent},
-            power_levels::{PowerLevelAction, RoomPowerLevels},
+            power_levels::{PowerLevelAction, RoomPowerLevels, UserPowerLevel},
         },
         MessageLikeEventType, StateEventType,
     },
@@ -274,19 +274,27 @@ impl RoomMember {
     /// Get the normalized power level of this member.
     ///
     /// The normalized power level depends on the maximum power level that can
-    /// be found in a certain room, positive values are always in the range of
-    /// 0-100.
-    pub fn normalized_power_level(&self) -> i64 {
+    /// be found in a certain room, positive values that are not `Infinite` are
+    /// always in the range of 0-100.
+    pub fn normalized_power_level(&self) -> UserPowerLevel {
+        let UserPowerLevel::Int(power_level) = self.power_level() else {
+            return UserPowerLevel::Infinite;
+        };
+
+        let mut power_level = i64::from(power_level);
+
         if self.max_power_level > 0 {
-            (self.power_level() * 100) / self.max_power_level
-        } else {
-            self.power_level()
+            power_level = (power_level * 100) / self.max_power_level;
         }
+
+        UserPowerLevel::Int(
+            power_level.try_into().expect("normalized power level should fit in Int"),
+        )
     }
 
     /// Get the power level of this member.
-    pub fn power_level(&self) -> i64 {
-        self.power_levels.for_user(self.user_id()).into()
+    pub fn power_level(&self) -> UserPowerLevel {
+        self.power_levels.for_user(self.user_id())
     }
 
     /// Whether this user can ban other users based on the power levels.

crates/matrix-sdk-base/src/room/mod.rs

@@ -47,8 +47,9 @@ pub use room_info::{
     apply_redaction, BaseRoomInfo, InviteAcceptanceDetails, RoomInfo, RoomInfoNotableUpdate,
     RoomInfoNotableUpdateReasons,
 };
+#[cfg(feature = "e2e-encryption")]
+use ruma::{events::AnySyncTimelineEvent, serde::Raw};
 use ruma::{
-    assign,
     events::{
         direct::OwnedDirectUserIdentifier,
         receipt::{Receipt, ReceiptThread, ReceiptType},
@@ -57,15 +58,12 @@ use ruma::{
             guest_access::GuestAccess,
             history_visibility::HistoryVisibility,
             join_rules::JoinRule,
-            power_levels::{RoomPowerLevels, RoomPowerLevelsEventContent},
+            power_levels::{RoomPowerLevels, RoomPowerLevelsEventContent, RoomPowerLevelsSource},
         },
     },
-    int,
     room::RoomType,
     EventId, OwnedEventId, OwnedMxcUri, OwnedRoomAliasId, OwnedRoomId, OwnedUserId, RoomId, UserId,
 };
-#[cfg(feature = "e2e-encryption")]
-use ruma::{events::AnySyncTimelineEvent, serde::Raw};
 use serde::{Deserialize, Serialize};
 pub use state::{RoomState, RoomStateFilter};
 pub(crate) use tags::RoomNotableTags;
@@ -364,13 +362,16 @@ impl Room {
 
     /// Get the current power levels of this room.
     pub async fn power_levels(&self) -> Result<RoomPowerLevels, Error> {
-        Ok(self
+        let power_levels_content = self
             .store
             .get_state_event_static::<RoomPowerLevelsEventContent>(self.room_id())
             .await?
             .ok_or(Error::InsufficientData)?
-            .deserialize()?
-            .power_levels())
+            .deserialize()?;
+        let creators = self.creators().ok_or(Error::InsufficientData)?;
+        let rules = self.inner.read().room_version_rules_or_default();
+
+        Ok(power_levels_content.power_levels(&rules.authorization, creators))
     }
 
     /// Get the current power levels of this room, or a sensible default if they
@@ -380,14 +381,13 @@ impl Room {
             return power_levels;
         }
 
-        // As a fallback, create the default power levels of a room, with the creator at
-        // level 100.
-        let creator = self.creator();
-        assign!(
-            RoomPowerLevelsEventContent::new(),
-            { users: creator.into_iter().map(|user_id| (user_id, int!(100))).collect() }
+        // As a fallback, create the default power levels of a room.
+        let rules = self.inner.read().room_version_rules_or_default();
+        RoomPowerLevels::new(
+            RoomPowerLevelsSource::None,
+            &rules.authorization,
+            self.creators().into_iter().flatten(),
         )
-        .into()
     }
 
     /// Get the `m.room.name` of this room.

crates/matrix-sdk-base/src/room/room_info.rs

@@ -47,7 +47,7 @@ use ruma::{
         RedactedStateEventContent, StateEventType, StaticStateEventContent, SyncStateEvent,
     },
     room::RoomType,
-    room_version_rules::{RedactionRules, RoomVersionRules},
+    room_version_rules::{AuthorizationRules, RedactionRules, RoomVersionRules},
     serde::Raw,
     EventId, MilliSecondsSinceUnixEpoch, MxcUri, OwnedEventId, OwnedMxcUri, OwnedRoomAliasId,
     OwnedRoomId, OwnedUserId, RoomAliasId, RoomId, RoomVersionId,
@@ -230,7 +230,8 @@ impl BaseRoomInfo {
                 self.tombstone = Some(t.into());
             }
             AnySyncStateEvent::RoomPowerLevels(p) => {
-                self.max_power_level = p.power_levels().max().into();
+                // The rules and creators do not affect the max power level.
+                self.max_power_level = p.power_levels(&AuthorizationRules::V1, vec![]).max().into();
             }
             AnySyncStateEvent::CallMember(m) => {
                 let Some(o_ev) = m.as_original() else {
@@ -306,7 +307,8 @@ impl BaseRoomInfo {
                 self.tombstone = Some(t.into());
             }
             AnyStrippedStateEvent::RoomPowerLevels(p) => {
-                self.max_power_level = p.power_levels().max().into();
+                // The rules and creators do not affect the max power level.
+                self.max_power_level = p.power_levels(&AuthorizationRules::V1, vec![]).max().into();
             }
             AnyStrippedStateEvent::CallMember(_) => {
                 // Ignore stripped call state events. Rooms that are not in Joined or Left state

crates/matrix-sdk-base/src/sliding_sync.rs

@@ -1302,6 +1302,17 @@ mod tests {
         let client = logged_in_base_client(Some(own_user_id)).await;
         let room_id = room_id!("!r:e.uk");
 
+        // The room create event.
+        let create = json!({
+            "sender":"@ignacio:example.com",
+            "state_key":"",
+            "type":"m.room.create",
+            "event_id": "$idc",
+            "origin_server_ts": 12344415,
+            "content":{ "room_version": "11" },
+            "room_id": room_id,
+        });
+
         // Give the current user invite or kick permissions in this room
         let power_levels = json!({
             "sender":"@alice:example.com",
@@ -1327,7 +1338,10 @@ mod tests {
         // When the sliding sync response contains a timeline
         let events = &[knock_event];
         let mut room = room_with_timeline(events);
-        room.required_state.push(Raw::new(&power_levels).unwrap().cast_unchecked());
+        room.required_state.extend([
+            Raw::new(&create).unwrap().cast_unchecked(),
+            Raw::new(&power_levels).unwrap().cast_unchecked(),
+        ]);
         let response = response_with_room(room_id, room);
         client
             .process_sliding_sync(&response, &RequestedRequiredStates::default())

crates/matrix-sdk-base/src/store/integration_tests.rs

@@ -29,6 +29,7 @@ use ruma::{
         RoomAccountDataEventType, StateEventType, SyncStateEvent,
     },
     owned_event_id, owned_mxc_uri, room_id,
+    room_version_rules::AuthorizationRules,
     serde::Raw,
     uint, user_id, EventId, MilliSecondsSinceUnixEpoch, OwnedEventId, OwnedUserId, RoomId,
     TransactionId, UserId,
@@ -1944,7 +1945,7 @@ fn first_receipt_event_id() -> &'static EventId {
 }
 
 fn power_level_event() -> Raw<AnySyncStateEvent> {
-    let content = RoomPowerLevelsEventContent::default();
+    let content = RoomPowerLevelsEventContent::new(&AuthorizationRules::V1);
 
     let event = json!({
         "event_id": "$h29iv0s8:example.com",

crates/matrix-sdk-base/src/store/mod.rs

@@ -32,6 +32,7 @@ use std::{
 
 use eyeball_im::{Vector, VectorDiff};
 use futures_util::Stream;
+use matrix_sdk_common::ROOM_VERSION_RULES_FALLBACK;
 use once_cell::sync::OnceCell;
 
 #[cfg(any(test, feature = "testing"))]
@@ -49,6 +50,7 @@ use ruma::{
         presence::PresenceEvent,
         receipt::ReceiptEventContent,
         room::{
+            create::RoomCreateEventContent,
             member::{RoomMemberEventContent, StrippedRoomMemberEvent},
             power_levels::{RoomPowerLevels, RoomPowerLevelsEventContent},
             redaction::SyncRoomRedactionEvent,
@@ -69,7 +71,7 @@ use crate::{
     deserialized_responses::DisplayName,
     event_cache::store as event_cache_store,
     room::{RoomInfo, RoomInfoNotableUpdate, RoomState},
-    MinimalRoomMemberEvent, Room, RoomStateFilter, SessionMeta,
+    MinimalRoomMemberEvent, Room, RoomCreateWithCreatorEventContent, RoomStateFilter, SessionMeta,
 };
 
 pub(crate) mod ambiguity_map;
@@ -639,16 +641,28 @@ impl StateChanges {
         self.any_state_static_for_key::<RoomMemberEventContent, _>(room_id, user_id)
     }
 
+    /// Get the create event for the given room from an event contained in these
+    /// `StateChanges`, if any.
+    pub(crate) fn create(&self, room_id: &RoomId) -> Option<RoomCreateWithCreatorEventContent> {
+        self.any_state_static_for_key::<RoomCreateEventContent, _>(room_id, &EmptyStateKey)
+            .map(|event| {
+                RoomCreateWithCreatorEventContent::from_event_content(event.content, event.sender)
+            })
+            // Fallback to the content in the room info.
+            .or_else(|| self.room_infos.get(room_id)?.create().cloned())
+    }
+
     /// Get the power levels for the given room from an event contained in these
     /// `StateChanges`, if any.
     pub(crate) fn power_levels(&self, room_id: &RoomId) -> Option<RoomPowerLevels> {
-        Some(
-            self.any_state_static_for_key::<RoomPowerLevelsEventContent, _>(
-                room_id,
-                &EmptyStateKey,
-            )?
-            .power_levels(),
-        )
+        let power_levels_content = self
+            .any_state_static_for_key::<RoomPowerLevelsEventContent, _>(room_id, &EmptyStateKey)?;
+
+        let create_content = self.create(room_id)?;
+        let rules = create_content.room_version.rules().unwrap_or(ROOM_VERSION_RULES_FALLBACK);
+        let creators = create_content.creators();
+
+        Some(power_levels_content.power_levels(&rules.authorization, creators))
     }
 }