Struct Call 

pub struct Call {
    pub remote_media: RemoteMedia,
    pub rtp_socket: Arc<UdpSocket>,
    pub local_rtp_addr: SocketAddr,
    /* private fields */
}

An established call: negotiated remote media plus the local RTP socket.

The same handle is produced by Caller::dial (outbound) and crate::IncomingCall::accept (inbound), so call control is uniform.

Fields

remote_media: RemoteMedia

Where the remote endpoint expects RTP (from the negotiated SDP).

rtp_socket: Arc<UdpSocket>

Local RTP socket; share via Arc to send and receive concurrently.

local_rtp_addr: SocketAddr

Local RTP address advertised in our SDP.

Implementations

impl Call

pub async fn set_hold( &mut self, on: bool, ) -> Result<(), Box<dyn Error + Send + Sync>>

Put the peer on hold (on = true, a=sendonly) or resume the call (on = false, a=sendrecv) by sending an in-dialog re-INVITE with a fresh SDP re-offer (RFC 3264 §8.4).

The local hold state only flips once the peer accepts the re-INVITE with a 2xx; a non-2xx final surfaces the server’s reason and leaves the call unchanged. The o= version is bumped for each re-offer regardless, as RFC 3264 requires.

pub fn is_held(&self) -> bool

true if the call is currently on hold (we sent a sendonly re-INVITE the peer accepted).

pub fn session_timer(&self) -> Option<SessionTimer>

The RFC 4028 session timer negotiated when the call was set up, or None if neither side asked for one. Drive it with crate::session_timer_loop against Call::session_handle.

pub fn session_handle(&self) -> CallSession

A cloneable handle that sends refresh re-INVITEs / BYE on this call’s dialog, for running crate::session_timer_loop in a background task alongside the audio path. Shares the dialog with the Call, so their in-dialog requests serialize correctly.

pub fn inbound_requests(&self) -> InboundRequests

Opt in to handle this call’s inbound in-dialog requests — the peer’s re-INVITEs (e.g. an RFC 4028 session refresh, or a peer-initiated hold) and INFOs (e.g. SIP-INFO DTMF) — instead of having the endpoint auto-answer them 200 OK.

Returns a stream; each InboundRequest must be answered (with InboundRequest::respond / InboundRequest::ok). While the returned InboundRequests is alive, those requests route here; drop it to revert to auto-answering. BYE / OPTIONS are always auto-answered. Call this once per Call.

pub fn terminated(&self) -> CancellationToken

A token that fires when the peer ends the call by sending an in-dialog BYE. The endpoint auto-answers the BYE 200 OK; this is purely the notification. Clone it and await CancellationToken::cancelled in a task to drive call teardown (stop audio, finalize a recording). It does not fire for a local Call::hangup — the caller already knows.

pub fn peer_uri(&self) -> &Uri

The peer’s remote-target URI (its Contact) — the address a third party should INVITE to reach this exact peer. Used as the Refer-To target of an attended transfer (read off the consultation call), paired with Call::dialog_triplet for the Replaces.

pub fn dialog_triplet(&self) -> DialogTriplet

This call’s dialog identity (Call-ID + our/remote tags), for naming it in an attended transfer’s Replaces (RFC 3891). Read it off the consultation call (the leg we built to the transfer target) and pass it to Call::attended_transfer on the call being transferred.

pub async fn send_dtmf_info( &mut self, digit: DtmfDigit, duration_ms: u32, ) -> InfoOutcome

Send one DTMF press via SIP INFO (application/dtmf-relay).

Use this only when the remote did not negotiate RFC 4733 — i.e. RemoteMedia::dtmf_payload_type is None. When telephone-event is available, prefer crate::send_dtmf_burst over RTP. A InfoOutcome::UnsupportedMedia result means the remote rejects this transport too; stop sending further presses on this dialog.

pub async fn blind_transfer( &mut self, target: Uri, ) -> Result<(), Box<dyn Error + Send + Sync>>

Blind-transfer the call: ask the peer to place a fresh call to target by sending an in-dialog REFER with a Refer-To (RFC 3515).

Returns Ok(()) once the peer accepts the REFER with a 2xx (202 Accepted) — at which point the transfer is in progress, not yet complete. The peer then reports the outcome as a series of in-dialog NOTIFYs (a message/sipfrag status line) that arrive on Call::inbound_requests; the consumer watches those (parsing each with crate::parse_sipfrag_status) and tears its own leg down once the target answers. A non-2xx final to the REFER surfaces the peer’s reason and leaves the call unchanged — the peer won’t honour the transfer, so the consumer should keep the call up.

This is blind (unattended) transfer: we do not first call target ourselves. Attended transfer (consult target, then REFER with Replaces) is a separate method, not yet implemented.

pub async fn attended_transfer( &mut self, target: Uri, replaces: &DialogTriplet, ) -> Result<(), Box<dyn Error + Send + Sync>>

Attended-transfer the call: ask the peer (the party we hold) to take over the consultation dialog named by replaces by sending an in-dialog REFER whose Refer-To carries target plus a Replaces header (RFC 3515 + RFC 3891).

replaces is the dialog identity of the consultation call — the leg we already established to target ourselves — read via Call::dialog_triplet. When the peer accepts (202), it INVITEs target with that Replaces, so target replaces the consultation leg rather than ringing afresh. The outcome arrives exactly as for a blind transfer — NOTIFY/sipfrag on Call::inbound_requests — so the consumer drives both the same way. A non-2xx final to the REFER surfaces the peer’s reason and leaves the call unchanged.

pub async fn hangup(&mut self) -> Result<(), Box<dyn Error + Send + Sync>>

Hang up by sending an in-dialog BYE. Returns once the peer 2xxs it (or the transaction gives up).

Trait Implementations

impl Drop for Call

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.