WidgetDriver: Introduce to-device filter.

A new widget filter is required to add support for to-device events.
This allows to let the widget only send and receive to-device events it has negotiated capabilities for.

Author: toger5

crates/matrix-sdk/src/widget/capabilities.rs

@@ -60,7 +60,7 @@ pub struct Capabilities {
 impl Capabilities {
     /// Checks if a givent event is allowed to be forwarded to the widget.
     ///
-    /// - `event_filter_input` is a minimized event respresntation that contains
+    /// - `event_filter_input` is a minimized event representation that contains
     ///   only the information needed to check if the widget is allowed to
     ///   receive the event. (See [`FilterInput`])
     pub(super) fn allow_reading(&self, event_filter_input: &FilterInput) -> bool {
@@ -69,7 +69,7 @@ impl Capabilities {
 
     /// Checks if a givent event is allowed to be sent by the widget.
     ///
-    /// - `event_filter_input` is a minimized event respresntation that contains
+    /// - `event_filter_input` is a minimized event representation that contains
     ///   only the information needed to check if the widget is allowed to send
     ///   the event to a matrix room. (See [`FilterInput`])
     pub(super) fn allow_sending(&self, event_filter_input: &FilterInput) -> bool {
@@ -103,6 +103,7 @@ impl Serialize for Capabilities {
                 match self.0 {
                     Filter::MessageLike(filter) => PrintMessageLikeEventFilter(filter).fmt(f),
                     Filter::State(filter) => PrintStateEventFilter(filter).fmt(f),
+                    Filter::ToDevice(filter) => filter.fmt(f),
                 }
             }
         }

crates/matrix-sdk/src/widget/filter.rs

@@ -12,10 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use std::fmt;
+
 use ruma::{
     events::{
-        AnyMessageLikeEventContent, AnyTimelineEvent, MessageLikeEventType, StateEventType,
-        TimelineEventType,
+        AnyMessageLikeEventContent, AnyTimelineEvent, AnyToDeviceEvent, MessageLikeEventType,
+        StateEventType, TimelineEventType, ToDeviceEventType,
     },
     serde::Raw,
 };
@@ -34,6 +36,8 @@ pub enum Filter {
     MessageLike(MessageLikeEventFilter),
     /// Filter for state events.
     State(StateEventFilter),
+    /// Filter for to device events.
+    ToDevice(ToDeviceEventFilter),
 }
 
 impl Filter {
@@ -44,6 +48,7 @@ impl Filter {
         match self {
             Self::MessageLike(filter) => filter.matches(filter_input),
             Self::State(filter) => filter.matches(filter_input),
+            Self::ToDevice(filter) => filter.matches(filter_input),
         }
     }
     /// Returns the event type that this filter is configured to match.
@@ -54,6 +59,7 @@ impl Filter {
         match self {
             Self::MessageLike(filter) => filter.filter_event_type(),
             Self::State(filter) => filter.filter_event_type(),
+            Self::ToDevice(filter) => filter.event_type.to_string(),
         }
     }
 }
@@ -126,14 +132,43 @@ impl StateEventFilter {
     }
 }
 
+/// Filter for to-device events.
+#[derive(Clone, Debug)]
+#[cfg_attr(test, derive(PartialEq))]
+pub struct ToDeviceEventFilter {
+    /// The event type this to-device-filter filters for.
+    pub event_type: ToDeviceEventType,
+}
+
+impl ToDeviceEventFilter {
+    /// Create a new `ToDeviceEventFilter` with the given event type.
+    pub fn new(event_type: ToDeviceEventType) -> Self {
+        Self { event_type }
+    }
+}
+
+impl ToDeviceEventFilter {
+    fn matches(&self, filter_input: &FilterInput) -> bool {
+        matches!(filter_input,FilterInput::ToDevice(f_in) if f_in.event_type == self.event_type)
+    }
+}
+
+impl fmt::Display for ToDeviceEventFilter {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.event_type)
+    }
+}
+
 // Filter input:
 
-/// The input data for the filter. This can either be constructed from a
-/// [`Raw<AnyTimelineEvent>`] or a [`SendEventRequest`].
+/// The input data for the filter. This can be constructed from a
+/// [`Raw<AnyTimelineEvent>`], a [`SendEventRequest`] or a [`Raw<AnyToDeviceEvent>`]
+/// or using the FilterInput constructors.
 #[derive(Debug)]
 pub enum FilterInput {
     State(FilterInputState),
     MessageLike(FilterInputMessageLike),
+    ToDevice(FilterInputToDevice),
 }
 
 impl FilterInput {
@@ -207,6 +242,20 @@ impl TryFrom<Raw<AnyTimelineEvent>> for FilterInput {
     }
 }
 
+#[derive(Debug, Deserialize)]
+pub struct FilterInputToDevice {
+    #[serde(rename = "type")]
+    pub(super) event_type: ToDeviceEventType,
+}
+
+/// Create a filter input of type [`FilterInput::ToDevice`]`.
+impl TryFrom<Raw<AnyToDeviceEvent>> for FilterInput {
+    type Error = serde_json::Error;
+    fn try_from(raw_event: Raw<AnyToDeviceEvent>) -> Result<Self, Self::Error> {
+        raw_event.deserialize_as::<FilterInputToDevice>().map(FilterInput::ToDevice)
+    }
+}
+
 impl From<&SendEventRequest> for FilterInput {
     fn from(request: &SendEventRequest) -> Self {
         match &request.state_key {
@@ -243,7 +292,9 @@ mod tests {
     use super::{
         Filter, FilterInput, FilterInputMessageLike, MessageLikeEventFilter, StateEventFilter,
     };
-    use crate::widget::filter::MessageLikeFilterEventContent;
+    use crate::widget::filter::{
+        FilterInputToDevice, MessageLikeFilterEventContent, ToDeviceEventFilter,
+    };
 
     fn message_event(event_type: MessageLikeEventType) -> FilterInput {
         FilterInput::MessageLike(FilterInputMessageLike { event_type, content: Default::default() })
@@ -424,4 +475,12 @@ mod tests {
         assert!(!room_message_filter()
             .matches(&FilterInput::message_like(MessageLikeEventType::Reaction.to_string())));
     }
+
+    #[test]
+    fn test_to_device_filter_does_match() {
+        let f = Filter::ToDevice(ToDeviceEventFilter::new("my.custom.to.device".into()));
+        assert!(f.matches(&FilterInput::ToDevice(FilterInputToDevice {
+            event_type: "my.custom.to.device".into(),
+        })));
+    }
 }