Move peer API logic into submodule in medea-flutter-webrtc-native crate (#231, #210)

Author: turtletongue

crates/native/src/api/mod.rs

@@ -0,0 +1,63 @@
+//! [RTCIceConnectionState][1] definitions.
+//!
+//! [1]: https://w3.org/TR/webrtc#dom-rtciceconnectionstate
+
+use libwebrtc_sys as sys;
+
+/// [RTCIceConnectionState][1] representation.
+///
+/// [1]: https://w3.org/TR/webrtc#dom-rtciceconnectionstate
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum IceConnectionState {
+    /// [RTCIceConnectionState.new][1] representation.
+    ///
+    /// [1]: https://w3.org/TR/webrtc#dom-rtciceconnectionstate-new
+    New,
+
+    /// [RTCIceConnectionState.checking][1] representation.
+    ///
+    /// [1]: https://w3.org/TR/webrtc#dom-rtciceconnectionstate-checking
+    Checking,
+
+    /// [RTCIceConnectionState.connected][1] representation.
+    ///
+    /// [1]: https://w3.org/TR/webrtc#dom-rtciceconnectionstate-connected
+    Connected,
+
+    /// [RTCIceConnectionState.completed][1] representation.
+    ///
+    /// [1]: https://w3.org/TR/webrtc#dom-rtciceconnectionstate-completed
+    Completed,
+
+    /// [RTCIceConnectionState.failed][1] representation.
+    ///
+    /// [1]: https://w3.org/TR/webrtc#dom-rtciceconnectionstate-failed
+    Failed,
+
+    /// [RTCIceConnectionState.disconnected][1] representation.
+    ///
+    /// [1]: https://w3.org/TR/webrtc#dom-rtciceconnectionstate-disconnected
+    Disconnected,
+
+    /// [RTCIceConnectionState.closed][1] representation.
+    ///
+    /// [1]: https://w3.org/TR/webrtc#dom-rtciceconnectionstate-closed
+    Closed,
+}
+
+impl From<sys::IceConnectionState> for IceConnectionState {
+    fn from(state: sys::IceConnectionState) -> Self {
+        match state {
+            sys::IceConnectionState::kIceConnectionNew => Self::New,
+            sys::IceConnectionState::kIceConnectionChecking => Self::Checking,
+            sys::IceConnectionState::kIceConnectionConnected => Self::Connected,
+            sys::IceConnectionState::kIceConnectionCompleted => Self::Completed,
+            sys::IceConnectionState::kIceConnectionFailed => Self::Failed,
+            sys::IceConnectionState::kIceConnectionDisconnected => {
+                Self::Disconnected
+            }
+            sys::IceConnectionState::kIceConnectionClosed => Self::Closed,
+            _ => unreachable!(),
+        }
+    }
+}

crates/native/src/api/peer/events/ice_connection_state.rs

@@ -0,0 +1,37 @@
+//! [RTCIceGatheringState][1] definitions.
+//!
+//! [1]: https://w3.org/TR/webrtc#dom-rtcicegatheringstate
+
+use libwebrtc_sys as sys;
+
+/// [RTCIceGatheringState][1] representation.
+///
+/// [1]: https://w3.org/TR/webrtc#dom-rtcicegatheringstate
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum IceGatheringState {
+    /// [RTCIceGatheringState.new][1] representation.
+    ///
+    /// [1]: https://w3.org/TR/webrtc#dom-rtcicegatheringstate-new
+    New,
+
+    /// [RTCIceGatheringState.gathering][1] representation.
+    ///
+    /// [1]: https://w3.org/TR/webrtc#dom-rtcicegatheringstate-gathering
+    Gathering,
+
+    /// [RTCIceGatheringState.complete][1] representation.
+    ///
+    /// [1]: https://w3.org/TR/webrtc#dom-rtcicegatheringstate-complete
+    Complete,
+}
+
+impl From<sys::IceGatheringState> for IceGatheringState {
+    fn from(state: sys::IceGatheringState) -> Self {
+        match state {
+            sys::IceGatheringState::kIceGatheringNew => Self::New,
+            sys::IceGatheringState::kIceGatheringGathering => Self::Gathering,
+            sys::IceGatheringState::kIceGatheringComplete => Self::Complete,
+            _ => unreachable!(),
+        }
+    }
+}

crates/native/src/api/peer/events/ice_gathering_state.rs

@@ -0,0 +1,108 @@
+//! [`PeerConnection`]'s events.
+
+pub mod ice_connection_state;
+pub mod ice_gathering_state;
+pub mod peer_connection_state;
+pub mod rtc_track_event;
+pub mod signaling_state;
+
+use std::sync::Arc;
+
+pub use self::{
+    ice_connection_state::IceConnectionState,
+    ice_gathering_state::IceGatheringState,
+    peer_connection_state::PeerConnectionState, rtc_track_event::RtcTrackEvent,
+    signaling_state::SignalingState,
+};
+use crate::{PeerConnection, frb_generated::RustOpaque};
+
+/// Representation of [`PeerConnection`]'s events.
+#[derive(Clone)]
+pub enum PeerConnectionEvent {
+    /// [`PeerConnection`] has been created.
+    PeerCreated {
+        /// Rust side [`PeerConnection`].
+        peer: RustOpaque<Arc<PeerConnection>>,
+    },
+
+    /// [RTCIceCandidate][1] has been discovered.
+    ///
+    /// [1]: https://w3.org/TR/webrtc#dom-rtcicecandidate
+    IceCandidate {
+        /// Media stream "identification-tag" defined in [RFC 5888] for the
+        /// media component the discovered [RTCIceCandidate][1] is associated
+        /// with.
+        ///
+        /// [1]: https://w3.org/TR/webrtc#dom-rtcicecandidate
+        /// [RFC 5888]: https://tools.ietf.org/html/rfc5888
+        sdp_mid: String,
+
+        /// Index (starting at zero) of the media description in the SDP this
+        /// [RTCIceCandidate][1] is associated with.
+        ///
+        /// [1]: https://w3.org/TR/webrtc#dom-rtcicecandidate
+        sdp_mline_index: i32,
+
+        /// Candidate-attribute as defined in Section 15.1 of [RFC 5245].
+        ///
+        /// If this [RTCIceCandidate][1] represents an end-of-candidates
+        /// indication or a peer reflexive remote candidate, candidate is an
+        /// empty string.
+        ///
+        /// [1]: https://w3.org/TR/webrtc#dom-rtcicecandidate
+        /// [RFC 5245]: https://tools.ietf.org/html/rfc5245
+        candidate: String,
+    },
+
+    /// [`PeerConnection`]'s ICE gathering state has changed.
+    IceGatheringStateChange(IceGatheringState),
+
+    /// Failure occurred when gathering [RTCIceCandidate][1].
+    ///
+    /// [1]: https://w3.org/TR/webrtc#dom-rtcicecandidate
+    IceCandidateError {
+        /// Local IP address used to communicate with the STUN or TURN server.
+        address: String,
+
+        /// Port used to communicate with the STUN or TURN server.
+        port: i32,
+
+        /// STUN or TURN URL identifying the STUN or TURN server for which the
+        /// failure occurred.
+        url: String,
+
+        /// Numeric STUN error code returned by the STUN or TURN server
+        /// [`STUN-PARAMETERS`][1].
+        ///
+        /// If no host candidate can reach the server, it will be set to the
+        /// value `701` which is outside the STUN error code range.
+        ///
+        /// [1]: https://tinyurl.com/stun-parameters-6
+        error_code: i32,
+
+        /// STUN reason text returned by the STUN or TURN server
+        /// [`STUN-PARAMETERS`][1].
+        ///
+        /// If the server could not be reached, it will be set to an
+        /// implementation-specific value providing details about the error.
+        ///
+        /// [1]: https://tinyurl.com/stun-parameters-6
+        error_text: String,
+    },
+
+    /// Negotiation or renegotiation of the [`PeerConnection`] needs to be
+    /// performed.
+    NegotiationNeeded,
+
+    /// [`PeerConnection`]'s [`SignalingState`] has been changed.
+    SignallingChange(SignalingState),
+
+    /// [`PeerConnection`]'s [`IceConnectionState`] has been changed.
+    IceConnectionStateChange(IceConnectionState),
+
+    /// [`PeerConnection`]'s [`PeerConnectionState`] has been changed.
+    ConnectionStateChange(PeerConnectionState),
+
+    /// New incoming media has been negotiated.
+    Track(RtcTrackEvent),
+}

crates/native/src/api/peer/events/mod.rs

@@ -0,0 +1,54 @@
+//! Current state of a [`PeerConnection`].
+
+use libwebrtc_sys as sys;
+
+#[cfg(doc)]
+use crate::{PeerConnection, api::IceConnectionState};
+
+/// Indicator of the current state of a [`PeerConnection`].
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum PeerConnectionState {
+    /// At least one of the connection's ICE transports is in the new state,
+    /// and none of them are in one of the following states: `connecting`,
+    /// `checking`, `failed`, `disconnected`, or all of the connection's
+    /// transports are in the `closed` state.
+    New,
+
+    /// One or more of the ICE transports are currently in the process of
+    /// establishing a connection. That is, their [`IceConnectionState`] is
+    /// either [`IceConnectionState::Checking`] or
+    /// [`IceConnectionState::Connected`], and no transports are in the
+    /// `failed` state.
+    Connecting,
+
+    /// Every ICE transport used by the connection is either in use (state
+    /// `connected` or `completed`) or is closed (state `closed`). In addition,
+    /// at least one transport is either `connected` or `completed`.
+    Connected,
+
+    /// At least one of the ICE transports for the connection is in the
+    /// `disconnected` state and none of the other transports are in the state
+    /// `failed`, `connecting` or `checking`.
+    Disconnected,
+
+    /// One or more of the ICE transports on the connection is in the `failed`
+    /// state.
+    Failed,
+
+    /// Peer connection is closed.
+    Closed,
+}
+
+impl From<sys::PeerConnectionState> for PeerConnectionState {
+    fn from(state: sys::PeerConnectionState) -> Self {
+        match state {
+            sys::PeerConnectionState::kNew => Self::New,
+            sys::PeerConnectionState::kConnecting => Self::Connecting,
+            sys::PeerConnectionState::kConnected => Self::Connected,
+            sys::PeerConnectionState::kDisconnected => Self::Disconnected,
+            sys::PeerConnectionState::kFailed => Self::Failed,
+            sys::PeerConnectionState::kClosed => Self::Closed,
+            _ => unreachable!(),
+        }
+    }
+}

crates/native/src/api/peer/events/peer_connection_state.rs

@@ -0,0 +1,19 @@
+//! Representation of a [`MediaStreamTrack`] event.
+
+#[cfg(doc)]
+use crate::PeerConnection;
+use crate::api::{MediaStreamTrack, RtcRtpTransceiver};
+
+/// Representation of a track event, sent when a new [`MediaStreamTrack`] is
+/// added to an [`RtcRtpTransceiver`] as part of a [`PeerConnection`].
+#[derive(Clone)]
+pub struct RtcTrackEvent {
+    /// [`MediaStreamTrack`] associated with the [RTCRtpReceiver] identified
+    /// by the receiver.
+    ///
+    /// [RTCRtpReceiver]: https://w3.org/TR/webrtc#dom-rtcrtpreceiver
+    pub track: MediaStreamTrack,
+
+    /// [`RtcRtpTransceiver`] object associated with the event.
+    pub transceiver: RtcRtpTransceiver,
+}

crates/native/src/api/peer/events/rtc_track_event.rs

@@ -0,0 +1,57 @@
+//! [RTCSignalingState] definitions.
+//!
+//! [RTCSignalingState]: https://w3.org/TR/webrtc#state-definitions
+
+use libwebrtc_sys as sys;
+
+/// [RTCSignalingState] representation.
+///
+/// [RTCSignalingState]: https://w3.org/TR/webrtc#state-definitions
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum SignalingState {
+    /// [RTCSignalingState.stable][1] representation.
+    ///
+    /// [1]: https://w3.org/TR/webrtc#dom-rtcsignalingstate-stable
+    Stable,
+
+    /// [RTCSignalingState.have-local-offer][1] representation.
+    ///
+    /// [1]: https://w3.org/TR/webrtc#dom-rtcsignalingstate-have-local-offer
+    HaveLocalOffer,
+
+    /// [RTCSignalingState.have-local-pranswer][1] representation.
+    ///
+    /// [1]: https://tinyurl.com/have-local-pranswer
+    HaveLocalPrAnswer,
+
+    /// [RTCSignalingState.have-remote-offer][1] representation.
+    ///
+    /// [1]: https://tinyurl.com/have-remote-offer
+    HaveRemoteOffer,
+
+    /// [RTCSignalingState.have-remote-pranswer][1] representation.
+    ///
+    /// [1]: https://tinyurl.com/have-remote-pranswer
+    HaveRemotePrAnswer,
+
+    /// [RTCSignalingState.closed][1] representation.
+    ///
+    /// [1]: https://w3.org/TR/webrtc#dom-rtcsignalingstate-closed
+    Closed,
+}
+
+impl From<sys::SignalingState> for SignalingState {
+    fn from(state: sys::SignalingState) -> Self {
+        match state {
+            sys::SignalingState::kStable => Self::Stable,
+            sys::SignalingState::kHaveLocalOffer => Self::HaveLocalOffer,
+            sys::SignalingState::kHaveLocalPrAnswer => Self::HaveLocalPrAnswer,
+            sys::SignalingState::kHaveRemoteOffer => Self::HaveRemoteOffer,
+            sys::SignalingState::kHaveRemotePrAnswer => {
+                Self::HaveRemotePrAnswer
+            }
+            sys::SignalingState::kClosed => Self::Closed,
+            _ => unreachable!(),
+        }
+    }
+}