Struct AsyncRtspServer 

pub struct AsyncRtspServer<S> { /* private fields */ }

An async RTSP server connection that owns a socket and drives a ServerSession.

Reads requests off the socket (framed by a tokio_util codec over rtsp_types), calls ServerSession::handle_request, writes the response bytes back, and returns the ServerEvents. Every awaited IO is bounded by RtspTimeouts.

Implementations

impl AsyncRtspServer<TcpStream>

pub fn accept(stream: TcpStream) -> Self

Wraps an accepted plain-TCP connection with a fresh ServerSession whose Session ids come from the OS random source.

Panics

When the OS random source is unavailable.

pub fn accept_with(stream: TcpStream, session: ServerSession) -> Self

Wraps an accepted plain-TCP connection with a pre-configured session.

pub fn accept_with_timeouts( stream: TcpStream, session: ServerSession, timeouts: RtspTimeouts, ) -> Self

Like accept_with, with explicit RtspTimeouts.

impl AsyncRtspServer<TlsStream<TcpStream>>

pub async fn accept_tls(stream: TcpStream, config: ServerConfig) -> Result<Self>

Performs the TLS handshake over an accepted TCP connection (an rtsps:// server), then wraps the TLS stream with a fresh session.

pub async fn accept_tls_with_timeouts( stream: TcpStream, config: ServerConfig, timeouts: RtspTimeouts, ) -> Result<Self>

Like accept_tls, with explicit RtspTimeouts: handshake bounds the TLS handshake.

impl<S> AsyncRtspServer<S>

where S: AsyncRead + AsyncWrite + Unpin,

pub fn with_stream(stream: S, session: ServerSession) -> Self

Wraps an already-connected stream (plain or TLS) and a session, with the default RtspTimeouts.

pub fn with_stream_timeouts( stream: S, session: ServerSession, timeouts: RtspTimeouts, ) -> Self

Wraps an already-connected stream with explicit RtspTimeouts.

pub fn timeouts(&self) -> RtspTimeouts

The timeouts this adapter applies.

pub fn state(&self) -> SessionState

The current session state.

pub fn session_id(&self) -> Option<&str>

The allocated session id, once a SETUP has been handled.

pub fn stream_mut(&mut self) -> &mut S

Mutable access to the underlying stream, for writing raw bytes (e.g. deliberately fragmenting an interleaved frame, or sending several frames back-to-back) alongside the framed send_interleaved helper.

pub async fn next_request(&mut self) -> Result<Option<Vec<ServerEvent>>>

Reads the next complete request or interleaved frame, handling a request (writing the response back) and returning the produced events, or surfacing an interleaved $-frame as ServerEvent::MediaData.

The FIRST call on a connection waits at most RtspTimeouts::handshake for a complete request; later calls wait at most RtspTimeouts::read_idle. A frame must complete inside that single deadline, so a client dripping bytes cannot hold the connection forever.

Cancel-safe: dropping the future while the response is being written loses neither the response bytes nor the events; the next call finishes the write and returns them.

Returns Ok(None) when the peer closes the connection cleanly before a full request or frame arrives.

pub async fn send_interleaved( &mut self, channel: u8, payload: &[u8], ) -> Result<()>

Sends an interleaved ($-framed) media frame to the client on channel (§10.12), e.g. an RTP or RTCP packet during PLAY.

Trait Implementations

impl<S: Debug> Debug for AsyncRtspServer<S>

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

Formats the value using the given formatter.