fix: Make sure Heroes are reactive to status changes.

Author: pixlwave

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

@@ -469,6 +469,13 @@ impl Room {
         self.store.get_user_ids(self.room_id(), RoomMemberships::JOIN).await
     }
 
+    /// The user IDs of this room's heroes, as stored, for cheaply checking
+    /// hero membership without loading their global profiles.
+    #[cfg(feature = "unstable-msc4426")]
+    pub(crate) fn hero_user_ids(&self) -> Vec<OwnedUserId> {
+        self.info.read().heroes().iter().map(|hero| hero.user_id.clone()).collect()
+    }
+
     /// Get the heroes for this room.
     ///
     /// This also filters out possible service members from the list of heroes

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

@@ -1458,6 +1458,9 @@ bitflags! {
 
         /// The user's `m.fully_read` marker has changed.
         const FULLY_READ = 0b0000_0001_0000_0000;
+
+        /// A room hero's global profile changed (e.g. their status or call).
+        const HEROES = 0b0000_0010_0000_0000;
     }
 }
 

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

@@ -219,12 +219,29 @@ impl BaseClient {
         )
         .await?;
 
-        // Notify subscribers (e.g. open timelines) about global profile updates, which
-        // don't otherwise touch any room and so trigger no other broadcast.
+        // Profile-only updates don't modify any rooms, so nothing else broadcasts
+        // them. Surface the change so subscribers can react accordingly.
         if !extensions.profiles.is_empty() {
             let _ = self
                 .global_profile_updates_sender
                 .send(extensions.profiles.keys().cloned().collect());
+
+            // Nudge `RoomInfo` so hero status/call fields are re-read.
+            #[cfg(feature = "unstable-msc4426")]
+            for room in self.state_store.rooms() {
+                if room
+                    .hero_user_ids()
+                    .iter()
+                    .any(|user_id| extensions.profiles.contains_key(user_id))
+                {
+                    let _ = self.state_store.room_info_notable_update_sender.send(
+                        crate::RoomInfoNotableUpdate {
+                            room_id: room.room_id().to_owned(),
+                            reasons: crate::RoomInfoNotableUpdateReasons::HEROES,
+                        },
+                    );
+                }
+            }
         }
 
         let mut context = processors::Context::default();
@@ -1643,6 +1660,62 @@ mod tests {
         );
     }
 
+    #[cfg(feature = "unstable-msc4426")]
+    #[async_test]
+    async fn test_hero_global_profile_update_triggers_notable_update() {
+        use ruma::profile::UserProfileUpdate;
+
+        let client = logged_in_base_client(None).await;
+        let room_id = room_id!("!r:e.uk");
+        let alice = owned_user_id!("@alice:e.uk");
+
+        // Given a room where Alice is a hero.
+        let mut room = http::response::Room::new();
+        room.heroes = Some(vec![assign!(http::response::Hero::new(alice.clone()), {
+            name: Some("Alice".to_owned()),
+        })]);
+        let response = response_with_room(room_id, room);
+        client
+            .process_sliding_sync(
+                &response,
+                &RequestedRequiredStates::default(),
+                &client.state_store_lock().lock().await,
+            )
+            .await
+            .expect("Failed to process sync");
+
+        let mut room_info_notable_update = client.room_info_notable_update_receiver();
+
+        // When a subsequent sync carries only a profiles-extension update for Alice.
+        let mut response = http::Response::new("1".to_owned());
+        response.extensions.profiles.insert(
+            alice.clone(),
+            UserProfileUpdate::from_iter([(
+                "org.matrix.msc4426.status".to_owned(),
+                json!({ "text": "Away", "emoji": "🌴" }),
+            )]),
+        );
+        client
+            .process_sliding_sync(
+                &response,
+                &RequestedRequiredStates::default(),
+                &client.state_store_lock().lock().await,
+            )
+            .await
+            .expect("Failed to process sync");
+
+        // Then a `HEROES` notable update is emitted for the room, so consumers
+        // re-read the hero profiles.
+        assert_matches!(
+            room_info_notable_update.recv().await,
+            Ok(RoomInfoNotableUpdate { room_id: received_room_id, reasons }) => {
+                assert_eq!(received_room_id, room_id);
+                assert!(reasons.contains(RoomInfoNotableUpdateReasons::HEROES));
+            }
+        );
+        assert!(room_info_notable_update.is_empty());
+    }
+
     #[async_test]
     async fn test_recency_stamp_is_found_when_processing_sliding_sync_response() {
         // Given a logged-in client