WidgetDriver: add ToDevice widget events and machine actions.

It consists of the following changes:
 - add a `NotifyNewToDeviceEvent` ToWidget request (a request that will be sent to the widget from the client when the client receives a widget action over the widget api)
 - add the `SendToDeviceRequest` (driver request that will be sent from the widget and asks the driver to send a ToDevice event)
 - add the ToDeviceActions to the required enums: `IncomingMessage`(machine), `MatrixDriverResponse`, `FromWidgetResponse`, `FromWidgetRequest`, `MatrixDriverRequestData`

Author: toger5

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

@@ -23,7 +23,7 @@ use ruma::{
 use serde::Deserialize;
 use tracing::debug;
 
-use super::machine::SendEventRequest;
+use super::machine::{SendEventRequest, SendToDeviceRequest};
 
 /// A Filter for Matrix events. It is used to decide if a given event can be
 /// sent to the widget and if a widget is allowed to send an event to a
@@ -147,8 +147,8 @@ impl ToDeviceEventFilter {
 }
 
 impl ToDeviceEventFilter {
-    fn matches(&self, filter_input: &FilterInput) -> bool {
-        matches!(filter_input,FilterInput::ToDevice(f_in) if f_in.event_type == self.event_type)
+    fn matches(&self, filter_input: &FilterInput<'_>) -> bool {
+        matches!(filter_input,FilterInput::ToDevice(f_in) if f_in.event_type == self.event_type.to_string())
     }
 }
 
@@ -243,11 +243,17 @@ pub struct FilterInputToDevice<'a> {
 /// Create a filter input of type [`FilterInput::ToDevice`]`.
 impl<'a> TryFrom<&'a Raw<AnyToDeviceEvent>> for FilterInput<'a> {
     type Error = serde_json::Error;
-    fn try_from(raw_event: Raw<AnyToDeviceEvent>) -> Result<Self, Self::Error> {
+    fn try_from(raw_event: &'a Raw<AnyToDeviceEvent>) -> Result<Self, Self::Error> {
         // deserialize_as::<FilterInput> will first try state, message like and then to-device.
         // The `AnyToDeviceEvent` would match message like first, so we need to explicitly
         // deserialize as `FilterInputToDevice`.
-        raw_event.deserialize_as::<FilterInputToDevice>().map(FilterInput::ToDevice)
+        raw_event.deserialize_as::<FilterInputToDevice<'a>>().map(FilterInput::ToDevice)
+    }
+}
+
+impl<'a> From<&'a SendToDeviceRequest> for FilterInput<'a> {
+    fn from(request: &'a SendToDeviceRequest) -> Self {
+        FilterInput::ToDevice(FilterInputToDevice { event_type: &request.event_type })
     }
 }
 

crates/matrix-sdk/src/widget/machine/driver_req.rs

@@ -14,12 +14,17 @@
 
 //! A high-level API for requests that we send to the matrix driver.
 
-use std::marker::PhantomData;
+use std::{collections::BTreeMap, marker::PhantomData};
 
 use ruma::{
-    api::client::{account::request_openid_token, delayed_events::update_delayed_event},
-    events::AnyTimelineEvent,
+    api::client::{
+        account::request_openid_token, delayed_events::update_delayed_event,
+        to_device::send_event_to_device,
+    },
+    events::{AnyTimelineEvent, AnyToDeviceEventContent},
     serde::Raw,
+    to_device::DeviceIdOrAllDevices,
+    OwnedUserId,
 };
 use serde::Deserialize;
 use serde_json::value::RawValue as RawJsonValue;
@@ -52,6 +57,9 @@ pub(crate) enum MatrixDriverRequestData {
     /// Send matrix event that corresponds to the given description.
     SendMatrixEvent(SendEventRequest),
 
+    /// Send matrix event that corresponds to the given description.
+    SendToDeviceEvent(SendToDeviceRequest),
+
     /// Data for sending a UpdateDelayedEvent client server api request.
     UpdateDelayedEvent(UpdateDelayedEventRequest),
 }
@@ -253,6 +261,45 @@ impl FromMatrixDriverResponse for SendEventResponse {
     }
 }
 
+/// Ask the client to send matrix event that corresponds to the given
+/// description and returns an event ID (or a delay ID,
+/// see [MSC4140](https://github.com/matrix-org/matrix-spec-proposals/pull/4140)) as a response.
+#[derive(Clone, Debug, Deserialize)]
+pub(crate) struct SendToDeviceRequest {
+    /// The type of the event.
+    #[serde(rename = "type")]
+    pub(crate) event_type: String,
+    // If the to_device message should be encrypted or not.
+    pub(crate) encrypted: bool,
+    /// The messages that will be encrypted (per device) and sent.
+    /// They are organized in a map of user_id -> device_id -> content like the
+    /// cs api request.
+    pub(crate) messages:
+        BTreeMap<OwnedUserId, BTreeMap<DeviceIdOrAllDevices, Raw<AnyToDeviceEventContent>>>,
+}
+
+impl From<SendToDeviceRequest> for MatrixDriverRequestData {
+    fn from(value: SendToDeviceRequest) -> Self {
+        MatrixDriverRequestData::SendToDeviceEvent(value)
+    }
+}
+
+impl MatrixDriverRequest for SendToDeviceRequest {
+    type Response = send_event_to_device::v3::Response;
+}
+
+impl FromMatrixDriverResponse for send_event_to_device::v3::Response {
+    fn from_response(ev: MatrixDriverResponse) -> Option<Self> {
+        match ev {
+            MatrixDriverResponse::MatrixToDeviceSent(response) => Some(response),
+            _ => {
+                error!("bug in MatrixDriver, received wrong event response");
+                None
+            }
+        }
+    }
+}
+
 /// Ask the client to send a UpdateDelayedEventRequest with the given `delay_id`
 /// and `action`. Defined by [MSC4157](https://github.com/matrix-org/matrix-spec-proposals/pull/4157)
 #[derive(Deserialize, Debug, Clone)]

crates/matrix-sdk/src/widget/machine/from_widget.rs

@@ -17,14 +17,15 @@ use ruma::{
     api::client::{
         delayed_events::{delayed_message_event, delayed_state_event, update_delayed_event},
         error::{ErrorBody, StandardErrorBody},
+        to_device::send_event_to_device,
     },
     events::AnyTimelineEvent,
     serde::Raw,
     OwnedEventId, OwnedRoomId,
 };
 use serde::{Deserialize, Serialize};
 
-use super::{SendEventRequest, UpdateDelayedEventRequest};
+use super::{driver_req::SendToDeviceRequest, SendEventRequest, UpdateDelayedEventRequest};
 use crate::{widget::StateKeySelector, Error, HttpError, RumaApiError};
 
 #[derive(Deserialize, Debug)]
@@ -37,6 +38,7 @@ pub(super) enum FromWidgetRequest {
     #[serde(rename = "org.matrix.msc2876.read_events")]
     ReadEvent(ReadEventRequest),
     SendEvent(SendEventRequest),
+    SendToDevice(SendToDeviceRequest),
     #[serde(rename = "org.matrix.msc4157.update_delayed_event")]
     DelayedEventUpdate(UpdateDelayedEventRequest),
 }
@@ -68,7 +70,7 @@ impl FromWidgetErrorResponse {
         }
     }
 
-    /// Create a error response to send to the widget from a matrix sdk error.
+    /// Create an error response to send to the widget from a matrix sdk error.
     pub(crate) fn from_error(error: Error) -> Self {
         match error {
             Error::Http(e) => FromWidgetErrorResponse::from_http_error(*e),
@@ -97,6 +99,7 @@ struct FromWidgetError {
     message: String,
 
     /// Optional matrix error hinting at workarounds for specific errors.
+    #[serde(skip_serializing_if = "Option::is_none")]
     matrix_api_error: Option<FromWidgetMatrixErrorBody>,
 }
 
@@ -230,10 +233,26 @@ impl From<delayed_state_event::unstable::Response> for SendEventResponse {
 /// [`update_delayed_event`](update_delayed_event::unstable::Response)
 /// which derives Serialize. (The response struct from Ruma does not derive
 /// serialize)
+/// This is intentionally an empty tuple struct (not a unit struct), so that it
+/// serializes to `{}` instead of `Null` when returned to the widget as json.
 #[derive(Serialize, Debug)]
 pub(crate) struct UpdateDelayedEventResponse {}
 impl From<update_delayed_event::unstable::Response> for UpdateDelayedEventResponse {
     fn from(_: update_delayed_event::unstable::Response) -> Self {
         Self {}
     }
 }
+
+/// The response to the widget that it received the to-device event.
+/// Only used as the response for the successful send case.
+/// FromWidgetErrorResponse will be used otherwise.
+/// This is intentionally an empty tuple struct (not a unit struct), so that it
+/// serializes to `{}` instead of `Null` when returned to the widget as json.
+#[derive(Serialize, Debug)]
+pub(crate) struct SendToDeviceEventResponse {}
+
+impl From<send_event_to_device::v3::Response> for SendToDeviceEventResponse {
+    fn from(_: send_event_to_device::v3::Response) -> Self {
+        Self {}
+    }
+}

crates/matrix-sdk/src/widget/machine/incoming.rs

@@ -13,8 +13,8 @@
 // limitations under the License.
 
 use ruma::{
-    api::client::{account::request_openid_token, delayed_events},
-    events::AnyTimelineEvent,
+    api::client::{account::request_openid_token, delayed_events, to_device::send_event_to_device},
+    events::{AnyTimelineEvent, AnyToDeviceEvent},
     serde::Raw,
 };
 use serde::{de, Deserialize, Deserializer};
@@ -47,8 +47,12 @@ pub(crate) enum IncomingMessage {
     /// The `MatrixDriver` notified the `WidgetMachine` of a new matrix event.
     ///
     /// This means that the machine previously subscribed to some events
-    /// ([`crate::widget::Action::Subscribe`] request).
+    /// ([`crate::widget::Action::SubscribeTimeline`] request).
     MatrixEventReceived(Raw<AnyTimelineEvent>),
+
+    /// The `MatrixDriver` notified the `WidgetMachine` of a new to_device
+    /// event.
+    ToDeviceReceived(Raw<AnyToDeviceEvent>),
 }
 
 pub(crate) enum MatrixDriverResponse {
@@ -65,6 +69,7 @@ pub(crate) enum MatrixDriverResponse {
     /// Client sent some matrix event. The response contains the event ID.
     /// A response to an `Action::SendMatrixEvent` command.
     MatrixEventSent(SendEventResponse),
+    MatrixToDeviceSent(send_event_to_device::v3::Response),
     MatrixDelayedEventUpdate(delayed_events::update_delayed_event::unstable::Response),
 }
 

crates/matrix-sdk/src/widget/machine/mod.rs

@@ -17,7 +17,7 @@
 use std::time::Duration;
 
 use driver_req::UpdateDelayedEventRequest;
-use from_widget::UpdateDelayedEventResponse;
+use from_widget::{SendToDeviceEventResponse, UpdateDelayedEventResponse};
 use indexmap::IndexMap;
 use ruma::{
     serde::{JsonObject, Raw},
@@ -41,8 +41,9 @@ use self::{
     openid::{OpenIdResponse, OpenIdState},
     pending::{PendingRequests, RequestLimits},
     to_widget::{
-        NotifyCapabilitiesChanged, NotifyNewMatrixEvent, NotifyOpenIdChanged, RequestCapabilities,
-        ToWidgetRequest, ToWidgetRequestHandle, ToWidgetResponse,
+        NotifyCapabilitiesChanged, NotifyNewMatrixEvent, NotifyNewToDeviceEvent,
+        NotifyOpenIdChanged, RequestCapabilities, ToWidgetRequest, ToWidgetRequestHandle,
+        ToWidgetResponse,
     },
 };
 #[cfg(doc)]
@@ -64,7 +65,9 @@ mod tests;
 mod to_widget;
 
 pub(crate) use self::{
-    driver_req::{MatrixDriverRequestData, ReadStateEventRequest, SendEventRequest},
+    driver_req::{
+        MatrixDriverRequestData, ReadStateEventRequest, SendEventRequest, SendToDeviceRequest,
+    },
     from_widget::SendEventResponse,
     incoming::{IncomingMessage, MatrixDriverResponse},
 };
@@ -179,6 +182,21 @@ impl WidgetMachine {
                     })
                     .unwrap_or_default()
             }
+            IncomingMessage::ToDeviceReceived(to_device_raw) => {
+                let CapabilitiesState::Negotiated(capabilities) = &self.capabilities else {
+                    error!("Received to device event before capabilities negotiation");
+                    return Vec::new();
+                };
+
+                capabilities
+                    .allow_reading(&to_device_raw)
+                    .then(|| {
+                        self.send_to_widget_request(NotifyNewToDeviceEvent(to_device_raw))
+                            .map(|(_request, action)| vec![action])
+                            .unwrap_or_default()
+                    })
+                    .unwrap_or_default()
+            }
         }
     }
 
@@ -247,6 +265,11 @@ impl WidgetMachine {
                 .map(|a| vec![a])
                 .unwrap_or_default(),
 
+            FromWidgetRequest::SendToDevice(req) => self
+                .process_to_device_request(req, raw_request)
+                .map(|a| vec![a])
+                .unwrap_or_default(),
+
             FromWidgetRequest::GetOpenId {} => {
                 let mut actions =
                     vec![Self::send_from_widget_response(raw_request, Ok(OpenIdResponse::Pending))];
@@ -436,7 +459,35 @@ impl WidgetMachine {
                 result.map_err(FromWidgetErrorResponse::from_error),
             )]
         });
+        Some(action)
+    }
 
+    fn process_to_device_request(
+        &mut self,
+        request: SendToDeviceRequest,
+        raw_request: Raw<FromWidgetRequest>,
+    ) -> Option<Action> {
+        let CapabilitiesState::Negotiated(capabilities) = &self.capabilities else {
+            error!("Received send event request before capabilities negotiation");
+            return None;
+        };
+
+        if !capabilities.allow_sending(&request) {
+            return Some(Self::send_from_widget_error_string_response(
+                raw_request,
+                format!("Not allowed to send to-device message of type: {}", request.event_type),
+            ));
+        }
+
+        let (request, action) = self.send_matrix_driver_request(request)?;
+        request.then(|result, _| {
+            vec![Self::send_from_widget_response(
+                raw_request,
+                result
+                    .map(Into::<SendToDeviceEventResponse>::into)
+                    .map_err(FromWidgetErrorResponse::from_error),
+            )]
+        });
         Some(action)
     }
 

crates/matrix-sdk/src/widget/machine/to_widget.rs

@@ -14,7 +14,10 @@
 
 use std::marker::PhantomData;
 
-use ruma::{events::AnyTimelineEvent, serde::Raw};
+use ruma::{
+    events::{AnyTimelineEvent, AnyToDeviceEvent},
+    serde::Raw,
+};
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 use serde_json::value::RawValue as RawJsonValue;
 use tracing::error;
@@ -124,3 +127,14 @@ impl ToWidgetRequest for NotifyNewMatrixEvent {
 
 #[derive(Deserialize)]
 pub(crate) struct Empty {}
+
+/// Notify the widget that we received a new matrix event.
+/// This is a "response" to the widget subscribing to the events in the room.
+#[derive(Serialize)]
+#[serde(transparent)]
+pub(crate) struct NotifyNewToDeviceEvent(pub(crate) Raw<AnyToDeviceEvent>);
+
+impl ToWidgetRequest for NotifyNewToDeviceEvent {
+    const ACTION: &'static str = "send_to_device";
+    type ResponseData = Empty;
+}

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

@@ -236,6 +236,8 @@ impl WidgetDriver {
                         .update_delayed_event(req.delay_id, req.action)
                         .await
                         .map(MatrixDriverResponse::MatrixDelayedEventUpdate),
+
+                    MatrixDriverRequestData::SendToDeviceEvent(req) => todo!(),
                 };
 
                 // Forward the matrix driver response to the incoming message stream.