Struct matrix_sdk::room::Joined
source · [−]pub struct Joined { /* private fields */ }
Expand description
A room in the joined state.
The JoinedRoom
contains all methods specific to a Room
with type
RoomType::Joined
. Operations may fail once the underlying Room
changes
RoomType
.
Implementations
sourceimpl Joined
impl Joined
sourcepub fn new(client: Client, room: BaseRoom) -> Option<Self>
pub fn new(client: Client, room: BaseRoom) -> Option<Self>
Create a new room::Joined
if the underlying BaseRoom
has type
RoomType::Joined
.
Arguments
-
client
- The client used to make requests. -
room
- The underlying room.
sourcepub async fn ban_user(
&self,
user_id: &UserId,
reason: Option<&str>
) -> Result<()>
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 withUserId
. -
reason
- The reason for banning this user.
sourcepub async fn kick_user(
&self,
user_id: &UserId,
reason: Option<&str>
) -> Result<()>
pub async fn kick_user(
&self,
user_id: &UserId,
reason: Option<&str>
) -> Result<()>
Kick a user out of this room.
Arguments
-
user_id
- TheUserId
of the user that should be kicked out of the room. -
reason
- Optional reason why the room member is being kicked out.
sourcepub async fn invite_user_by_id(&self, user_id: &UserId) -> Result<()>
pub async fn invite_user_by_id(&self, user_id: &UserId) -> Result<()>
Invite the specified user by UserId
to this room.
Arguments
user_id
- TheUserId
of the user to invite to the room.
sourcepub async fn invite_user_by_3pid(&self, invite_id: Invite3pid<'_>) -> Result<()>
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.
sourcepub async fn typing_notice(&self, typing: bool) -> Result<()>
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_joined_room(&room_id) {
room.typing_notice(true).await?
}
sourcepub async fn read_receipt(&self, event_id: &EventId) -> Result<()>
pub async fn read_receipt(&self, event_id: &EventId) -> Result<()>
Send a request to notify this room that the user has read specific event.
Arguments
event_id
- TheEventId
specifies the event to set the read receipt on.
sourcepub async fn read_marker(
&self,
fully_read: &EventId,
read_receipt: Option<&EventId>
) -> Result<()>
pub async fn read_marker(
&self,
fully_read: &EventId,
read_receipt: Option<&EventId>
) -> Result<()>
Send a request to notify this room that the user has read up to specific event.
Arguments
-
fully_read - The
EventId
of the event the user has read to. -
read_receipt - An
EventId
to specify the event to set the read receipt on.
sourcepub async fn enable_encryption(&self) -> Result<()>
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_joined_room(&room_id) {
room.enable_encryption().await?
}
sourcepub async fn send(
&self,
content: impl MessageLikeEventContent,
txn_id: Option<&TransactionId>
) -> Result<Response>
pub async fn send(
&self,
content: impl MessageLikeEventContent,
txn_id: Option<&TransactionId>
) -> Result<Response>
Send a room message to this room.
Returns the parsed response from the server.
If the encryption feature is enabled this method will transparently encrypt the room message if this room is encrypted.
Note: If you just want to send a custom JSON payload to a room, you
can use the Joined::send_raw()
method for that.
Arguments
-
content
- The content of the message event. -
txn_id
- A locally-unique ID describing a message transaction with the homeserver. Unless you’re doing something special, you can pass inNone
which will create a suitable one for you automatically.- On the sending side, this field is used for re-trying earlier failed transactions. Subsequent messages must never re-use an earlier transaction ID.
- On the receiving side, the field is used for recognizing our own
messages when they arrive down the sync: the server includes the
ID in the
MessageLikeUnsigned
fieldtransaction_id
of the correspondingSyncMessageLikeEvent
, but only for the sending device. Other devices will not see it. This is then used to ignore events sent by our own device and/or to implement local echo.
Example
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_joined_room(&room_id) {
room.send(content, Some(&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))
},
};
let txn_id = TransactionId::new();
if let Some(room) = client.get_joined_room(&room_id) {
room.send(content, Some(&txn_id)).await?;
}
sourcepub async fn send_raw(
&self,
content: Value,
event_type: &str,
txn_id: Option<&TransactionId>
) -> Result<Response>
pub async fn send_raw(
&self,
content: Value,
event_type: &str,
txn_id: Option<&TransactionId>
) -> Result<Response>
Send a room message to this room from a json Value
.
Returns the parsed response from the server.
If the encryption feature is enabled this method will transparently encrypt the room message if this room is encrypted.
This method is equivalent to the Joined::send()
method but allows
sending custom JSON payloads, e.g. constructed using the
serde_json::json!()
macro.
Arguments
-
content
- The content of the event as a jsonValue
. -
event_type
- The type of the event. -
txn_id
- A locally-unique ID describing a message transaction with the homeserver. Unless you’re doing something special, you can pass inNone
which will create a suitable one for you automatically.- On the sending side, this field is used for re-trying earlier failed transactions. Subsequent messages must never re-use an earlier transaction ID.
- On the receiving side, the field is used for recognizing our own
messages when they arrive down the sync: the server includes the
ID in the
StateUnsigned
fieldtransaction_id
of the correspondingSyncMessageLikeEvent
, but only for the sending device. Other devices will not see it. This is then used to ignore events sent by our own device and/or to implement local echo.
Example
use serde_json::json;
let content = json!({
"body": "Hello world",
});
if let Some(room) = client.get_joined_room(&room_id) {
room.send_raw(content, "m.room.message", None).await?;
}
sourcepub async fn send_attachment<R: Read + Seek, T: Read>(
&self,
body: &str,
content_type: &Mime,
reader: &mut R,
config: AttachmentConfig<'_, T>
) -> Result<Response>
pub async fn send_attachment<R: Read + Seek, T: Read>(
&self,
body: &str,
content_type: &Mime,
reader: &mut R,
config: AttachmentConfig<'_, T>
) -> Result<Response>
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
Client::upload()
and afterwards the
send()
.
Arguments
-
body
- A textual representation of the media that is going to be uploaded. Usually the file name. -
content_type
- The type of the media, this will be used as the content-type header. -
reader
- AReader
that will be used to fetch the raw bytes of the media. -
config
- Metadata and configuration for the attachment.
Examples
let path = PathBuf::from("/home/example/my-cat.jpg");
let mut image = File::open(path)?;
if let Some(room) = client.get_joined_room(&room_id) {
room.send_attachment(
"My favorite cat",
&mime::IMAGE_JPEG,
&mut image,
AttachmentConfig::new(),
).await?;
}
sourcepub async fn send_state_event(
&self,
content: impl StateEventContent,
state_key: &str
) -> Result<Response>
pub async fn send_state_event(
&self,
content: impl StateEventContent,
state_key: &str
) -> Result<Response>
Send a room 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. This value is often a zero-length string.
Example
use matrix_sdk::ruma::{
events::{
macros::EventContent,
room::member::{RoomMemberEventContent, MembershipState},
},
assign, mxc_uri,
};
let avatar_url = mxc_uri!("mxc://example.org/avatar").to_owned();
let content = assign!(RoomMemberEventContent::new(MembershipState::Join), {
avatar_url: Some(avatar_url),
});
if let Some(room) = client.get_joined_room(&room_id) {
room.send_state_event(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!();
if let Some(room) = client.get_joined_room(&room_id) {
room.send_state_event(content, "").await?;
}
sourcepub async fn send_state_event_raw(
&self,
content: Value,
event_type: &str,
state_key: &str
) -> Result<Response>
pub async fn send_state_event_raw(
&self,
content: Value,
event_type: &str,
state_key: &str
) -> Result<Response>
Send a raw room state event to the homeserver.
Returns the parsed response from the server.
Arguments
-
content
- The raw content of the state event. -
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.
Example
use serde_json::json;
let content = json!({
"avatar_url": "mxc://example.org/SEsfnsuifSDFSSEF",
"displayname": "Alice Margatroid",
"membership": "join"
});
if let Some(room) = client.get_joined_room(&room_id) {
room.send_state_event_raw(content, "m.room.member", "").await?;
}
sourcepub async fn redact(
&self,
event_id: &EventId,
reason: Option<&str>,
txn_id: Option<OwnedTransactionId>
) -> HttpResult<Response>
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.
Example
use matrix_sdk::ruma::event_id;
if let Some(room) = client.get_joined_room(&room_id) {
let event_id = event_id!("$xxxxxx:example.org");
let reason = Some("Indecent material");
room.redact(&event_id, reason, None).await?;
}
Methods from Deref<Target = Common>
sourcepub async fn avatar(&self, format: MediaFormat) -> Result<Option<Vec<u8>>>
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.
Example
let client = Client::new(homeserver).await.unwrap();
client.login(user, "password", None, None).await.unwrap();
let room_id = room_id!("!roomid:example.com");
let room = client
.get_joined_room(&room_id)
.unwrap();
if let Some(avatar) = room.avatar(MediaFormat::File).await.unwrap() {
std::fs::write("avatar.png", avatar);
}
sourcepub async fn messages(&self, options: MessagesOptions<'_>) -> Result<Messages>
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 request = MessagesOptions::backward("t47429-4392820_219380_26003_2265");
let mut client = Client::new(homeserver).await.unwrap();
let room = client
.get_joined_room(room_id!("!roomid:example.com"))
.unwrap();
assert!(room.messages(request).await.is_ok());
sourcepub async fn event(&self, event_id: &EventId) -> Result<RoomEvent>
pub async fn event(&self, event_id: &EventId) -> Result<RoomEvent>
Fetch the event with the given EventId
in this room.
sourcepub async fn sync_members(&self) -> Result<Option<MembersResponse>>
pub async fn sync_members(&self) -> Result<Option<MembersResponse>>
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
.
sourcepub async fn active_members(&self) -> Result<Vec<RoomMember>>
pub async fn active_members(&self) -> Result<Vec<RoomMember>>
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.
sourcepub async fn active_members_no_sync(&self) -> Result<Vec<RoomMember>>
pub async fn active_members_no_sync(&self) -> Result<Vec<RoomMember>>
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.
sourcepub async fn joined_members(&self) -> Result<Vec<RoomMember>>
pub async fn joined_members(&self) -> Result<Vec<RoomMember>>
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.
sourcepub async fn joined_members_no_sync(&self) -> Result<Vec<RoomMember>>
pub async fn joined_members_no_sync(&self) -> Result<Vec<RoomMember>>
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.
sourcepub async fn get_member(&self, user_id: &UserId) -> Result<Option<RoomMember>>
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.
sourcepub async fn get_member_no_sync(
&self,
user_id: &UserId
) -> Result<Option<RoomMember>>
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.
sourcepub async fn members(&self) -> Result<Vec<RoomMember>>
pub async fn members(&self) -> Result<Vec<RoomMember>>
Get all members for this room, includes invited, joined and left 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 members_no_sync() if you want a method that doesn’t do any requests.
sourcepub async fn members_no_sync(&self) -> Result<Vec<RoomMember>>
pub async fn members_no_sync(&self) -> Result<Vec<RoomMember>>
Get all members for this room, includes invited, joined and left 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.
Use members() if you want to ensure to always get the full member list.
sourcepub async fn get_state_events(
&self,
event_type: StateEventType
) -> Result<Vec<Raw<AnySyncStateEvent>>>
pub async fn get_state_events(
&self,
event_type: StateEventType
) -> Result<Vec<Raw<AnySyncStateEvent>>>
Get all state events of a given type in this room.
sourcepub async fn get_state_events_static<C>(
&self
) -> Result<Vec<Raw<SyncStateEvent<C>>>> where
C: StaticEventContent + StateEventContent + RedactContent,
C::Redacted: StateEventContent + RedactedEventContent,
pub async fn get_state_events_static<C>(
&self
) -> Result<Vec<Raw<SyncStateEvent<C>>>> where
C: StaticEventContent + StateEventContent + RedactContent,
C::Redacted: StateEventContent + RedactedEventContent,
Get all state events of a given statically-known type in this room.
Example
use matrix_sdk::ruma::{events::room::member::SyncRoomMemberEvent, serde::Raw};
let room_members: Vec<Raw<SyncRoomMemberEvent>> = room.get_state_events_static().await?;
sourcepub async fn get_state_event(
&self,
event_type: StateEventType,
state_key: &str
) -> Result<Option<Raw<AnySyncStateEvent>>>
pub async fn get_state_event(
&self,
event_type: StateEventType,
state_key: &str
) -> Result<Option<Raw<AnySyncStateEvent>>>
Get a specific state event in this room.
sourcepub async fn get_state_event_static<C>(
&self,
state_key: &str
) -> Result<Option<Raw<SyncStateEvent<C>>>> where
C: StaticEventContent + StateEventContent + RedactContent,
C::Redacted: StateEventContent + RedactedEventContent,
pub async fn get_state_event_static<C>(
&self,
state_key: &str
) -> Result<Option<Raw<SyncStateEvent<C>>>> where
C: StaticEventContent + StateEventContent + RedactContent,
C::Redacted: StateEventContent + RedactedEventContent,
Get a specific state event of statically-known type in this room.
Example
use matrix_sdk::ruma::events::room::power_levels::SyncRoomPowerLevelsEvent;
let power_levels: SyncRoomPowerLevelsEvent = room
.get_state_event_static("").await?
.expect("every room has a power_levels event")
.deserialize()?;
sourcepub async fn account_data(
&self,
data_type: RoomAccountDataEventType
) -> Result<Option<Raw<AnyRoomAccountDataEvent>>>
pub async fn account_data(
&self,
data_type: RoomAccountDataEventType
) -> Result<Option<Raw<AnyRoomAccountDataEvent>>>
Get account data in this room.
sourcepub async fn account_data_static<C>(
&self
) -> Result<Option<Raw<RoomAccountDataEvent<C>>>> where
C: StaticEventContent + RoomAccountDataEventContent,
pub async fn account_data_static<C>(
&self
) -> Result<Option<Raw<RoomAccountDataEvent<C>>>> where
C: StaticEventContent + RoomAccountDataEventContent,
Get account data of statically-known type in this room.
Example
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"),
}
sourcepub async fn contains_only_verified_devices(&self) -> Result<bool>
Available on crate feature e2e-encryption
only.
pub async fn contains_only_verified_devices(&self) -> Result<bool>
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.
sourcepub async fn set_tag(
&self,
tag: TagName,
tag_info: TagInfo
) -> HttpResult<Response>
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 theorder
parameter.
Example
use matrix_sdk::ruma::events::tag::TagInfo;
if let Some(room) = client.get_joined_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?;
}
sourcepub async fn remove_tag(&self, tag: TagName) -> HttpResult<Response>
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.
sourcepub async fn set_is_direct(&self, is_direct: bool) -> Result<()>
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.
sourcepub async fn decrypt_event(
&self,
event: &OriginalSyncRoomEncryptedEvent
) -> Result<RoomEvent>
Available on crate feature e2e-encryption
only.
pub async fn decrypt_event(
&self,
event: &OriginalSyncRoomEncryptedEvent
) -> Result<RoomEvent>
e2e-encryption
only.Tries to decrypt a room event.
Arguments
event
- The room event to be decrypted.
Returns the decrypted event.
Methods from Deref<Target = BaseRoom>
sourcepub fn own_user_id(&self) -> &UserId
pub fn own_user_id(&self) -> &UserId
Get our own user id.
sourcepub fn unread_notification_counts(&self) -> UnreadNotificationsCount
pub fn unread_notification_counts(&self) -> UnreadNotificationsCount
Get the unread notification counts.
sourcepub fn are_members_synced(&self) -> bool
pub fn are_members_synced(&self) -> bool
Check if the room has it’s members fully synced.
Members might be missing if lazy member loading was enabled for the sync.
Returns true if no members are missing, false otherwise.
sourcepub fn last_prev_batch(&self) -> Option<String>
pub fn last_prev_batch(&self) -> Option<String>
Get the prev_batch
token that was received from the last sync. May be
None
if the last sync contained the full room history.
sourcepub fn avatar_url(&self) -> Option<OwnedMxcUri>
pub fn avatar_url(&self) -> Option<OwnedMxcUri>
Get the avatar url of this room.
sourcepub fn canonical_alias(&self) -> Option<OwnedRoomAliasId>
pub fn canonical_alias(&self) -> Option<OwnedRoomAliasId>
Get the canonical alias of this room.
sourcepub fn create_content(&self) -> Option<RoomCreateEventContent>
pub fn create_content(&self) -> Option<RoomCreateEventContent>
Get the m.room.create
content of this room.
This usually isn’t optional but some servers might not send an
m.room.create
event as the first event for a given room, thus this can
be optional.
It can also be redacted in current room versions, leaving only the
creator
field.
sourcepub fn direct_targets(&self) -> HashSet<OwnedUserId, RandomState>
pub fn direct_targets(&self) -> HashSet<OwnedUserId, RandomState>
If this room is a direct message, get the members that we’re sharing the room with.
Note: The member list might have been modified in the meantime and the targets might not even be in the room anymore. This setting should only be considered as guidance.
sourcepub fn is_encrypted(&self) -> bool
pub fn is_encrypted(&self) -> bool
Is the room encrypted.
sourcepub fn encryption_settings(&self) -> Option<RoomEncryptionEventContent>
pub fn encryption_settings(&self) -> Option<RoomEncryptionEventContent>
Get the m.room.encryption
content that enabled end to end encryption
in the room.
sourcepub fn guest_access(&self) -> GuestAccess
pub fn guest_access(&self) -> GuestAccess
Get the guest access policy of this room.
sourcepub fn history_visibility(&self) -> HistoryVisibility
pub fn history_visibility(&self) -> HistoryVisibility
Get the history visibility policy of this room.
sourcepub fn max_power_level(&self) -> i64
pub fn max_power_level(&self) -> i64
Get the maximum power level that this room contains.
This is useful if one wishes to normalize the power levels, e.g. from 0-100 where 100 would be the max power level.
sourcepub fn is_tombstoned(&self) -> bool
pub fn is_tombstoned(&self) -> bool
Has the room been tombstoned.
sourcepub fn tombstone(&self) -> Option<RoomTombstoneEventContent>
pub fn tombstone(&self) -> Option<RoomTombstoneEventContent>
Get the m.room.tombstone
content of this room if there is one.
sourcepub async fn display_name(&'_ self) -> Result<DisplayName, StoreError>
pub async fn display_name(&'_ self) -> Result<DisplayName, StoreError>
Calculate the canonical display name of the room, taking into account its name, aliases and members.
The display name is calculated according to this algorithm.
sourcepub async fn joined_user_ids(
&'_ self
) -> Result<Vec<OwnedUserId, Global>, StoreError>
pub async fn joined_user_ids(
&'_ self
) -> Result<Vec<OwnedUserId, Global>, StoreError>
Get the list of users ids that are considered to be joined members of this room.
sourcepub async fn members(&'_ self) -> Result<Vec<RoomMember, Global>, StoreError>
pub async fn members(&'_ self) -> Result<Vec<RoomMember, Global>, StoreError>
Get the all RoomMember
s of this room that are known to the store.
sourcepub async fn joined_members(
&'_ self
) -> Result<Vec<RoomMember, Global>, StoreError>
pub async fn joined_members(
&'_ self
) -> Result<Vec<RoomMember, Global>, StoreError>
Get the list of RoomMember
s that are considered to be joined members
of this room.
sourcepub async fn active_members(
&'_ self
) -> Result<Vec<RoomMember, Global>, StoreError>
pub async fn active_members(
&'_ self
) -> Result<Vec<RoomMember, Global>, StoreError>
Get the list of RoomMember
s that are considered to be joined or
invited members of this room.
sourcepub fn clone_info(&self) -> RoomInfo
pub fn clone_info(&self) -> RoomInfo
Clone the inner RoomInfo
sourcepub fn update_summary(&self, summary: RoomInfo)
pub fn update_summary(&self, summary: RoomInfo)
Update the summary with given RoomInfo
sourcepub async fn get_member(
&'_ self,
user_id: &'_ UserId
) -> Result<Option<RoomMember>, StoreError>
pub async fn get_member(
&'_ self,
user_id: &'_ UserId
) -> Result<Option<RoomMember>, StoreError>
Get the RoomMember
with the given user_id
.
Returns None
if the member was never part of this room, otherwise
return a RoomMember
that can be in a joined, invited, left, banned
state.
Get the Tags
for this room.
sourcepub async fn user_read_receipt(
&'_ self,
user_id: &'_ UserId
) -> Result<Option<(OwnedEventId, Receipt)>, StoreError>
pub async fn user_read_receipt(
&'_ self,
user_id: &'_ UserId
) -> Result<Option<(OwnedEventId, Receipt)>, StoreError>
Get the read receipt as a EventId
and Receipt
tuple for the given
user_id
in this room.
sourcepub async fn event_read_receipts(
&'_ self,
event_id: &'_ EventId
) -> Result<Vec<(OwnedUserId, Receipt), Global>, StoreError>
pub async fn event_read_receipts(
&'_ self,
event_id: &'_ EventId
) -> Result<Vec<(OwnedUserId, Receipt), Global>, StoreError>
Get the read receipts as a list of UserId
and Receipt
tuples for the
given event_id
in this room.
Trait Implementations
Auto Trait Implementations
impl !RefUnwindSafe for Joined
impl Send for Joined
impl Sync for Joined
impl Unpin for Joined
impl !UnwindSafe for Joined
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> Instrument for T
impl<T> Instrument for T
sourcefn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
sourcefn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
impl<T> Pointable for T
impl<T> Pointable for T
sourceimpl<T> ToOwned for T where
T: Clone,
impl<T> ToOwned for T where
T: Clone,
type Owned = T
type Owned = T
The resulting type after obtaining ownership.
sourcefn clone_into(&self, target: &mut T)
fn clone_into(&self, target: &mut T)
toowned_clone_into
)Uses borrowed data to replace owned data, usually by cloning. Read more
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
impl<V, T> VZip<V> for T where
V: MultiLane<T>,
fn vzip(self) -> V
sourceimpl<T> WithSubscriber for T
impl<T> WithSubscriber for T
sourcefn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where
S: Into<Dispatch>,
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self> where
S: Into<Dispatch>,
Attaches the provided Subscriber
to this type, returning a
WithDispatch
wrapper. Read more
sourcefn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default Subscriber
to this type, returning a
WithDispatch
wrapper. Read more