Struct mxlink::Rooms

pub struct Rooms { /* private fields */ }

Implementations

impl Rooms

pub async fn own_display_name_in_room( &self, room: &Room, ) -> Result<Option<String>>

pub async fn start_typing_notice(&self, room: &Room) -> TypingNoticeGuard

Starts sending typing notices for the given room and returns a guard object.

If multiple callers invoke this method for the same room, only the first caller will start the typing notice sending loop and it will remain active until all callers have released their guards.

When all guard objects for a given room have gone out of scope, the typing notice will be turned off.

pub fn on_invitation<F, Fut>(&self, callback: F)

where F: FnOnce(StrippedRoomMemberEvent, Room) -> Fut + Send + 'static + Clone + Sync, Fut: Future<Output = Result<InvitationDecision, CallbackError>> + Send + 'static,

Register a callback to be called when an invitation for the room arrives. The callback is expected to return a decision as to whether the room should be joined or not.

Examples found in repository

examples/quick_start.rs (line 72)

async fn register_event_handlers(matrix_link: MatrixLink) {
    let rooms = matrix_link.rooms();

    // We auto-accept all invitations
    rooms.on_invitation(|_event, _room| async move { Ok(InvitationDecision::Join) });

    // We send an introduction to all rooms we join
    let messaging = matrix_link.messaging();
    rooms.on_joined(|_event, room| async move {
        let _ = messaging
            .send_text_markdown(&room, "Hello!".to_owned(), MessageResponseType::InRoom)
            .await
            .expect("Failed to send message");

        Ok(())
    });

    // We listen for reactions to messages and send a reply to the original message that received the reaction
    let messaging = matrix_link.messaging();
    let reacting = matrix_link.reacting();
    reacting.on_actionable_reaction(|event, room, reaction_event_content| async move {
        let response_text = if reaction_event_content.relates_to.key == "👍️" {
            format!("{} reacted to this message with thumbs up!", event.sender())
        } else {
            format!(
                "{} reacted to this message with an unknown-to-me reaction ({}).",
                event.sender(),
                reaction_event_content.relates_to.key,
            )
        };

        let response_type =
            MessageResponseType::Reply(reaction_event_content.relates_to.event_id.clone());

        let _ = messaging
            .send_notice_markdown(&room, response_text, response_type)
            .await
            .expect("Failed to send message");

        Ok(())
    });
}

pub fn on_joined<F, Fut>(&self, callback: F)

where F: FnOnce(AnySyncTimelineEvent, Room) -> Fut + Send + 'static + Clone + Sync, Fut: Future<Output = Result<(), CallbackError>> + Send + 'static,

Register a callback to be called when a room has been joined.

Examples found in repository

examples/quick_start.rs (lines 76-83)

async fn register_event_handlers(matrix_link: MatrixLink) {
    let rooms = matrix_link.rooms();

    // We auto-accept all invitations
    rooms.on_invitation(|_event, _room| async move { Ok(InvitationDecision::Join) });

    // We send an introduction to all rooms we join
    let messaging = matrix_link.messaging();
    rooms.on_joined(|_event, room| async move {
        let _ = messaging
            .send_text_markdown(&room, "Hello!".to_owned(), MessageResponseType::InRoom)
            .await
            .expect("Failed to send message");

        Ok(())
    });

    // We listen for reactions to messages and send a reply to the original message that received the reaction
    let messaging = matrix_link.messaging();
    let reacting = matrix_link.reacting();
    reacting.on_actionable_reaction(|event, room, reaction_event_content| async move {
        let response_text = if reaction_event_content.relates_to.key == "👍️" {
            format!("{} reacted to this message with thumbs up!", event.sender())
        } else {
            format!(
                "{} reacted to this message with an unknown-to-me reaction ({}).",
                event.sender(),
                reaction_event_content.relates_to.key,
            )
        };

        let response_type =
            MessageResponseType::Reply(reaction_event_content.relates_to.event_id.clone());

        let _ = messaging
            .send_notice_markdown(&room, response_text, response_type)
            .await
            .expect("Failed to send message");

        Ok(())
    });
}

pub fn on_being_last_member<F, Fut>(&self, callback: F)

where F: FnOnce(AnySyncTimelineEvent, Room) -> Fut + Send + 'static + Clone + Sync, Fut: Future<Output = Result<(), CallbackError>> + Send + 'static,

Register a callback to be called when we’ve determined to be the last member in the room. When this happens, you usually may wish to clean up and leave the room.

Trait Implementations

impl Clone for Rooms

fn clone(&self) -> Rooms

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.