feat(knocking): process knocked rooms separately during sync

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

@@ -523,34 +523,35 @@ impl BaseClient {
  Ok(timeline)
  }
 
+ /// Handles the stripped state events in `invite_state`, modifying the
+ /// room's info and posting notifications as needed.
+ ///
+ /// * `room` - The [`Room`] to modify.
+ /// * `events` - The contents of `invite_state` in the form of list of pairs
+ /// of raw stripped state events with their deserialized counterpart.
+ /// * `push_rules` - The push rules for this room.
+ /// * `room_info` - The current room's info.
+ /// * `changes` - The accumulated list of changes to apply once the
+ /// processing is finished.
+ /// * `notifications` - Notifications to post for the current room.
  #[instrument(skip_all, fields(room_id = ?room_info.room_id))]
  pub(crate) async fn handle_invited_state(
  &self,
  room: &Room,
- events: &[Raw<AnyStrippedStateEvent>],
+ events: &[(Raw<AnyStrippedStateEvent>, AnyStrippedStateEvent)],
  push_rules: &Ruleset,
  room_info: &mut RoomInfo,
  changes: &mut StateChanges,
  notifications: &mut BTreeMap<OwnedRoomId, Vec<Notification>>,
  ) -> Result<()> {
  let mut state_events = BTreeMap::new();
 
- for raw_event in events {
- match raw_event.deserialize() {
- Ok(e) => {
- room_info.handle_stripped_state_event(&e);
- state_events
- .entry(e.event_type())
- .or_insert_with(BTreeMap::new)
- .insert(e.state_key().to_owned(), raw_event.clone());
- }
- Err(err) => {
- warn!(
- room_id = ?room_info.room_id,
- "Couldn't deserialize stripped state event: {err:?}",
- );
- }
- }
+ for (raw_event, event) in events {
+ room_info.handle_stripped_state_event(event);
+ state_events
+ .entry(event.event_type())
+ .or_insert_with(BTreeMap::new)
+ .insert(event.state_key().to_owned(), raw_event.clone());
  }
 
  changes.stripped_state.insert(room_info.room_id().to_owned(), state_events.clone());
@@ -1121,13 +1122,16 @@ impl BaseClient {
  self.room_info_notable_update_sender.clone(),
  );
 
+ let invite_state =
+ Self::deserialize_stripped_state_events(&new_info.invite_state.events);
+
  let mut room_info = room.clone_info();
  room_info.mark_as_invited();
  room_info.mark_state_fully_synced();
 
  self.handle_invited_state(
  &room,
- &new_info.invite_state.events,
+ &invite_state,
  &push_rules,
  &mut room_info,
  &mut changes,
@@ -1140,6 +1144,34 @@ impl BaseClient {
  new_rooms.invite.insert(room_id, new_info);
  }
 
+ for (room_id, new_info) in response.rooms.knock {
+ let room = self.store.get_or_create_room(
+ &room_id,
+ RoomState::Knocked,
+ self.room_info_notable_update_sender.clone(),
+ );
+
+ let knock_state = Self::deserialize_stripped_state_events(&new_info.knock_state.events);
+
+ let mut room_info = room.clone_info();
+ room_info.mark_as_knocked();
+ room_info.mark_state_fully_synced();
+
+ self.handle_invited_state(
+ &room,
+ &knock_state,
+ &push_rules,
+ &mut room_info,
+ &mut changes,
+ &mut notifications,
+ )
+ .await?;
+
+ changes.add_room(room_info);
+
+ new_rooms.knocked.insert(room_id, new_info);
+ }
+
  account_data_processor.apply(&mut changes, &self.store).await;
 
  changes.presence = response
@@ -1582,6 +1614,21 @@ impl BaseClient {
  .collect()
  }
 
+ pub(crate) fn deserialize_stripped_state_events(
+ raw_events: &[Raw<AnyStrippedStateEvent>],
+ ) -> Vec<(Raw<AnyStrippedStateEvent>, AnyStrippedStateEvent)> {
+ raw_events
+ .iter()
+ .filter_map(|raw_event| match raw_event.deserialize() {
+ Ok(event) => Some((raw_event.clone(), event)),
+ Err(e) => {
+ warn!("Couldn't deserialize stripped state event: {e}");
+ None
+ }
+ })
+ .collect()
+ }
+
  /// Returns a new receiver that gets future room info notable updates.
  ///
  /// Learn more by reading the [`RoomInfoNotableUpdate`] type.

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

@@ -17,7 +17,10 @@
 use std::fmt;
 
 pub use matrix_sdk_common::debug::*;
-use ruma::{api::client::sync::sync_events::v3::InvitedRoom, serde::Raw};
+use ruma::{
+ api::client::sync::sync_events::v3::{InvitedRoom, KnockedRoom},
+ serde::Raw,
+};
 
 /// A wrapper around a slice of `Raw` events that implements `Debug` in a way
 /// that only prints the event type of each item.
@@ -46,6 +49,20 @@ impl<'a> fmt::Debug for DebugInvitedRoom<'a> {
  }
 }
 
+/// A wrapper around a knocked on room as found in `/sync` responses that
+/// implements `Debug` in a way that only prints the event ID and event type for
+/// the raw events contained in `knock_state`.
+pub struct DebugKnockedRoom<'a>(pub &'a KnockedRoom);
+
+#[cfg(not(tarpaulin_include))]
+impl<'a> fmt::Debug for DebugKnockedRoom<'a> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_struct("KnockedRoom")
+ .field("knock_state", &DebugListOfRawEvents(&self.0.knock_state.events))
+ .finish()
+ }
+}
+
 pub(crate) struct DebugListOfRawEvents<'a, T>(pub &'a [Raw<T>]);
 
 #[cfg(not(tarpaulin_include))]