Struct mxlink::Reacting

pub struct Reacting { /* private fields */ }

Implementations

impl Reacting

pub async fn react( &self, room: &Room, target_event_id: OwnedEventId, reaction_key: String, ) -> Result<Response, Error>

Reacts to the given event with a reaction. reaction_key could be an emoji or a custom string (text).

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

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

Register a callback to be called when a reaction is received in any room and it seems like one that we should handle. Reactions by our own user are ignored.

Examples found in repository

examples/quick_start.rs (lines 88-108)

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

Trait Implementations

impl Clone for Reacting

fn clone(&self) -> Reacting

Returns a copy of the value.

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

Performs copy-assignment from source.