Struct mediasoup::direct_transport::DirectTransport

pub struct DirectTransport { /* fields omitted */ }

A direct transport represents a direct connection between the mediasoup Rust process and a Router instance in a mediasoup-worker thread.

A direct transport can be used to directly send and receive data messages from/to Rust by means of DataProducers and DataConsumers of type Direct created on a direct transport. Direct messages sent by a DataProducer in a direct transport can be consumed by endpoints connected through a SCTP capable transport (WebRtcTransport, PlainTransport, PipeTransport and also by the Rust application by means of a DataConsumer created on a DirectTransport (and vice-versa: messages sent over SCTP/DataChannel can be consumed by the Rust application by means of a DataConsumer created on a DirectTransport).

A direct transport can also be used to inject and directly consume RTP and RTCP packets in Rust by using the DirectProducer::send and Consumer::on_rtp API (plus DirectTransport::send_rtcp and DirectTransport::on_rtcp API).

Implementations

impl DirectTransport

pub async fn send_rtcp(
    &self,
    rtcp_packet: Bytes
) -> Result<(), NotificationError>

Send a RTCP packet from the Rust process.

• rtcp_packet - Bytes containing a valid RTCP packet (can be a compound packet).

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

Callback is called when the direct transport receives a RTCP packet from its router.

pub fn downgrade(&self) -> WeakDirectTransport

Downgrade DirectTransport to WeakDirectTransport instance.

Trait Implementations

impl Clone for DirectTransport

fn clone(&self) -> DirectTransport

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DirectTransport

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

Formats the value using the given formatter.

impl Transport for DirectTransport

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, 

Create a Producer.

Transport will be kept alive as long as at least one producer instance is alive.

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, 

Create a Consumer.

Transport will be kept alive as long as at least one consumer instance is alive.

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, 

Create a DataProducer.

Transport will be kept alive as long as at least one data producer instance is alive.

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, 

Create a DataConsumer.

Transport will be kept alive as long as at least one data consumer instance is alive.

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 DirectTransport

type Dump = DirectTransportDump

type Stat = DirectTransportStat

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.

Check the RTC Statistics section for more details (TypeScript-oriented, but concepts apply here as well).

#[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.