refactor(live_location_share) : remove the event_cache early return

Author: ganfra

crates/matrix-sdk/src/live_location_share.rs

@@ -116,18 +116,21 @@ impl LiveLocationShares {
     async fn get_initial_live_location_shares(
         room: &Room,
     ) -> crate::Result<Vector<LiveLocationShare>> {
-        let Ok((event_cache, _handles)) = room.event_cache().await else {
-            return Ok(Vector::new());
-        };
+        // Beacon infos are stored in the state store, not the event cache.
         let beacon_infos = room.get_state_events_static::<BeaconInfoEventContent>().await?;
+        // Event cache is only needed for finding last location (optional).
+        let event_cache = room.event_cache().await.ok().map(|(cache, _handles)| cache);
         let mut shares = Vector::new();
         for raw_beacon_info in beacon_infos {
             let Ok(event) = raw_beacon_info.deserialize() else { continue };
             let Some((user_id, beacon_info, event_id)) = Self::extract_live_beacon_info(event)
             else {
                 continue;
             };
-            let last_location = Self::find_last_location(&event_cache, &event_id).await;
+            let last_location = match &event_cache {
+                Some(cache) => Self::find_last_location(cache, &event_id).await,
+                None => None,
+            };
             shares.push_back(LiveLocationShare {
                 user_id,
                 beacon_info,

crates/matrix-sdk/tests/integration/room/beacon/mod.rs

@@ -313,9 +313,6 @@ async fn test_observe_single_live_location_share() {
     let _response = client.sync_once(sync_settings.clone()).await.unwrap();
     server.reset().await;
 
-    // Enable the event cache so the initial snapshot can be loaded from it.
-    client.event_cache().subscribe().unwrap();
-
     let room = client.get_room(*DEFAULT_TEST_ROOM_ID).unwrap();
     let live_location_shares = room.subscribe_to_live_location_shares().await;
     let (initial, stream) = live_location_shares.subscribe();
@@ -444,9 +441,6 @@ async fn test_location_update_for_already_tracked_user() {
     let _response = client.sync_once(sync_settings.clone()).await.unwrap();
     server.reset().await;
 
-    // Enable the event cache so the initial snapshot can be loaded from it.
-    client.event_cache().subscribe().unwrap();
-
     let room = client.get_room(*DEFAULT_TEST_ROOM_ID).unwrap();
     let live_location_shares = room.subscribe_to_live_location_shares().await;
     let (initial, stream) = live_location_shares.subscribe();
@@ -537,9 +531,6 @@ async fn test_beacon_info_stop_removes_user_from_stream() {
     let _response = client.sync_once(sync_settings.clone()).await.unwrap();
     server.reset().await;
 
-    // Enable the event cache so the initial snapshot can be loaded from it.
-    client.event_cache().subscribe().unwrap();
-
     let room = client.get_room(*DEFAULT_TEST_ROOM_ID).unwrap();
     let live_location_shares = room.subscribe_to_live_location_shares().await;
     let (initial, stream) = live_location_shares.subscribe();
@@ -549,28 +540,6 @@ async fn test_beacon_info_stop_removes_user_from_stream() {
     assert_eq!(initial.len(), 1);
     assert!(initial[0].last_location.is_none());
 
-    // Alice's beacon arrives — updates the existing share with last_location.
-    sync_builder.add_joined_room(
-        JoinedRoomBuilder::new(*DEFAULT_TEST_ROOM_ID).add_timeline_event(
-            f.beacon(owned_event_id!("$alice_beacon_info"), 10.0, 20.0, 5, None)
-                .event_id(event_id!("$loc1"))
-                .sender(user_id!("@alice:localhost"))
-                .server_ts(now)
-                .into_raw_sync(),
-        ),
-    );
-    mock_sync(&server, sync_builder.build_json_sync_response(), None).await;
-    let _response = client.sync_once(sync_settings.clone()).await.unwrap();
-    server.reset().await;
-
-    let diffs = stream.next().await.expect("Expected alice added");
-    let shares = diffs.into_iter().fold(initial, |mut v, diff| {
-        diff.apply(&mut v);
-        v
-    });
-    assert_eq!(shares.len(), 1);
-    assert_eq!(shares[0].user_id, user_id!("@alice:localhost"));
-
     // Alice stops her share — beacon_info timeline event with live: false.
     sync_builder.add_joined_room(
         JoinedRoomBuilder::new(*DEFAULT_TEST_ROOM_ID).add_timeline_event(
@@ -587,7 +556,7 @@ async fn test_beacon_info_stop_removes_user_from_stream() {
 
     // Stream emits an update with an empty list — alice is removed.
     let diffs = stream.next().await.expect("Expected share removal");
-    let shares = diffs.into_iter().fold(shares, |mut v, diff| {
+    let shares = diffs.into_iter().fold(initial, |mut v, diff| {
         diff.apply(&mut v);
         v
     });
@@ -630,9 +599,6 @@ async fn test_multiple_users_in_stream() {
     let _response = client.sync_once(sync_settings.clone()).await.unwrap();
     server.reset().await;
 
-    // Enable the event cache so the initial snapshot can be loaded from it.
-    client.event_cache().subscribe().unwrap();
-
     let room = client.get_room(*DEFAULT_TEST_ROOM_ID).unwrap();
     let live_location_shares = room.subscribe_to_live_location_shares().await;
     let (initial, stream) = live_location_shares.subscribe();
@@ -697,3 +663,64 @@ async fn test_multiple_users_in_stream() {
         "geo:50,60;u=8"
     );
 }
+
+#[async_test]
+async fn test_initial_load_contains_location_from_event_cache() {
+    let (client, server) = logged_in_client_with_server().await;
+
+    // Enable event cache BEFORE syncing so events get cached.
+    client.event_cache().subscribe().unwrap();
+
+    let now = MilliSecondsSinceUnixEpoch::now();
+    let f = EventFactory::new();
+    let mut sync_builder = SyncResponseBuilder::new();
+
+    // Alice has a live beacon_info.
+    let beacon_info_event = f
+        .beacon_info(
+            Some("Alice location".to_owned()),
+            Duration::from_millis(300_000),
+            true,
+            Some(now),
+        )
+        .event_id(event_id!("$alice_beacon_info"))
+        .sender(user_id!("@alice:localhost"))
+        .state_key(user_id!("@alice:localhost"))
+        .into_raw_sync_state();
+
+    // A beacon event in the timeline.
+    let beacon_event = f
+        .beacon(owned_event_id!("$alice_beacon_info"), 48.8566, 2.3522, 10, Some(now))
+        .event_id(event_id!("$alice_location"))
+        .sender(user_id!("@alice:localhost"))
+        .server_ts(now)
+        .into_raw_sync();
+
+    sync_builder.add_joined_room(
+        JoinedRoomBuilder::new(*DEFAULT_TEST_ROOM_ID)
+            .add_state_event(beacon_info_event)
+            .add_timeline_event(beacon_event),
+    );
+
+    mock_sync(&server, sync_builder.build_json_sync_response(), None).await;
+
+    let sync_settings =
+        SyncSettings::new().timeout(Duration::from_millis(3000)).token(SyncToken::NoToken);
+    let _response = client.sync_once(sync_settings.clone()).await.unwrap();
+    server.reset().await;
+
+    let room = client.get_room(*DEFAULT_TEST_ROOM_ID).unwrap();
+    let live_location_shares = room.subscribe_to_live_location_shares().await;
+    let (initial, _stream) = live_location_shares.subscribe();
+
+    // Initial snapshot should contain both beacon_info AND last_location.
+    assert_eq!(initial.len(), 1);
+    let share = &initial[0];
+    assert_eq!(share.user_id, user_id!("@alice:localhost"));
+    assert_eq!(share.beacon_info.description, Some("Alice location".to_owned()));
+
+    let last_location =
+        share.last_location.as_ref().expect("Expected last_location in initial load");
+    assert_eq!(last_location.location.uri, "geo:48.8566,2.3522;u=10");
+    assert_eq!(last_location.ts, now);
+}