xmpp_parsers/
call_invites.rs

Help
// Copyright (c) 2025 Emmanuel Gil Peyrot <linkmauve@linkmauve.fr>
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

use xso::{AsXml, FromXml};

use crate::message::MessagePayload;
use crate::ns;

/// An `<invite/>` element, to invite someone to a call.
#[derive(FromXml, AsXml, Debug, Clone, PartialEq)]
#[xml(namespace = ns::CALL_INVITES, name = "invite")]
pub struct Invite {
    /// Indicates if the call is intended to be joined with participants sending audio or not.
    // TODO: Figure out how to default audio to true.
    #[xml(attribute(default))]
    pub audio: bool,

    /// Indicates if the call is intended to be joined with participants sending video or not.
    #[xml(attribute(default))]
    pub video: bool,

    /// A `<jingle/>` element, indicating the possibility to join this call using Jingle.
    #[xml(child)]
    pub jingle: Jingle,

    /// An external URI, indicating alternate methods to join this call.
    #[xml(extract(n = .., name = "external", fields(attribute(name = "uri", type_ = String))))]
    pub external_uris: Vec<String>,
}

impl MessagePayload for Invite {}

/// A `<jingle/>` element, indicating the possibility to join this call using Jingle.
#[derive(FromXml, AsXml, Debug, Clone, PartialEq)]
#[xml(namespace = ns::CALL_INVITES, name = "jingle")]
pub struct Jingle {
    /// The ID of the Jingle session.
    #[xml(attribute)]
    pub sid: String,

    /// An optional 'jid' attribute, to indicate the JID the Jingle session will be initiated from.
    /// If no 'jid' attribute is provided, the default is the sender of the message stanza.
    #[xml(attribute(default))]
    pub jid: Option<String>,
}

/// A call invite can be retracted by sending a message containing a `<retract/>` element.
#[derive(FromXml, AsXml, Debug, Clone, PartialEq)]
#[xml(namespace = ns::CALL_INVITES, name = "retract")]
pub struct Retract {
    /// Identifier of the initial [`Invite`] message to be retracted.
    #[xml(attribute)]
    pub id: String,
}

/// A call invite can be accepted by sending a message containing an `<accept/>` element.
#[derive(FromXml, AsXml, Debug, Clone, PartialEq)]
#[xml(namespace = ns::CALL_INVITES, name = "accept")]
pub struct Accept {
    /// Identifier of the initial [`Invite`] message to be accepted.
    #[xml(attribute)]
    pub id: String,

    /// The payload of an `<accept/>` element, either Jingle or an external URI.
    #[xml(child)]
    pub payload: AcceptPayload,
}

/// The payload of an `<accept/>` element, either Jingle or an external URI.
#[derive(FromXml, AsXml, Debug, Clone, PartialEq)]
#[xml()]
pub enum AcceptPayload {
    /// The client picked Jingle, it should then send a session-initiate.
    #[xml(transparent)]
    Jingle(Jingle),

    /// The client picked an external method, it should now handle the URI.
    // TODO: This variant doesn’t work for now.
    #[xml(namespace = ns::CALL_INVITES, name = "external")]
    ExternalUri(
        #[xml(extract(name = "external", fields(attribute(name = "uri", type_ = String))))] String,
    ),
}

/// A call invite can be rejected by sending a message containing a `<reject/>` element.
#[derive(FromXml, AsXml, Debug, Clone, PartialEq)]
#[xml(namespace = ns::CALL_INVITES, name = "reject")]
pub struct Reject {
    /// Identifier of the initial [`Invite`] message to be rejected.
    #[xml(attribute)]
    pub id: String,
}

/// When a client leaves a call, it sends a message containing a `<left/>` element.
#[derive(FromXml, AsXml, Debug, Clone, PartialEq)]
#[xml(namespace = ns::CALL_INVITES, name = "left")]
pub struct Left {
    /// Identifier of the initial [`Invite`] message that got left.
    #[xml(attribute)]
    pub id: String,
}

#[cfg(test)]
mod tests {
    use super::*;
    use minidom::Element;

    #[cfg(target_pointer_width = "32")]
    #[test]
    fn test_size() {
        assert_size!(Invite, 40);
        assert_size!(Jingle, 24);
        assert_size!(Retract, 12);
        assert_size!(Accept, 36);
        assert_size!(AcceptPayload, 24);
        assert_size!(Reject, 12);
        assert_size!(Left, 12);
    }

    #[cfg(target_pointer_width = "64")]
    #[test]
    fn test_size() {
        assert_size!(Invite, 80);
        assert_size!(Jingle, 48);
        assert_size!(Retract, 24);
        assert_size!(Accept, 72);
        assert_size!(AcceptPayload, 48);
        assert_size!(Reject, 24);
        assert_size!(Left, 24);
    }

    #[test]
    fn invite_example_1() {
        let elem: Element =
            "<invite video='true' xmlns='urn:xmpp:call-invites:0'><jingle sid='sid1'/></invite>"
                .parse()
                .unwrap();
        let invite = Invite::try_from(elem).unwrap();
        // TODO: Figure out how to default audio to true.
        //assert_eq!(invite.audio, true);
        assert_eq!(invite.video, true);
        assert_eq!(invite.jingle.sid, "sid1");
        assert_eq!(invite.jingle.jid, None);
        assert_eq!(invite.external_uris.len(), 0);
    }

    #[test]
    fn invite_example_2() {
        let elem: Element = "<invite xmlns='urn:xmpp:call-invites:0'><jingle sid='sid2' jid='mixer@example.com/uuid'/><external uri='https://example.com/uuid'/><external uri='tel:+12345678'/></invite>".parse().unwrap();
        let invite = Invite::try_from(elem).unwrap();
        // TODO: Figure out how to default audio to true.
        //assert_eq!(invite.audio, true);
        assert_eq!(invite.video, false);
        assert_eq!(invite.jingle.sid, "sid2");
        assert_eq!(invite.jingle.jid.unwrap(), "mixer@example.com/uuid");
        assert_eq!(invite.external_uris.len(), 2);
        assert_eq!(invite.external_uris[0], "https://example.com/uuid");
        assert_eq!(invite.external_uris[1], "tel:+12345678");
    }

    #[test]
    fn retract_example_3() {
        let elem: Element = "<retract id='id1' xmlns='urn:xmpp:call-invites:0'/>"
            .parse()
            .unwrap();
        let retract = Retract::try_from(elem).unwrap();
        assert_eq!(retract.id, "id1");
    }

    #[test]
    fn accept_example_4() {
        let elem: Element = "<accept id='id1' xmlns='urn:xmpp:call-invites:0'><jingle sid='sid1' jid='mixer@example.com/uuid'/></accept>".parse().unwrap();
        let accept = Accept::try_from(elem).unwrap();
        assert_eq!(accept.id, "id1");
        let AcceptPayload::Jingle(jingle) = accept.payload else {
            panic!("Unexpected payload.")
        };
        assert_eq!(jingle.sid, "sid1");
        assert_eq!(jingle.jid.unwrap(), "mixer@example.com/uuid");
    }

    // TODO: Fix the AcceptPayload::ExternalUri to make this example work.
    #[test]
    #[ignore]
    fn accept_external() {
        let elem: Element = "<accept id='id2' xmlns='urn:xmpp:call-invites:0'><external uri='tel:+12345678'/></accept>".parse().unwrap();
        let accept = Accept::try_from(elem).unwrap();
        assert_eq!(accept.id, "id2");
        let AcceptPayload::ExternalUri(uri) = accept.payload else {
            panic!("Unexpected payload.")
        };
        assert_eq!(uri, "tel:+12345678");
    }

    #[test]
    fn reject_example_5() {
        let elem: Element = "<reject id='id1' xmlns='urn:xmpp:call-invites:0'/>"
            .parse()
            .unwrap();
        let reject = Reject::try_from(elem).unwrap();
        assert_eq!(reject.id, "id1");
    }

    #[test]
    fn left_example_6() {
        let elem: Element = "<left id='id1' xmlns='urn:xmpp:call-invites:0'/>"
            .parse()
            .unwrap();
        let left = Left::try_from(elem).unwrap();
        assert_eq!(left.id, "id1");
    }
}
xmpp_parsers/call_invites.rs

xmpp_parsers/
call_invites.rs
