feat(room): add a new function that will only subscribe to a thread if needed

Author: bnjbvr

crates/matrix-sdk/src/room/mod.rs

@@ -3771,6 +3771,26 @@ impl Room {
         }
     }
 
+    /// Subscribe to a thread if needed, based on a current subscription to it.
+    ///
+    /// This is like [`Self::subscribe_thread`], but it first checks if the user
+    /// has already subscribed to a thread, so as to minimize sending
+    /// unnecessary subscriptions which would be ignored by the server.
+    pub async fn subscribe_thread_if_needed(
+        &self,
+        thread_root: &EventId,
+        automatic: Option<OwnedEventId>,
+    ) -> Result<()> {
+        if let Some(prev_sub) = self.load_or_fetch_thread_subscription(thread_root).await? {
+            // If we have a previous subscription, we should only send the new one if it's
+            // manual and the previous one was automatic.
+            if !prev_sub.automatic || automatic.is_some() {
+                return Ok(());
+            }
+        }
+        self.subscribe_thread(thread_root.to_owned(), automatic).await
+    }
+
     /// Unsubscribe from a given thread in this room.
     ///
     /// # Arguments
@@ -3852,6 +3872,20 @@ impl Room {
 
         Ok(subscription)
     }
+
+    /// Return the current thread subscription for the given thread root in this
+    /// room, by getting it from storage if possible, or fetching it from
+    /// network otherwise.
+    ///
+    /// See also [`Self::fetch_thread_subscription`] for the exact semantics of
+    /// this method.
+    pub async fn load_or_fetch_thread_subscription(
+        &self,
+        thread_root: &EventId,
+    ) -> Result<Option<ThreadSubscription>> {
+        // A bit of a lie at the moment, since thread subscriptions are not sync'd yet.
+        self.fetch_thread_subscription(thread_root.to_owned()).await
+    }
 }
 
 #[cfg(feature = "e2e-encryption")]

crates/matrix-sdk/tests/integration/room/thread.rs

@@ -79,6 +79,97 @@ async fn test_subscribe_thread() {
     assert_matches!(subscription, None);
 }
 
+#[async_test]
+async fn test_subscribe_thread_if_needed() {
+    let server = MatrixMockServer::new().await;
+    let client = server.client_builder().build().await;
+
+    let room_id = room_id!("!test:example.org");
+    let room = server.sync_joined_room(&client, room_id).await;
+
+    // If there's no prior subscription, the function `subscribe_thread_if_needed`
+    // will automatically subscribe to the thread, whether the new subscription
+    // is automatic or not.
+    for (root_id, automatic) in [
+        (owned_event_id!("$root"), None),
+        (owned_event_id!("$woot"), Some(owned_event_id!("$woot"))),
+    ] {
+        server
+            .mock_put_thread_subscription()
+            .match_room_id(room_id.to_owned())
+            .match_thread_id(root_id.clone())
+            .ok()
+            .mock_once()
+            .mount()
+            .await;
+
+        room.subscribe_thread_if_needed(&root_id, automatic).await.unwrap();
+    }
+
+    // If there's a prior automatic subscription, the function
+    // `subscribe_thread_if_needed` will only subscribe to the thread if the new
+    // subscription is manual.
+    {
+        let root_id = owned_event_id!("$toot");
+
+        server
+            .mock_get_thread_subscription()
+            .match_room_id(room_id.to_owned())
+            .match_thread_id(root_id.clone())
+            .ok(true)
+            .mock_once()
+            .mount()
+            .await;
+
+        server
+            .mock_put_thread_subscription()
+            .match_room_id(room_id.to_owned())
+            .match_thread_id(root_id.clone())
+            .ok()
+            .mock_once()
+            .mount()
+            .await;
+
+        room.subscribe_thread_if_needed(&root_id, None).await.unwrap();
+    }
+
+    // Otherwise, it will be a no-op.
+    {
+        let root_id = owned_event_id!("$foot");
+
+        server
+            .mock_get_thread_subscription()
+            .match_room_id(room_id.to_owned())
+            .match_thread_id(root_id.clone())
+            .ok(true)
+            .mock_once()
+            .mount()
+            .await;
+
+        room.subscribe_thread_if_needed(&root_id, Some(owned_event_id!("$foot"))).await.unwrap();
+    }
+
+    // The function `subscribe_thread_if_needed` is a no-op if there's a prior
+    // manual subscription, whether the new subscription is automatic or not.
+    for (root_id, automatic) in [
+        (owned_event_id!("$root"), None),
+        (owned_event_id!("$woot"), Some(owned_event_id!("$woot"))),
+    ] {
+        server
+            .mock_get_thread_subscription()
+            .match_room_id(room_id.to_owned())
+            .match_thread_id(root_id.clone())
+            .ok(false)
+            .mock_once()
+            .mount()
+            .await;
+
+        // No-op! (The PUT endpoint hasn't been mocked, so this would result in a 404 if
+        // it were trying to hit it.)
+        room.subscribe_thread_if_needed(&root_id, automatic).await.unwrap();
+    }
+}
+
 #[async_test]
 async fn test_thread_push_rule_is_triggered_for_subscribed_threads() {
     // This test checks that the evaluation of push rules for threads will correctly