From b959d4be29427eaadf467e1dfb11bd803e53ae42 Mon Sep 17 00:00:00 2001 From: Jonas Platte Date: Fri, 1 Oct 2021 16:49:10 +0200 Subject: [PATCH] Use new event type aliases --- .../examples/appservice_autojoin.rs | 9 +-- crates/matrix-sdk-appservice/src/lib.rs | 4 +- crates/matrix-sdk-appservice/tests/tests.rs | 7 +-- crates/matrix-sdk-base/src/rooms/members.rs | 5 +- .../src/deserialized_responses.rs | 37 ++++++------ .../src/gossiping/machine.rs | 31 +++++----- crates/matrix-sdk-crypto/src/gossiping/mod.rs | 24 ++++---- crates/matrix-sdk-crypto/src/machine.rs | 15 +++-- crates/matrix-sdk-crypto/src/olm/account.rs | 6 +- .../src/olm/group_sessions/inbound.rs | 6 +- crates/matrix-sdk/README.md | 10 ++-- crates/matrix-sdk/examples/autojoin.rs | 8 +-- crates/matrix-sdk/examples/command_bot.rs | 7 +-- crates/matrix-sdk/examples/image_bot.rs | 11 +--- crates/matrix-sdk/examples/login.rs | 7 +-- .../examples/wasm_command_bot/src/lib.rs | 12 ++-- crates/matrix-sdk/src/client.rs | 57 +++++++------------ crates/matrix-sdk/src/event_handler.rs | 12 ++-- 18 files changed, 113 insertions(+), 155 deletions(-) diff --git a/crates/matrix-sdk-appservice/examples/appservice_autojoin.rs b/crates/matrix-sdk-appservice/examples/appservice_autojoin.rs index a5b8b9ff2..161f35334 100644 --- a/crates/matrix-sdk-appservice/examples/appservice_autojoin.rs +++ b/crates/matrix-sdk-appservice/examples/appservice_autojoin.rs @@ -4,10 +4,7 @@ use matrix_sdk_appservice::{ matrix_sdk::{ room::Room, ruma::{ - events::{ - room::member::{MemberEventContent, MembershipState}, - SyncStateEvent, - }, + events::room::member::{MembershipState, SyncMemberEvent}, UserId, }, }, @@ -18,7 +15,7 @@ use tracing::trace; pub async fn handle_room_member( appservice: AppService, room: Room, - event: SyncStateEvent, + event: SyncMemberEvent, ) -> Result<()> { if !appservice.user_id_is_in_namespace(&event.state_key)? { trace!("not an appservice user: {}", event.state_key); @@ -46,7 +43,7 @@ pub async fn main() -> Result<(), Box> { appservice .register_event_handler({ let appservice = appservice.clone(); - move |event: SyncStateEvent, room: Room| { + move |event: SyncMemberEvent, room: Room| { handle_room_member(appservice.clone(), room, event) } }) diff --git a/crates/matrix-sdk-appservice/src/lib.rs b/crates/matrix-sdk-appservice/src/lib.rs index c131e029c..611eea1ea 100644 --- a/crates/matrix-sdk-appservice/src/lib.rs +++ b/crates/matrix-sdk-appservice/src/lib.rs @@ -35,7 +35,7 @@ //! # async { //! # //! use matrix_sdk_appservice::{ -//! ruma::events::{SyncStateEvent, room::member::MemberEventContent}, +//! ruma::events::room::member::SyncMemberEvent, //! AppService, AppServiceRegistration //! }; //! @@ -55,7 +55,7 @@ //! ")?; //! //! let mut appservice = AppService::new(homeserver_url, server_name, registration).await?; -//! appservice.register_event_handler(|_ev: SyncStateEvent| async { +//! appservice.register_event_handler(|_ev: SyncMemberEvent| async { //! // do stuff //! }); //! diff --git a/crates/matrix-sdk-appservice/tests/tests.rs b/crates/matrix-sdk-appservice/tests/tests.rs index b4f315af6..37052846c 100644 --- a/crates/matrix-sdk-appservice/tests/tests.rs +++ b/crates/matrix-sdk-appservice/tests/tests.rs @@ -5,10 +5,7 @@ use std::{ use matrix_sdk::{ config::{ClientConfig, RequestConfig}, - ruma::{ - api::appservice::Registration, - events::{room::member::MemberEventContent, SyncStateEvent}, - }, + ruma::{api::appservice::Registration, events::room::member::SyncMemberEvent}, }; use matrix_sdk_appservice::*; use matrix_sdk_test::{appservice::TransactionBuilder, async_test, EventsJson}; @@ -209,7 +206,7 @@ async fn test_event_handler() -> Result<()> { appservice .register_event_handler({ let on_state_member = on_state_member.clone(); - move |_ev: SyncStateEvent| { + move |_ev: SyncMemberEvent| { *on_state_member.lock().unwrap() = true; future::ready(()) } diff --git a/crates/matrix-sdk-base/src/rooms/members.rs b/crates/matrix-sdk-base/src/rooms/members.rs index 2bbb6fe3b..66f05cd96 100644 --- a/crates/matrix-sdk-base/src/rooms/members.rs +++ b/crates/matrix-sdk-base/src/rooms/members.rs @@ -17,8 +17,7 @@ use std::sync::Arc; use ruma::{ events::{ presence::PresenceEvent, - room::{member::MemberEventContent, power_levels::PowerLevelsEventContent}, - SyncStateEvent, + room::{member::MemberEventContent, power_levels::SyncPowerLevelsEvent}, }, MxcUri, UserId, }; @@ -32,7 +31,7 @@ pub struct RoomMember { pub(crate) profile: Arc>, #[allow(dead_code)] pub(crate) presence: Arc>, - pub(crate) power_levels: Arc>>, + pub(crate) power_levels: Arc>, pub(crate) max_power_level: i64, pub(crate) is_room_creator: bool, pub(crate) display_name_ambiguous: bool, diff --git a/crates/matrix-sdk-common/src/deserialized_responses.rs b/crates/matrix-sdk-common/src/deserialized_responses.rs index c1d2b31f9..148a44eeb 100644 --- a/crates/matrix-sdk-common/src/deserialized_responses.rs +++ b/crates/matrix-sdk-common/src/deserialized_responses.rs @@ -9,8 +9,11 @@ use ruma::{ }, }, events::{ - room::member::MemberEventContent, AnyRoomEvent, AnySyncRoomEvent, StateEvent, - StrippedStateEvent, SyncStateEvent, Unsigned, + room::member::{ + MemberEvent as RumaMemberEvent, MemberEventContent, + StrippedMemberEvent as RumaStrippedMemberEvent, SyncMemberEvent as RumaSyncMemberEvent, + }, + AnyRoomEvent, AnySyncRoomEvent, Unsigned, }, serde::Raw, DeviceIdBox, DeviceKeyAlgorithm, EventId, MilliSecondsSinceUnixEpoch, RoomId, UserId, @@ -244,10 +247,7 @@ impl Timeline { } #[derive(Clone, Debug, Deserialize, Serialize)] -#[serde( - try_from = "SyncStateEvent", - into = "SyncStateEvent" -)] +#[serde(try_from = "RumaSyncMemberEvent", into = "RumaSyncMemberEvent")] pub struct MemberEvent { pub content: MemberEventContent, pub event_id: EventId, @@ -258,10 +258,10 @@ pub struct MemberEvent { pub unsigned: Unsigned, } -impl TryFrom> for MemberEvent { +impl TryFrom for MemberEvent { type Error = ruma::identifiers::Error; - fn try_from(event: SyncStateEvent) -> Result { + fn try_from(event: RumaSyncMemberEvent) -> Result { Ok(MemberEvent { content: event.content, event_id: event.event_id, @@ -274,10 +274,10 @@ impl TryFrom> for MemberEvent { } } -impl TryFrom> for MemberEvent { +impl TryFrom for MemberEvent { type Error = ruma::identifiers::Error; - fn try_from(event: StateEvent) -> Result { + fn try_from(event: RumaMemberEvent) -> Result { Ok(MemberEvent { content: event.content, event_id: event.event_id, @@ -290,9 +290,9 @@ impl TryFrom> for MemberEvent { } } -impl From for SyncStateEvent { - fn from(other: MemberEvent) -> SyncStateEvent { - SyncStateEvent { +impl From for RumaSyncMemberEvent { + fn from(other: MemberEvent) -> Self { + Self { content: other.content, event_id: other.event_id, sender: other.sender, @@ -305,20 +305,17 @@ impl From for SyncStateEvent { } #[derive(Clone, Debug, Deserialize, Serialize)] -#[serde( - try_from = "StrippedStateEvent", - into = "StrippedStateEvent" -)] +#[serde(try_from = "RumaStrippedMemberEvent", into = "RumaStrippedMemberEvent")] pub struct StrippedMemberEvent { pub content: MemberEventContent, pub sender: UserId, pub state_key: UserId, } -impl TryFrom> for StrippedMemberEvent { +impl TryFrom for StrippedMemberEvent { type Error = ruma::identifiers::Error; - fn try_from(event: StrippedStateEvent) -> Result { + fn try_from(event: RumaStrippedMemberEvent) -> Result { Ok(StrippedMemberEvent { content: event.content, sender: event.sender, @@ -327,7 +324,7 @@ impl TryFrom> for StrippedMemberEvent { } } -impl From for StrippedStateEvent { +impl From for RumaStrippedMemberEvent { fn from(other: StrippedMemberEvent) -> Self { Self { content: other.content, diff --git a/crates/matrix-sdk-crypto/src/gossiping/machine.rs b/crates/matrix-sdk-crypto/src/gossiping/machine.rs index 96355283b..cdaadfc79 100644 --- a/crates/matrix-sdk-crypto/src/gossiping/machine.rs +++ b/crates/matrix-sdk-crypto/src/gossiping/machine.rs @@ -27,15 +27,16 @@ use matrix_sdk_common::uuid::Uuid; use ruma::{ api::client::r0::keys::claim_keys::Request as KeysClaimRequest, events::{ - forwarded_room_key::ToDeviceForwardedRoomKeyEventContent, - room_key_request::{Action, RequestedKeyInfo, ToDeviceRoomKeyRequestEventContent}, + forwarded_room_key::{ToDeviceForwardedRoomKeyEvent, ToDeviceForwardedRoomKeyEventContent}, + room_key_request::{Action, RequestedKeyInfo, ToDeviceRoomKeyRequestEvent}, secret::{ - request::{ - RequestAction, SecretName, ToDeviceRequestEventContent as SecretRequestEventContent, + request::{RequestAction, SecretName, ToDeviceRequestEvent as SecretRequestEvent}, + send::{ + ToDeviceSendEvent as SecretSendEvent, + ToDeviceSendEventContent as SecretSendEventContent, }, - send::ToDeviceSendEventContent as SecretSendEventContent, }, - AnyToDeviceEvent, AnyToDeviceEventContent, ToDeviceEvent, + AnyToDeviceEvent, AnyToDeviceEventContent, }, DeviceId, DeviceIdBox, DeviceKeyAlgorithm, EventEncryptionAlgorithm, RoomId, UserId, }; @@ -139,10 +140,7 @@ impl GossipMachine { } /// Receive a room key request event. - pub fn receive_incoming_key_request( - &self, - event: &ToDeviceEvent, - ) { + pub fn receive_incoming_key_request(&self, event: &ToDeviceRoomKeyRequestEvent) { self.receive_event(event.clone().into()) } @@ -160,10 +158,7 @@ impl GossipMachine { } } - pub fn receive_incoming_secret_request( - &self, - event: &ToDeviceEvent, - ) { + pub fn receive_incoming_secret_request(&self, event: &SecretRequestEvent) { self.receive_event(event.clone().into()) } @@ -229,7 +224,7 @@ impl GossipMachine { async fn handle_secret_request( &self, - event: &ToDeviceEvent, + event: &SecretRequestEvent, ) -> OlmResult> { let secret_name = match &event.content.action { RequestAction::Request(s) => s, @@ -313,7 +308,7 @@ impl GossipMachine { /// Handle a single incoming key request. async fn handle_key_request( &self, - event: &ToDeviceEvent, + event: &ToDeviceRoomKeyRequestEvent, ) -> OlmResult> { let key_info = match &event.content.action { Action::Request => { @@ -757,7 +752,7 @@ impl GossipMachine { pub async fn receive_secret( &self, sender_key: &str, - event: &mut ToDeviceEvent, + event: &mut SecretSendEvent, ) -> Result, CryptoStoreError> { debug!( sender = event.sender.as_str(), @@ -846,7 +841,7 @@ impl GossipMachine { pub async fn receive_forwarded_room_key( &self, sender_key: &str, - event: &mut ToDeviceEvent, + event: &mut ToDeviceForwardedRoomKeyEvent, ) -> Result<(Option, Option), CryptoStoreError> { let key_info = self.get_key_info(&event.content).await?; diff --git a/crates/matrix-sdk-crypto/src/gossiping/mod.rs b/crates/matrix-sdk-crypto/src/gossiping/mod.rs index e0e346d05..37df4b563 100644 --- a/crates/matrix-sdk-crypto/src/gossiping/mod.rs +++ b/crates/matrix-sdk-crypto/src/gossiping/mod.rs @@ -21,11 +21,15 @@ pub(crate) use machine::GossipMachine; use matrix_sdk_common::uuid::Uuid; use ruma::{ events::{ - room_key_request::{Action, RequestedKeyInfo, ToDeviceRoomKeyRequestEventContent}, - secret::request::{ - RequestAction, SecretName, ToDeviceRequestEventContent as SecretRequestEventContent, + room_key_request::{ + Action, RequestedKeyInfo, ToDeviceRoomKeyRequestEvent, + ToDeviceRoomKeyRequestEventContent, }, - AnyToDeviceEventContent, ToDeviceEvent, + secret::request::{ + RequestAction, SecretName, ToDeviceRequestEvent as SecretRequestEvent, + ToDeviceRequestEventContent as SecretRequestEventContent, + }, + AnyToDeviceEventContent, }, to_device::DeviceIdOrAllDevices, DeviceId, DeviceIdBox, UserId, @@ -190,18 +194,18 @@ impl PartialEq for GossipRequest { #[derive(Debug, Clone)] enum RequestEvent { - KeyShare(ToDeviceEvent), - Secret(ToDeviceEvent), + KeyShare(ToDeviceRoomKeyRequestEvent), + Secret(SecretRequestEvent), } -impl From> for RequestEvent { - fn from(e: ToDeviceEvent) -> Self { +impl From for RequestEvent { + fn from(e: SecretRequestEvent) -> Self { Self::Secret(e) } } -impl From> for RequestEvent { - fn from(e: ToDeviceEvent) -> Self { +impl From for RequestEvent { + fn from(e: ToDeviceRoomKeyRequestEvent) -> Self { Self::KeyShare(e) } } diff --git a/crates/matrix-sdk-crypto/src/machine.rs b/crates/matrix-sdk-crypto/src/machine.rs index 49d5d03d6..c7df05320 100644 --- a/crates/matrix-sdk-crypto/src/machine.rs +++ b/crates/matrix-sdk-crypto/src/machine.rs @@ -39,12 +39,11 @@ use ruma::{ assign, events::{ room::encrypted::{ - EncryptedEventContent, EncryptedEventScheme, ToDeviceEncryptedEventContent, + EncryptedEventContent, EncryptedEventScheme, SyncEncryptedEvent, ToDeviceEncryptedEvent, }, - room_key::ToDeviceRoomKeyEventContent, + room_key::ToDeviceRoomKeyEvent, secret::request::SecretName, - AnyMessageEventContent, AnyRoomEvent, AnyToDeviceEvent, EventContent, SyncMessageEvent, - ToDeviceEvent, + AnyMessageEventContent, AnyRoomEvent, AnyToDeviceEvent, EventContent, }, DeviceId, DeviceIdBox, DeviceKeyAlgorithm, EventEncryptionAlgorithm, RoomId, UInt, UserId, }; @@ -561,7 +560,7 @@ impl OlmMachine { /// * `event` - The to-device event that should be decrypted. async fn decrypt_to_device_event( &self, - event: &ToDeviceEvent, + event: &ToDeviceEncryptedEvent, ) -> OlmResult { let mut decrypted = self.account.decrypt_to_device_event(event).await?; // Handle the decrypted event, e.g. fetch out Megolm sessions out of @@ -586,7 +585,7 @@ impl OlmMachine { &self, sender_key: &str, signing_key: &str, - event: &mut ToDeviceEvent, + event: &mut ToDeviceRoomKeyEvent, ) -> OlmResult<(Option, Option)> { match event.content.algorithm { EventEncryptionAlgorithm::MegolmV1AesSha2 => { @@ -977,7 +976,7 @@ impl OlmMachine { /// * `session_id` - The id that uniquely identifies the session. pub async fn request_room_key( &self, - event: &SyncMessageEvent, + event: &SyncEncryptedEvent, room_id: &RoomId, ) -> MegolmResult<(Option, OutgoingRequest)> { let content = match &event.content.scheme { @@ -1038,7 +1037,7 @@ impl OlmMachine { /// * `room_id` - The ID of the room where the event was sent to. pub async fn decrypt_room_event( &self, - event: &SyncMessageEvent, + event: &SyncEncryptedEvent, room_id: &RoomId, ) -> MegolmResult { let content = match &event.content.scheme { diff --git a/crates/matrix-sdk-crypto/src/olm/account.rs b/crates/matrix-sdk-crypto/src/olm/account.rs index 99acecd00..fc6f5870a 100644 --- a/crates/matrix-sdk-crypto/src/olm/account.rs +++ b/crates/matrix-sdk-crypto/src/olm/account.rs @@ -34,8 +34,8 @@ use ruma::{ api::client::r0::keys::{upload_keys, upload_signatures::Request as SignatureUploadRequest}, encryption::{CrossSigningKey, DeviceKeys, OneTimeKey, SignedKey}, events::{ - room::encrypted::{EncryptedEventScheme, ToDeviceEncryptedEventContent}, - AnyToDeviceEvent, OlmV1Keys, ToDeviceEvent, + room::encrypted::{EncryptedEventScheme, ToDeviceEncryptedEvent}, + AnyToDeviceEvent, OlmV1Keys, }, serde::{CanonicalJsonValue, Raw}, DeviceId, DeviceIdBox, DeviceKeyAlgorithm, DeviceKeyId, EventEncryptionAlgorithm, RoomId, UInt, @@ -114,7 +114,7 @@ impl Deref for Account { impl Account { pub async fn decrypt_to_device_event( &self, - event: &ToDeviceEvent, + event: &ToDeviceEncryptedEvent, ) -> OlmResult { debug!(sender = event.sender.as_str(), "Decrypting a to-device event"); diff --git a/crates/matrix-sdk-crypto/src/olm/group_sessions/inbound.rs b/crates/matrix-sdk-crypto/src/olm/group_sessions/inbound.rs index fa71c5614..05732e8fa 100644 --- a/crates/matrix-sdk-crypto/src/olm/group_sessions/inbound.rs +++ b/crates/matrix-sdk-crypto/src/olm/group_sessions/inbound.rs @@ -27,10 +27,10 @@ use ruma::{ events::{ forwarded_room_key::ToDeviceForwardedRoomKeyEventContent, room::{ - encrypted::{EncryptedEventContent, EncryptedEventScheme}, + encrypted::{EncryptedEventScheme, SyncEncryptedEvent}, history_visibility::HistoryVisibility, }, - AnySyncRoomEvent, SyncMessageEvent, + AnySyncRoomEvent, }, serde::Raw, DeviceKeyAlgorithm, EventEncryptionAlgorithm, RoomId, @@ -298,7 +298,7 @@ impl InboundGroupSession { /// * `event` - The event that should be decrypted. pub(crate) async fn decrypt( &self, - event: &SyncMessageEvent, + event: &SyncEncryptedEvent, ) -> MegolmResult<(Raw, u32)> { let content = match &event.content.scheme { EncryptedEventScheme::MegolmV1AesSha2(c) => c, diff --git a/crates/matrix-sdk/README.md b/crates/matrix-sdk/README.md index bc9c23c3b..d5f2092ba 100644 --- a/crates/matrix-sdk/README.md +++ b/crates/matrix-sdk/README.md @@ -11,7 +11,7 @@ Connecting and logging in to a homeserver is pretty starightforward: use std::convert::TryFrom; use matrix_sdk::{ Client, config::SyncSettings, Result, - ruma::{UserId, events::{SyncMessageEvent, room::message::MessageEventContent}}, + ruma::{UserId, events::room::message::SyncMessageEvent}, }; #[tokio::main] @@ -23,11 +23,9 @@ async fn main() -> Result<()> { client.login(alice, "password", None, None).await?; client - .register_event_handler( - |ev: SyncMessageEvent| async move { - println!("Received a message {:?}", ev); - }, - ) + .register_event_handler(|ev: SyncMessageEvent| async move { + println!("Received a message {:?}", ev); + }) .await; // Syncing is important to synchronize the client state with the server. diff --git a/crates/matrix-sdk/examples/autojoin.rs b/crates/matrix-sdk/examples/autojoin.rs index b3e4e2231..1a83d043e 100644 --- a/crates/matrix-sdk/examples/autojoin.rs +++ b/crates/matrix-sdk/examples/autojoin.rs @@ -3,17 +3,13 @@ use std::{env, process::exit}; use matrix_sdk::{ config::{ClientConfig, SyncSettings}, room::Room, - ruma::events::{room::member::MemberEventContent, StrippedStateEvent}, + ruma::events::room::member::StrippedMemberEvent, Client, }; use tokio::time::{sleep, Duration}; use url::Url; -async fn on_stripped_state_member( - room_member: StrippedStateEvent, - client: Client, - room: Room, -) { +async fn on_stripped_state_member(room_member: StrippedMemberEvent, client: Client, room: Room) { if room_member.state_key != client.user_id().await.unwrap() { return; } diff --git a/crates/matrix-sdk/examples/command_bot.rs b/crates/matrix-sdk/examples/command_bot.rs index 861b78fed..6e894cd41 100644 --- a/crates/matrix-sdk/examples/command_bot.rs +++ b/crates/matrix-sdk/examples/command_bot.rs @@ -3,15 +3,14 @@ use std::{env, process::exit}; use matrix_sdk::{ config::{ClientConfig, SyncSettings}, room::Room, - ruma::events::{ - room::message::{MessageEventContent, MessageType, TextMessageEventContent}, - SyncMessageEvent, + ruma::events::room::message::{ + MessageEventContent, MessageType, SyncMessageEvent, TextMessageEventContent, }, Client, }; use url::Url; -async fn on_room_message(event: SyncMessageEvent, room: Room) { +async fn on_room_message(event: SyncMessageEvent, room: Room) { if let Room::Joined(room) = room { let msg_body = if let SyncMessageEvent { content: diff --git a/crates/matrix-sdk/examples/image_bot.rs b/crates/matrix-sdk/examples/image_bot.rs index 5a5dd0c6e..bb06a2cc0 100644 --- a/crates/matrix-sdk/examples/image_bot.rs +++ b/crates/matrix-sdk/examples/image_bot.rs @@ -11,20 +11,15 @@ use matrix_sdk::{ self, config::SyncSettings, room::Room, - ruma::events::{ - room::message::{MessageEventContent, MessageType, TextMessageEventContent}, - SyncMessageEvent, + ruma::events::room::message::{ + MessageEventContent, MessageType, SyncMessageEvent, TextMessageEventContent, }, Client, }; use tokio::sync::Mutex; use url::Url; -async fn on_room_message( - event: SyncMessageEvent, - room: Room, - image: Arc>, -) { +async fn on_room_message(event: SyncMessageEvent, room: Room, image: Arc>) { if let Room::Joined(room) = room { let msg_body = if let SyncMessageEvent { content: diff --git a/crates/matrix-sdk/examples/login.rs b/crates/matrix-sdk/examples/login.rs index 80f5ad025..669ecf706 100644 --- a/crates/matrix-sdk/examples/login.rs +++ b/crates/matrix-sdk/examples/login.rs @@ -4,15 +4,14 @@ use matrix_sdk::{ self, config::SyncSettings, room::Room, - ruma::events::{ - room::message::{MessageEventContent, MessageType, TextMessageEventContent}, - SyncMessageEvent, + ruma::events::room::message::{ + MessageEventContent, MessageType, SyncMessageEvent, TextMessageEventContent, }, Client, }; use url::Url; -async fn on_room_message(event: SyncMessageEvent, room: Room) { +async fn on_room_message(event: SyncMessageEvent, room: Room) { if let Room::Joined(room) = room { if let SyncMessageEvent { content: diff --git a/crates/matrix-sdk/examples/wasm_command_bot/src/lib.rs b/crates/matrix-sdk/examples/wasm_command_bot/src/lib.rs index f1c76955e..cd56ec83f 100644 --- a/crates/matrix-sdk/examples/wasm_command_bot/src/lib.rs +++ b/crates/matrix-sdk/examples/wasm_command_bot/src/lib.rs @@ -3,8 +3,10 @@ use matrix_sdk::{ deserialized_responses::SyncResponse, ruma::{ events::{ - room::message::{MessageEventContent, MessageType, TextMessageEventContent}, - AnyMessageEventContent, AnySyncMessageEvent, AnySyncRoomEvent, SyncMessageEvent, + room::message::{ + MessageEventContent, MessageType, SyncMessageEvent, TextMessageEventContent, + }, + AnyMessageEventContent, AnySyncMessageEvent, AnySyncRoomEvent, }, RoomId, }, @@ -17,11 +19,7 @@ use web_sys::console; struct WasmBot(Client); impl WasmBot { - async fn on_room_message( - &self, - room_id: &RoomId, - event: &SyncMessageEvent, - ) { + async fn on_room_message(&self, room_id: &RoomId, event: &SyncMessageEvent) { let msg_body = if let SyncMessageEvent { content: MessageEventContent { diff --git a/crates/matrix-sdk/src/client.rs b/crates/matrix-sdk/src/client.rs index 8dc5ef0c9..49eb19b6b 100644 --- a/crates/matrix-sdk/src/client.rs +++ b/crates/matrix-sdk/src/client.rs @@ -540,8 +540,7 @@ impl Client { /// events::{ /// macros::EventContent, /// push_rules::PushRulesEvent, - /// room::{message::MessageEventContent, topic::TopicEventContent}, - /// SyncMessageEvent, SyncStateEvent, + /// room::{message::SyncMessageEvent, topic::SyncTopicEvent}, /// }, /// Int, MilliSecondsSinceUnixEpoch, /// }, @@ -552,27 +551,23 @@ impl Client { /// # let _ = async { /// client /// .register_event_handler( - /// |ev: SyncMessageEvent, - /// room: Room, - /// client: Client| async move { + /// |ev: SyncMessageEvent, room: Room, client: Client| async move { /// // Common usage: Room event plus room and client. /// }, /// ) /// .await /// .register_event_handler( - /// |ev: SyncMessageEvent, - /// room: Room, - /// encryption_info: Option| async move { - /// // An `Option` parameter lets you distinguish between - /// // unencrypted events and events that were decrypted by the SDK. + /// |ev: SyncMessageEvent, room: Room, encryption_info: Option| { + /// async move { + /// // An `Option` parameter lets you distinguish between + /// // unencrypted events and events that were decrypted by the SDK. + /// } /// }, /// ) /// .await - /// .register_event_handler( - /// |ev: SyncStateEvent| async move { - /// // You can omit any or all arguments after the first. - /// } - /// ) + /// .register_event_handler(|ev: SyncTopicEvent| async move { + /// // You can omit any or all arguments after the first. + /// }) /// .await; /// /// // Custom events work exactly the same way, you just need to declare @@ -585,18 +580,16 @@ impl Client { /// expires_at: MilliSecondsSinceUnixEpoch, /// } /// - /// client.register_event_handler( - /// |ev: SyncMessageEvent, room: Room| async move { - /// todo!("Display the token"); - /// }, - /// ).await; + /// client.register_event_handler(|ev: SyncTokenEvent, room: Room| async move { + /// todo!("Display the token"); + /// }).await; /// /// // Adding your custom data to the handler can be done as well /// let data = "MyCustomIdentifier".to_string(); /// /// client.register_event_handler({ /// let data = data.clone(); - /// move |ev: SyncMessageEvent | { + /// move |ev: SyncMessageEvent | { /// let data = data.clone(); /// async move { /// println!("Calling the handler with identifier {}", data); @@ -1794,7 +1787,7 @@ impl Client { /// # let password = ""; /// use matrix_sdk::{ /// Client, config::SyncSettings, - /// ruma::events::{SyncMessageEvent, room::message::MessageEventContent}, + /// ruma::events::room::message::SyncMessageEvent, /// }; /// /// let client = Client::new(homeserver)?; @@ -1805,12 +1798,9 @@ impl Client { /// /// // Register our handler so we start responding once we receive a new /// // event. - /// client.register_event_handler( - /// |ev: SyncMessageEvent| - /// async move { - /// println!("Received event {}: {:?}", ev.sender, ev.content); - /// }, - /// ).await; + /// client.register_event_handler(|ev: SyncMessageEvent| async move { + /// println!("Received event {}: {:?}", ev.sender, ev.content); + /// }).await; /// /// // Now keep on syncing forever. `sync()` will use the stored sync token /// // from our `sync_once()` call automatically. @@ -1891,7 +1881,7 @@ impl Client { /// # let password = ""; /// use matrix_sdk::{ /// Client, config::SyncSettings, - /// ruma::events::{SyncMessageEvent, room::message::MessageEventContent}, + /// ruma::events::room::message::SyncMessageEvent, /// }; /// /// let client = Client::new(homeserver)?; @@ -1899,12 +1889,9 @@ impl Client { /// /// // Register our handler so we start responding once we receive a new /// // event. - /// client.register_event_handler( - /// |ev: SyncMessageEvent| - /// async move { - /// println!("Received event {}: {:?}", ev.sender, ev.content); - /// }, - /// ).await; + /// client.register_event_handler(|ev: SyncMessageEvent| async move { + /// println!("Received event {}: {:?}", ev.sender, ev.content); + /// }).await; /// /// // Now keep on syncing forever. `sync()` will use the latest sync token /// // automatically. diff --git a/crates/matrix-sdk/src/event_handler.rs b/crates/matrix-sdk/src/event_handler.rs index 016030cd3..96e669ec1 100644 --- a/crates/matrix-sdk/src/event_handler.rs +++ b/crates/matrix-sdk/src/event_handler.rs @@ -458,7 +458,7 @@ mod test { use matrix_sdk_test::{EventBuilder, EventsJson}; use ruma::{ - events::{room::member::MemberEventContent, StrippedStateEvent, SyncStateEvent}, + events::room::member::{StrippedMemberEvent, SyncMemberEvent}, room_id, }; use serde_json::json; @@ -479,7 +479,7 @@ mod test { client .register_event_handler({ let member_count = member_count.clone(); - move |_ev: SyncStateEvent, _room: room::Room| { + move |_ev: SyncMemberEvent, _room: room::Room| { member_count.fetch_add(1, SeqCst); future::ready(()) } @@ -487,7 +487,7 @@ mod test { .await .register_event_handler({ let typing_count = typing_count.clone(); - move |_ev: SyncStateEvent| { + move |_ev: SyncMemberEvent| { typing_count.fetch_add(1, SeqCst); future::ready(()) } @@ -495,9 +495,7 @@ mod test { .await .register_event_handler({ let power_levels_count = power_levels_count.clone(); - move |_ev: SyncStateEvent, - _client: Client, - _room: room::Room| { + move |_ev: SyncMemberEvent, _client: Client, _room: room::Room| { power_levels_count.fetch_add(1, SeqCst); future::ready(()) } @@ -505,7 +503,7 @@ mod test { .await .register_event_handler({ let invited_member_count = invited_member_count.clone(); - move |_ev: StrippedStateEvent| { + move |_ev: StrippedMemberEvent| { invited_member_count.fetch_add(1, SeqCst); future::ready(()) }