change(ffi): stop retrieving room list last messages from through the timeline

As per the plan defined in #4718:

```
the room_list_service::room::RoomInner shouldn't make use of its inner timeline;
it's only used in a direct getter, or to compute the latest room event, but it's not working
as intended, since local echoes aren't properly displayed in the room list.
This non-working feature can be removed, in favor of #4112
```

Author: stefanceriu

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

@@ -86,10 +86,6 @@ impl Room {
     pub(crate) fn new(inner: SdkRoom, utd_hook: Option<Arc<UtdHookManager>>) -> Self {
         Room { inner, timeline: Default::default(), utd_hook }
     }
-
-    pub(crate) fn with_timeline(inner: SdkRoom, timeline: TimelineLock) -> Self {
-        Room { inner, timeline, utd_hook: None }
-    }
 }
 
 #[matrix_sdk_ffi_macros::export]

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

@@ -4,31 +4,22 @@ use std::{fmt::Debug, mem::MaybeUninit, ptr::addr_of_mut, sync::Arc, time::Durat
 
 use async_compat::get_runtime_handle;
 use eyeball_im::VectorDiff;
-use futures_util::{pin_mut, StreamExt, TryFutureExt};
+use futures_util::{pin_mut, StreamExt};
 use matrix_sdk::ruma::{
     api::client::sync::sync_events::UnreadNotificationsCount as RumaUnreadNotificationsCount,
     RoomId,
 };
-use matrix_sdk_ui::{
-    room_list_service::filters::{
-        new_filter_all, new_filter_any, new_filter_category, new_filter_favourite,
-        new_filter_fuzzy_match_room_name, new_filter_invite, new_filter_joined,
-        new_filter_non_left, new_filter_none, new_filter_normalized_match_room_name,
-        new_filter_unread, BoxedFilterFn, RoomCategory,
-    },
-    timeline::default_event_filter,
+use matrix_sdk_ui::room_list_service::filters::{
+    new_filter_all, new_filter_any, new_filter_category, new_filter_favourite,
+    new_filter_fuzzy_match_room_name, new_filter_invite, new_filter_joined, new_filter_non_left,
+    new_filter_none, new_filter_normalized_match_room_name, new_filter_unread, BoxedFilterFn,
+    RoomCategory,
 };
 use ruma::{OwnedRoomOrAliasId, OwnedServerName, ServerName};
-use tokio::sync::RwLock;
 
 use crate::{
-    error::ClientError,
-    room::{Membership, Room},
-    room_info::RoomInfo,
-    room_preview::RoomPreview,
-    timeline::{configuration::TimelineEventTypeFilter, EventTimelineItem, Timeline},
-    utils::AsyncRuntimeDropped,
-    TaskHandle,
+    error::ClientError, room::Membership, room_info::RoomInfo, room_preview::RoomPreview,
+    timeline::EventTimelineItem, utils::AsyncRuntimeDropped, TaskHandle,
 };
 
 #[derive(Debug, thiserror::Error, uniffi::Error)]
@@ -593,67 +584,6 @@ impl RoomListItem {
         Ok(Arc::new(RoomPreview::new(AsyncRuntimeDropped::new(client), room_preview)))
     }
 
-    /// Build a full `Room` FFI object, filling its associated timeline.
-    ///
-    /// An error will be returned if the room is a state different than joined
-    /// or if its internal timeline hasn't been initialized.
-    fn full_room(&self) -> Result<Arc<Room>, RoomListError> {
-        if !matches!(self.membership(), Membership::Joined) {
-            return Err(RoomListError::IncorrectRoomMembership {
-                expected: vec![Membership::Joined],
-                actual: self.membership(),
-            });
-        }
-
-        if let Some(timeline) = self.inner.timeline() {
-            Ok(Arc::new(Room::with_timeline(
-                self.inner.inner_room().clone(),
-                Arc::new(RwLock::new(Some(Timeline::from_arc(timeline)))),
-            )))
-        } else {
-            Err(RoomListError::TimelineNotInitialized {
-                room_name: self.inner.inner_room().room_id().to_string(),
-            })
-        }
-    }
-
-    /// Checks whether the Room's timeline has been initialized before.
-    fn is_timeline_initialized(&self) -> bool {
-        self.inner.is_timeline_initialized()
-    }
-
-    /// 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.
-    /// * `internal_id_prefix` - An optional String that will be prepended to
-    ///   all the timeline item's internal IDs, making it possible to
-    ///   distinguish different timeline instances from each other.
-    async fn init_timeline(
-        &self,
-        event_type_filter: Option<Arc<TimelineEventTypeFilter>>,
-        internal_id_prefix: Option<String>,
-    ) -> Result<(), RoomListError> {
-        let mut timeline_builder = self
-            .inner
-            .default_room_timeline_builder()
-            .map_err(|err| RoomListError::InitializingTimeline { error: err.to_string() })?;
-
-        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
-                default_event_filter(event, room_version_id) && event_type_filter.filter(event)
-            });
-        }
-
-        if let Some(internal_id_prefix) = internal_id_prefix {
-            timeline_builder = timeline_builder.with_internal_id_prefix(internal_id_prefix);
-        }
-
-        self.inner.init_timeline_with_builder(timeline_builder).map_err(RoomListError::from).await
-    }
-
     /// Checks whether the room is encrypted or not.
     ///
     /// **Note**: this info may not be reliable if you don't set up

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

@@ -99,11 +99,6 @@ impl Timeline {
         Arc::new(Self { inner })
     }
 
-    pub(crate) fn from_arc(inner: Arc<matrix_sdk_ui::timeline::Timeline>) -> Arc<Self> {
-        // SAFETY: repr(transparent) means transmuting the arc this way is allowed
-        unsafe { Arc::from_raw(Arc::into_raw(inner) as _) }
-    }
-
     fn send_attachment(
         self: Arc<Self>,
         params: UploadParameters,

crates/matrix-sdk-ui/src/room_list_service/room.rs

@@ -17,14 +17,10 @@
 use core::fmt;
 use std::{ops::Deref, sync::Arc};
 
-use async_once_cell::OnceCell as AsyncOnceCell;
 use ruma::RoomId;
 
 use super::Error;
-use crate::{
-    timeline::{EventTimelineItem, TimelineBuilder},
-    Timeline,
-};
+use crate::timeline::{EventTimelineItem, TimelineBuilder};
 
 /// A room in the room list.
 ///
@@ -43,9 +39,6 @@ impl fmt::Debug for Room {
 struct RoomInner {
     /// The underlying client room.
     room: matrix_sdk::Room,
-
-    /// The timeline of the room.
-    timeline: AsyncOnceCell<Arc<Timeline>>,
 }
 
 impl Deref for Room {
@@ -59,7 +52,7 @@ impl Deref for Room {
 impl Room {
     /// Create a new `Room`.
     pub(super) fn new(room: matrix_sdk::Room) -> Self {
-        Self { inner: Arc::new(RoomInner { room, timeline: AsyncOnceCell::new() }) }
+        Self { inner: Arc::new(RoomInner { room }) }
     }
 
     /// Get the room ID.
@@ -77,56 +70,13 @@ impl Room {
         &self.inner.room
     }
 
-    /// Get the timeline of the room if one exists.
-    pub fn timeline(&self) -> Option<Arc<Timeline>> {
-        self.inner.timeline.get().cloned()
-    }
-
-    /// Get whether the timeline has been already initialised or not.
-    pub fn is_timeline_initialized(&self) -> bool {
-        self.inner.timeline.get().is_some()
-    }
-
-    /// Initialize the timeline of the room with an event type filter so only
-    /// some events are returned. If a previous timeline exists, it'll
-    /// return an error. Otherwise, a Timeline will be returned.
-    pub async fn init_timeline_with_builder(&self, builder: TimelineBuilder) -> Result<(), Error> {
-        if self.inner.timeline.get().is_some() {
-            Err(Error::TimelineAlreadyExists(self.inner.room.room_id().to_owned()))
-        } else {
-            self.inner
-                .timeline
-                .get_or_try_init(async { Ok(Arc::new(builder.build().await?)) })
-                .await
-                .map_err(Error::InitializingTimeline)?;
-            Ok(())
-        }
-    }
-
-    /// Get the latest event in the timeline.
-    ///
-    /// The latest event comes first from the `Timeline`, it can be a local or a
-    /// remote event. Note that the `Timeline` can have more information esp. if
-    /// it has run a backpagination for example. Otherwise if the `Timeline`
-    /// doesn't have any latest event, it comes from the cache. This method
-    /// does not fetch any events or calculate anything — if it's not already
-    /// available, we return `None`.
+    /// Get the room's latest event from the cache. This method does not fetch
+    /// any events or calculate anything — if it's not already available, we
+    /// return `None`.
     ///
     /// Reminder: this method also returns `None` is the latest event is not
     /// suitable for use in a message preview.
     pub async fn latest_event(&self) -> Option<EventTimelineItem> {
-        // Look for a local event in the `Timeline`.
-        //
-        // First off, let's see if a `Timeline` exists…
-        if let Some(timeline) = self.inner.timeline.get() {
-            // If it contains a `latest_event`…
-            if let Some(timeline_last_event) = timeline.latest_event().await {
-                // If it's a local event or a remote event, we return it.
-                return Some(timeline_last_event);
-            }
-        }
-
-        // Otherwise, fallback to the classical path.
         if let Some(latest_event) = self.inner.room.latest_event() {
             EventTimelineItem::from_latest_event(
                 self.inner.room.client(),

crates/matrix-sdk-ui/tests/integration/room_list_service.rs

@@ -2464,8 +2464,7 @@ async fn test_room_timeline() -> Result<(), Error> {
     mock_encryption_state(&server, false).await;
 
     let room = room_list.room(room_id)?;
-    room.init_timeline_with_builder(room.default_room_timeline_builder().unwrap()).await?;
-    let timeline = room.timeline().unwrap();
+    let timeline = room.default_room_timeline_builder().unwrap().build().await?;
 
     let (previous_timeline_items, mut timeline_items_stream) = timeline.subscribe().await;
 
@@ -2566,7 +2565,7 @@ async fn test_room_latest_event() -> Result<(), Error> {
     };
 
     let room = room_list.room(room_id)?;
-    room.init_timeline_with_builder(room.default_room_timeline_builder().unwrap()).await?;
+    let timeline = room.default_room_timeline_builder().unwrap().build().await?;
 
     // The latest event does not exist.
     assert!(room.latest_event().await.is_none());
@@ -2617,9 +2616,6 @@ async fn test_room_latest_event() -> Result<(), Error> {
     assert!(latest_event.is_local_echo().not());
     assert_eq!(latest_event.event_id(), Some(event_id!("$x1:bar.org")));
 
-    // Now let's compare with the result of the `Timeline`.
-    let timeline = room.timeline().unwrap();
-
     // The latest event matches the latest event of the `Timeline`.
     assert_matches!(
         timeline.latest_event().await,
@@ -2643,15 +2639,6 @@ async fn test_room_latest_event() -> Result<(), Error> {
         }
     );
 
-    // The latest event is a local event.
-    assert_matches!(
-        room.latest_event().await,
-        Some(event) => {
-            assert!(event.is_local_echo());
-            assert_eq!(event.event_id(), None);
-        }
-    );
-
     Ok(())
 }
 
@@ -2893,10 +2880,7 @@ async fn test_multiple_timeline_init() {
         // Get a RoomListService::Room, initialize the timeline, start a pagination.
         let room = room_list.room(room_id).unwrap();
 
-        let builder = room.default_room_timeline_builder().unwrap();
-        room.init_timeline_with_builder(builder).await.unwrap();
-
-        let timeline = room.timeline().unwrap();
+        let timeline = room.default_room_timeline_builder().unwrap().build().await.unwrap();
 
         spawn(async move { timeline.paginate_backwards(20).await })
     };
@@ -2909,6 +2893,5 @@ async fn test_multiple_timeline_init() {
     task.abort();
 
     // A new timeline for the same room can still be constructed.
-    let builder = room.default_room_timeline_builder().unwrap();
-    room.init_timeline_with_builder(builder).await.unwrap();
+    room.default_room_timeline_builder().unwrap().build().await.unwrap();
 }

labs/multiverse/src/main.rs

@@ -280,14 +280,13 @@ impl App {
                     }
                 };
 
-                if let Err(err) = ui_room.init_timeline_with_builder(builder).await {
-                    error!("error when creating default timeline: {err}");
+                let Ok(timeline) = builder.build().await else {
+                    error!("error when creating default timeline");
                     continue;
-                }
+                };
 
                 // Save the timeline in the cache.
-                let sdk_timeline = ui_room.timeline().unwrap();
-                let (items, stream) = sdk_timeline.subscribe().await;
+                let (items, stream) = timeline.subscribe().await;
                 let items = Arc::new(Mutex::new(items));
 
                 // Spawn a timeline task that will listen to all the timeline item changes.
@@ -306,7 +305,7 @@ impl App {
 
                 new_timelines.push((
                     ui_room.room_id().to_owned(),
-                    Timeline { timeline: sdk_timeline, items, task: timeline_task },
+                    Timeline { timeline: Arc::new(timeline), items, task: timeline_task },
                 ));
 
                 // Save the room list service room in the cache.

labs/multiverse/src/widgets/room_view/mod.rs

@@ -12,6 +12,7 @@ use matrix_sdk::{
     },
     RoomState,
 };
+use matrix_sdk_ui::timeline::TimelineBuilder;
 use ratatui::{prelude::*, widgets::*};
 use tokio::{spawn, task::JoinHandle};
 
@@ -328,7 +329,12 @@ impl RoomView {
         };
 
         // Mark as read!
-        match room.timeline().unwrap().mark_as_read(ReceiptType::Read).await {
+        let Ok(timeline) = TimelineBuilder::new(&room).build().await else {
+            self.status_handle.set_message("failed creating timeline".to_owned());
+            return;
+        };
+
+        match timeline.mark_as_read(ReceiptType::Read).await {
             Ok(did) => {
                 self.status_handle.set_message(format!(
                     "did {}send a read receipt!",