rtc 0.9.0

Sans-I/O WebRTC implementation in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

//! ICE candidate pair statistics.
//!
//! This module contains the [`RTCIceCandidatePairStats`] type which provides
//! information about ICE candidate pairs used for connectivity checks.

use super::RTCStats;
use ::serde::{Deserialize, Serialize};
use ice::candidate::candidate_pair::CandidatePairState;
use shared::serde::instant_to_epoch;
use std::time::Instant;

/// The state of an ICE candidate pair.
///
/// This enum represents the current state of a candidate pair
/// in the ICE connectivity check process.
#[derive(Default, PartialEq, Eq, Debug, Copy, Clone, Serialize, Deserialize)]
pub enum RTCStatsIceCandidatePairState {
    /// State has not been set.
    #[default]
    Unspecified,

    /// Connectivity checks have not started for this pair.
    #[serde(rename = "frozen")]
    Frozen,

    /// Connectivity checks are waiting to be performed.
    #[serde(rename = "waiting")]
    Waiting,

    /// Connectivity checks are in progress.
    #[serde(rename = "in-progress")]
    InProgress,

    /// Connectivity checks have failed for this pair.
    #[serde(rename = "failed")]
    Failed,

    /// Connectivity checks have succeeded for this pair.
    #[serde(rename = "succeeded")]
    Succeeded,
}

impl From<CandidatePairState> for RTCStatsIceCandidatePairState {
    fn from(state: CandidatePairState) -> Self {
        match state {
            CandidatePairState::Unspecified => RTCStatsIceCandidatePairState::Unspecified,
            CandidatePairState::Waiting => RTCStatsIceCandidatePairState::Waiting,
            CandidatePairState::InProgress => RTCStatsIceCandidatePairState::InProgress,
            CandidatePairState::Failed => RTCStatsIceCandidatePairState::Failed,
            CandidatePairState::Succeeded => RTCStatsIceCandidatePairState::Succeeded,
        }
    }
}

/// Statistics for an ICE candidate pair.
///
/// This struct corresponds to the `RTCIceCandidatePairStats` dictionary in the
/// W3C WebRTC Statistics API. It provides detailed information about
/// connectivity checks and data transfer for a specific candidate pair.
///
/// # W3C Reference
///
/// See [RTCIceCandidatePairStats](https://www.w3.org/TR/webrtc-stats/#candidatepair-dict*)
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RTCIceCandidatePairStats {
    /// Base statistics fields (timestamp, type, id).
    #[serde(flatten)]
    pub stats: RTCStats,

    /// The ID of the transport this candidate pair belongs to.
    pub transport_id: String,

    /// The ID of the local candidate in this pair.
    pub local_candidate_id: String,

    /// The ID of the remote candidate in this pair.
    pub remote_candidate_id: String,

    /// Total number of packets sent using this candidate pair.
    pub packets_sent: u64,

    /// Total number of packets received using this candidate pair.
    pub packets_received: u64,

    /// Total number of bytes sent using this candidate pair.
    pub bytes_sent: u64,

    /// Total number of bytes received using this candidate pair.
    pub bytes_received: u64,

    /// Timestamp of the last packet sent using this candidate pair.
    #[serde(with = "instant_to_epoch")]
    pub last_packet_sent_timestamp: Instant,

    /// Timestamp of the last packet received using this candidate pair.
    #[serde(with = "instant_to_epoch")]
    pub last_packet_received_timestamp: Instant,

    /// Total round trip time in seconds for all STUN requests.
    ///
    /// Divide by `responses_received` to get the average RTT.
    pub total_round_trip_time: f64,

    /// The most recent round trip time measurement in seconds.
    pub current_round_trip_time: f64,

    /// Number of STUN connectivity check requests sent.
    pub requests_sent: u64,

    /// Number of STUN connectivity check requests received.
    pub requests_received: u64,

    /// Number of STUN connectivity check responses sent.
    pub responses_sent: u64,

    /// Number of STUN connectivity check responses received.
    pub responses_received: u64,

    /// Number of ICE consent freshness requests sent.
    pub consent_requests_sent: u64,

    /// Number of packets discarded due to send errors.
    pub packets_discarded_on_send: u32,

    /// Number of bytes discarded due to send errors.
    pub bytes_discarded_on_send: u32,

    /// Estimated available outgoing bitrate in bits per second.
    ///
    /// Calculated using congestion control feedback.
    pub available_outgoing_bitrate: f64,

    /// Estimated available incoming bitrate in bits per second.
    ///
    /// Calculated using congestion control feedback.
    pub available_incoming_bitrate: f64,

    /// Current state of the candidate pair.
    pub state: RTCStatsIceCandidatePairState,

    /// Whether this candidate pair has been nominated.
    ///
    /// A nominated pair is one that has been selected for use
    /// by the ICE controlling agent.
    pub nominated: bool,
}