mirror/matrix-rust-sdk
1
0
Fork 0
mirror of https://github.com/matrix-org/matrix-rust-sdk.git synced 2026-05-18 21:52:30 -04:00
Code Issues Packages Projects Releases Wiki Activity

Use new event type aliases

Browse Source
This commit is contained in:
Jonas Platte
2021-10-01 16:49:10 +02:00
parent 39d6ebdd53
commit b959d4be29
18 changed files with 113 additions and 155 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
crates/matrix-sdk-appservice/examples/appservice_autojoin.rs
View File

@@ -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<MemberEventContent>,
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<dyn std::error::Error>> {
appservice
.register_event_handler({
let appservice = appservice.clone();
move |event: SyncStateEvent<MemberEventContent>, room: Room| {
move |event: SyncMemberEvent, room: Room| {
handle_room_member(appservice.clone(), room, event)
}
})

4
crates/matrix-sdk-appservice/src/lib.rs
View File

@@ -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<MemberEventContent>| async {
//! appservice.register_event_handler(|_ev: SyncMemberEvent| async {
//! // do stuff
//! });
//!

7
crates/matrix-sdk-appservice/tests/tests.rs
View File

@@ -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<MemberEventContent>| {
move |_ev: SyncMemberEvent| {
*on_state_member.lock().unwrap() = true;
future::ready(())
}

5
crates/matrix-sdk-base/src/rooms/members.rs
View File

@@ -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<Option<MemberEventContent>>,
#[allow(dead_code)]
pub(crate) presence: Arc<Option<PresenceEvent>>,
pub(crate) power_levels: Arc<Option<SyncStateEvent<PowerLevelsEventContent>>>,
pub(crate) power_levels: Arc<Option<SyncPowerLevelsEvent>>,
pub(crate) max_power_level: i64,
pub(crate) is_room_creator: bool,
pub(crate) display_name_ambiguous: bool,

37
crates/matrix-sdk-common/src/deserialized_responses.rs
View File

@@ -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<MemberEventContent>",
into = "SyncStateEvent<MemberEventContent>"
)]
#[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<SyncStateEvent<MemberEventContent>> for MemberEvent {
impl TryFrom<RumaSyncMemberEvent> for MemberEvent {
type Error = ruma::identifiers::Error;
fn try_from(event: SyncStateEvent<MemberEventContent>) -> Result<Self, Self::Error> {
fn try_from(event: RumaSyncMemberEvent) -> Result<Self, Self::Error> {
Ok(MemberEvent {
content: event.content,
event_id: event.event_id,
@@ -274,10 +274,10 @@ impl TryFrom<SyncStateEvent<MemberEventContent>> for MemberEvent {
}
}
impl TryFrom<StateEvent<MemberEventContent>> for MemberEvent {
impl TryFrom<RumaMemberEvent> for MemberEvent {
type Error = ruma::identifiers::Error;
fn try_from(event: StateEvent<MemberEventContent>) -> Result<Self, Self::Error> {
fn try_from(event: RumaMemberEvent) -> Result<Self, Self::Error> {
Ok(MemberEvent {
content: event.content,
event_id: event.event_id,
@@ -290,9 +290,9 @@ impl TryFrom<StateEvent<MemberEventContent>> for MemberEvent {
}
}
impl From<MemberEvent> for SyncStateEvent<MemberEventContent> {
fn from(other: MemberEvent) -> SyncStateEvent<MemberEventContent> {
SyncStateEvent {
impl From<MemberEvent> 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<MemberEvent> for SyncStateEvent<MemberEventContent> {
}
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(
try_from = "StrippedStateEvent<MemberEventContent>",
into = "StrippedStateEvent<MemberEventContent>"
)]
#[serde(try_from = "RumaStrippedMemberEvent", into = "RumaStrippedMemberEvent")]
pub struct StrippedMemberEvent {
pub content: MemberEventContent,
pub sender: UserId,
pub state_key: UserId,
}
impl TryFrom<StrippedStateEvent<MemberEventContent>> for StrippedMemberEvent {
impl TryFrom<RumaStrippedMemberEvent> for StrippedMemberEvent {
type Error = ruma::identifiers::Error;
fn try_from(event: StrippedStateEvent<MemberEventContent>) -> Result<Self, Self::Error> {
fn try_from(event: RumaStrippedMemberEvent) -> Result<Self, Self::Error> {
Ok(StrippedMemberEvent {
content: event.content,
sender: event.sender,
@@ -327,7 +324,7 @@ impl TryFrom<StrippedStateEvent<MemberEventContent>> for StrippedMemberEvent {
}
}
impl From<StrippedMemberEvent> for StrippedStateEvent<MemberEventContent> {
impl From<StrippedMemberEvent> for RumaStrippedMemberEvent {
fn from(other: StrippedMemberEvent) -> Self {
Self {
content: other.content,

31
crates/matrix-sdk-crypto/src/gossiping/machine.rs
View File

@@ -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<ToDeviceRoomKeyRequestEventContent>,
) {
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<SecretRequestEventContent>,
) {
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<SecretRequestEventContent>,
event: &SecretRequestEvent,
) -> OlmResult<Option<Session>> {
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<ToDeviceRoomKeyRequestEventContent>,
event: &ToDeviceRoomKeyRequestEvent,
) -> OlmResult<Option<Session>> {
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<SecretSendEventContent>,
event: &mut SecretSendEvent,
) -> Result<Option<AnyToDeviceEvent>, 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<ToDeviceForwardedRoomKeyEventContent>,
event: &mut ToDeviceForwardedRoomKeyEvent,
) -> Result<(Option<AnyToDeviceEvent>, Option<InboundGroupSession>), CryptoStoreError> {
let key_info = self.get_key_info(&event.content).await?;

24
crates/matrix-sdk-crypto/src/gossiping/mod.rs
View File

@@ -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<ToDeviceRoomKeyRequestEventContent>),
Secret(ToDeviceEvent<SecretRequestEventContent>),
KeyShare(ToDeviceRoomKeyRequestEvent),
Secret(SecretRequestEvent),
}
impl From<ToDeviceEvent<SecretRequestEventContent>> for RequestEvent {
fn from(e: ToDeviceEvent<SecretRequestEventContent>) -> Self {
impl From<SecretRequestEvent> for RequestEvent {
fn from(e: SecretRequestEvent) -> Self {
Self::Secret(e)
}
}
impl From<ToDeviceEvent<ToDeviceRoomKeyRequestEventContent>> for RequestEvent {
fn from(e: ToDeviceEvent<ToDeviceRoomKeyRequestEventContent>) -> Self {
impl From<ToDeviceRoomKeyRequestEvent> for RequestEvent {
fn from(e: ToDeviceRoomKeyRequestEvent) -> Self {
Self::KeyShare(e)
}
}

15
crates/matrix-sdk-crypto/src/machine.rs
View File

@@ -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<ToDeviceEncryptedEventContent>,
event: &ToDeviceEncryptedEvent,
) -> OlmResult<OlmDecryptionInfo> {
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<ToDeviceRoomKeyEventContent>,
event: &mut ToDeviceRoomKeyEvent,
) -> OlmResult<(Option<AnyToDeviceEvent>, Option<InboundGroupSession>)> {
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<EncryptedEventContent>,
event: &SyncEncryptedEvent,
room_id: &RoomId,
) -> MegolmResult<(Option<OutgoingRequest>, 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<EncryptedEventContent>,
event: &SyncEncryptedEvent,
room_id: &RoomId,
) -> MegolmResult<SyncRoomEvent> {
let content = match &event.content.scheme {

6
crates/matrix-sdk-crypto/src/olm/account.rs
View File

@@ -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<ToDeviceEncryptedEventContent>,
event: &ToDeviceEncryptedEvent,
) -> OlmResult<OlmDecryptionInfo> {
debug!(sender = event.sender.as_str(), "Decrypting a to-device event");

6
crates/matrix-sdk-crypto/src/olm/group_sessions/inbound.rs
View File

@@ -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<EncryptedEventContent>,
event: &SyncEncryptedEvent,
) -> MegolmResult<(Raw<AnySyncRoomEvent>, u32)> {
let content = match &event.content.scheme {
EncryptedEventScheme::MegolmV1AesSha2(c) => c,

10
crates/matrix-sdk/README.md
View File

@@ -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<MessageEventContent>| 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.

8
crates/matrix-sdk/examples/autojoin.rs
View File

@@ -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<MemberEventContent>,
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;
}

7
crates/matrix-sdk/examples/command_bot.rs
View File

@@ -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<MessageEventContent>, room: Room) {
async fn on_room_message(event: SyncMessageEvent, room: Room) {
if let Room::Joined(room) = room {
let msg_body = if let SyncMessageEvent {
content:

11
crates/matrix-sdk/examples/image_bot.rs
View File

@@ -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<MessageEventContent>,
room: Room,
image: Arc<Mutex<File>>,
) {
async fn on_room_message(event: SyncMessageEvent, room: Room, image: Arc<Mutex<File>>) {
if let Room::Joined(room) = room {
let msg_body = if let SyncMessageEvent {
content:

7
crates/matrix-sdk/examples/login.rs
View File

@@ -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<MessageEventContent>, room: Room) {
async fn on_room_message(event: SyncMessageEvent, room: Room) {
if let Room::Joined(room) = room {
if let SyncMessageEvent {
content:

12
crates/matrix-sdk/examples/wasm_command_bot/src/lib.rs
View File

@@ -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<MessageEventContent>,
) {
async fn on_room_message(&self, room_id: &RoomId, event: &SyncMessageEvent) {
let msg_body = if let SyncMessageEvent {
content:
MessageEventContent {

57
crates/matrix-sdk/src/client.rs
View File

@@ -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<MessageEventContent>,
/// 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<MessageEventContent>,
/// room: Room,
/// encryption_info: Option<EncryptionInfo>| async move {
/// // An `Option<EncryptionInfo>` parameter lets you distinguish between
/// // unencrypted events and events that were decrypted by the SDK.
/// |ev: SyncMessageEvent, room: Room, encryption_info: Option<EncryptionInfo>| {
/// async move {
/// // An `Option<EncryptionInfo>` parameter lets you distinguish between
/// // unencrypted events and events that were decrypted by the SDK.
/// }
/// },
/// )
/// .await
/// .register_event_handler(
/// |ev: SyncStateEvent<TopicEventContent>| 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<TokenEventContent>, 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<MessageEventContent> | {
/// 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<MessageEventContent>|
/// 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<MessageEventContent>|
/// 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.

12
crates/matrix-sdk/src/event_handler.rs
View File

@@ -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<MemberEventContent>, _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<MemberEventContent>| {
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<MemberEventContent>,
_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<MemberEventContent>| {
move |_ev: StrippedMemberEvent| {
invited_member_count.fetch_add(1, SeqCst);
future::ready(())
}