feat(push): add experimental support for applying MSC4359 ("Do not Disturb" notification settings)

Signed-off-by: Johannes Marbach <[email protected]>

Author: Johennes

Cargo.lock

@@ -65,7 +65,7 @@ rand = "0.8.5"
 regex = "1.11.2"
 reqwest = { version = "0.12.23", default-features = false }
 rmp-serde = "1.3.0"
-ruma = { git = "https://github.com/ruma/ruma", rev = "2f64faeabb85950de27e9829faeb389d2779ac57", features = [
+ruma = { git = "https://github.com/ruma/ruma", rev = "de227ef5c5b2d2ecff89ab021ebe53c5d565577d", features = [
     "client-api-c",
     "compat-upload-signatures",
     "compat-arbitrary-length-ids",
@@ -85,11 +85,12 @@ ruma = { git = "https://github.com/ruma/ruma", rev = "2f64faeabb85950de27e9829fa
     "unstable-msc4286",
     "unstable-msc4306",
     "unstable-msc4308",
-    "unstable-msc4310"
+    "unstable-msc4310",
+    "unstable-msc4359"
 ] }
 sentry = { version = "0.42.0", default-features = false }
 sentry-tracing = "0.42.0"
-serde = { version = "1.0.219", features = ["rc"] }
+serde = { version = "1.0.221", features = ["rc"] }
 serde_html_form = "0.2.7"
 serde_json = "1.0.143"
 sha2 = "0.10.9"

Cargo.toml

@@ -27,6 +27,7 @@ crate-type = [
 default = ["bundled-sqlite", "unstable-msc4274", "experimental-element-recent-emojis"]
 bundled-sqlite = ["matrix-sdk/bundled-sqlite"]
 unstable-msc4274 = ["matrix-sdk-ui/unstable-msc4274"]
+unstable-msc4359 = ["matrix-sdk-ui/unstable-msc4359"]
 # Required when targeting a Javascript environment, like Wasm in a browser.
 js = ["matrix-sdk-ui/js"]
 # Use the TLS implementation provided by the host system, necessary on iOS and Wasm platforms.

bindings/matrix-sdk-ffi/Cargo.toml

@@ -65,6 +65,9 @@ testing = [
 # Add support for inline media galleries via msgtypes
 unstable-msc4274 = []
 
+# "Do not Disturb" notification settings
+unstable-msc4359 = ["ruma/unstable-msc4359"]
+
 experimental-element-recent-emojis = []
 
 [dependencies]

crates/matrix-sdk-base/Cargo.toml

@@ -32,6 +32,8 @@ use matrix_sdk_crypto::{
 };
 #[cfg(doc)]
 use ruma::DeviceId;
+#[cfg(feature = "unstable-msc4359")]
+use ruma::events::do_not_disturb::{DoNotDisturbEventContent, DoNotDisturbRoomKey};
 #[cfg(feature = "e2e-encryption")]
 use ruma::events::room::{history_visibility::HistoryVisibility, member::MembershipState};
 use ruma::{
@@ -1135,6 +1137,37 @@ impl BaseClient {
             }
         }
     }
+
+    /// Checks whether the provided `room_id` belongs to a room in "Do not
+    /// Disturb" mode.
+    #[cfg(feature = "unstable-msc4359")]
+    pub async fn is_room_in_do_not_disturb_mode(&self, room_id: &RoomId) -> bool {
+        match self.state_store.get_account_data_event_static::<DoNotDisturbEventContent>().await {
+            Ok(Some(raw_do_not_disturb_room_list)) => {
+                match raw_do_not_disturb_room_list.deserialize() {
+                    Ok(current_do_not_disturb_room_list) => {
+                        current_do_not_disturb_room_list
+                            .content
+                            .rooms
+                            .contains_key(&DoNotDisturbRoomKey::AllRooms)
+                            || current_do_not_disturb_room_list
+                                .content
+                                .rooms
+                                .contains_key(&DoNotDisturbRoomKey::SingleRoom(room_id.to_owned()))
+                    }
+                    Err(error) => {
+                        warn!(?error, "Failed to deserialize the 'Do not Disturb' room list event");
+                        false
+                    }
+                }
+            }
+            Ok(None) => false,
+            Err(error) => {
+                warn!(?error, "Could not get the 'Do not Disturb' room list from the state store");
+                false
+            }
+        }
+    }
 }
 
 /// Represent the `required_state` values sent by a sync request.
@@ -1772,6 +1805,24 @@ mod tests {
         assert!(client.is_user_ignored(ignored_user_id).await);
     }
 
+    #[cfg(feature = "unstable-msc4359")]
+    #[async_test]
+    async fn test_is_room_in_do_not_disturb() {
+        let dnd_room_id = room_id!("!sonofagun");
+        let client = logged_in_base_client(None).await;
+
+        assert!(!client.is_room_in_do_not_disturb_mode(dnd_room_id).await);
+
+        let mut sync_builder = SyncResponseBuilder::new();
+        let f = EventFactory::new();
+        let response = sync_builder
+            .add_global_account_data(f.do_not_disturb_room_list([dnd_room_id.to_owned()]))
+            .build_sync_response();
+        client.receive_sync_response(response).await.unwrap();
+
+        assert!(client.is_room_in_do_not_disturb_mode(dnd_room_id).await);
+    }
+
     #[async_test]
     async fn test_invite_details_are_set() {
         let user_id = user_id!("@alice:localhost");

crates/matrix-sdk-base/src/client.rs

@@ -25,6 +25,9 @@ unstable-msc3956 = ["ruma/unstable-msc3956"]
 # Add support for inline media galleries via msgtypes
 unstable-msc4274 = ["matrix-sdk/unstable-msc4274"]
 
+# "Do not Disturb" notification settings
+unstable-msc4359 = ["matrix-sdk/unstable-msc4359"]
+
 # Enable experimental support for encrypting state events; see
 # https://github.com/matrix-org/matrix-rust-sdk/issues/5397.
 experimental-encrypted-state-events = [
@@ -38,6 +41,7 @@ async-rx.workspace = true
 async-stream.workspace = true
 async_cell = "0.2.3"
 bitflags.workspace = true
+cfg-if.workspace = true
 chrono.workspace = true
 eyeball.workspace = true
 eyeball-im.workspace = true

crates/matrix-sdk-ui/Cargo.toml

@@ -18,6 +18,7 @@ use std::{
     time::Duration,
 };
 
+use cfg_if::cfg_if;
 use futures_util::{StreamExt as _, pin_mut};
 use matrix_sdk::{
     Client, ClientBuildError, SlidingSyncList, SlidingSyncMode, room::Room, sleep::sleep,
@@ -637,7 +638,19 @@ impl NotificationClient {
         let notification_item =
             NotificationItem::new(room, raw_event, push_actions, state_events).await?;
 
-        if self.client.is_user_ignored(notification_item.event.sender()).await {
+        let is_room_in_do_not_disturb = {
+            cfg_if! {
+                if #[cfg(feature = "unstable-msc4359")] {
+                    self.client.is_room_in_do_not_disturb_mode(room.room_id()).await
+                } else {
+                    false
+                }
+            }
+        };
+
+        if self.client.is_user_ignored(notification_item.event.sender()).await
+            || is_room_in_do_not_disturb
+        {
             Ok(NotificationStatus::EventFilteredOut)
         } else {
             Ok(NotificationStatus::Event(Box::new(notification_item)))

crates/matrix-sdk-ui/src/notification_client.rs

@@ -1095,6 +1095,112 @@ async fn test_notification_client_sliding_sync_filters_out_events_from_ignored_u
     };
 }
 
+#[cfg(feature = "unstable-msc4359")]
+#[async_test]
+async fn test_notification_client_sliding_sync_filters_out_events_from_do_not_disturb_rooms() {
+    let server = MatrixMockServer::new().await;
+    let client = server.client_builder().build().await;
+
+    let sender = user_id!("@user:example.org");
+    let my_user_id = client.user_id().unwrap().to_owned();
+
+    let room_id = room_id!("!a98sd12bjh:example.org");
+    let room_name = "The Maltese Falcon";
+    let sender_display_name = "John Mastodon";
+    let event_id = event_id!("$example_event_id");
+
+    let raw_event = EventFactory::new()
+        .room(room_id)
+        .sender(sender)
+        .text_msg("Heya")
+        .event_id(event_id)
+        .into_raw_sync();
+
+    let event_factory = EventFactory::new().room(room_id);
+
+    let sender_member_event = event_factory
+        .member(sender)
+        .display_name(sender_display_name)
+        .membership(MembershipState::Join)
+        .into_raw_sync();
+
+    let own_member_event = event_factory
+        .member(&my_user_id)
+        .display_name("My self")
+        .membership(MembershipState::Join)
+        .into_raw_sync();
+
+    let power_levels_event =
+        event_factory.sender(sender).power_levels(&mut BTreeMap::new()).into_raw_sync();
+
+    let pos = Mutex::new(0);
+    Mock::given(SlidingSyncMatcher)
+        .respond_with(move |request: &Request| {
+            let partial_request: PartialSlidingSyncRequest = request.body_json().unwrap();
+            // Repeat the transaction id in the response, to validate sticky parameters.
+            let mut pos = pos.lock().unwrap();
+            *pos += 1;
+            let pos_as_str = (*pos).to_string();
+            ResponseTemplate::new(200).set_body_json(json!({
+                "txn_id": partial_request.txn_id,
+                "pos": pos_as_str,
+                "rooms": {
+                    room_id: {
+                        "name": room_name,
+                        "initial": true,
+
+                        "required_state": [
+                            // Sender's member information.
+                            sender_member_event,
+
+                            // Own member information.
+                            own_member_event,
+
+                            // Power levels.
+                            power_levels_event,
+                        ],
+
+                        "timeline": [
+                            raw_event,
+                        ]
+                    }
+                },
+
+                "extensions": {
+                    "account_data": {
+                        "global": [{
+                            "type": "dm.filament.do_not_disturb",
+                            "content": {
+                                "rooms": { room_id: {} }
+                            }
+                        }]
+                    }
+                }
+            }))
+        })
+        .mount(server.server())
+        .await;
+
+    let dummy_sync_service = Arc::new(SyncService::builder(client.clone()).build().await.unwrap());
+    let process_setup =
+        NotificationProcessSetup::SingleProcess { sync_service: dummy_sync_service };
+    let notification_client = NotificationClient::new(client, process_setup).await.unwrap();
+    let mut result = notification_client
+        .get_notifications_with_sliding_sync(&[NotificationItemsRequest {
+            room_id: room_id.to_owned(),
+            event_ids: vec![event_id.to_owned()],
+        }])
+        .await
+        .unwrap();
+
+    let Some(Ok(item)) = result.remove(event_id) else {
+        panic!("fetching notification for {event_id} failed");
+    };
+    let NotificationStatus::EventFilteredOut = item else {
+        panic!("notification for {event_id} was not filtered out");
+    };
+}
+
 #[async_test]
 async fn test_notification_client_context_filters_out_events_from_ignored_users() {
     let server = MatrixMockServer::new().await;
@@ -1172,3 +1278,82 @@ async fn test_notification_client_context_filters_out_events_from_ignored_users(
 
     assert_matches!(result, NotificationStatus::EventFilteredOut);
 }
+
+#[cfg(feature = "unstable-msc4359")]
+#[async_test]
+async fn test_notification_client_context_filters_out_events_from_do_not_disturb_rooms() {
+    let server = MatrixMockServer::new().await;
+    let client = server.client_builder().build().await;
+
+    let sender = user_id!("@user:example.org");
+    let room_id = room_id!("!a98sd12bjh:example.org");
+    let event_id = event_id!("$example_event_id");
+
+    server.sync_joined_room(&client, room_id).await;
+
+    // Add mock for sliding sync so we get the ignored user list from its account
+    // data
+    let pos = Mutex::new(0);
+    Mock::given(SlidingSyncMatcher)
+        .respond_with(move |request: &Request| {
+            let partial_request: PartialSlidingSyncRequest = request.body_json().unwrap();
+            // Repeat the transaction id in the response, to validate sticky parameters.
+            let mut pos = pos.lock().unwrap();
+            *pos += 1;
+            let pos_as_str = (*pos).to_string();
+            ResponseTemplate::new(200).set_body_json(json!({
+                "txn_id": partial_request.txn_id,
+                "pos": pos_as_str,
+                "rooms": {},
+
+                "extensions": {
+                    "account_data": {
+                        "global": [{
+                            "type": "dm.filament.do_not_disturb",
+                            "content": {
+                                "rooms": { room_id: {} }
+                            }
+                        }]
+                    }
+                }
+            }))
+        })
+        .mount(server.server())
+        .await;
+
+    let event = EventFactory::new()
+        .room(room_id)
+        .sender(sender)
+        .text_msg("Heya")
+        .event_id(event_id)
+        .into_event();
+
+    // Mock the /context response
+    server
+        .mock_room_event_context()
+        .ok(RoomContextResponseTemplate::new(event).start("start").end("end"))
+        .mock_once()
+        .mount()
+        .await;
+
+    let dummy_sync_service = Arc::new(SyncService::builder(client.clone()).build().await.unwrap());
+    let process_setup =
+        NotificationProcessSetup::SingleProcess { sync_service: dummy_sync_service };
+    let notification_client = NotificationClient::new(client, process_setup).await.unwrap();
+
+    // Call sync first so we get the list of ignored users in the notification
+    // client This should still work in a real life usage
+    let _ = notification_client
+        .get_notifications_with_sliding_sync(&[NotificationItemsRequest {
+            room_id: room_id.to_owned(),
+            event_ids: vec![event_id.to_owned()],
+        }])
+        .await;
+
+    // If the event is not found even though there was a mocked response for it, it
+    // was discarded as expected.
+    let result =
+        notification_client.get_notification_with_context(room_id, event_id).await.unwrap();
+
+    assert_matches!(result, NotificationStatus::EventFilteredOut);
+}

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

@@ -71,6 +71,9 @@ docsrs = ["e2e-encryption", "sqlite", "indexeddb", "sso-login", "qrcode"]
 # Add support for inline media galleries via msgtypes
 unstable-msc4274 = ["ruma/unstable-msc4274", "matrix-sdk-base/unstable-msc4274"]
 
+# "Do not Disturb" notification settings
+unstable-msc4359 = ["matrix-sdk-base/unstable-msc4359"]
+
 experimental-search = ["matrix-sdk-search"]
 
 experimental-element-recent-emojis = ["matrix-sdk-base/experimental-element-recent-emojis"]

crates/matrix-sdk/Cargo.toml

@@ -2860,6 +2860,13 @@ impl Client {
         self.base_client().is_user_ignored(user_id).await
     }
 
+    /// Checks whether the provided `room_id` belongs to a room in "Do not
+    /// Disturb" mode.
+    #[cfg(feature = "unstable-msc4359")]
+    pub async fn is_room_in_do_not_disturb_mode(&self, room_id: &RoomId) -> bool {
+        self.base_client().is_room_in_do_not_disturb_mode(room_id).await
+    }
+
     /// Gets the `max_upload_size` value from the homeserver, getting either a
     /// cached value or with a `/_matrix/client/v1/media/config` request if it's
     /// missing.