Struct Room

Source

pub struct Room { /* private fields */ }

Expand description

A room in the room list.

It’s cheap to clone this type.

Implementations§

Source §

impl Room

Source

pub fn id(&self) -> &RoomId

Get the room ID.

Source

pub fn cached_display_name(&self) -> Option<String>

Get a computed room name for the room.

Source

pub fn inner_room(&self) -> &Room

Get the underlying matrix_sdk::Room.

Source

pub fn timeline(&self) -> Option<Arc<Timeline>>

Get the timeline of the room if one exists.

Source

pub fn is_timeline_initialized(&self) -> bool

Get whether the timeline has been already initialised or not.

Source

pub async fn init_timeline_with_builder( &self, builder: TimelineBuilder, ) -> Result<(), Error>

Initialize the timeline of the room with an event type filter so only some events are returned. If a previous timeline exists, it’ll return an error. Otherwise, a Timeline will be returned.

Source

pub async fn latest_event(&self) -> Option<EventTimelineItem>

Get the latest event in the timeline.

The latest event comes first from the Timeline, it can be a local or a remote event. Note that the Timeline can have more information esp. if it has run a backpagination for example. Otherwise if the Timeline doesn’t have any latest event, it comes from the cache. This method does not fetch any events or calculate anything — if it’s not already available, we return None.

Reminder: this method also returns None is the latest event is not suitable for use in a message preview.

Source

pub async fn default_room_timeline_builder( &self, ) -> Result<TimelineBuilder, Error>

Create a new TimelineBuilder with the default configuration.

If the room was synced before some initial events will be added to the TimelineBuilder.

Methods from Deref<Target = Room>§

Source

pub async fn make_edit_event( &self, event_id: &EventId, new_content: EditedContent, ) -> Result<AnyMessageLikeEventContent, EditError>

Create a new edit event for the target event id with the new content.

The event can then be sent with Room::send or a crate::send_queue::RoomSendQueue.

Source

pub async fn leave(&self) -> Result<(), Error>

Leave this room.

Only invited and joined rooms can be left.

Source

pub async fn join(&self) -> Result<(), Error>

Join this room.

Only invited and left rooms can be joined via this method.

Source

pub fn client(&self) -> Client

Get the inner client saved in this room instance.

Returns the client this room is part of.

Source

pub fn is_synced(&self) -> bool

Get the sync state of this room, i.e. whether it was fully synced with the server.

Source

pub async fn avatar( &self, format: MediaFormat, ) -> Result<Option<Vec<u8>>, Error>

Gets the avatar of this room, if set.

Returns the avatar. If a thumbnail is requested no guarantee on the size of the image is given.

§Arguments

format - The desired format of the avatar.

§Examples

let client = Client::new(homeserver).await.unwrap();
client.matrix_auth().login_username(user, "password").send().await.unwrap();
let room_id = room_id!("!roomid:example.com");
let room = client.get_room(&room_id).unwrap();
if let Some(avatar) = room.avatar(MediaFormat::File).await.unwrap() {
    std::fs::write("avatar.png", avatar);
}

Source

pub async fn messages( &self, options: MessagesOptions, ) -> Result<Messages, Error>

Sends a request to /_matrix/client/r0/rooms/{room_id}/messages and returns a Messages struct that contains a chunk of room and state events (RoomEvent and AnyStateEvent).

With the encryption feature, messages are decrypted if possible. If decryption fails for an individual message, that message is returned undecrypted.

§Examples

use matrix_sdk::{room::MessagesOptions, Client};

let options =
    MessagesOptions::backward().from("t47429-4392820_219380_26003_2265");

let mut client = Client::new(homeserver).await.unwrap();
let room = client.get_room(room_id!("!roomid:example.com")).unwrap();
assert!(room.messages(options).await.is_ok());

Source

pub fn add_event_handler<Ev, Ctx, H>(&self, handler: H) -> EventHandlerHandle
where Ev: SyncEvent + DeserializeOwned + Send + 'static, H: EventHandler<Ev, Ctx>,

Register a handler for events of a specific type, within this room.

This method works the same way as Client::add_event_handler, except that the handler will only be called for events within this room. See that method for more details on event handler functions.

room.add_event_handler(hdl) is equivalent to client.add_room_event_handler(room_id, hdl). Use whichever one is more convenient in your use case.

Source

pub fn subscribe_to_updates(&self) -> Receiver<RoomUpdate>

Subscribe to all updates for this room.

The returned receiver will receive a new message for each sync response that contains updates for this room.

Source

pub fn subscribe_to_typing_notifications( &self, ) -> (EventHandlerDropGuard, Receiver<Vec<OwnedUserId>>)

Subscribe to typing notifications for this room.

The returned receiver will receive a new vector of user IDs for each sync response that contains ‘m.typing’ event. The current user ID will be filtered out.

Source

pub async fn subscribe_to_identity_status_changes( &self, ) -> Result<impl Stream<Item = Vec<IdentityStatusChange>>, Error>

Subscribe to updates about users who are in “pin violation” i.e. their identity has changed and the user has not yet acknowledged this.

The returned receiver will receive a new vector of IdentityStatusChange each time a /keys/query response shows a changed identity for a member of this room, or a sync shows a change to the membership of an affected user. (Changes to the current user are not directly included, but some changes to the current user’s identity can trigger changes to how we see other users’ identities, which will be included.)

The first item in the stream provides the current state of the room: each member of the room who is not in “pinned” or “verified” state will be included (except the current user).

If the changed_to property of an IdentityStatusChange is set to PinViolation then a warning should be displayed to the user. If it is set to Pinned then no warning should be displayed.

Note that if a user who is in pin violation leaves the room, a Pinned update is sent, to indicate that the warning should be removed, even though the user’s identity is not necessarily pinned.

Source

pub async fn event( &self, event_id: &EventId, request_config: Option<RequestConfig>, ) -> Result<TimelineEvent, Error>

Fetch the event with the given EventId in this room.

It uses the given RequestConfig if provided, or the client’s default one otherwise.

Source

pub async fn event_with_context( &self, event_id: &EventId, lazy_load_members: bool, context_size: UInt, request_config: Option<RequestConfig>, ) -> Result<EventWithContextResponse, Error>

Fetch the event with the given EventId in this room, using the /context endpoint to get more information.

Source

pub async fn is_encrypted(&self) -> Result<bool, Error>

Check whether this room is encrypted. If the room encryption state is not synced yet, it will send a request to fetch it.

Returns true if the room is encrypted, otherwise false.

Source

pub async fn crypto_context_info(&self) -> CryptoContextInfo

Gets additional context info about the client crypto.

Source

pub async fn sync_members(&self) -> Result<(), Error>

Sync the member list with the server.

This method will de-duplicate requests if it is called multiple times in quick succession, in that case the return value will be None. This method does nothing if the members are already synced.

Source

pub async fn get_member( &self, user_id: &UserId, ) -> Result<Option<RoomMember>, Error>

Get a specific member of this room.

Note: This method will fetch the members from the homeserver if the member list isn’t synchronized due to member lazy loading. Because of that it might panic if it isn’t run on a tokio thread.

Use get_member_no_sync() if you want a method that doesn’t do any requests.

§Arguments

user_id - The ID of the user that should be fetched out of the store.

Source

pub async fn get_member_no_sync( &self, user_id: &UserId, ) -> Result<Option<RoomMember>, Error>

Get a specific member of this room.

Note: This method will not fetch the members from the homeserver if the member list isn’t synchronized due to member lazy loading. Thus, members could be missing.

Use get_member() if you want to ensure to always have the full member list to chose from.

§Arguments

user_id - The ID of the user that should be fetched out of the store.

Source

pub async fn members( &self, memberships: RoomMemberships, ) -> Result<Vec<RoomMember>, Error>

Get members for this room, with the given memberships.

Note: This method will fetch the members from the homeserver if the member list isn’t synchronized due to member lazy loading. Because of that it might panic if it isn’t run on a tokio thread.

Use members_no_sync() if you want a method that doesn’t do any requests.

Source

pub async fn members_no_sync( &self, memberships: RoomMemberships, ) -> Result<Vec<RoomMember>, Error>

Get members for this room, with the given memberships.

Note: This method will not fetch the members from the homeserver if the member list isn’t synchronized due to member lazy loading. Thus, members could be missing.

Use members() if you want to ensure to always get the full member list.

Source

pub async fn get_state_events( &self, event_type: StateEventType, ) -> Result<Vec<RawAnySyncOrStrippedState>, Error>

Get all state events of a given type in this room.

Source

pub async fn get_state_events_static<C>( &self, ) -> Result<Vec<RawSyncOrStrippedState<C>>, Error>
where C: StaticEventContent + StaticStateEventContent + RedactContent, <C as RedactContent>::Redacted: RedactedStateEventContent,

Get all state events of a given statically-known type in this room.

§Examples

use matrix_sdk::ruma::{
    events::room::member::RoomMemberEventContent, serde::Raw,
};

let room_members =
    room.get_state_events_static::<RoomMemberEventContent>().await?;

Source

pub async fn get_state_events_for_keys( &self, event_type: StateEventType, state_keys: &[&str], ) -> Result<Vec<RawAnySyncOrStrippedState>, Error>

Get the state events of a given type with the given state keys in this room.

Source

pub async fn get_state_events_for_keys_static<'a, C, K, I>( &self, state_keys: I, ) -> Result<Vec<RawSyncOrStrippedState<C>>, Error>
where C: StaticEventContent + StaticStateEventContent + RedactContent, <C as StateEventContent>::StateKey: Borrow<K>, <C as RedactContent>::Redacted: RedactedStateEventContent, K: AsRef<str> + Sync + 'a, I: IntoIterator<Item = &'a K> + Send, ::IntoIter: Send,

Get the state events of a given statically-known type with the given state keys in this room.

§Examples

use matrix_sdk::ruma::events::room::member::RoomMemberEventContent;

let room_members = room
    .get_state_events_for_keys_static::<RoomMemberEventContent, _, _>(
        user_ids,
    )
    .await?;

Source

pub async fn get_state_event( &self, event_type: StateEventType, state_key: &str, ) -> Result<Option<RawAnySyncOrStrippedState>, Error>

Get a specific state event in this room.

Source

pub async fn get_state_event_static<C>( &self, ) -> Result<Option<RawSyncOrStrippedState<C>>, Error>
where C: StaticEventContent + StaticStateEventContent<StateKey = EmptyStateKey> + RedactContent, <C as RedactContent>::Redacted: RedactedStateEventContent,

Get a specific state event of statically-known type with an empty state key in this room.

§Examples

use matrix_sdk::ruma::events::room::power_levels::RoomPowerLevelsEventContent;

let power_levels = room
    .get_state_event_static::<RoomPowerLevelsEventContent>()
    .await?
    .expect("every room has a power_levels event")
    .deserialize()?;

Source

pub async fn get_state_event_static_for_key<C, K>( &self, state_key: &K, ) -> Result<Option<RawSyncOrStrippedState<C>>, Error>
where C: StaticEventContent + StaticStateEventContent + RedactContent, <C as StateEventContent>::StateKey: Borrow<K>, <C as RedactContent>::Redacted: RedactedStateEventContent, K: AsRef<str> + Sync + ?Sized,

Get a specific state event of statically-known type in this room.

§Examples

use matrix_sdk::ruma::{
    events::room::member::RoomMemberEventContent, serde::Raw, user_id,
};

let member_event = room
    .get_state_event_static_for_key::<RoomMemberEventContent, _>(user_id!(
        "@alice:example.org"
    ))
    .await?;

Source

pub async fn parent_spaces( &self, ) -> Result<impl Stream<Item = Result<ParentSpace, Error>>, Error>

Returns the parents this room advertises as its parents.

Results are in no particular order.

Source

pub async fn account_data( &self, data_type: RoomAccountDataEventType, ) -> Result<Option<Raw<AnyRoomAccountDataEvent>>, Error>

Read account data in this room, from storage.

Source

pub async fn account_data_static<C>( &self, ) -> Result<Option<Raw<RoomAccountDataEvent<C>>>, Error>
where C: StaticEventContent + RoomAccountDataEventContent,

Get account data of a statically-known type in this room, from storage.

§Examples

use matrix_sdk::ruma::events::fully_read::FullyReadEventContent;

match room.account_data_static::<FullyReadEventContent>().await? {
    Some(fully_read) => {
        println!("Found read marker: {:?}", fully_read.deserialize()?)
    }
    None => println!("No read marker for this room"),
}

Source

pub async fn contains_only_verified_devices(&self) -> Result<bool, Error>

Check if all members of this room are verified and all their devices are verified.

Returns true if all devices in the room are verified, otherwise false.

Source

pub async fn set_account_data<T>(&self, content: T) -> Result<Response, Error>
where T: RoomAccountDataEventContent,

Set the given account data event for this room.

§Example

use matrix_sdk::ruma::events::fully_read::FullyReadEventContent;
let content = FullyReadEventContent::new(event_id);

room.set_account_data(content).await?;

Source

pub async fn set_account_data_raw( &self, event_type: RoomAccountDataEventType, content: Raw<AnyRoomAccountDataEventContent>, ) -> Result<Response, Error>

Set the given raw account data event in this room.

§Example

use matrix_sdk::ruma::{
    events::{
        marked_unread::MarkedUnreadEventContent,
        AnyRoomAccountDataEventContent, EventContent,
    },
    serde::Raw,
};
let marked_unread_content = MarkedUnreadEventContent::new(true);
let full_event: AnyRoomAccountDataEventContent =
    marked_unread_content.clone().into();
room.set_account_data_raw(
    marked_unread_content.event_type(),
    Raw::new(&full_event).unwrap(),
)
.await?;

Source

pub async fn set_tag( &self, tag: TagName, tag_info: TagInfo, ) -> Result<Response, Error>

Adds a tag to the room, or updates it if it already exists.

Returns the create_tag::v3::Response from the server.

§Arguments

tag - The tag to add or update.
tag_info - Information about the tag, generally containing the order parameter.

§Examples

use matrix_sdk::ruma::events::tag::TagInfo;

if let Some(room) = client.get_room(&room_id) {
    let mut tag_info = TagInfo::new();
    tag_info.order = Some(0.9);
    let user_tag = UserTagName::from_str("u.work")?;

    room.set_tag(TagName::User(user_tag), tag_info).await?;
}

Source

pub async fn remove_tag(&self, tag: TagName) -> Result<Response, Error>

Removes a tag from the room.

Returns the delete_tag::v3::Response from the server.

§Arguments

tag - The tag to remove.

Source

pub async fn set_is_favourite( &self, is_favourite: bool, tag_order: Option<f64>, ) -> Result<(), Error>

Add or remove the m.favourite flag for this room.

If is_favourite is true, and the m.low_priority tag is set on the room, the tag will be removed too.

§Arguments

is_favourite - Whether to mark this room as favourite.
tag_order - The order of the tag if any.

Source

pub async fn set_is_low_priority( &self, is_low_priority: bool, tag_order: Option<f64>, ) -> Result<(), Error>

Add or remove the m.lowpriority flag for this room.

If is_low_priority is true, and the m.favourite tag is set on the room, the tag will be removed too.

§Arguments

is_low_priority - Whether to mark this room as low_priority or not.
tag_order - The order of the tag if any.

Source

pub async fn set_is_direct(&self, is_direct: bool) -> Result<(), Error>

Sets whether this room is a DM.

When setting this room as DM, it will be marked as DM for all active members of the room. When unsetting this room as DM, it will be unmarked as DM for all users, not just the members.

§Arguments

is_direct - Whether to mark this room as direct.

Source

pub async fn decrypt_event( &self, event: &Raw<OriginalSyncMessageLikeEvent<RoomEncryptedEventContent>>, ) -> Result<TimelineEvent, Error>

Tries to decrypt a room event.

§Arguments

event - The room event to be decrypted.

Returns the decrypted event. In the case of a decryption error, returns a TimelineEvent representing the decryption error.

Source

pub async fn discard_room_key(&self) -> Result<(), Error>

Forces the currently active room key, which is used to encrypt messages, to be rotated.

A new room key will be crated and shared with all the room members the next time a message will be sent. You don’t have to call this method, room keys will be rotated automatically when necessary. This method is still useful for debugging purposes.

For more info please take a look a the encryption module documentation.

Source

pub async fn ban_user( &self, user_id: &UserId, reason: Option<&str>, ) -> Result<(), Error>

Ban the user with UserId from this room.

§Arguments

user_id - The user to ban with UserId.
reason - The reason for banning this user.

Source

pub async fn unban_user( &self, user_id: &UserId, reason: Option<&str>, ) -> Result<(), Error>

Unban the user with UserId from this room.

§Arguments

user_id - The user to unban with UserId.
reason - The reason for unbanning this user.

Source

pub async fn kick_user( &self, user_id: &UserId, reason: Option<&str>, ) -> Result<(), Error>

Kick a user out of this room.

§Arguments

user_id - The UserId of the user that should be kicked out of the room.
reason - Optional reason why the room member is being kicked out.

Source

pub async fn invite_user_by_id(&self, user_id: &UserId) -> Result<(), Error>

Invite the specified user by UserId to this room.

§Arguments

user_id - The UserId of the user to invite to the room.

Source

pub async fn invite_user_by_3pid( &self, invite_id: Invite3pid, ) -> Result<(), Error>

Invite the specified user by third party id to this room.

§Arguments

invite_id - A third party id of a user to invite to the room.

Source

pub async fn typing_notice(&self, typing: bool) -> Result<(), Error>

Activate typing notice for this room.

The typing notice remains active for 4s. It can be deactivate at any point by setting typing to false. If this method is called while the typing notice is active nothing will happen. This method can be called on every key stroke, since it will do nothing while typing is active.

§Arguments

typing - Whether the user is typing or has stopped typing.

§Examples

use std::time::Duration;

use matrix_sdk::ruma::api::client::typing::create_typing_event::v3::Typing;

let room_id = room_id!("!SVkFJHzfwvuaIEawgC:localhost");

if let Some(room) = client.get_room(&room_id) {
    room.typing_notice(true).await?
}

Source

pub async fn send_single_receipt( &self, receipt_type: ReceiptType, thread: ReceiptThread, event_id: OwnedEventId, ) -> Result<(), Error>

Send a request to set a single receipt.

§Arguments

receipt_type - The type of the receipt to set. Note that it is possible to set the fully-read marker although it is technically not a receipt.
thread - The thread where this receipt should apply, if any. Note that this must be ReceiptThread::Unthreaded when sending a ReceiptType::FullyRead.
event_id - The EventId of the event to set the receipt on.

Source

pub async fn send_multiple_receipts( &self, receipts: Receipts, ) -> Result<(), Error>

Send a request to set multiple receipts at once.

§Arguments

receipts - The Receipts to send.

If receipts is empty, this is a no-op.

Source

pub async fn enable_encryption(&self) -> Result<(), Error>

Enable End-to-end encryption in this room.

This method will be a noop if encryption is already enabled, otherwise sends a m.room.encryption state event to the room. This might fail if you don’t have the appropriate power level to enable end-to-end encryption.

A sync needs to be received to update the local room state. This method will wait for a sync to be received, this might time out if no sync loop is running or if the server is slow.

§Examples

let room_id = room_id!("!SVkFJHzfwvuaIEawgC:localhost");

if let Some(room) = client.get_room(&room_id) {
    room.enable_encryption().await?
}

Source

pub async fn sync_up(&self)

Wait for the room to be fully synced.

This method makes sure the room that was returned when joining a room has been echoed back in the sync.

Warning: This waits until a sync happens and does not return if no sync is happening. It can also return early when the room is not a joined room anymore.

Source

pub fn send( &self, content: impl MessageLikeEventContent, ) -> SendMessageLikeEvent<'_>

Send a message-like event to this room.

Returns the parsed response from the server.

If the encryption feature is enabled this method will transparently encrypt the event if this room is encrypted (except for m.reaction events, which are never encrypted).

Note: If you just want to send an event with custom JSON content to a room, you can use the send_raw() method for that.

If you want to set a transaction ID for the event, use .with_transaction_id() on the returned value before .awaiting it.

§Arguments

content - The content of the message event.

§Examples

use matrix_sdk::ruma::{
    events::{
        macros::EventContent,
        room::message::{RoomMessageEventContent, TextMessageEventContent},
    },
    uint, MilliSecondsSinceUnixEpoch, TransactionId,
};

let content = RoomMessageEventContent::text_plain("Hello world");
let txn_id = TransactionId::new();

if let Some(room) = client.get_room(&room_id) {
    room.send(content).with_transaction_id(txn_id).await?;
}

// Custom events work too:
#[derive(Clone, Debug, Deserialize, Serialize, EventContent)]
#[ruma_event(type = "org.shiny_new_2fa.token", kind = MessageLike)]
struct TokenEventContent {
    token: String,
    #[serde(rename = "exp")]
    expires_at: MilliSecondsSinceUnixEpoch,
}

let content = TokenEventContent {
    token: generate_token(),
    expires_at: {
        let now = MilliSecondsSinceUnixEpoch::now();
        MilliSecondsSinceUnixEpoch(now.0 + uint!(30_000))
    },
};

if let Some(room) = client.get_room(&room_id) {
    room.send(content).await?;
}

Source

pub fn send_raw<'a>( &'a self, event_type: &'a str, content: impl IntoRawMessageLikeEventContent, ) -> SendRawMessageLikeEvent<'a>

Send a message-like event with custom JSON content to this room.

Returns the parsed response from the server.

If the encryption feature is enabled this method will transparently encrypt the event if this room is encrypted (except for m.reaction events, which are never encrypted).

This method is equivalent to the send() method but allows sending custom JSON payloads, e.g. constructed using the serde_json::json!() macro.

If you want to set a transaction ID for the event, use .with_transaction_id() on the returned value before .awaiting it.

§Arguments

event_type - The type of the event.
content - The content of the event as a raw JSON value. The argument type can be serde_json::Value, but also other raw JSON types; for the full list check the documentation of IntoRawMessageLikeEventContent.

§Examples

use serde_json::json;

if let Some(room) = client.get_room(&room_id) {
    room.send_raw("m.room.message", json!({ "body": "Hello world" })).await?;
}

Source

pub fn send_attachment<'a>( &'a self, filename: &'a str, content_type: &'a Mime, data: Vec<u8>, config: AttachmentConfig, ) -> SendAttachment<'a>

Send an attachment to this room.

This will upload the given data that the reader produces using the upload() method and post an event to the given room. If the room is encrypted and the encryption feature is enabled the upload will be encrypted.

This is a convenience method that calls the upload() and afterwards the send().

§Arguments

filename - The file name.
content_type - The type of the media, this will be used as the content-type header.
reader - A Reader that will be used to fetch the raw bytes of the media.
config - Metadata and configuration for the attachment.

§Examples

let mut image = fs::read("/home/example/my-cat.jpg")?;

if let Some(room) = client.get_room(&room_id) {
    room.send_attachment(
        "my_favorite_cat.jpg",
        &mime::IMAGE_JPEG,
        image,
        AttachmentConfig::new(),
    ).await?;
}

Source

pub async fn update_power_levels( &self, updates: Vec<(&UserId, Int)>, ) -> Result<Response, Error>

Update the power levels of a select set of users of this room.

Issue a power_levels state event request to the server, changing the given UserId -> Int levels. May fail if the power_levels aren’t locally known yet or the server rejects the state event update, e.g. because of insufficient permissions. Neither permissions to update nor whether the data might be stale is checked prior to issuing the request.

Source

pub async fn apply_power_level_changes( &self, changes: RoomPowerLevelChanges, ) -> Result<(), Error>

Applies a set of power level changes to this room.

Any values that are None in the given RoomPowerLevelChanges will remain unchanged.

Source

pub async fn reset_power_levels(&self) -> Result<RoomPowerLevels, Error>

Resets the room’s power levels to the default values

Source

pub async fn get_suggested_user_role( &self, user_id: &UserId, ) -> Result<RoomMemberRole, Error>

Gets the suggested role for the user with the provided user_id.

This method checks the RoomPowerLevels events instead of loading the member list and looking for the member.

Source

pub async fn get_user_power_level(&self, user_id: &UserId) -> Result<i64, Error>

Gets the power level the user with the provided user_id.

This method checks the RoomPowerLevels events instead of loading the member list and looking for the member.

Source

pub async fn users_with_power_levels(&self) -> HashMap<OwnedUserId, i64>

Gets a map with the UserId of users with power levels other than 0 and this power level.

Source

pub async fn set_name(&self, name: String) -> Result<Response, Error>

Sets the name of this room.

Source

pub async fn set_room_topic(&self, topic: &str) -> Result<Response, Error>

Sets a new topic for this room.

Source

pub async fn set_avatar_url( &self, url: &MxcUri, info: Option<ImageInfo>, ) -> Result<Response, Error>

Sets the new avatar url for this room.

§Arguments

avatar_url - The owned matrix uri that represents the avatar
info - The optional image info that can be provided for the avatar

Source

pub async fn remove_avatar(&self) -> Result<Response, Error>

Removes the avatar from the room

Source

pub async fn upload_avatar( &self, mime: &Mime, data: Vec<u8>, info: Option<ImageInfo>, ) -> Result<Response, Error>

Uploads a new avatar for this room.

§Arguments

mime - The mime type describing the data
data - The data representation of the avatar
info - The optional image info provided for the avatar, the blurhash and the mimetype will always be updated

Source

pub async fn send_state_event( &self, content: impl StateEventContent<StateKey = EmptyStateKey>, ) -> Result<Response, Error>

Send a state event with an empty state key to the homeserver.

For state events with a non-empty state key, see send_state_event_for_key.

Returns the parsed response from the server.

§Arguments

content - The content of the state event.

§Examples

use matrix_sdk::ruma::{
    events::{
        macros::EventContent, room::encryption::RoomEncryptionEventContent,
        EmptyStateKey,
    },
    EventEncryptionAlgorithm,
};

let encryption_event_content = RoomEncryptionEventContent::new(
    EventEncryptionAlgorithm::MegolmV1AesSha2,
);
joined_room.send_state_event(encryption_event_content).await?;

// Custom event:
#[derive(Clone, Debug, Deserialize, Serialize, EventContent)]
#[ruma_event(
    type = "org.matrix.msc_9000.xxx",
    kind = State,
    state_key_type = EmptyStateKey,
)]
struct XxxStateEventContent {/* fields... */}

let content: XxxStateEventContent = todo!();
joined_room.send_state_event(content).await?;

Source

pub async fn send_state_event_for_key<C, K>( &self, state_key: &K, content: C, ) -> Result<Response, Error>
where C: StateEventContent, <C as StateEventContent>::StateKey: Borrow<K>, K: AsRef<str> + ?Sized,

Send a state event to the homeserver.

Returns the parsed response from the server.

§Arguments

content - The content of the state event.
state_key - A unique key which defines the overwriting semantics for this piece of room state.

§Examples

use matrix_sdk::ruma::{
    events::{
        macros::EventContent,
        room::member::{RoomMemberEventContent, MembershipState},
    },
    mxc_uri,
};

let avatar_url = mxc_uri!("mxc://example.org/avatar").to_owned();
let mut content = RoomMemberEventContent::new(MembershipState::Join);
content.avatar_url = Some(avatar_url);

joined_room.send_state_event_for_key(ruma::user_id!("@foo:bar.com"), content).await?;

// Custom event:
#[derive(Clone, Debug, Deserialize, Serialize, EventContent)]
#[ruma_event(type = "org.matrix.msc_9000.xxx", kind = State, state_key_type = String)]
struct XxxStateEventContent { /* fields... */ }

let content: XxxStateEventContent = todo!();
joined_room.send_state_event_for_key("foo", content).await?;

Source

pub async fn send_state_event_raw( &self, event_type: &str, state_key: &str, content: impl IntoRawStateEventContent, ) -> Result<Response, Error>

Send a raw room state event to the homeserver.

Returns the parsed response from the server.

§Arguments

event_type - The type of the event that we’re sending out.
state_key - A unique key which defines the overwriting semantics for this piece of room state. This value is often a zero-length string.
content - The content of the event as a raw JSON value. The argument type can be serde_json::Value, but also other raw JSON types; for the full list check the documentation of IntoRawStateEventContent.

§Examples

use serde_json::json;


if let Some(room) = client.get_room(&room_id) {
    room.send_state_event_raw("m.room.member", "", json!({
        "avatar_url": "mxc://example.org/SEsfnsuifSDFSSEF",
        "displayname": "Alice Margatroid",
        "membership": "join",
    })).await?;
}

Source

pub async fn redact( &self, event_id: &EventId, reason: Option<&str>, txn_id: Option<OwnedTransactionId>, ) -> Result<Response, HttpError>

Strips all information out of an event of the room.

Returns the redact_event::v3::Response from the server.

This cannot be undone. Users may redact their own events, and any user with a power level greater than or equal to the redact power level of the room may redact events there.

§Arguments

event_id - The ID of the event to redact
reason - The reason for the event being redacted.
txn_id - A unique ID that can be attached to this event as its transaction ID. If not given one is created for the message.

§Examples

use matrix_sdk::ruma::event_id;

if let Some(room) = client.get_room(&room_id) {
    let event_id = event_id!("$xxxxxx:example.org");
    let reason = Some("Indecent material");
    room.redact(&event_id, reason, None).await?;
}

Source