Enum CallState

pub enum CallState {
    Initiating,
    Proceeding,
    Ringing,
    Connected,
    Terminating,
    Terminated,
    Failed,
    Cancelled,
    IncomingPending,
}

Current state of a call in its lifecycle

Represents the various states a call can be in, from initiation through termination. These states correspond to SIP call flow stages and help determine what operations are valid at any given time.

State Transitions

Typical outgoing call flow: Initiating → Proceeding → Ringing → Connected → Terminating → Terminated

Typical incoming call flow: IncomingPending → Connected → Terminating → Terminated

Examples

use rvoip_client_core::call::CallState;
 
let state = CallState::Connected;
assert!(state.is_active());
assert!(state.is_in_progress());
assert!(!state.is_terminated());

Variants

Initiating

Call is being initiated (sending INVITE)

Initial state for outgoing calls when the INVITE request is being sent but no response has been received yet.

Proceeding

Received 100 Trying or similar provisional response

The remote party has acknowledged receipt of the INVITE and is processing the call request.

Ringing

Received 180 Ringing

The remote party’s phone is ringing. This indicates the call setup is progressing normally.

Connected

Call is connected and media is flowing

The call has been answered and media (audio/video) can be exchanged. This is the primary active state for established calls.

Terminating

Call is being terminated (sending/received BYE)

Either party has initiated call termination but the termination process is not yet complete.

Terminated

Call has ended normally

The call was successfully terminated by either party. This is a final state.

Failed

Call failed to establish

The call setup failed due to network issues, busy signal, rejection, or other errors. This is a final state.

Cancelled

Call was cancelled before connection

The call was cancelled by the caller before the remote party answered. This is a final state.

IncomingPending

Incoming call waiting for user decision

A call invitation has been received and is waiting for the user to accept, reject, or ignore it.

Implementations

impl CallState

pub fn is_active(&self) -> bool

Check if the call is in an active state (can send/receive media)

Returns true only for the Connected state where media can be actively exchanged between parties.

Examples

use rvoip_client_core::call::CallState;
 
assert!(CallState::Connected.is_active());
assert!(!CallState::Ringing.is_active());
assert!(!CallState::Terminated.is_active());

pub fn is_terminated(&self) -> bool

Check if the call is in a terminated state

Returns true for any final state where the call has ended and no further operations are possible.

Examples

use rvoip_client_core::call::CallState;
 
assert!(CallState::Terminated.is_terminated());
assert!(CallState::Failed.is_terminated());
assert!(CallState::Cancelled.is_terminated());
assert!(!CallState::Connected.is_terminated());
assert!(!CallState::Ringing.is_terminated());

pub fn is_in_progress(&self) -> bool

Check if the call is still in progress

Returns true for any non-terminal state where the call is still active or progressing through setup/teardown.

Examples

use rvoip_client_core::call::CallState;
 
assert!(CallState::Connected.is_in_progress());
assert!(CallState::Ringing.is_in_progress());
assert!(CallState::Initiating.is_in_progress());
assert!(!CallState::Terminated.is_in_progress());
assert!(!CallState::Failed.is_in_progress());

Trait Implementations

impl Clone for CallState

fn clone(&self) -> CallState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CallState

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CallState

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for CallState

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for CallState

fn eq(&self, other: &CallState) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for CallState

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for CallState

impl StructuralPartialEq for CallState