feat(ffi): bindings for global search

Author: bnjbvr

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

@@ -13,11 +13,12 @@
 // limitations under the License.
 
 use matrix_sdk::deserialized_responses::TimelineEvent;
-use matrix_sdk_ui::search::RoomSearch;
+use matrix_sdk_ui::search::{GlobalSearch, RoomSearch};
 use ruma::OwnedUserId;
 use tokio::sync::Mutex;
 
 use crate::{
+    client::Client,
     error::ClientError,
     room::Room,
     timeline::{ProfileDetails, TimelineItemContent},
@@ -42,23 +43,10 @@ pub struct RoomSearchIterator {
 
 #[matrix_sdk_ffi_macros::export]
 impl RoomSearchIterator {
-    /// Return a list of event ids for the next batch of search results, or
-    /// `None` if there are no more results.
-    pub async fn next(&self) -> Option<Vec<String>> {
-        match self.inner.lock().await.next().await {
-            Ok(Some(event_ids)) => Some(event_ids.into_iter().map(|id| id.to_string()).collect()),
-            Ok(None) => None,
-            Err(e) => {
-                eprintln!("Error during search: {e}");
-                None
-            }
-        }
-    }
-
     /// Return a list of events for the next batch of search results, or `None`
     /// if there are no more results.
     pub async fn next_events(&self) -> Result<Option<Vec<RoomSearchResult>>, ClientError> {
-        let Some(events) = self.inner.lock().await.next_events().await? else {
+        let Some(events) = self.inner.lock().await.next_events(20).await? else {
             return Ok(None);
         };
 
@@ -106,3 +94,80 @@ impl RoomSearchResult {
         })
     }
 }
+
+#[derive(Clone, uniffi::Enum)]
+pub enum SearchRoomFilter {
+    /// All the joined rooms (= DMs + groups).
+    AllJoinedRooms,
+    /// Only DM rooms.
+    AllJoinedDms,
+    /// Only non-DM (group) rooms.
+    AllJoinedGroups,
+}
+
+#[matrix_sdk_ffi_macros::export]
+impl Client {
+    pub async fn search(
+        &self,
+        query: String,
+        filter: SearchRoomFilter,
+    ) -> Result<GlobalSearchIterator, ClientError> {
+        let sdk_client = (*self.inner).clone();
+        let mut search = GlobalSearch::builder(sdk_client.clone(), query);
+
+        match filter {
+            SearchRoomFilter::AllJoinedRooms => {}
+            SearchRoomFilter::AllJoinedDms => search = search.only_dm_rooms().await?,
+            SearchRoomFilter::AllJoinedGroups => search = search.only_groups().await?,
+        }
+
+        Ok(GlobalSearchIterator { sdk_client, inner: Mutex::new(search.build()) })
+    }
+}
+
+#[derive(uniffi::Record)]
+pub struct BasicGlobalSearchResult {
+    room_id: String,
+    event_id: String,
+}
+
+#[derive(uniffi::Record)]
+pub struct GlobalSearchResult {
+    room_id: String,
+    result: RoomSearchResult,
+}
+
+#[derive(uniffi::Object)]
+pub struct GlobalSearchIterator {
+    sdk_client: matrix_sdk::Client,
+    inner: Mutex<GlobalSearch>,
+}
+
+#[matrix_sdk_ffi_macros::export]
+impl GlobalSearchIterator {
+    /// Return a list of events for the next batch of search results, or `None`
+    /// if there are no more results.
+    pub async fn next_events(
+        &self,
+        num_results: u64,
+    ) -> Result<Option<Vec<GlobalSearchResult>>, ClientError> {
+        let Some(events) = self.inner.lock().await.next_events(num_results as usize).await? else {
+            return Ok(None);
+        };
+
+        let mut results = Vec::with_capacity(events.len());
+
+        for (room_id, event) in events {
+            let Some(room) = self.sdk_client.get_room(&room_id) else {
+                continue;
+            };
+            if let Some(result) = RoomSearchResult::from(&room, event).await {
+                results.push(GlobalSearchResult { room_id: room_id.to_string(), result });
+            }
+        }
+
+        results.shrink_to_fit();
+
+        Ok(Some(results))
+    }
+}