sdk: implement MSC3489 live location sharing

Cargo.toml

@@ -53,7 +53,9 @@ ruma = { git = "https://github.com/ruma/ruma", rev = "e5a370f7e5fcebb0da6e4945e5
  "compat-encrypted-stickers",
  "unstable-msc3401",
  "unstable-msc3266",
- "unstable-msc4075"
+ "unstable-msc3488",
+ "unstable-msc3489",
+ "unstable-msc4075",
 ] }
 ruma-common = { git = "https://github.com/ruma/ruma", rev = "e5a370f7e5fcebb0da6e4945e51c5fafba9aa5f0" }
 serde = "1.0.151"

bindings/matrix-sdk-ffi/src/event.rs

@@ -119,6 +119,7 @@ impl TryFrom<AnySyncStateEvent> for StateEventContent {
 
 #[derive(uniffi::Enum)]
 pub enum MessageLikeEventContent {
+ Beacon,
  CallAnswer,
  CallInvite,
  CallNotify { notify_type: NotifyType },
@@ -144,6 +145,7 @@ impl TryFrom<AnySyncMessageLikeEvent> for MessageLikeEventContent {
 
  fn try_from(value: AnySyncMessageLikeEvent) -> anyhow::Result<Self> {
  let content = match value {
+ AnySyncMessageLikeEvent::Beacon(_) => MessageLikeEventContent::Beacon,
  AnySyncMessageLikeEvent::CallAnswer(_) => MessageLikeEventContent::CallAnswer,
  AnySyncMessageLikeEvent::CallInvite(_) => MessageLikeEventContent::CallInvite,
  AnySyncMessageLikeEvent::CallNotify(content) => {
@@ -230,6 +232,7 @@ where
 
 #[derive(Clone, uniffi::Enum)]
 pub enum StateEventType {
+ BeaconInfo,
  CallMember,
  PolicyRuleRoom,
  PolicyRuleServer,
@@ -257,6 +260,7 @@ pub enum StateEventType {
 impl From<StateEventType> for ruma::events::StateEventType {
  fn from(val: StateEventType) -> Self {
  match val {
+ StateEventType::BeaconInfo => Self::BeaconInfo,
  StateEventType::CallMember => Self::CallMember,
  StateEventType::PolicyRuleRoom => Self::PolicyRuleRoom,
  StateEventType::PolicyRuleServer => Self::PolicyRuleServer,
@@ -285,6 +289,7 @@ impl From<StateEventType> for ruma::events::StateEventType {
 
 #[derive(Clone, uniffi::Enum)]
 pub enum MessageLikeEventType {
+ Beacon,
  CallAnswer,
  CallCandidates,
  CallHangup,
@@ -313,6 +318,7 @@ pub enum MessageLikeEventType {
 impl From<MessageLikeEventType> for ruma::events::MessageLikeEventType {
  fn from(val: MessageLikeEventType) -> Self {
  match val {
+ MessageLikeEventType::Beacon => Self::Beacon,
  MessageLikeEventType::CallAnswer => Self::CallAnswer,
  MessageLikeEventType::CallInvite => Self::CallInvite,
  MessageLikeEventType::CallNotify => Self::CallNotify,

bindings/matrix-sdk-ffi/src/room.rs

@@ -160,6 +160,20 @@ impl Room {
  }
  }
 
+ pub async fn send_beacon_info(&self, duration_millis: u64) -> Result<(), ClientError> {
+ RUNTIME.block_on(async move {
+ self.inner.send_beacon_info(duration_millis).await?;
+ Ok(())
+ })
+ }
+
+ pub async fn stop_beacon_info(&self) -> Result<(), ClientError> {
+ RUNTIME.block_on(async move {
+ self.inner.stop_beacon_info().await?;
+ Ok(())
+ })
+ }
+
  /// Forces the currently active room key, which is used to encrypt messages,
  /// to be rotated.
  ///

bindings/matrix-sdk-ffi/src/timeline/content.rs

@@ -23,7 +23,7 @@ use ruma::events::{
 use tracing::warn;
 
 use super::ProfileDetails;
-use crate::ruma::{ImageInfo, MessageType, PollKind};
+use crate::ruma::{ImageInfo, LocationContent, MessageType, PollKind};
 
 #[derive(Clone, uniffi::Object)]
 pub struct TimelineItemContent(pub(crate) matrix_sdk_ui::timeline::TimelineItemContent);
@@ -44,6 +44,29 @@ impl TimelineItemContent {
  source: Arc::new(MediaSource::from(content.source.clone())),
  }
  }
+ Content::BeaconInfoState(beacon_state) => {
+ let Some(location) = beacon_state.last_location() else {
+ return TimelineItemContentKind::FailedToParseMessageLike {
+ event_type: "org.matrix.msc3672.beacon".to_string(),
+ error: "Could not find beacon last location content".to_string(),
+ };
+ };
+
+ let body = location.description.unwrap_or_else(|| "Location".to_string());
+
+ let location = LocationContent {
+ body,
+ geo_uri: location.uri,
+ description: None,
+ zoom_level: None,
+ asset: None,
+ };
+
+ TimelineItemContentKind::BeaconInfoState {
+ location,
+ user_id: String::from(beacon_state.user_id()),
+ }
+ }
  Content::Poll(poll_state) => TimelineItemContentKind::from(poll_state.results()),
  Content::CallInvite => TimelineItemContentKind::CallInvite,
  Content::CallNotify => TimelineItemContentKind::CallNotify,
@@ -110,6 +133,10 @@ impl TimelineItemContent {
 
 #[derive(uniffi::Enum)]
 pub enum TimelineItemContentKind {
+ BeaconInfoState {
+ location: LocationContent,
+ user_id: String,
+ },
  Message,
  RedactedMessage,
  Sticker {

bindings/matrix-sdk-ffi/src/timeline/mod.rs

@@ -19,16 +19,21 @@ use as_variant::as_variant;
 use content::{InReplyToDetails, RepliedToEventDetails};
 use eyeball_im::VectorDiff;
 use futures_util::{pin_mut, StreamExt as _};
-use matrix_sdk::attachment::{
- AttachmentConfig, AttachmentInfo, BaseAudioInfo, BaseFileInfo, BaseImageInfo,
- BaseThumbnailInfo, BaseVideoInfo, Thumbnail,
+use matrix_sdk::{
+ attachment::{
+ AttachmentConfig, AttachmentInfo, BaseAudioInfo, BaseFileInfo, BaseImageInfo,
+ BaseThumbnailInfo, BaseVideoInfo, Thumbnail,
+ },
+ deserialized_responses::SyncOrStrippedState,
 };
 use matrix_sdk_ui::timeline::{
  EventItemOrigin, LiveBackPaginationStatus, Profile, RepliedToEvent, TimelineDetails,
 };
 use mime::Mime;
 use ruma::{
  events::{
+ beacon::BeaconEventContent,
+ beacon_info::BeaconInfoEventContent,
  location::{AssetType as RumaAssetType, LocationContent, ZoomLevel},
  poll::{
  unstable_end::UnstablePollEndEventContent,
@@ -44,15 +49,15 @@ use ruma::{
  ForwardThread, LocationMessageEventContent, MessageType,
  RoomMessageEventContentWithoutRelation,
  },
- AnyMessageLikeEventContent,
+ AnyMessageLikeEventContent, SyncStateEvent,
  },
  EventId, OwnedTransactionId,
 };
 use tokio::{
  sync::Mutex,
  task::{AbortHandle, JoinHandle},
 };
-use tracing::{error, warn};
+use tracing::{error, info, warn};
 use uuid::Uuid;
 
 use self::content::{Reaction, ReactionSenderData, TimelineItemContent};
@@ -521,6 +526,51 @@ impl Timeline {
  Ok(())
  }
 
+ /// Sends a user's location as a beacon based on their last beacon_info
+ /// event.
+ ///
+ /// Retrieves the last beacon_info from the room state and sends a beacon
+ /// with the geo_uri. Since only one active beacon_info per user per
+ /// room is allowed, we can grab the currently live beacon_info event
+ /// from the room state.
+ ///
+ /// TODO: Does the logic belong in self.inner.room() or here?
+ pub async fn send_user_location_beacon(
+ self: Arc<Self>,
+ geo_uri: String,
+ ) -> Result<(), ClientError> {
+ let Some(raw_event) = self
+ .inner
+ .room()
+ .get_state_event_static_for_key::<BeaconInfoEventContent, _>(
+ self.inner.room().own_user_id(),
+ )
+ .await?
+ else {
+ todo!("How to handle case of missing beacon event for state key?")
+ };
+
+ match raw_event.deserialize() {
+ Ok(SyncOrStrippedState::Sync(SyncStateEvent::Original(beacon_info))) => {
+ if beacon_info.content.is_live() {
+ let beacon_event =
+ BeaconEventContent::new(beacon_info.event_id, geo_uri.clone(), None);
+ let message_content = AnyMessageLikeEventContent::Beacon(beacon_event.clone());
+
+ RUNTIME.spawn(async move {
+ self.inner.send(message_content).await;
+ });
+ }
+ }
+ Ok(SyncOrStrippedState::Sync(SyncStateEvent::Redacted(_))) => {}
+ Ok(SyncOrStrippedState::Stripped(_)) => {}
+ Err(e) => {
+ info!(room_id = ?self.inner.room().room_id(), "Could not deserialize m.beacon_info: {e}");
+ }
+ }
+ Ok(())
+ }
+
  pub async fn send_location(
  self: Arc<Self>,
  body: String,

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

@@ -15,6 +15,7 @@ pub use normal::{Room, RoomHero, RoomInfo, RoomInfoUpdate, RoomState, RoomStateF
 use ruma::{
  assign,
  events::{
+ beacon_info::BeaconInfoEventContent,
  call::member::CallMemberEventContent,
  macros::EventContent,
  room::{
@@ -78,6 +79,8 @@ impl fmt::Display for DisplayName {
 pub struct BaseRoomInfo {
  /// The avatar URL of this room.
  pub(crate) avatar: Option<MinimalStateEvent<RoomAvatarEventContent>>,
+ #[serde(skip_serializing_if = "BTreeMap::is_empty", default)]
+ pub(crate) beacons: BTreeMap<OwnedUserId, MinimalStateEvent<BeaconInfoEventContent>>,
  /// The canonical alias of this room.
  pub(crate) canonical_alias: Option<MinimalStateEvent<RoomCanonicalAliasEventContent>>,
  /// The `m.room.create` event content of this room.
@@ -191,6 +194,9 @@ impl BaseRoomInfo {
  ev.as_original().is_some_and(|o| !o.content.active_memberships(None).is_empty())
  });
  }
+ AnySyncStateEvent::BeaconInfo(b) => {
+ self.beacons.insert(b.state_key().clone(), b.into());
+ }
  _ => return false,
  }
 
@@ -332,6 +338,7 @@ impl Default for BaseRoomInfo {
  fn default() -> Self {
  Self {
  avatar: None,
+ beacons: BTreeMap::new(),
  canonical_alias: None,
  create: None,
  dm_targets: Default::default(),

crates/matrix-sdk-base/src/store/migration_helpers.rs

@@ -199,6 +199,7 @@ impl BaseRoomInfoV1 {
 
  Box::new(BaseRoomInfo {
  avatar,
+ beacons: BTreeMap::new(),
  canonical_alias,
  create,
  dm_targets,

crates/matrix-sdk-ui/src/timeline/beacons.rs

@@ -0,0 +1,97 @@
+//! This module handles rendering of MSC3489 live location sharing in the
+//! timeline.
+
+use std::collections::HashMap;
+
+use ruma::{
+ events::{
+ beacon::BeaconEventContent, beacon_info::BeaconInfoEventContent, location::LocationContent,
+ FullStateEventContent,
+ },
+ EventId, OwnedEventId, OwnedUserId,
+};
+
+/// Holds the state of a beacon_info.
+///
+/// This struct should be created for each beacon_info event handled and then
+/// updated whenever handling any beacon event that relates to the same
+/// beacon_info event.
+#[derive(Clone, Debug)]
+pub struct BeaconState {
+ pub(super) beacon_info_event_content: BeaconInfoEventContent,
+ pub(super) last_location: Option<LocationContent>,
+ pub(super) user_id: OwnedUserId,
+}
+
+impl BeaconState {
+ pub(super) fn new(
+ content: FullStateEventContent<BeaconInfoEventContent>,
+ user_id: OwnedUserId,
+ ) -> Self {
+ match &content {
+ FullStateEventContent::Original { content, .. } => BeaconState {
+ beacon_info_event_content: content.clone(),
+ last_location: None,
+ user_id,
+ },
+ FullStateEventContent::Redacted(_) => {
+ todo!("How should this be handled?")
+ }
+ }
+ }
+
+ /// Update the state with the last known associated beacon info.
+ ///
+ /// Used when a new beacon_info event is sent with the live field set
+ /// to false.
+ pub(super) fn update_beacon_info(&self, content: &BeaconInfoEventContent) -> Self {
+ let mut clone = self.clone();
+ clone.beacon_info_event_content = content.clone();
+ clone
+ }
+
+ /// Update the state with the last known associated beacon location.
+ pub(super) fn update_beacon(&self, content: &BeaconEventContent) -> Self {
+ let mut clone = self.clone();
+ clone.last_location = Some(content.location.clone());
+ clone
+ }
+
+ /// Get the last known beacon location.
+ pub fn last_location(&self) -> Option<LocationContent> {
+ self.last_location.clone()
+ }
+
+ /// Get the user_id of the user who sent the beacon_info event.
+ pub fn user_id(&self) -> OwnedUserId {
+ self.user_id.clone()
+ }
+}
+
+impl From<BeaconState> for BeaconInfoEventContent {
+ fn from(value: BeaconState) -> Self {
+ BeaconInfoEventContent::new(
+ value.beacon_info_event_content.description.clone(),
+ value.beacon_info_event_content.timeout,
+ value.beacon_info_event_content.live,
+ None,
+ )
+ }
+}
+
+/// Acts as a cache for beacons before their beacon_infos have been handled.
+#[derive(Clone, Debug, Default)]
+pub(super) struct BeaconPendingEvents {
+ pub(super) pending_beacons: HashMap<OwnedEventId, BeaconEventContent>,
+}
+
+impl BeaconPendingEvents {
+ pub(super) fn add_beacon(&mut self, start_id: &EventId, content: &BeaconEventContent) {
+ self.pending_beacons.insert(start_id.to_owned(), content.clone());
+ }
+ pub(super) fn apply(&mut self, beacon_info_event_id: &EventId, beacon_state: &mut BeaconState) {
+ if let Some(newest_beacon) = self.pending_beacons.get_mut(beacon_info_event_id) {
+ beacon_state.last_location = Some(newest_beacon.location.clone());
+ }
+ }
+}