Merge branch 'main' into ambiguity-changes

Signed-off-by: Kévin Commaille <[email protected]>

.typos.toml

@@ -24,10 +24,11 @@ singing = "signing"
 Nd = "Nd"
 
 [files]
-# Our json files contain a bunch of base64 encoded ed25519 keys which aren't
-# automatically ignored, we ignore them here.
 extend-exclude = [
+    # Our json files contain a bunch of base64 encoded ed25519 keys.
     "*.json",
-    # We are using some fuzzy match patterns that can be understood as typos confusingly.
+    # Fuzzy match patterns that can be understood as typos confusingly.
     "crates/matrix-sdk-ui/tests/integration/room_list_service.rs",
+    # Hand-crafted base64 session keys that are understood as typos.
+    "crates/matrix-sdk-indexeddb/src/crypto_store/migrations.rs",
 ]

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

@@ -4,7 +4,10 @@ use matrix_sdk::{
     self, encryption::CryptoStoreError, oidc::OidcError, HttpError, IdParseError,
     NotificationSettingsError as SdkNotificationSettingsError, StoreError,
 };
-use matrix_sdk_ui::{encryption_sync_service, notification_client, sync_service, timeline};
+use matrix_sdk_ui::{
+    encryption_sync_service, event_graph::EventGraphError, notification_client, sync_service,
+    timeline,
+};
 use uniffi::UnexpectedUniFFICallbackError;
 
 #[derive(Debug, thiserror::Error)]
@@ -115,6 +118,12 @@ impl From<RoomError> for ClientError {
     }
 }
 
+impl From<EventGraphError> for ClientError {
+    fn from(e: EventGraphError) -> Self {
+        Self::new(e)
+    }
+}
+
 #[derive(Debug, thiserror::Error, uniffi::Error)]
 #[uniffi(flat_error)]
 pub enum RoomError {

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

@@ -216,3 +216,113 @@ where
         event.as_original().context("Failed to get original content")?.content.clone();
     Ok(original_content)
 }
+
+#[derive(Clone, uniffi::Enum)]
+pub enum StateEventType {
+    CallMember,
+    PolicyRuleRoom,
+    PolicyRuleServer,
+    PolicyRuleUser,
+    RoomAliases,
+    RoomAvatar,
+    RoomCanonicalAlias,
+    RoomCreate,
+    RoomEncryption,
+    RoomGuestAccess,
+    RoomHistoryVisibility,
+    RoomJoinRules,
+    RoomMemberEvent,
+    RoomName,
+    RoomPinnedEvents,
+    RoomPowerLevels,
+    RoomServerAcl,
+    RoomThirdPartyInvite,
+    RoomTombstone,
+    RoomTopic,
+    SpaceChild,
+    SpaceParent,
+}
+
+impl From<StateEventType> for ruma::events::StateEventType {
+    fn from(val: StateEventType) -> Self {
+        match val {
+            StateEventType::CallMember => Self::CallMember,
+            StateEventType::PolicyRuleRoom => Self::PolicyRuleRoom,
+            StateEventType::PolicyRuleServer => Self::PolicyRuleServer,
+            StateEventType::PolicyRuleUser => Self::PolicyRuleUser,
+            StateEventType::RoomAliases => Self::RoomAliases,
+            StateEventType::RoomAvatar => Self::RoomAvatar,
+            StateEventType::RoomCanonicalAlias => Self::RoomCanonicalAlias,
+            StateEventType::RoomCreate => Self::RoomCreate,
+            StateEventType::RoomEncryption => Self::RoomEncryption,
+            StateEventType::RoomGuestAccess => Self::RoomGuestAccess,
+            StateEventType::RoomHistoryVisibility => Self::RoomHistoryVisibility,
+            StateEventType::RoomJoinRules => Self::RoomJoinRules,
+            StateEventType::RoomMemberEvent => Self::RoomMember,
+            StateEventType::RoomName => Self::RoomName,
+            StateEventType::RoomPinnedEvents => Self::RoomPinnedEvents,
+            StateEventType::RoomPowerLevels => Self::RoomPowerLevels,
+            StateEventType::RoomServerAcl => Self::RoomServerAcl,
+            StateEventType::RoomThirdPartyInvite => Self::RoomThirdPartyInvite,
+            StateEventType::RoomTombstone => Self::RoomTombstone,
+            StateEventType::RoomTopic => Self::RoomTopic,
+            StateEventType::SpaceChild => Self::SpaceChild,
+            StateEventType::SpaceParent => Self::SpaceParent,
+        }
+    }
+}
+
+#[derive(Clone, uniffi::Enum)]
+pub enum MessageLikeEventType {
+    CallAnswer,
+    CallCandidates,
+    CallHangup,
+    CallInvite,
+    KeyVerificationAccept,
+    KeyVerificationCancel,
+    KeyVerificationDone,
+    KeyVerificationKey,
+    KeyVerificationMac,
+    KeyVerificationReady,
+    KeyVerificationStart,
+    PollEnd,
+    PollResponse,
+    PollStart,
+    Reaction,
+    RoomEncrypted,
+    RoomMessage,
+    RoomRedaction,
+    Sticker,
+    UnstablePollEnd,
+    UnstablePollResponse,
+    UnstablePollStart,
+}
+
+impl From<MessageLikeEventType> for ruma::events::MessageLikeEventType {
+    fn from(val: MessageLikeEventType) -> Self {
+        match val {
+            MessageLikeEventType::CallAnswer => Self::CallAnswer,
+            MessageLikeEventType::CallInvite => Self::CallInvite,
+            MessageLikeEventType::CallHangup => Self::CallHangup,
+            MessageLikeEventType::CallCandidates => Self::CallCandidates,
+            MessageLikeEventType::KeyVerificationReady => Self::KeyVerificationReady,
+            MessageLikeEventType::KeyVerificationStart => Self::KeyVerificationStart,
+            MessageLikeEventType::KeyVerificationCancel => Self::KeyVerificationCancel,
+            MessageLikeEventType::KeyVerificationAccept => Self::KeyVerificationAccept,
+            MessageLikeEventType::KeyVerificationKey => Self::KeyVerificationKey,
+            MessageLikeEventType::KeyVerificationMac => Self::KeyVerificationMac,
+            MessageLikeEventType::KeyVerificationDone => Self::KeyVerificationDone,
+            MessageLikeEventType::Reaction => Self::Reaction,
+            MessageLikeEventType::RoomEncrypted => Self::RoomEncrypted,
+            MessageLikeEventType::RoomMessage => Self::RoomMessage,
+            MessageLikeEventType::RoomRedaction => Self::RoomRedaction,
+            MessageLikeEventType::Sticker => Self::Sticker,
+            MessageLikeEventType::PollEnd => Self::PollEnd,
+            MessageLikeEventType::PollResponse => Self::PollResponse,
+            MessageLikeEventType::PollStart => Self::PollStart,
+            MessageLikeEventType::UnstablePollEnd => Self::UnstablePollEnd,
+            MessageLikeEventType::UnstablePollResponse => Self::UnstablePollResponse,
+            MessageLikeEventType::UnstablePollStart => Self::UnstablePollStart,
+        }
+    }
+}

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

@@ -1,7 +1,7 @@
 use std::{convert::TryFrom, sync::Arc};
 
 use anyhow::{Context, Result};
-use matrix_sdk::{room::Room as SdkRoom, RoomMemberships, RoomState};
+use matrix_sdk::{room::Room as SdkRoom, RoomMemberships, RoomNotableTags, RoomState};
 use matrix_sdk_ui::timeline::RoomExt;
 use mime::Mime;
 use ruma::{
@@ -17,8 +17,9 @@ use super::RUNTIME;
 use crate::{
     chunk_iterator::ChunkIterator,
     error::{ClientError, MediaInfoError, RoomError},
+    event::{MessageLikeEventType, StateEventType},
     room_info::RoomInfo,
-    room_member::{MessageLikeEventType, RoomMember, StateEventType},
+    room_member::RoomMember,
     ruma::ImageInfo,
     timeline::{EventTimelineItem, Timeline},
     utils::u64_to_uint,
@@ -139,21 +140,17 @@ impl Room {
         }
     }
 
-    pub async fn timeline(&self) -> Arc<Timeline> {
+    pub async fn timeline(&self) -> Result<Arc<Timeline>, ClientError> {
         let mut write_guard = self.timeline.write().await;
         if let Some(timeline) = &*write_guard {
-            timeline.clone()
+            Ok(timeline.clone())
         } else {
-            let timeline = Timeline::new(self.inner.timeline().await);
+            let timeline = Timeline::new(self.inner.timeline().await?);
             *write_guard = Some(timeline.clone());
-            timeline
+            Ok(timeline)
         }
     }
 
-    pub async fn poll_history(&self) -> Arc<Timeline> {
-        Timeline::new(self.inner.poll_history().await)
-    }
-
     pub fn display_name(&self) -> Result<String, ClientError> {
         let r = self.inner.clone();
         RUNTIME.block_on(async move { Ok(r.display_name().await?.to_string()) })
@@ -256,6 +253,21 @@ impl Room {
         })))
     }
 
+    pub fn subscribe_to_notable_tags(
+        self: Arc<Self>,
+        listener: Box<dyn RoomNotableTagsListener>,
+    ) -> Arc<TaskHandle> {
+        Arc::new(TaskHandle::new(RUNTIME.spawn(async move {
+            let (initial, mut subscriber) = self.inner.notable_tags_stream().await;
+            // Send the initial value
+            listener.call(initial);
+            // Then wait for changes
+            while let Some(notable_tags) = subscriber.next().await {
+                listener.call(notable_tags);
+            }
+        })))
+    }
+
     /// Redacts an event from the room.
     ///
     /// # Arguments
@@ -512,6 +524,11 @@ pub trait RoomInfoListener: Sync + Send {
     fn call(&self, room_info: RoomInfo);
 }
 
+#[uniffi::export(callback_interface)]
+pub trait RoomNotableTagsListener: Sync + Send {
+    fn call(&self, notable_tags: RoomNotableTags);
+}
+
 #[derive(uniffi::Object)]
 pub struct RoomMembersIterator {
     chunk_iterator: ChunkIterator<matrix_sdk::room::RoomMember>,

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

@@ -46,6 +46,8 @@ pub enum RoomListError {
     TimelineAlreadyExists { room_name: String },
     #[error("A timeline instance hasn't been initialized for room {room_name}")]
     TimelineNotInitialized { room_name: String },
+    #[error("Timeline couldn't be initialized: {error}")]
+    InitializingTimeline { error: String },
 }
 
 impl From<matrix_sdk_ui::room_list_service::Error> for RoomListError {
@@ -60,6 +62,9 @@ impl From<matrix_sdk_ui::room_list_service::Error> for RoomListError {
             TimelineAlreadyExists(room_id) => {
                 Self::TimelineAlreadyExists { room_name: room_id.to_string() }
             }
+            InitializingTimeline(source) => {
+                Self::InitializingTimeline { error: source.to_string() }
+            }
         }
     }
 }
@@ -473,14 +478,15 @@ impl RoomListItem {
     }
 
     /// Initializes the timeline for this room using the provided parameters.
+    ///
     /// * `event_type_filter` - An optional [`TimelineEventTypeFilter`] to be
     ///   used to filter timeline events besides the default timeline filter. If
     ///   `None` is passed, only the default timeline filter will be used.
     async fn init_timeline(
         &self,
         event_type_filter: Option<Arc<TimelineEventTypeFilter>>,
     ) -> Result<(), RoomListError> {
-        let mut timeline_builder = self.inner.default_room_timeline_builder();
+        let mut timeline_builder = self.inner.default_room_timeline_builder().await;
         if let Some(event_type_filter) = event_type_filter {
             timeline_builder = timeline_builder.event_filter(move |event, room_version_id| {
                 // Always perform the default filter first
@@ -501,14 +507,6 @@ impl RoomListItem {
     async fn latest_event(&self) -> Option<Arc<EventTimelineItem>> {
         self.inner.latest_event().await.map(EventTimelineItem).map(Arc::new)
     }
-
-    fn has_unread_notifications(&self) -> bool {
-        self.inner.has_unread_notifications()
-    }
-
-    fn unread_notifications(&self) -> Arc<UnreadNotificationsCount> {
-        Arc::new(self.inner.unread_notifications().into())
-    }
 }
 
 #[derive(Clone, Debug, uniffi::Enum)]