Enum OutgoingMessage

pub enum OutgoingMessage {
    Welcome {
        peer_id: String,
    },
    PeerStatusChanged(PeerStatus),
    StartSession {
        peer_id: String,
        session_id: String,
        offer: Option<String>,
    },
    SessionStarted {
        peer_id: String,
        session_id: String,
    },
    EndSession(EndSessionMessage),
    Peer(PeerMessage),
    List {
        producers: Vec<Peer>,
    },
    ListConsumers {
        consumers: Vec<Peer>,
    },
    Error {
        details: String,
    },
}

Messages sent from the server to peers

Variants

Welcome

Welcoming message, sets the Peer ID linked to a new connection

Fields

peer_id: String

PeerStatusChanged(PeerStatus)

Notifies listeners that a peer status has changed

StartSession

Instructs a peer to generate an offer or an answer and inform about the session ID

Fields

peer_id: String

session_id: String

offer: Option<String>

SessionStarted

Let consumer know that the requested session is starting with the specified identifier

Fields

peer_id: String

session_id: String

EndSession(EndSessionMessage)

Signals that the session the peer was in was ended

Peer(PeerMessage)

Messages directly forwarded from one peer to another

List

Provides the current list of producers

Fields

producers: Vec<Peer>

ListConsumers

Provides the current list of consumers (awaiting a session request)

Fields

consumers: Vec<Peer>

Error

Notifies that an error occurred with the peer’s current session

Fields

details: String

Trait Implementations

impl Debug for OutgoingMessage

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for OutgoingMessage

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for OutgoingMessage

fn eq(&self, other: &OutgoingMessage) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for OutgoingMessage

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for OutgoingMessage

impl StructuralPartialEq for OutgoingMessage