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/machine/driver_req.rs

@@ -14,12 +14,20 @@
 
 //! 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, MessageLikeEventType, StateEventType, TimelineEventType},
+    api::client::{
+        account::request_openid_token, delayed_events::update_delayed_event,
+        to_device::send_event_to_device,
+    },
+    events::{
+        AnyTimelineEvent, AnyToDeviceEventContent, MessageLikeEventType, StateEventType,
+        TimelineEventType, ToDeviceEventType,
+    },
     serde::Raw,
+    to_device::DeviceIdOrAllDevices,
+    OwnedUserId,
 };
 use serde::Deserialize;
 use serde_json::value::RawValue as RawJsonValue;
@@ -52,6 +60,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 +264,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: ToDeviceEventType,
+    // 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, MessageLikeEventType, StateEventType},
     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

@@ -16,8 +16,8 @@
 
 use std::{iter, time::Duration};
 
-use driver_req::UpdateDelayedEventRequest;
-use from_widget::UpdateDelayedEventResponse;
+use driver_req::{SendToDeviceRequest, UpdateDelayedEventRequest};
+use from_widget::{SendToDeviceEventResponse, UpdateDelayedEventResponse};
 use indexmap::IndexMap;
 use ruma::{
     serde::{JsonObject, Raw},
@@ -41,15 +41,16 @@ 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)]
 use super::WidgetDriver;
 use super::{
     capabilities::{SEND_DELAYED_EVENT, UPDATE_DELAYED_EVENT},
-    filter::FilterInput,
+    filter::{FilterInput, FilterInputToDevice},
     Capabilities, StateKeySelector,
 };
 use crate::Result;
@@ -179,6 +180,25 @@ impl WidgetMachine {
                 }
                 Vec::new()
             }
+            IncomingMessage::ToDeviceReceived(to_device_raw) => {
+                let CapabilitiesState::Negotiated(capabilities) = &self.capabilities else {
+                    error!("Received to device event before capabilities negotiation");
+                    return Vec::new();
+                };
+                let event_filter_in = match to_device_raw.clone().try_into() {
+                    Ok(filter_in) => filter_in,
+                    Err(e) => {
+                        error!("Failed to convert to device event to filter input: {e}");
+                        return Vec::new();
+                    }
+                };
+                if capabilities.allow_reading(&event_filter_in) {
+                    let action =
+                        self.send_to_widget_request(NotifyNewToDeviceEvent(to_device_raw)).1;
+                    return action.map(|a| vec![a]).unwrap_or_default();
+                }
+                Vec::new()
+            }
         }
     }
 
@@ -247,6 +267,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 (request, request_action) = self.send_matrix_driver_request(RequestOpenId);
                 request.then(|res, machine| {
@@ -425,7 +450,38 @@ impl WidgetMachine {
                 result.map_err(FromWidgetErrorResponse::from_error),
             )]
         });
+        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;
+        };
+
+        let filter_in =
+            FilterInput::ToDevice(FilterInputToDevice { event_type: request.event_type.clone() });
 
+        if !capabilities.allow_sending(&filter_in) {
+            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),
+            )]
+        });
         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;
@@ -130,3 +133,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

@@ -235,6 +235,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.