temp: sync discussion fixme

Author: toger5

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

@@ -228,6 +228,8 @@ impl MatrixDriver {
             // not (as per MSC3819).
             move |raw: Raw<AnyToDeviceEvent>, encryption_info: Option<EncryptionInfo>| {
                 // Only sent encrypted to-device events
+                // TODO only if the room is enxrypted
+                // self.room.
                 if encryption_info.is_some() {
                     let _ = tx.send(raw);
                 }
@@ -252,44 +254,30 @@ impl MatrixDriver {
     ) -> Result<send_event_to_device::v3::Response> {
         let client = self.room.client();
 
+        // TODO: always encrypt based on the room encryption event
+        // Temporarly just log that the encryption flag is deprecated.
+        // TODO make encrypted a Option<bool>
         let request = if encrypted {
             // We first want to get all missing session before we start any to device
             // sending!
-            client.claim_one_time_keys(messages.keys().map(|u| u.as_ref())).await?;
-            let encrypted_content: BTreeMap<
+            // TODO transform this into an array of devicesLists per content.
+
+            let responses: BTreeMap<
                 OwnedUserId,
                 BTreeMap<DeviceIdOrAllDevices, Raw<AnyToDeviceEventContent>>,
             > = join_all(messages.into_iter().map(|(user_id, device_content_map)| {
+                // TODO maybe group by content.
                 let event_type = event_type.clone();
                 async move {
-                    (
-                        user_id.clone(),
-                        to_device_crypto::encrypted_device_content_map(
-                            &self.room.client(),
-                            &user_id,
-                            &event_type,
-                            device_content_map,
-                        )
-                        .await,
-                    )
+                    client.encryption().send_raw_to_device(devices, event_type, content);
                 }
             }))
             .await
             .into_iter()
             .collect();
-
-            RumaToDeviceRequest::new_raw(
-                ToDeviceEventType::RoomEncrypted,
-                TransactionId::new(),
-                encrypted_content,
-            )
-        } else {
-            RumaToDeviceRequest::new_raw(event_type, TransactionId::new(), messages)
+            //TODO do sth with the responsesn
+            response.map_err(Into::into)
         };
-
-        let response = client.send(request).await;
-
-        response.map_err(Into::into)
     }
 }
 
@@ -312,117 +300,6 @@ fn attach_room_id(raw_ev: &Raw<AnySyncTimelineEvent>, room_id: &RoomId) -> Raw<A
     Raw::new(&ev_obj).unwrap().cast()
 }
 
-/// Move this into the `matrix_crypto` crate!
-/// This module contains helper functions to encrypt to device events.
-mod to_device_crypto {
-    use std::collections::BTreeMap;
-
-    use futures_util::future::join_all;
-    use ruma::{
-        events::{AnyToDeviceEventContent, ToDeviceEventType},
-        serde::Raw,
-        to_device::DeviceIdOrAllDevices,
-        UserId,
-    };
-    use serde_json::Value;
-    use tracing::{info, warn};
-
-    use crate::{encryption::identities::Device, executor::spawn, Client, Error, Result};
-
-    /// This encrypts to device content for a collection of devices.
-    /// It will ignore all devices where errors occurred or where the device
-    /// is not verified or where th user has a has_verification_violation.
-    async fn encrypted_content_for_devices(
-        unencrypted_content: &Raw<AnyToDeviceEventContent>,
-        devices: Vec<Device>,
-        event_type: &ToDeviceEventType,
-    ) -> Result<impl Iterator<Item = (DeviceIdOrAllDevices, Raw<AnyToDeviceEventContent>)>> {
-        let content: Value = unencrypted_content.deserialize_as().map_err(Into::<Error>::into)?;
-        let event_type = event_type.clone();
-        let device_content_tasks = devices.into_iter().map(|device| spawn({
-                let event_type = event_type.clone();
-                let content = content.clone();
-
-                async move {
-                    // This is not yet used. It is incompatible with the spa guest mode (the spa will not verify its crypto identity)
-                    // if !device.is_cross_signed_by_owner() {
-                    //     info!("Device {} is not verified, skipping encryption", device.device_id());
-                    //     return None;
-                    // }
-                    match device
-                        .inner
-                        .encrypt_event_raw(&event_type.to_string(), &content)
-                        .await {
-                            Ok(encrypted) => Some((device.device_id().to_owned().into(), encrypted.cast())),
-                            Err(e) =>{ info!("Failed to encrypt to_device event from widget for device: {} because, {}", device.device_id(), e); None},
-                        }
-                }
-            }));
-        let device_encrypted_content_map =
-            join_all(device_content_tasks).await.into_iter().flatten().flatten();
-        Ok(device_encrypted_content_map)
-    }
-
-    /// Convert the device content map for one user into the same content
-    /// map with encrypted content This needs to flatten the vectors
-    /// we get from `encrypted_content_for_devices`
-    /// since one `DeviceIdOrAllDevices` id can be multiple devices.
-    pub(super) async fn encrypted_device_content_map(
-        client: &Client,
-        user_id: &UserId,
-        event_type: &ToDeviceEventType,
-        device_content_map: BTreeMap<DeviceIdOrAllDevices, Raw<AnyToDeviceEventContent>>,
-    ) -> BTreeMap<DeviceIdOrAllDevices, Raw<AnyToDeviceEventContent>> {
-        let device_map_futures =
-                device_content_map.into_iter().map(|(device_or_all_id, content)| spawn({
-                    let client = client.clone();
-                    let user_id = user_id.to_owned();
-                    let event_type = event_type.clone();
-                    async move {
-                        let Ok(user_devices) = client.encryption().get_user_devices(&user_id).await else {
-                            warn!("Failed to get user devices for user: {}", user_id);
-                            return None;
-                        };
-                        // This is not yet used. It is incompatible with the spa guest mode (the spa will not verify its crypto identity)
-                        // let Ok(user_identity) = client.encryption().get_user_identity(&user_id).await else{
-                        //     warn!("Failed to get user identity for user: {}", user_id);
-                        //     return None;
-                        // };
-                        // if user_identity.map(|i|i.has_verification_violation()).unwrap_or(false) {
-                        //     info!("User {} has a verification violation, skipping encryption", user_id);
-                        //     return None;
-                        // }
-                        let devices: Vec<Device> = match device_or_all_id {
-                            DeviceIdOrAllDevices::DeviceId(device_id) => {
-                                vec![user_devices.get(&device_id)].into_iter().flatten().collect()
-                            }
-                            DeviceIdOrAllDevices::AllDevices => user_devices.devices().collect(),
-                        };
-                        encrypted_content_for_devices(
-                            &content,
-                            devices,
-                            &event_type,
-                        )
-                        .await
-                        .map_err(|e| info!("WidgetDriver: could not encrypt content for to device widget event content: {}. because, {}", content.json(), e))
-                        .ok()
-                }}));
-        let content_map_iterator = join_all(device_map_futures).await.into_iter();
-
-        // The first flatten takes the iterator over Result<Option<impl Iterator<Item =
-        // (DeviceIdOrAllDevices, Raw<AnyToDeviceEventContent>)>>, JoinError>>
-        // and flattens the Result (drops Err() items)
-        // The second takes the iterator over: Option<impl Iterator<Item =
-        // (DeviceIdOrAllDevices, Raw<AnyToDeviceEventContent>)>>
-        // and flattens the Option (drops None items)
-        // The third takes the iterator over iterators: impl Iterator<Item =
-        // (DeviceIdOrAllDevices, Raw<AnyToDeviceEventContent>)>
-        // and flattens it to just an iterator over (DeviceIdOrAllDevices,
-        // Raw<AnyToDeviceEventContent>)
-        content_map_iterator.flatten().flatten().flatten().collect()
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use insta;

crates/matrix-sdk/tests/integration/widget.rs

@@ -27,6 +27,7 @@ use matrix_sdk::{
 use matrix_sdk_common::{executor::spawn, timeout::timeout};
 use matrix_sdk_test::{async_test, event_factory::EventFactory, JoinedRoomBuilder, ALICE, BOB};
 use once_cell::sync::Lazy;
+use rand::rngs::mock;
 use ruma::{
     event_id,
     events::{room::member::MembershipState, MessageLikeEventType, StateEventType},
@@ -64,6 +65,7 @@ async fn run_test_driver(
         }
     }
     let mock_server = MatrixMockServer::new().await;
+    mock_server.server().body_print_limit();
     let client = mock_server.client_builder().build().await;
 
     let room = mock_server.sync_joined_room(&client, &ROOM_ID).await;
@@ -967,7 +969,7 @@ async fn test_send_encrypted_to_device_event() {
                 },
             }
         }),
-        json! {{"error":{"message":"Sending encrypted to-device events is not supported by the widget driver."}}},
+        json! {{}},
         0,
     )
     .await;