Move Room::subscribe_to_live_location_shares to Room::observable_live_location_share

crates/matrix-sdk/src/lib.rs

@@ -94,6 +94,7 @@ pub use sliding_sync::{
 #[cfg(feature = "uniffi")]
 uniffi::setup_scaffolding!();
 
+pub mod live_location_share;
 #[cfg(any(test, feature = "testing"))]
 pub mod test_utils;
 

crates/matrix-sdk/src/live_location_share.rs

@@ -0,0 +1,82 @@
+// Copyright 2024 The Matrix.org Foundation C.I.C.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Types for live location sharing.
+
+use async_stream::stream;
+use ruma::{
+    events::{
+        beacon::OriginalSyncBeaconEvent, beacon_info::BeaconInfoEventContent,
+        location::LocationContent,
+    },
+    MilliSecondsSinceUnixEpoch, OwnedUserId, RoomId,
+};
+
+use crate::{event_handler::ObservableEventHandler, Client, Room};
+use futures_util::Stream;
+
+/// An observable live location.
+#[derive(Debug)]
+pub struct ObservableLiveLocation {
+    observable_room_events: ObservableEventHandler<(OriginalSyncBeaconEvent, Room)>,
+}
+
+impl ObservableLiveLocation {
+    /// Create a new `ObservableLiveLocation` for a particular room.
+    pub(crate) fn new(client: &Client, room_id: &RoomId) -> Self {
+        Self { observable_room_events: client.observe_room_events(room_id) }
+    }
+
+    /// Get a stream of [`LiveLocationShare`].
+    pub fn subscribe(&self) -> impl Stream<Item = LiveLocationShare> {
+        let stream = self.observable_room_events.subscribe();
+
+        stream! {
+            for await (event, room) in stream {
+                yield LiveLocationShare {
+                    last_location: LastLocation {
+                        location: event.content.location,
+                        ts: event.content.ts,
+                    },
+                    beacon_info: room
+                        .get_user_beacon_info(&event.sender)
+                        .await
+                        .ok()
+                        .map(|info| info.content),
+                    user_id: event.sender,
+                };
+            }
+        }
+    }
+}
+
+/// Details of the last known location beacon.
+#[derive(Clone, Debug)]
+pub struct LastLocation {
+    /// The most recent location content of the user.
+    pub location: LocationContent,
+    /// The timestamp of when the location was updated.
+    pub ts: MilliSecondsSinceUnixEpoch,
+}
+
+/// Details of a users live location share.
+#[derive(Clone, Debug)]
+pub struct LiveLocationShare {
+    /// The user's last known location.
+    pub last_location: LastLocation,
+    /// Information about the associated beacon event.
+    pub beacon_info: Option<BeaconInfoEventContent>,
+    /// The user ID of the person sharing their live location.
+    pub user_id: OwnedUserId,
+}

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

@@ -132,6 +132,7 @@ use crate::{
     error::{BeaconError, WrongRoomState},
     event_cache::{self, EventCacheDropHandles, RoomEventCache},
     event_handler::{EventHandler, EventHandlerDropGuard, EventHandlerHandle, SyncEvent},
+    live_location_share::ObservableLiveLocation,
     media::{MediaFormat, MediaRequestParameters},
     notification_settings::{IsEncrypted, IsOneToOne, RoomNotificationMode},
     room::power_levels::{RoomPowerLevelChanges, RoomPowerLevelsExt},
@@ -2990,17 +2991,18 @@ impl Room {
         Ok(())
     }
 
-    /// Get the beacon information event in the room for the current user.
+    /// Get the beacon information event in the room for the `user_id`.
     ///
     /// # Errors
     ///
     /// Returns an error if the event is redacted, stripped, not found or could
     /// not be deserialized.
-    async fn get_user_beacon_info(
+    pub(crate) async fn get_user_beacon_info(
         &self,
+        user_id: &UserId,
     ) -> Result<OriginalSyncStateEvent<BeaconInfoEventContent>, BeaconError> {
         let raw_event = self
-            .get_state_event_static_for_key::<BeaconInfoEventContent, _>(self.own_user_id())
+            .get_state_event_static_for_key::<BeaconInfoEventContent, _>(user_id)
             .await?
             .ok_or(BeaconError::NotFound)?;
 
@@ -3053,7 +3055,7 @@ impl Room {
     ) -> Result<send_state_event::v3::Response, BeaconError> {
         self.ensure_room_joined()?;
 
-        let mut beacon_info_event = self.get_user_beacon_info().await?;
+        let mut beacon_info_event = self.get_user_beacon_info(self.own_user_id()).await?;
         beacon_info_event.content.stop();
         Ok(self.send_state_event_for_key(self.own_user_id(), beacon_info_event.content).await?)
     }
@@ -3075,7 +3077,7 @@ impl Room {
     ) -> Result<send_message_event::v3::Response, BeaconError> {
         self.ensure_room_joined()?;
 
-        let beacon_info_event = self.get_user_beacon_info().await?;
+        let beacon_info_event = self.get_user_beacon_info(self.own_user_id()).await?;
 
         if beacon_info_event.content.is_live() {
             let content = BeaconEventContent::new(beacon_info_event.event_id, geo_uri, None);
@@ -3085,6 +3087,11 @@ impl Room {
         }
     }
 
+    /// Observe live location shares.
+    pub fn observe_live_location_share(&self) -> ObservableLiveLocation {
+        ObservableLiveLocation::new(&self.client, self.room_id())
+    }
+
     /// Send a call notification event in the current room.
     ///
     /// This is only supposed to be used in **custom** situations where the user