chore: update dependencies

Part-of: <https://gitlab.gnome.org/GNOME/fractal/-/merge_requests/1152>

Cargo.toml

@@ -49,6 +49,7 @@ regex = "1.5.4"
 mime_guess = "2.0.3"
 num_enum = "0.5.6"
 thiserror = "1.0.25"
+rqrr = "0.4.0"
 
 [dependencies.sourceview]
 package = "sourceview5"
@@ -74,5 +75,5 @@ features = ["socks", "sso-login", "markdown", "qrcode", "experimental-timeline"]
 
 [dependencies.ruma]
 git = "https://github.com/ruma/ruma"
-rev = "ca8c66c885241a7ba3805399604eda4a38979f6b"
+rev = "c745d3baf720b38a254e640a526717864e87a065"
 features = ["unstable-pre-spec", "client-api-c"]

src/contrib/qr_code_scanner/qr_code_detector.rs

@@ -2,12 +2,16 @@ use std::convert::AsRef;
 
 use glib::Sender;
 use gst_video::{video_frame::VideoFrameRef, VideoInfo};
+use image::{GenericImage, GenericImageView, Luma};
 use log::debug;
-use matrix_sdk::encryption::verification::QrVerificationData;
+use matrix_sdk::encryption::verification::{DecodingError, QrVerificationData};
+use thiserror::Error;
 
 use super::*;
 use crate::contrib::qr_code_scanner::camera_paintable::Action;
 
+const HEADER: &[u8] = b"MATRIX";
+
 mod imp {
     use std::sync::Mutex;
 
@@ -104,7 +108,7 @@ mod imp {
 
                 let image = samples.as_view_mut::<image::Luma<u8>>().unwrap();
 
-                if let Ok(code) = QrVerificationData::from_luma(image) {
+                if let Ok(code) = decode_qr(image) {
                     let mut previous_code = self.code.lock().unwrap();
                     if previous_code.as_ref() != Some(&code) {
                         previous_code.replace(code.clone());
@@ -138,3 +142,43 @@ impl QrCodeDetector {
         sink
     }
 }
+
+// From https://github.com/matrix-org/matrix-rust-sdk/blob/79d13148fbba58db0ff5f62b27e7856cbbbe13c2/crates/matrix-sdk-qrcode/src/utils.rs#L81-L104
+pub(crate) fn decode_qr<I>(image: I) -> Result<QrVerificationData, QrDecodingError>
+where
+    I: GenericImage<Pixel = Luma<u8>> + GenericImageView<Pixel = Luma<u8>>,
+{
+    let mut image = rqrr::PreparedImage::prepare(image);
+    let grids = image.detect_grids();
+
+    let mut error = None;
+
+    for grid in grids {
+        let mut decoded = Vec::new();
+
+        match grid.decode_to(&mut decoded) {
+            Ok(_) => {
+                if decoded.starts_with(HEADER) {
+                    return QrVerificationData::from_bytes(decoded).map_err(Into::into);
+                }
+            }
+            Err(e) => error = Some(e),
+        }
+    }
+
+    Err(error
+        .map(|e| e.into())
+        .unwrap_or_else(|| DecodingError::Header.into()))
+}
+
+/// All possible errors when decoding a QR Code.
+#[derive(Debug, Error)]
+pub enum QrDecodingError {
+    /// An error occurred when decoding the QR data.
+    #[error(transparent)]
+    Matrix(#[from] DecodingError),
+
+    /// An error occurred when decoding the QR image.
+    #[error(transparent)]
+    Rqrr(#[from] rqrr::DeQRError),
+}

src/session/account_settings/devices_page/device.rs

@@ -208,6 +208,6 @@ impl Device {
         self.imp()
             .crypto_device
             .get()
-            .map_or(false, |device| device.verified())
+            .map_or(false, |device| device.is_verified())
     }
 }

src/session/account_settings/user_page/mod.rs

@@ -1,4 +1,4 @@
-use std::{fs::File, time::Duration};
+use std::time::Duration;
 
 use adw::{prelude::*, subclass::prelude::*};
 use gettextrs::gettext;
@@ -267,13 +267,15 @@ impl UserPage {
             .and_then(|info| info.content_type())
             .and_then(|content_type| gio::content_type_get_mime_type(&content_type))
             .unwrap();
-        let mut file = File::open(file.path().unwrap()).unwrap();
+        let (data, _) = file.load_contents_future().await.unwrap();
 
         let client_clone = client.clone();
-        let handle =
-            spawn_tokio!(
-                async move { client_clone.upload(&mime.parse().unwrap(), &mut file).await }
-            );
+        let handle = spawn_tokio!(async move {
+            client_clone
+                .media()
+                .upload(&mime.parse().unwrap(), &data)
+                .await
+        });
 
         let uri = match handle.await.unwrap() {
             Ok(res) => res.content_uri,

src/session/avatar.rs

@@ -170,7 +170,7 @@ impl Avatar {
                 }),
             };
             let handle =
-                spawn_tokio!(async move { client.get_media_content(&request, true).await });
+                spawn_tokio!(async move { client.media().get_media_content(&request, true).await });
 
             spawn!(
                 glib::PRIORITY_LOW,
@@ -267,7 +267,7 @@ where
     };
     content.url = uri.clone();
 
-    joined_room.send_state_event(content, "").await?;
+    joined_room.send_state_event(content).await?;
     Ok(uri)
 }
 
@@ -285,7 +285,8 @@ where
     info!("Uploading avatar from file {:?}", filename);
     // TODO: Use blurhash
     let response = matrix_client
-        .upload(&content_type.parse()?, &mut image.as_slice())
+        .media()
+        .upload(&content_type.parse()?, &image)
         .await?;
     Ok(response.content_uri)
 }

src/session/content/room_history/item_row.rs

@@ -1,7 +1,7 @@
 use adw::{prelude::*, subclass::prelude::*};
 use gettextrs::gettext;
 use gtk::{gio, glib, glib::clone};
-use matrix_sdk::ruma::events::AnySyncRoomEvent;
+use matrix_sdk::ruma::events::AnySyncTimelineEvent;
 
 use crate::{
     components::{ContextMenuBin, ContextMenuBinExt, ContextMenuBinImpl, ReactionChooser},
@@ -287,7 +287,7 @@ impl ItemRow {
 
     fn set_event_widget(&self, event: &SupportedEvent) {
         match event.matrix_event() {
-            AnySyncRoomEvent::State(state) => {
+            AnySyncTimelineEvent::State(state) => {
                 let child = if let Some(Ok(child)) = self.child().map(|w| w.downcast::<StateRow>())
                 {
                     child

src/session/content/room_history/message_row/audio.rs

@@ -219,7 +219,7 @@ impl MessageAudio {
         }
 
         let client = session.client();
-        let handle = spawn_tokio!(async move { client.get_file(audio, true).await });
+        let handle = spawn_tokio!(async move { client.media().get_file(audio, true).await });
 
         spawn!(
             glib::PRIORITY_LOW,

src/session/content/room_history/message_row/media.rs

@@ -379,11 +379,11 @@ impl MessageMedia {
     {
         self.set_state(MediaState::Loading);
 
-        let client = session.client();
+        let media = session.client().media();
         let handle = spawn_tokio!(async move {
             let thumbnail =
                 if media_type != MediaType::Video && content.thumbnail_source().is_some() {
-                    client
+                    media
                         .get_thumbnail(
                             content.clone(),
                             MediaThumbnailSize {
@@ -405,7 +405,7 @@ impl MessageMedia {
                 Ok((Some(data), id))
             } else {
                 let id = media_type_uid(content.source());
-                client.get_file(content, true).await.map(|data| (data, id))
+                media.get_file(content, true).await.map(|data| (data, id))
             }
         });
 

src/session/mod.rs

@@ -45,7 +45,7 @@ use matrix_sdk::{
         },
         RoomId,
     },
-    store::{MigrationConflictStrategy, OpenStoreError, StateStore},
+    store::{MigrationConflictStrategy, OpenStoreError, SledStateStore},
     Client, ClientBuildError, Error, HttpError, RumaApiError, StoreError,
 };
 use rand::{distributions::Alphanumeric, thread_rng, Rng};
@@ -462,6 +462,7 @@ impl Session {
                     user_id: session.user_id.clone(),
                     device_id: session.device_id.clone(),
                     access_token: session.secret.access_token.clone(),
+                    refresh_token: None,
                 })
                 .await
                 .map(|_| (client, session))
@@ -923,30 +924,29 @@ impl Session {
             glib::PRIORITY_DEFAULT_IDLE,
             clone!(@weak self as obj => async move {
                 let obj_weak = glib::SendWeakRef::from(obj.downgrade());
-                    obj.client().add_event_handler(
-                        move |event: GlobalAccountDataEvent<DirectEventContent>| {
-                            let obj_weak = obj_weak.clone();
-                            async move {
-                                let ctx = glib::MainContext::default();
-                                ctx.spawn(async move {
-                                    spawn!(async move {
-                                        if let Some(session) = obj_weak.upgrade() {
-                                            let room_ids = event.content.iter().fold(HashSet::new(), |mut acc, (_, rooms)| {
-                                                acc.extend(rooms);
-                                                acc
-                                            });
-                                            for room_id in room_ids {
-                                                if let Some(room) = session.room_list().get(room_id) {
-                                                    room.load_category();
-                                                }
+                obj.client().add_event_handler(
+                    move |event: GlobalAccountDataEvent<DirectEventContent>| {
+                        let obj_weak = obj_weak.clone();
+                        async move {
+                            let ctx = glib::MainContext::default();
+                            ctx.spawn(async move {
+                                spawn!(async move {
+                                    if let Some(session) = obj_weak.upgrade() {
+                                        let room_ids = event.content.iter().fold(HashSet::new(), |mut acc, (_, rooms)| {
+                                            acc.extend(rooms);
+                                            acc
+                                        });
+                                        for room_id in room_ids {
+                                            if let Some(room) = session.room_list().get(room_id) {
+                                                room.load_category();
                                             }
                                         }
-                                    });
+                                    }
                                 });
-                            }
-                        },
-                    )
-                    .await;
+                            });
+                        }
+                    },
+                );
             })
         );
     }
@@ -955,21 +955,19 @@ impl Session {
         let session_weak = glib::SendWeakRef::from(self.downgrade());
         let client = self.client();
         spawn_tokio!(async move {
-            client
-                .add_event_handler(move |_: SyncRoomEncryptionEvent, matrix_room: MatrixRoom| {
-                    let session_weak = session_weak.clone();
-                    async move {
-                        let ctx = glib::MainContext::default();
-                        ctx.spawn(async move {
-                            if let Some(session) = session_weak.upgrade() {
-                                if let Some(room) = session.room_list().get(matrix_room.room_id()) {
-                                    room.set_is_encrypted(true);
-                                }
+            client.add_event_handler(move |_: SyncRoomEncryptionEvent, matrix_room: MatrixRoom| {
+                let session_weak = session_weak.clone();
+                async move {
+                    let ctx = glib::MainContext::default();
+                    ctx.spawn(async move {
+                        if let Some(session) = session_weak.upgrade() {
+                            if let Some(room) = session.room_list().get(matrix_room.room_id()) {
+                                room.set_is_encrypted(true);
                             }
-                        });
-                    }
-                })
-                .await;
+                        }
+                    });
+                }
+            });
         });
     }
 }
@@ -986,7 +984,7 @@ async fn create_client(
     passphrase: String,
     use_discovery: bool,
 ) -> Result<Client, ClientSetupError> {
-    let state_store = StateStore::builder()
+    let state_store = SledStateStore::builder()
         .path(path)
         .passphrase(passphrase)
         .migration_conflict_strategy(MigrationConflictStrategy::Drop)

src/session/room/event/mod.rs

@@ -1,7 +1,7 @@
 use gtk::{glib, prelude::*, subclass::prelude::*};
 use log::warn;
 use matrix_sdk::{
-    deserialized_responses::SyncRoomEvent,
+    deserialized_responses::SyncTimelineEvent,
     ruma::{MilliSecondsSinceUnixEpoch, OwnedEventId, OwnedUserId},
 };
 
@@ -17,8 +17,8 @@ pub use supported_event::SupportedEvent;
 pub use unsupported_event::UnsupportedEvent;
 
 #[derive(Clone, Debug, glib::Boxed)]
-#[boxed_type(name = "BoxedSyncRoomEvent")]
-pub struct BoxedSyncRoomEvent(SyncRoomEvent);
+#[boxed_type(name = "BoxedSyncTimelineEvent")]
+pub struct BoxedSyncTimelineEvent(SyncTimelineEvent);
 
 mod imp {
     use std::cell::RefCell;
@@ -67,7 +67,7 @@ mod imp {
     pub struct Event {
         /// The SDK event containing encryption information and the serialized
         /// event as `Raw`.
-        pub pure_event: RefCell<Option<SyncRoomEvent>>,
+        pub pure_event: RefCell<Option<SyncTimelineEvent>>,
 
         /// The room containing this `Event`.
         pub room: OnceCell<WeakRef<Room>>,
@@ -90,7 +90,7 @@ mod imp {
                         "pure-event",
                         "Pure Event",
                         "The pure Matrix event of this Event",
-                        BoxedSyncRoomEvent::static_type(),
+                        BoxedSyncTimelineEvent::static_type(),
                         glib::ParamFlags::WRITABLE,
                     ),
                     glib::ParamSpecString::new(
@@ -129,7 +129,7 @@ mod imp {
         ) {
             match pspec.name() {
                 "pure-event" => {
-                    let event = value.get::<BoxedSyncRoomEvent>().unwrap();
+                    let event = value.get::<BoxedSyncTimelineEvent>().unwrap();
                     obj.set_pure_event(event.0);
                 }
                 "room" => {
@@ -171,7 +171,7 @@ impl Event {
     /// Create an `Event` with the given pure SDK event and room.
     ///
     /// Constructs the proper subtype according to the event.
-    pub fn new(pure_event: SyncRoomEvent, room: &Room) -> Self {
+    pub fn new(pure_event: SyncTimelineEvent, room: &Room) -> Self {
         SupportedEvent::try_from_event(pure_event.clone(), room)
             .map(|event| event.upcast())
             .unwrap_or_else(|error| {
@@ -191,10 +191,10 @@ pub trait EventExt: 'static {
     fn room(&self) -> Room;
 
     /// The pure SDK event of this `Event`.
-    fn pure_event(&self) -> SyncRoomEvent;
+    fn pure_event(&self) -> SyncTimelineEvent;
 
     /// Set the pure SDK event of this `Event`.
-    fn set_pure_event(&self, pure_event: SyncRoomEvent);
+    fn set_pure_event(&self, pure_event: SyncTimelineEvent);
 
     /// The source JSON of this `Event`.
     fn original_source(&self) -> String;
@@ -257,11 +257,11 @@ impl<O: IsA<Event>> EventExt for O {
             .unwrap()
     }
 
-    fn pure_event(&self) -> SyncRoomEvent {
+    fn pure_event(&self) -> SyncTimelineEvent {
         self.upcast_ref().imp().pure_event.borrow().clone().unwrap()
     }
 
-    fn set_pure_event(&self, pure_event: SyncRoomEvent) {
+    fn set_pure_event(&self, pure_event: SyncTimelineEvent) {
         let priv_ = self.upcast_ref().imp();
         priv_.pure_event.replace(Some(pure_event));
 

src/session/room/event/supported_event.rs

@@ -1,7 +1,7 @@
 use gtk::{glib, glib::clone, prelude::*, subclass::prelude::*};
 use log::debug;
 use matrix_sdk::{
-    deserialized_responses::SyncRoomEvent,
+    deserialized_responses::SyncTimelineEvent,
     media::MediaEventContent,
     ruma::{
         events::{
@@ -10,8 +10,8 @@ use matrix_sdk::{
                 message::{MessageType, Relation},
                 redaction::SyncRoomRedactionEvent,
             },
-            AnyMessageLikeEventContent, AnySyncMessageLikeEvent, AnySyncRoomEvent,
-            AnySyncStateEvent, SyncMessageLikeEvent, SyncStateEvent,
+            AnyMessageLikeEventContent, AnySyncMessageLikeEvent, AnySyncStateEvent,
+            AnySyncTimelineEvent, SyncMessageLikeEvent, SyncStateEvent,
         },
         serde::Raw,
         MilliSecondsSinceUnixEpoch, OwnedEventId, OwnedTransactionId, OwnedUserId,
@@ -20,7 +20,7 @@ use matrix_sdk::{
 };
 use serde_json::Error as JsonError;
 
-use super::{BoxedSyncRoomEvent, Event, EventImpl};
+use super::{BoxedSyncTimelineEvent, Event, EventImpl};
 use crate::{
     prelude::*,
     session::room::{
@@ -32,8 +32,8 @@ use crate::{
 };
 
 #[derive(Clone, Debug, glib::Boxed)]
-#[boxed_type(name = "BoxedAnySyncRoomEvent")]
-pub struct BoxedAnySyncRoomEvent(AnySyncRoomEvent);
+#[boxed_type(name = "BoxedAnySyncTimelineEvent")]
+pub struct BoxedAnySyncTimelineEvent(AnySyncTimelineEvent);
 
 mod imp {
     use std::cell::RefCell;
@@ -46,7 +46,7 @@ mod imp {
     #[derive(Debug, Default)]
     pub struct SupportedEvent {
         /// The deserialized Matrix event.
-        pub matrix_event: RefCell<Option<AnySyncRoomEvent>>,
+        pub matrix_event: RefCell<Option<AnySyncTimelineEvent>>,
         /// Events that replace this one, in the order they arrive.
         pub replacing_events: RefCell<Vec<super::SupportedEvent>>,
         pub reactions: ReactionList,
@@ -69,7 +69,7 @@ mod imp {
                         "matrix-event",
                         "Matrix Event",
                         "The deserialized Matrix event of this Event",
-                        BoxedAnySyncRoomEvent::static_type(),
+                        BoxedAnySyncTimelineEvent::static_type(),
                         glib::ParamFlags::WRITABLE,
                     ),
                     glib::ParamSpecObject::new(
@@ -94,7 +94,7 @@ mod imp {
         ) {
             match pspec.name() {
                 "matrix-event" => {
-                    let matrix_event = value.get::<BoxedAnySyncRoomEvent>().unwrap();
+                    let matrix_event = value.get::<BoxedAnySyncTimelineEvent>().unwrap();
                     obj.set_matrix_event(matrix_event.0);
                 }
                 _ => unimplemented!(),
@@ -179,9 +179,9 @@ impl SupportedEvent {
     /// room.
     ///
     /// Returns an error if the pure event fails to deserialize.
-    pub fn try_from_event(pure_event: SyncRoomEvent, room: &Room) -> Result<Self, JsonError> {
-        let matrix_event = BoxedAnySyncRoomEvent(pure_event.event.deserialize()?);
-        let pure_event = BoxedSyncRoomEvent(pure_event);
+    pub fn try_from_event(pure_event: SyncTimelineEvent, room: &Room) -> Result<Self, JsonError> {
+        let matrix_event = BoxedAnySyncTimelineEvent(pure_event.event.deserialize()?);
+        let pure_event = BoxedSyncTimelineEvent(pure_event);
         Ok(glib::Object::new(&[
             ("pure-event", &pure_event),
             ("matrix-event", &matrix_event),
@@ -191,8 +191,8 @@ impl SupportedEvent {
     }
 
     /// Set the deserialized Matrix event of this `SupportedEvent`.
-    fn set_matrix_event(&self, matrix_event: AnySyncRoomEvent) {
-        if let AnySyncRoomEvent::MessageLike(AnySyncMessageLikeEvent::RoomEncrypted(
+    fn set_matrix_event(&self, matrix_event: AnySyncTimelineEvent) {
+        if let AnySyncTimelineEvent::MessageLike(AnySyncMessageLikeEvent::RoomEncrypted(
             SyncMessageLikeEvent::Original(_),
         )) = matrix_event
         {
@@ -206,7 +206,7 @@ impl SupportedEvent {
     }
 
     /// The deserialized Matrix event of this `SupportedEvent`.
-    pub fn matrix_event(&self) -> AnySyncRoomEvent {
+    pub fn matrix_event(&self) -> AnySyncTimelineEvent {
         self.imp().matrix_event.borrow().clone().unwrap()
     }
 
@@ -226,7 +226,7 @@ impl SupportedEvent {
                 if let Some(keys_handle) = priv_.keys_handle.take() {
                     self.room().disconnect(keys_handle);
                 }
-                let pure_event = SyncRoomEvent::from(decrypted);
+                let pure_event = SyncTimelineEvent::from(decrypted);
                 let matrix_event = pure_event.event.deserialize().unwrap();
                 self.set_pure_event(pure_event);
                 self.set_matrix_event(matrix_event);
@@ -295,7 +295,7 @@ impl SupportedEvent {
     /// The ID of the event this `SupportedEvent` relates to, if any.
     pub fn related_event_id(&self) -> Option<OwnedEventId> {
         match self.imp().matrix_event.borrow().as_ref()? {
-            AnySyncRoomEvent::MessageLike(ref message) => match message {
+            AnySyncTimelineEvent::MessageLike(ref message) => match message {
                 AnySyncMessageLikeEvent::RoomRedaction(SyncRoomRedactionEvent::Original(event)) => {
                     Some(event.redacts.clone())
                 }
@@ -329,12 +329,12 @@ impl SupportedEvent {
     /// - `RoomMessage` with `Relation::Replacement`
     pub fn is_replacing_event(&self) -> bool {
         match self.imp().matrix_event.borrow().as_ref().unwrap() {
-            AnySyncRoomEvent::MessageLike(AnySyncMessageLikeEvent::RoomMessage(
+            AnySyncTimelineEvent::MessageLike(AnySyncMessageLikeEvent::RoomMessage(
                 SyncMessageLikeEvent::Original(message),
             )) => {
                 matches!(message.content.relates_to, Some(Relation::Replacement(_)))
             }
-            AnySyncRoomEvent::MessageLike(AnySyncMessageLikeEvent::RoomRedaction(_)) => true,
+            AnySyncTimelineEvent::MessageLike(AnySyncMessageLikeEvent::RoomRedaction(_)) => true,
             _ => false,
         }
     }
@@ -404,7 +404,7 @@ impl SupportedEvent {
             .filter(|event| {
                 matches!(
                     event.matrix_event(),
-                    AnySyncRoomEvent::MessageLike(AnySyncMessageLikeEvent::RoomRedaction(_))
+                    AnySyncTimelineEvent::MessageLike(AnySyncMessageLikeEvent::RoomRedaction(_))
                 )
             })
             .is_some()
@@ -433,7 +433,7 @@ impl SupportedEvent {
     /// The content of this `SupportedEvent`, if this is a message-like event.
     pub fn original_content(&self) -> Option<AnyMessageLikeEventContent> {
         match self.matrix_event() {
-            AnySyncRoomEvent::MessageLike(message) => message.original_content(),
+            AnySyncTimelineEvent::MessageLike(message) => message.original_content(),
             _ => None,
         }
     }
@@ -465,7 +465,7 @@ impl SupportedEvent {
     /// an incompatible event.
     pub async fn get_media_content(&self) -> Result<(String, String, Vec<u8>), matrix_sdk::Error> {
         if let AnyMessageLikeEventContent::RoomMessage(content) = self.original_content().unwrap() {
-            let client = self.room().session().client();
+            let media = self.room().session().client().media();
             match content.msgtype {
                 MessageType::File(content) => {
                     let uid = media_type_uid(content.source());
@@ -485,7 +485,7 @@ impl SupportedEvent {
                                 None,
                             )
                         });
-                    let handle = spawn_tokio!(async move { client.get_file(content, true).await });
+                    let handle = spawn_tokio!(async move { media.get_file(content, true).await });
                     let data = handle.await.unwrap()?.unwrap();
                     return Ok((uid, filename, data));
                 }
@@ -502,7 +502,7 @@ impl SupportedEvent {
                     } else {
                         content.body.clone()
                     };
-                    let handle = spawn_tokio!(async move { client.get_file(content, true).await });
+                    let handle = spawn_tokio!(async move { media.get_file(content, true).await });
                     let data = handle.await.unwrap()?.unwrap();
                     return Ok((uid, filename, data));
                 }
@@ -519,7 +519,7 @@ impl SupportedEvent {
                     } else {
                         content.body.clone()
                     };
-                    let handle = spawn_tokio!(async move { client.get_file(content, true).await });
+                    let handle = spawn_tokio!(async move { media.get_file(content, true).await });
                     let data = handle.await.unwrap()?.unwrap();
                     return Ok((uid, filename, data));
                 }
@@ -536,7 +536,7 @@ impl SupportedEvent {
                     } else {
                         content.body.clone()
                     };
-                    let handle = spawn_tokio!(async move { client.get_file(content, true).await });
+                    let handle = spawn_tokio!(async move { media.get_file(content, true).await });
                     let data = handle.await.unwrap()?.unwrap();
                     return Ok((uid, filename, data));
                 }
@@ -590,7 +590,7 @@ impl SupportedEvent {
         let priv_ = self.imp();
 
         if self.related_event_id().is_some() {
-            if let Some(AnySyncRoomEvent::MessageLike(AnySyncMessageLikeEvent::RoomMessage(
+            if let Some(AnySyncTimelineEvent::MessageLike(AnySyncMessageLikeEvent::RoomMessage(
                 SyncMessageLikeEvent::Original(message),
             ))) = priv_.matrix_event.borrow().as_ref()
             {
@@ -603,13 +603,13 @@ impl SupportedEvent {
 
         // List of all events to be shown.
         match priv_.matrix_event.borrow().as_ref() {
-            Some(AnySyncRoomEvent::MessageLike(message)) => !matches!(
+            Some(AnySyncTimelineEvent::MessageLike(message)) => !matches!(
                 message,
                 AnySyncMessageLikeEvent::RoomMessage(SyncMessageLikeEvent::Original(_))
                     | AnySyncMessageLikeEvent::RoomEncrypted(SyncMessageLikeEvent::Original(_))
                     | AnySyncMessageLikeEvent::Sticker(SyncMessageLikeEvent::Original(_))
             ),
-            Some(AnySyncRoomEvent::State(state)) => !matches!(
+            Some(AnySyncTimelineEvent::State(state)) => !matches!(
                 state,
                 AnySyncStateEvent::RoomCreate(SyncStateEvent::Original(_))
                     | AnySyncStateEvent::RoomMember(SyncStateEvent::Original(_))

src/session/room/event/unsupported_event.rs

@@ -1,7 +1,7 @@
 use gtk::{glib, prelude::*, subclass::prelude::*};
-use matrix_sdk::{deserialized_responses::SyncRoomEvent, ruma::events::RoomEventType};
+use matrix_sdk::{deserialized_responses::SyncTimelineEvent, ruma::events::RoomEventType};
 
-use super::{BoxedSyncRoomEvent, Event, EventImpl};
+use super::{BoxedSyncTimelineEvent, Event, EventImpl};
 use crate::session::room::{
     timeline::{TimelineItem, TimelineItemImpl},
     Room,
@@ -34,8 +34,8 @@ glib::wrapper! {
 
 impl UnsupportedEvent {
     /// Construct an `UnsupportedEvent` from the given pure event and room.
-    pub fn new(pure_event: SyncRoomEvent, room: &Room) -> Self {
-        let pure_event = BoxedSyncRoomEvent(pure_event);
+    pub fn new(pure_event: SyncTimelineEvent, room: &Room) -> Self {
+        let pure_event = BoxedSyncTimelineEvent(pure_event);
         glib::Object::new(&[("pure-event", &pure_event), ("room", room)])
             .expect("Failed to create UnsupportedEvent")
     }

src/session/room/member.rs

@@ -1,5 +1,6 @@
 use gtk::{glib, prelude::*, subclass::prelude::*};
 use matrix_sdk::{
+    room::RoomMember,
     ruma::{
         events::{
             room::member::{MembershipState, RoomMemberEventContent},
@@ -7,7 +8,6 @@ use matrix_sdk::{
         },
         OwnedMxcUri, UserId,
     },
-    RoomMember,
 };
 
 use crate::{

src/session/room/member_list.rs

@@ -105,7 +105,7 @@ impl MemberList {
     ///
     /// If some of the values do not correspond to existing members, new members
     /// are created.
-    pub fn update_from_room_members(&self, new_members: &[matrix_sdk::RoomMember]) {
+    pub fn update_from_room_members(&self, new_members: &[matrix_sdk::room::RoomMember]) {
         let mut members = self.imp().members.borrow_mut();
         let prev_len = members.len();
         for member in new_members {

src/session/room/mod.rs

@@ -17,7 +17,7 @@ use gtk::{glib, glib::clone, prelude::*, subclass::prelude::*};
 use log::{debug, error, info, warn};
 use matrix_sdk::{
     attachment::AttachmentConfig,
-    deserialized_responses::{JoinedRoom, LeftRoom, SyncRoomEvent},
+    deserialized_responses::{JoinedRoom, LeftRoom, SyncTimelineEvent},
     room::Room as MatrixRoom,
     ruma::{
         api::client::sync::sync_events::v3::InvitedRoom,
@@ -34,14 +34,14 @@ use matrix_sdk::{
             room_key::ToDeviceRoomKeyEventContent,
             tag::{TagInfo, TagName},
             AnyRoomAccountDataEvent, AnyStrippedStateEvent, AnySyncMessageLikeEvent,
-            AnySyncRoomEvent, AnySyncStateEvent, EventContent, MessageLikeEventType,
+            AnySyncStateEvent, AnySyncTimelineEvent, EventContent, MessageLikeEventType,
             MessageLikeUnsigned, OriginalSyncMessageLikeEvent, StateEventType,
             SyncMessageLikeEvent, SyncStateEvent, ToDeviceEvent,
         },
         serde::Raw,
         EventId, MilliSecondsSinceUnixEpoch, OwnedEventId, OwnedRoomId, OwnedUserId, RoomId,
     },
-    DisplayName, Result as MatrixResult, RoomMember,
+    DisplayName, Result as MatrixResult,
 };
 use ruma::events::SyncEphemeralRoomEvent;
 
@@ -559,7 +559,9 @@ impl Room {
                         }
                         room.accept_invitation().await?;
                     }
-                    RoomType::Left => room.reject_invitation().await?,
+                    RoomType::Left => {
+                        room.reject_invitation().await?;
+                    }
                     RoomType::Outdated => unimplemented!(),
                     RoomType::Space => unimplemented!(),
                     RoomType::Direct => {
@@ -607,7 +609,9 @@ impl Room {
                             room.remove_tag(TagName::Favorite).await?;
                         }
                     }
-                    RoomType::Left => room.leave().await?,
+                    RoomType::Left => {
+                        room.leave().await?;
+                    }
                     RoomType::Outdated => unimplemented!(),
                     RoomType::Space => unimplemented!(),
                     RoomType::Direct => {
@@ -782,8 +786,7 @@ impl Room {
 
                 // Listen to changes in the read receipts.
                 let room_weak = glib::SendWeakRef::from(obj.downgrade());
-                obj.session().client().add_room_event_handler(
-                    obj.room_id(),
+                obj.matrix_room().add_event_handler(
                     move |event: SyncEphemeralRoomEvent<ReceiptEventContent>| {
                         let room_weak = room_weak.clone();
                         async move {
@@ -797,8 +800,7 @@ impl Room {
                             });
                         }
                     },
-                )
-                .await;
+                );
             })
         );
     }
@@ -1057,8 +1059,7 @@ impl Room {
 
         let name_content = RoomNameEventContent::new(Some(room_name));
 
-        let handle =
-            spawn_tokio!(async move { joined_room.send_state_event(name_content, "").await });
+        let handle = spawn_tokio!(async move { joined_room.send_state_event(name_content).await });
 
         spawn!(
             glib::PRIORITY_DEFAULT_IDLE,
@@ -1097,7 +1098,7 @@ impl Room {
 
         let handle = spawn_tokio!(async move {
             joined_room
-                .send_state_event(RoomTopicEventContent::new(topic), "")
+                .send_state_event(RoomTopicEventContent::new(topic))
                 .await
         });
 
@@ -1157,7 +1158,7 @@ impl Room {
 
     /// Update the room state based on the new sync response
     /// FIXME: We should use the sdk's event handler to get updates
-    pub fn update_for_events(&self, batch: Vec<SyncRoomEvent>) {
+    pub fn update_for_events(&self, batch: Vec<SyncTimelineEvent>) {
         // FIXME: notify only when the count has changed
         self.notify_notification_count();
 
@@ -1167,7 +1168,7 @@ impl Room {
             .collect();
 
         for event in events.iter() {
-            if let AnySyncRoomEvent::State(state_event) = event {
+            if let AnySyncTimelineEvent::State(state_event) = event {
                 match state_event {
                     AnySyncStateEvent::RoomMember(SyncStateEvent::Original(event)) => {
                         self.members().update_member_for_member_event(event)
@@ -1237,7 +1238,7 @@ impl Room {
                 match handle.await.unwrap() {
                     Ok(members) => {
                         // Add all members needed to display room events.
-                        let members: Vec<RoomMember> = members.into_iter().filter(|member| {
+                        let members: Vec<_> = members.into_iter().filter(|member| {
                             &MembershipState::Leave != member.membership()
                         }).collect();
                         obj.members().update_from_room_members(&members);
@@ -1301,7 +1302,7 @@ impl Room {
                 unsigned: MessageLikeUnsigned::default(),
             };
 
-            let raw_event: Raw<AnySyncRoomEvent> = Raw::new(&matrix_event).unwrap().cast();
+            let raw_event: Raw<AnySyncTimelineEvent> = Raw::new(&matrix_event).unwrap().cast();
             let event = SupportedEvent::try_from_event(raw_event.into(), self).unwrap();
             self.imp()
                 .timeline
@@ -1352,7 +1353,7 @@ impl Room {
         };
 
         if let MatrixRoom::Joined(matrix_room) = self.matrix_room() {
-            let raw_event: Raw<AnySyncRoomEvent> = Raw::new(&event).unwrap().cast();
+            let raw_event: Raw<AnySyncTimelineEvent> = Raw::new(&event).unwrap().cast();
             let event = SupportedEvent::try_from_event(raw_event.into(), self).unwrap();
             self.imp()
                 .timeline
@@ -1416,7 +1417,7 @@ impl Room {
         if let MatrixRoom::Invited(matrix_room) = matrix_room {
             let handle = spawn_tokio!(async move { matrix_room.accept_invitation().await });
             match handle.await.unwrap() {
-                Ok(result) => Ok(result),
+                Ok(_) => Ok(()),
                 Err(error) => {
                     error!("Accepting invitation failed: {}", error);
 
@@ -1445,7 +1446,7 @@ impl Room {
         if let MatrixRoom::Invited(matrix_room) = matrix_room {
             let handle = spawn_tokio!(async move { matrix_room.reject_invitation().await });
             match handle.await.unwrap() {
-                Ok(result) => Ok(result),
+                Ok(_) => Ok(()),
                 Err(error) => {
                     error!("Rejecting invitation failed: {}", error);
 
@@ -1571,11 +1572,10 @@ impl Room {
             let body = body.to_string();
             spawn_tokio!(async move {
                 let config = AttachmentConfig::default();
-                let mut cursor = std::io::Cursor::new(&bytes);
                 matrix_room
                     // TODO This should be added to pending messages instead of
                     // sending it directly.
-                    .send_attachment(&body, &mime, &mut cursor, config)
+                    .send_attachment(&body, &mime, &bytes, config)
                     .await
                     .unwrap();
             });
@@ -1660,7 +1660,7 @@ impl Room {
     /// events.
     ///
     /// The events must be in reverse chronological order.
-    pub fn update_latest_unread<'a>(&self, events: impl Iterator<Item = &'a AnySyncRoomEvent>) {
+    pub fn update_latest_unread<'a>(&self, events: impl Iterator<Item = &'a AnySyncTimelineEvent>) {
         let mut latest_unread = self.latest_unread();
 
         for event in events {
@@ -1709,21 +1709,19 @@ impl Room {
             glib::PRIORITY_DEFAULT_IDLE,
             clone!(@weak self as obj => async move {
                 let obj_weak = glib::SendWeakRef::from(obj.downgrade());
-                    obj.session().client().add_room_event_handler(
-                        obj.room_id(),
-                        move |_: ToDeviceEvent<ToDeviceRoomKeyEventContent>| {
-                            let obj_weak = obj_weak.clone();
-                            async move {
-                                let ctx = glib::MainContext::default();
-                                ctx.spawn(async move {
-                                    if let Some(room) = obj_weak.upgrade() {
-                                        room.emit_by_name::<()>("new-encryption-keys", &[]);
-                                    }
-                                });
-                            }
-                        },
-                    )
-                    .await;
+                obj.matrix_room().add_event_handler(
+                    move |_: ToDeviceEvent<ToDeviceRoomKeyEventContent>| {
+                        let obj_weak = obj_weak.clone();
+                        async move {
+                            let ctx = glib::MainContext::default();
+                            ctx.spawn(async move {
+                                if let Some(room) = obj_weak.upgrade() {
+                                    room.emit_by_name::<()>("new-encryption-keys", &[]);
+                                }
+                            });
+                        }
+                    },
+                );
             })
         );
     }
@@ -1753,9 +1751,9 @@ impl Room {
 /// show in the timeline.
 ///
 /// [MSC2654]: https://github.com/matrix-org/matrix-spec-proposals/pull/2654
-fn count_as_unread(event: &AnySyncRoomEvent) -> bool {
+fn count_as_unread(event: &AnySyncTimelineEvent) -> bool {
     match event {
-        AnySyncRoomEvent::MessageLike(message_event) => match message_event {
+        AnySyncTimelineEvent::MessageLike(message_event) => match message_event {
             AnySyncMessageLikeEvent::RoomMessage(SyncMessageLikeEvent::Original(message)) => {
                 if matches!(message.content.msgtype, MessageType::Notice(_)) {
                     return false;
@@ -1770,9 +1768,9 @@ fn count_as_unread(event: &AnySyncRoomEvent) -> bool {
             AnySyncMessageLikeEvent::Sticker(SyncMessageLikeEvent::Original(_)) => true,
             _ => false,
         },
-        AnySyncRoomEvent::State(AnySyncStateEvent::RoomTombstone(SyncStateEvent::Original(_))) => {
-            true
-        }
+        AnySyncTimelineEvent::State(AnySyncStateEvent::RoomTombstone(
+            SyncStateEvent::Original(_),
+        )) => true,
         _ => false,
     }
 }

src/session/room/timeline/mod.rs

@@ -13,7 +13,7 @@ use futures::{lock::Mutex, pin_mut, Stream, StreamExt};
 use gtk::{gio, glib, prelude::*, subclass::prelude::*};
 use log::{error, warn};
 use matrix_sdk::{
-    deserialized_responses::SyncRoomEvent,
+    deserialized_responses::SyncTimelineEvent,
     ruma::{EventId, OwnedEventId, OwnedTransactionId, TransactionId},
     Error as MatrixError,
 };
@@ -45,7 +45,7 @@ impl Default for TimelineState {
 
 const MAX_BATCH_SIZE: usize = 20;
 type BackwardStream =
-    Pin<Box<dyn Stream<Item = Vec<matrix_sdk::Result<SyncRoomEvent>>> + 'static + Send>>;
+    Pin<Box<dyn Stream<Item = Vec<matrix_sdk::Result<SyncTimelineEvent>>> + 'static + Send>>;
 
 mod imp {
     use std::cell::{Cell, RefCell};
@@ -851,7 +851,7 @@ impl Timeline {
 
 async fn handle_forward_stream(
     timeline: glib::SendWeakRef<Timeline>,
-    stream: impl Stream<Item = SyncRoomEvent>,
+    stream: impl Stream<Item = SyncTimelineEvent>,
 ) {
     let stream = stream.ready_chunks(MAX_BATCH_SIZE);
     pin_mut!(stream);

src/session/room_creation/mod.rs

@@ -13,7 +13,7 @@ use matrix_sdk::{
         },
         assign,
     },
-    HttpError, RumaApiError,
+    Error, HttpError, RumaApiError,
 };
 
 use crate::{
@@ -230,7 +230,7 @@ impl RoomCreation {
                 match handle.await.unwrap() {
                         Ok(response) => {
                             if let Some(session) = obj.session() {
-                                let room = session.room_list().get_wait(response.room_id).await;
+                                let room = session.room_list().get_wait(response.room_id()).await;
                                 session.select_room(room);
                             }
                             obj.close();
@@ -247,7 +247,7 @@ impl RoomCreation {
     }
 
     /// Display the error that occurred during creation
-    fn handle_error(&self, error: HttpError) {
+    fn handle_error(&self, error: Error) {
         let priv_ = self.imp();
 
         priv_.create_button.set_loading(false);
@@ -255,9 +255,9 @@ impl RoomCreation {
         priv_.cancel_button.set_sensitive(true);
 
         // Treat the room address already taken error special
-        if let HttpError::Api(FromHttpResponseError::Server(ServerError::Known(
+        if let Error::Http(HttpError::Api(FromHttpResponseError::Server(ServerError::Known(
             RumaApiError::ClientApi(ref client_error),
-        ))) = error
+        )))) = error
         {
             if client_error.kind == RumaClientErrorKind::RoomInUse {
                 priv_.room_address.add_css_class("error");

src/session/room_list.rs

@@ -155,12 +155,13 @@ impl RoomList {
     }
 
     /// Waits till the Room becomes available
-    pub async fn get_wait(&self, room_id: OwnedRoomId) -> Option<Room> {
-        if let Some(room) = self.get(&room_id) {
+    pub async fn get_wait(&self, room_id: &RoomId) -> Option<Room> {
+        if let Some(room) = self.get(room_id) {
             Some(room)
         } else {
             let (sender, receiver) = futures::channel::oneshot::channel();
 
+            let room_id = room_id.to_owned();
             let sender = Cell::new(Some(sender));
             // FIXME: add a timeout
             let handler_id = self.connect_items_changed(move |obj, _, _, _| {
@@ -316,7 +317,7 @@ impl RoomList {
             glib::PRIORITY_DEFAULT_IDLE,
             clone!(@weak self as obj => async move {
                 match handle.await.unwrap() {
-                    Ok(response) => obj.pending_rooms_replace_or_remove(&identifier, response.room_id.as_ref()),
+                    Ok(response) => obj.pending_rooms_replace_or_remove(&identifier, response.room_id()),
                     Err(error) => {
                         obj.pending_rooms_remove(&identifier);
                         error!("Joining room {} failed: {}", identifier, error);

src/session/user.rs

@@ -199,7 +199,7 @@ impl User {
 
     fn init_is_verified(&self) {
         spawn!(clone!(@weak self as obj => async move {
-            let is_verified = obj.crypto_identity().await.map_or(false, |i| i.verified());
+            let is_verified = obj.crypto_identity().await.map_or(false, |i| i.is_verified());
 
             if is_verified == obj.is_verified() {
                 return;

src/session/verification/verification_list.rs

@@ -3,8 +3,8 @@ use log::{debug, warn};
 use matrix_sdk::ruma::{
     api::client::sync::sync_events::v3::ToDevice,
     events::{
-        room::message::MessageType, AnySyncMessageLikeEvent, AnySyncRoomEvent, AnyToDeviceEvent,
-        SyncMessageLikeEvent,
+        room::message::MessageType, AnySyncMessageLikeEvent, AnySyncTimelineEvent,
+        AnyToDeviceEvent, SyncMessageLikeEvent,
     },
     MilliSecondsSinceUnixEpoch, OwnedUserId, UserId,
 };
@@ -204,10 +204,10 @@ impl VerificationList {
     pub fn handle_response_room<'a>(
         &self,
         room: &Room,
-        events: impl Iterator<Item = &'a AnySyncRoomEvent>,
+        events: impl Iterator<Item = &'a AnySyncTimelineEvent>,
     ) {
         for message_event in events.filter_map(|event| {
-            if let AnySyncRoomEvent::MessageLike(message_event) = event {
+            if let AnySyncTimelineEvent::MessageLike(message_event) = event {
                 Some(message_event)
             } else {
                 None