Struct matrix_sdk::room::Room

source ·

pub struct Room { /* private fields */ }

Expand description

A struct containing methods that are common for Joined, Invited and Left Rooms

Implementations§

source §

impl Room

source

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

Leave this room.

Only invited and joined rooms can be left.

source

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

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>>>

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>

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 event(&self, event_id: &EventId) -> Result<TimelineEvent>

Fetch the event with the given EventId in this room.

source

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

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>

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 sync_members(&self) -> Result<()>

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 active_members(&self) -> Result<Vec<RoomMember>>

👎Deprecated: Use members with RoomMemberships::ACTIVE instead

Get active members for this room, includes invited, joined members.

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 active_members_no_sync() if you want a method that doesn’t do any requests.

source

pub async fn active_members_no_sync(&self) -> Result<Vec<RoomMember>>

👎Deprecated: Use members_no_sync with RoomMemberships::ACTIVE instead

Get active members for this room, includes invited, joined members.

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 from the list.

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

source

pub async fn joined_members(&self) -> Result<Vec<RoomMember>>

👎Deprecated: Use members with RoomMemberships::JOIN instead

Get all the joined members 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 joined_members_no_sync() if you want a method that doesn’t do any requests.

source

pub async fn joined_members_no_sync(&self) -> Result<Vec<RoomMember>>

👎Deprecated: Use members_no_sync with RoomMemberships::JOIN instead

Get all the joined members 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 from the list.

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

source

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

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>>

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>>

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>>

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>>

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>>>
where C: StaticEventContent + StaticStateEventContent + RedactContent, C::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>>

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>>>
where C: StaticEventContent + StaticStateEventContent + RedactContent, C::StateKey: Borrow<K>, C::Redacted: RedactedStateEventContent, K: AsRef<str> + Sized + Sync + 'a, I: IntoIterator<Item = &'a K> + Send, I::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>>

Get a specific state event in this room.

source

pub async fn get_state_event_static<C>( &self ) -> Result<Option<RawSyncOrStrippedState<C>>>
where C: StaticEventContent + StaticStateEventContent<StateKey = EmptyStateKey> + RedactContent, C::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>>>
where C: StaticEventContent + StaticStateEventContent + RedactContent, C::StateKey: Borrow<K>, C::Redacted: RedactedStateEventContent, K: AsRef<str> + ?Sized + Sync,

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>> + '_>

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>>>

Read account data in this room, from storage.

source

pub async fn account_data_static<C>( &self ) -> Result<Option<Raw<RoomAccountDataEvent<C>>>>
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>

Available on crate feature e2e-encryption only.

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_tag( &self, tag: TagName, tag_info: TagInfo ) -> HttpResult<Response>

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) -> HttpResult<Response>

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<()>

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<()>

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<()>

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<OriginalSyncRoomEncryptedEvent> ) -> Result<TimelineEvent>

Available on crate feature e2e-encryption only.

Tries to decrypt a room event.

§Arguments

event - The room event to be decrypted.

Returns the decrypted event.

source

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

Available on crate feature e2e-encryption only.

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<()>

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<()>

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<()>

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<()>

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<()>

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<()>

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<()>

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<()>

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<()>

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>

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<()>

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 room_power_levels(&self) -> Result<RoomPowerLevels>

Get the current power levels of this room.

source

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

Resets the room’s power levels to the default values

source

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

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>

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>

Sets the name of this room.

source

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

Sets a new topic for this room.

source

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

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>

Removes the avatar from the room

source

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

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>

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>
where C: StateEventContent, C::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>

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> ) -> HttpResult<Response>

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