Struct mediasoup::plain_transport::PlainTransport

pub struct PlainTransport { /* fields omitted */ }

A plain transport represents a network path through which RTP, RTCP (optionally secured with SRTP) and SCTP (DataChannel) is transmitted.

Implementations

impl PlainTransport

pub async fn connect(
    &self,
    remote_parameters: PlainTransportRemoteParameters
) -> Result<(), RequestError>

Provide the PlainTransport with remote parameters.

Notes on usage

• If comedia is enabled in this plain transport and SRTP is not, connect() must not be called.
• If comedia is enabled and SRTP is also enabled (enable_srtp was set in the Router::create_plain_transport options) then connect() must be called with just the remote srtp_parameters.
• If comedia is disabled, connect() must be eventually called with remote ip, port, optional rtcp_port (if RTCP-mux is not enabled) and optional srtp_parameters (if SRTP is enabled).

Examples

use mediasoup::plain_transport::PlainTransportRemoteParameters;

// Calling connect() on a PlainTransport created with comedia and rtcp_mux set.
plain_transport
    .connect(PlainTransportRemoteParameters {
        ip: Some("1.2.3.4".parse().unwrap()),
        port: Some(9998),
        rtcp_port: None,
        srtp_parameters: None,
    })
    .await?;

use mediasoup::plain_transport::PlainTransportRemoteParameters;

// Calling connect() on a PlainTransport created with comedia unset and rtcp_mux
// also unset.
plain_transport
    .connect(PlainTransportRemoteParameters {
        ip: Some("1.2.3.4".parse().unwrap()),
        port: Some(9998),
        rtcp_port: Some(9999),
        srtp_parameters: None,
    })
    .await?;

use mediasoup::plain_transport::PlainTransportRemoteParameters;
use mediasoup::srtp_parameters::{SrtpParameters, SrtpCryptoSuite};

// Calling connect() on a PlainTransport created with comedia set and
// enable_srtp enabled.
plain_transport
    .connect(PlainTransportRemoteParameters {
        ip: None,
        port: None,
        rtcp_port: None,
        srtp_parameters: Some(SrtpParameters {
            crypto_suite: SrtpCryptoSuite::AesCm128HmacSha180,
            key_base64: "ZnQ3eWJraDg0d3ZoYzM5cXN1Y2pnaHU5NWxrZTVv".to_string(),
        }),
    })
    .await?;

use mediasoup::plain_transport::PlainTransportRemoteParameters;
use mediasoup::srtp_parameters::{SrtpParameters, SrtpCryptoSuite};

// Calling connect() on a PlainTransport created with comedia unset, rtcpMux
// set and enableSrtp enabled.
plain_transport
    .connect(PlainTransportRemoteParameters {
        ip: Some("1.2.3.4".parse().unwrap()),
        port: Some(9998),
        rtcp_port: None,
        srtp_parameters: Some(SrtpParameters {
            crypto_suite: SrtpCryptoSuite::AesCm128HmacSha180,
            key_base64: "ZnQ3eWJraDg0d3ZoYzM5cXN1Y2pnaHU5NWxrZTVv".to_string(),
        }),
    })
    .await?;

pub async fn set_max_incoming_bitrate(
    &self,
    bitrate: u32
) -> Result<(), RequestError>

Set maximum incoming bitrate for media streams sent by the remote endpoint over this transport.

pub fn tuple(&self) -> TransportTuple

The transport tuple. If RTCP-mux is enabled (rtcp_mux is set), this tuple refers to both RTP and RTCP.

Notes on usage

• Once the plain transport is created, transport.tuple() will contain information about its local_ip, local_port and protocol.
• Information about remote_ip and remote_port will be set:
  • after calling connect() method, or
  • via dynamic remote address detection when using comedia mode.

pub fn rtcp_tuple(&self) -> Option<TransportTuple>

The transport tuple for RTCP. If RTCP-mux is enabled (rtcp_mux is set), its value is None.

Notes on usage

• Once the plain transport is created (with RTCP-mux disabled), transport.rtcp_tuple() will contain information about its local_ip, local_port and protocol.
• Information about remote_ip and remote_port will be set:
  • after calling connect() method, or
  • via dynamic remote address detection when using comedia mode.

pub fn sctp_parameters(&self) -> Option<SctpParameters>

Current SCTP state. Or None if SCTP is not enabled.

pub fn sctp_state(&self) -> Option<SctpState>

Current SCTP state. Or None if SCTP is not enabled.

pub fn srtp_parameters(&self) -> Option<SrtpParameters>

Local SRTP parameters representing the crypto suite and key material used to encrypt sending RTP and SRTP. Note that, if comedia mode is set, these local SRTP parameters may change after calling connect() with the remote SRTP parameters (to override the local SRTP crypto suite with the one given in connect()).

pub fn on_tuple<F: Fn(&TransportTuple) + Send + Sync + 'static>(
    &self,
    callback: F
) -> HandlerId

Callback is called after the remote RTP origin has been discovered. Only if comedia mode was set.

pub fn on_rtcp_tuple<F: Fn(&TransportTuple) + Send + Sync + 'static>(
    &self,
    callback: F
) -> HandlerId

Callback is called after the remote RTCP origin has been discovered. Only if comedia mode was set and rtcp_mux was not.

pub fn on_sctp_state_change<F: Fn(SctpState) + Send + Sync + 'static>(
    &self,
    callback: F
) -> HandlerId

Callback is called when the transport SCTP state changes.

pub fn downgrade(&self) -> WeakPlainTransport

Downgrade PlainTransport to WeakPlainTransport instance.

Trait Implementations

impl Clone for PlainTransport

fn clone(&self) -> PlainTransport

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PlainTransport

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

Formats the value using the given formatter.

impl Transport for PlainTransport

fn id(&self) -> TransportId

Transport id.

fn router_id(&self) -> RouterId

Router id.

fn app_data(&self) -> &AppData

Custom application data.

fn closed(&self) -> bool

Whether the transport is closed.

fn produce<'life0, 'async_trait>(
    &'life0 self,
    producer_options: ProducerOptions
) -> Pin<Box<dyn Future<Output = Result<Producer, ProduceError>> + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Instructs the router to receive audio or video RTP (or SRTP depending on the transport). This is the way to inject media into mediasoup.

fn consume<'life0, 'async_trait>(
    &'life0 self,
    consumer_options: ConsumerOptions
) -> Pin<Box<dyn Future<Output = Result<Consumer, ConsumeError>> + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Instructs the router to send audio or video RTP (or SRTP depending on the transport). This is the way to extract media from mediasoup.

fn produce_data<'life0, 'async_trait>(
    &'life0 self,
    data_producer_options: DataProducerOptions
) -> Pin<Box<dyn Future<Output = Result<DataProducer, ProduceDataError>> + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Instructs the router to receive data messages. Those messages can be delivered by an endpoint via SCTP protocol (AKA DataChannel in WebRTC) or can be directly sent from the Rust application if the transport is a DirectTransport.

fn consume_data<'life0, 'async_trait>(
    &'life0 self,
    data_consumer_options: DataConsumerOptions
) -> Pin<Box<dyn Future<Output = Result<DataConsumer, ConsumeDataError>> + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Instructs the router to send data messages to the endpoint via SCTP protocol (AKA DataChannel in WebRTC) or directly to the Rust process if the transport is a DirectTransport.

fn enable_trace_event<'life0, 'async_trait>(
    &'life0 self,
    types: Vec<TransportTraceEventType>
) -> Pin<Box<dyn Future<Output = Result<(), RequestError>> + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Instructs the transport to emit “trace” events. For monitoring purposes. Use with caution.

fn on_new_producer(
    &self,
    callback: Box<dyn Fn(&Producer) + Send + Sync + 'static>
) -> HandlerId

Callback is called when a new producer is created.

fn on_new_consumer(
    &self,
    callback: Box<dyn Fn(&Consumer) + Send + Sync + 'static>
) -> HandlerId

Callback is called when a new consumer is created.

fn on_new_data_producer(
    &self,
    callback: Box<dyn Fn(&DataProducer) + Send + Sync + 'static>
) -> HandlerId

Callback is called when a new data producer is created.

fn on_new_data_consumer(
    &self,
    callback: Box<dyn Fn(&DataConsumer) + Send + Sync + 'static>
) -> HandlerId

Callback is called when a new data consumer is created.

fn on_trace(
    &self,
    callback: Box<dyn Fn(&TransportTraceEventData) + Send + Sync + 'static>
) -> HandlerId

See Transport::enable_trace_event()

fn on_router_close(
    &self,
    callback: Box<dyn FnOnce() + Send + 'static>
) -> HandlerId

Callback is called when the router this transport belongs to is closed for whatever reason. The transport itself is also closed. on_transport_close callbacks are also called on all its producers and consumers.

fn on_close(&self, callback: Box<dyn FnOnce() + Send + 'static>) -> HandlerId

Callback is called when the router is closed for whatever reason.

impl TransportGeneric for PlainTransport

type Dump = PlainTransportDump

type Stat = PlainTransportStat

Stats data structure specific to each transport.

fn get_stats<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Vec<Self::Stat>, RequestError>> + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Returns current RTC statistics of the transport. Each transport class produces a different set of statistics.

#[must_use]fn dump<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<Self::Dump, RequestError>> + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Dump Transport.