Struct mediasoup::webrtc_transport::WebRtcTransport

pub struct WebRtcTransport { /* fields omitted */ }

A WebRTC transport represents a network path negotiated by both, a WebRTC endpoint and mediasoup, via ICE and DTLS procedures. A WebRTC transport may be used to receive media, to send media or to both receive and send. There is no limitation in mediasoup. However, due to their design, mediasoup-client and libmediasoupclient require separate WebRTC transports for sending and receiving.

Notes on usage

The WebRTC transport implementation of mediasoup is ICE Lite, meaning that it does not initiate ICE connections but expects ICE Binding Requests from endpoints.

Implementations

impl WebRtcTransport

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

Provide the WebRtcTransport with remote parameters.

Example

use mediasoup::data_structures::{DtlsParameters, DtlsRole, DtlsFingerprint};
use mediasoup::webrtc_transport::WebRtcTransportRemoteParameters;

// Calling connect() on a PlainTransport created with comedia and rtcp_mux set.
webrtc_transport
    .connect(WebRtcTransportRemoteParameters {
        dtls_parameters: DtlsParameters {
            role: DtlsRole::Server,
            fingerprints: vec![
                DtlsFingerprint::Sha256 {
                    value: [
                        0xE5, 0xF5, 0xCA, 0xA7, 0x2D, 0x93, 0xE6, 0x16, 0xAC, 0x21, 0x09,
                        0x9F, 0x23, 0x51, 0x62, 0x8C, 0xD0, 0x66, 0xE9, 0x0C, 0x22, 0x54,
                        0x2B, 0x82, 0x0C, 0xDF, 0xE0, 0xC5, 0x2C, 0x7E, 0xCD, 0x53,
                    ],
                },
            ],
        },
    })
    .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 ice_role(&self) -> IceRole

Local ICE role. Due to the mediasoup ICE Lite design, this is always Controlled.

pub fn ice_parameters(&self) -> &IceParameters

Local ICE parameters.

pub fn ice_candidates(&self) -> &Vec<IceCandidate>

Local ICE candidates.

pub fn ice_state(&self) -> IceState

Current ICE state.

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

The selected transport tuple if ICE is in Connected or Completed state. It is None if ICE is not established (no working candidate pair was found).

pub fn dtls_parameters(&self) -> DtlsParameters

Local DTLS parameters.

pub fn dtls_state(&self) -> DtlsState

Current DTLS state.

pub fn dtls_remote_cert(&self) -> Option<String>

The remote certificate in PEM format. It is Some once the DTLS state becomes Connected.

Notes on usage

The application may want to inspect the remote certificate for authorization purposes by using some certificates utility.

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

Local SCTP parameters. 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 async fn restart_ice(&self) -> Result<IceParameters, RequestError>

Restarts the ICE layer by generating new local ICE parameters that must be signaled to the remote endpoint.

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

Callback is called when the transport ICE state changes.

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

Callback is called after ICE state becomes Completed and when the ICE selected tuple changes.

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

Callback is called when the transport DTLS state changes.

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) -> WeakWebRtcTransport

Downgrade WebRtcTransport to WeakWebRtcTransport instance.

Trait Implementations

impl Clone for WebRtcTransport

pub fn clone(&self) -> WebRtcTransport

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Transport for WebRtcTransport

pub fn id(&self) -> TransportId

Transport id.

pub fn router_id(&self) -> RouterId

Router id.

pub fn app_data(&self) -> &AppData

Custom application data.

pub fn closed(&self) -> bool

Whether the transport is closed.

pub 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.

pub 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.

pub 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.

pub 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.

pub 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.

impl TransportGeneric for WebRtcTransport

type Dump = WebRtcTransportDump

type Stat = WebRtcTransportStat

pub 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.

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

Callback is called when a new producer is created.

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

Callback is called when a new consumer is created.

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

Callback is called when a new data producer is created.

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

Callback is called when a new data consumer is created.

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

See Transport::enable_trace_event()

pub fn on_router_close<F: FnOnce() + Send + 'static>(
    &self,
    callback: F
) -> 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.

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

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

#[must_use]pub 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.