feat(sdk): Add RoomEventCacheGenericUpdate::Cleared.

This patch adds the `RoomEventCacheGenericUpdate::Cleared` variant. It's
helpful to know when a room has been cleared.

Author: Hywan

crates/matrix-sdk/src/event_cache/mod.rs

@@ -488,10 +488,17 @@ impl EventCacheInner {
         // propagate updates to observers.
         try_join_all(room_locks.into_iter().map(|(room, mut state_guard)| async move {
             let updates_as_vector_diffs = state_guard.reset().await?;
+
             let _ = room.inner.sender.send(RoomEventCacheUpdate::UpdateTimelineEvents {
                 diffs: updates_as_vector_diffs,
                 origin: EventsOrigin::Cache,
             });
+
+            let _ = room
+                .inner
+                .generic_update_sender
+                .send(RoomEventCacheGenericUpdate::Cleared { room_id: room.inner.room_id.clone() });
+
             Ok::<_, EventCacheError>(())
         }))
         .await?;
@@ -637,13 +644,20 @@ pub enum RoomEventCacheGenericUpdate {
         /// The room ID owning the timeline.
         room_id: OwnedRoomId,
     },
+
+    /// The room has been cleared, all events have been deleted.
+    Cleared {
+        /// The ID of the room that has been cleared.
+        room_id: OwnedRoomId,
+    },
 }
 
 impl RoomEventCacheGenericUpdate {
     /// Get the room ID that has triggered this generic update.
     pub fn room_id(&self) -> &RoomId {
         match self {
             Self::TimelineUpdated { room_id } => room_id,
+            Self::Cleared { room_id } => room_id,
         }
     }
 }

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

@@ -383,6 +383,12 @@ impl RoomEventCache {
             origin: EventsOrigin::Cache,
         });
 
+        // Notify observers about the generic update.
+        let _ = self
+            .inner
+            .generic_update_sender
+            .send(RoomEventCacheGenericUpdate::Cleared { room_id: self.inner.room_id.clone() });
+
         Ok(())
     }
 
@@ -2444,6 +2450,7 @@ mod timed_tests {
         let (room_event_cache, _drop_handles) = room.event_cache().await.unwrap();
 
         let (items, mut stream) = room_event_cache.subscribe().await;
+        let mut generic_stream = event_cache.subscribe_to_room_generic_updates();
 
         // The rooms knows about all cached events.
         {
@@ -2486,6 +2493,18 @@ mod timed_tests {
         assert_eq!(diffs.len(), 1);
         assert_let!(VectorDiff::Clear = &diffs[0]);
 
+        // … same with a generic update.
+        assert_let_timeout!(
+            Ok(RoomEventCacheGenericUpdate::TimelineUpdated { room_id: received_room_id }) =
+                generic_stream.recv()
+        );
+        assert_eq!(received_room_id, room_id);
+        assert_let_timeout!(
+            Ok(RoomEventCacheGenericUpdate::Cleared { room_id: received_room_id }) =
+                generic_stream.recv()
+        );
+        assert_eq!(received_room_id, room_id);
+
         // Events individually are not forgotten by the event cache, after clearing a
         // room.
         assert!(room_event_cache.find_event(event_id1).await.is_some());
@@ -2896,6 +2915,8 @@ mod timed_tests {
         assert_eq!(events[0].event_id().as_deref(), Some(evid2));
         assert!(stream.is_empty());
 
+        let mut generic_stream = event_cache.subscribe_to_room_generic_updates();
+
         // Force loading the full linked chunk by back-paginating.
         let outcome = room_event_cache.pagination().run_backwards_once(20).await.unwrap();
         assert_eq!(outcome.events.len(), 1);
@@ -2913,6 +2934,13 @@ mod timed_tests {
 
         assert!(stream.is_empty());
 
+        // Same for the generic update.
+        assert_let_timeout!(
+            Ok(RoomEventCacheGenericUpdate::TimelineUpdated { room_id: received_room_id }) =
+                generic_stream.recv()
+        );
+        assert_eq!(received_room_id, room_id);
+
         // Shrink the linked chunk to the last chunk.
         let diffs = room_event_cache
             .inner
@@ -2933,6 +2961,9 @@ mod timed_tests {
 
         assert!(stream.is_empty());
 
+        // No generic update is sent in this case.
+        assert!(generic_stream.is_empty());
+
         // When reading the events, we do get only the last one.
         let events = room_event_cache.events().await;
         assert_eq!(events.len(), 1);