Cache already-drawn timeline items to avoid expensive draw flows

Cargo.toml

@@ -33,6 +33,7 @@ imbl = { version = "2.0.0", features = ["serde"] }  # same as matrix-sdk-ui
 imghdr = "0.7.0"
 matrix-sdk = { git = "https://github.com/matrix-org/matrix-rust-sdk", features = [ "experimental-sliding-sync" ] }
 matrix-sdk-ui = { git = "https://github.com/matrix-org/matrix-rust-sdk" }
+rangemap = "1.5.0"
 tokio = { version = "1.33.0", features = ["macros", "rt-multi-thread"] }
 tracing-subscriber = "0.3.17"
 unicode-segmentation = "1.10.1"

README.md

@@ -35,6 +35,7 @@ cargo run -- 'USERNAME' 'PASSWORD' ['HOMESERVER_URL']
 
 3. Build and run Robrix using `cargo-makepad`:
     * Fill in your username and password in the [`login.toml`](login.toml) file.
+    * Then use cargo makepad to build and run:
        ```sh
        cargo makepad android run -p robrix --release
        ```

src/media_cache.rs

@@ -1,9 +1,9 @@
 use std::{sync::{Mutex, Arc}, collections::{BTreeMap, btree_map::Entry}, time::SystemTime, ops::{Deref, DerefMut}};
 use makepad_widgets::{error, log};
 use matrix_sdk::{ruma::{OwnedMxcUri, events::room::MediaSource}, media::{MediaRequest, MediaFormat}};
-use crate::{sliding_sync::{self, MatrixRequest}, utils::{MEDIA_THUMBNAIL_FORMAT, MediaFormatConst}};
+use crate::{home::room_screen::TimelineUpdate, sliding_sync::{self, MatrixRequest}, utils::{MediaFormatConst, MEDIA_THUMBNAIL_FORMAT}};
 
-pub static AVATAR_CACHE: Mutex<MediaCache> = Mutex::new(MediaCache::new(MEDIA_THUMBNAIL_FORMAT));
+pub static AVATAR_CACHE: Mutex<MediaCache> = Mutex::new(MediaCache::new(MEDIA_THUMBNAIL_FORMAT, None));
 
 pub type MediaCacheEntryRef = Arc<Mutex<MediaCacheEntry>>;
 
@@ -24,6 +24,8 @@ pub struct MediaCache {
     cache: BTreeMap<OwnedMxcUri, MediaCacheEntryRef>,
     /// The default format to use when fetching media.
     default_format: MediaFormatConst,
+    /// A channel to send updates to a particular timeline when a media request has completed.
+    timeline_update_sender: Option<crossbeam_channel::Sender<TimelineUpdate>>,
 }
 impl Deref for MediaCache {
     type Target = BTreeMap<OwnedMxcUri, MediaCacheEntryRef>;
@@ -40,10 +42,17 @@ impl DerefMut for MediaCache {
 impl MediaCache {
     /// Creates a new media cache that will use the given media format
     /// when fetching media from the server.
-    pub const fn new(default_format: MediaFormatConst) -> Self {
+    ///
+    /// It will also optionally send updates to the given timeline update sender
+    /// when a media request has completed.
+    pub const fn new(
+        default_format: MediaFormatConst,
+        timeline_update_sender: Option<crossbeam_channel::Sender<TimelineUpdate>>,
+    ) -> Self {
         Self {
             cache: BTreeMap::new(),
             default_format,
+            timeline_update_sender,
         }
     }
 
@@ -83,6 +92,7 @@ impl MediaCache {
                 },
                 on_fetched: insert_into_cache,
                 destination,
+                update_sender: self.timeline_update_sender.clone(),
             }
         );
         MediaCacheEntry::Requested
@@ -91,7 +101,12 @@ impl MediaCache {
 }
 
 /// Insert data into a previously-requested media cache entry.
-fn insert_into_cache(value_ref: &Mutex<MediaCacheEntry>, _request: MediaRequest, data: matrix_sdk::Result<Vec<u8>>) {
+fn insert_into_cache(
+    value_ref: &Mutex<MediaCacheEntry>,
+    _request: MediaRequest,
+    data: matrix_sdk::Result<Vec<u8>>,
+    update_sender: Option<crossbeam_channel::Sender<TimelineUpdate>>,
+) {
     let new_value = match data {
         Ok(data) => {
 
@@ -120,4 +135,8 @@ fn insert_into_cache(value_ref: &Mutex<MediaCacheEntry>, _request: MediaRequest,
         }
     };
     *value_ref.lock().unwrap() = new_value;
+
+    if let Some(sender) = update_sender {
+        let _ = sender.send(TimelineUpdate::MediaFetched);
+    }
 }

src/sliding_sync.rs

@@ -130,11 +130,13 @@ pub enum MatrixRequest {
     },
     /// Request to fetch media from the server.
     /// Upon completion of the async media request, the `on_fetched` function
-    /// will be invoked with the `destination` and the result of the media fetch.
+    /// will be invoked with four arguments: the `destination`, the `media_request`,
+    /// the result of the media fetch, and the `update_sender`.
     FetchMedia {
         media_request: MediaRequest,
-        on_fetched: fn(&Mutex<MediaCacheEntry>, MediaRequest, matrix_sdk::Result<Vec<u8>>),
+        on_fetched: fn(&Mutex<MediaCacheEntry>, MediaRequest, matrix_sdk::Result<Vec<u8>>, Option<crossbeam_channel::Sender<TimelineUpdate>>),
         destination: Arc<Mutex<MediaCacheEntry>>,
+        update_sender: Option<crossbeam_channel::Sender<TimelineUpdate>>,
     },
     /// Request to send a message to the given room's timeline.
     SendMessage {
@@ -234,14 +236,14 @@ async fn async_worker(mut receiver: UnboundedReceiver<MatrixRequest>) -> Result<
                 });
             }
 
-            MatrixRequest::FetchMedia { media_request, on_fetched, destination } => {
+            MatrixRequest::FetchMedia { media_request, on_fetched, destination, update_sender } => {
                 let Some(client) = CLIENT.get() else { continue };
                 let media = client.media();
 
                 let _fetch_task = Handle::current().spawn(async move {
                     // log!("Sending fetch media request for {media_request:?}...");
                     let res = media.get_media_content(&media_request, true).await;
-                    on_fetched(&destination, media_request, res);
+                    on_fetched(&destination, media_request, res, update_sender);
                 });
             }
 
@@ -370,15 +372,22 @@ static ALL_ROOM_INFO: Mutex<BTreeMap<OwnedRoomId, RoomInfo>> = Mutex::new(BTreeM
 /// The logged-in Matrix client, which can be freely and cheaply cloned.
 static CLIENT: OnceLock<Client> = OnceLock::new();
 
-/// Returns the timeline update receiver for the given room, if one exists.
+/// Returns the timeline update sender and receiver endpoints for the given room,
+/// if and only if the receiver exists.
 ///
 /// This will only succeed once per room, as only a single channel receiver can exist.
 pub fn take_timeline_update_receiver(
     room_id: &OwnedRoomId,
-) -> Option<crossbeam_channel::Receiver<TimelineUpdate>> {
+) -> Option<(
+        crossbeam_channel::Sender<TimelineUpdate>,
+        crossbeam_channel::Receiver<TimelineUpdate>,
+    )>
+{
     ALL_ROOM_INFO.lock().unwrap()
         .get_mut(room_id)
-        .and_then(|ri| ri.timeline_update_receiver.take())
+        .and_then(|ri| ri.timeline_update_receiver.take()
+            .map(|receiver| (ri.timeline_update_sender.clone(), receiver))
+        )
 }