webrtc 0.20.0

Async-friendly 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
148
149
150
151
152
153
154
155
156

//! Integration tests for PeerConnection

use std::sync::Arc;
use webrtc::peer_connection::*;
use webrtc::peer_connection::{
    RTCConfigurationBuilder, RTCIceConnectionState, RTCPeerConnectionIceEvent,
    RTCPeerConnectionState, RTCSdpType,
};

mod common;
use common::block_on;

#[derive(Clone)]
struct TestHandler;

#[async_trait::async_trait]
impl PeerConnectionEventHandler for TestHandler {
    async fn on_negotiation_needed(&self) {
        println!("Negotiation needed");
    }

    async fn on_ice_candidate(&self, event: RTCPeerConnectionIceEvent) {
        println!("New ICE candidate: {:?}", event.candidate);
    }

    async fn on_ice_connection_state_change(&self, state: RTCIceConnectionState) {
        println!("ICE connection state changed: {:?}", state);
    }

    async fn on_connection_state_change(&self, state: RTCPeerConnectionState) {
        println!("Peer connection state changed: {:?}", state);
    }
}

#[test]
fn test_create_peer_connection() {
    block_on(async {
        let config = RTCConfigurationBuilder::new().build();
        let handler = Arc::new(TestHandler);

        let pc = PeerConnectionBuilder::new()
            .with_configuration(config)
            .with_handler(handler)
            .with_udp_addrs(vec!["127.0.0.1:0"])
            .build()
            .await
            .unwrap();

        // Verify we can close it
        pc.close().await.expect("Failed to close peer connection");
    })
}

#[test]
fn test_create_offer() {
    block_on(async {
        let config = RTCConfigurationBuilder::new().build();
        let handler = Arc::new(TestHandler);

        let pc = PeerConnectionBuilder::new()
            .with_configuration(config)
            .with_handler(handler)
            .with_udp_addrs(vec!["127.0.0.1:0"])
            .build()
            .await
            .unwrap();

        // Create an offer
        let offer = pc.create_offer(None).await.expect("Failed to create offer");

        // Verify offer has SDP content
        assert!(!offer.sdp.is_empty(), "Offer SDP should not be empty");
        assert_eq!(offer.sdp_type, RTCSdpType::Offer, "Should be an offer");

        pc.close().await.expect("Failed to close peer connection");
    })
}

#[test]
fn test_set_local_description() {
    block_on(async {
        let config = RTCConfigurationBuilder::new().build();
        let handler = Arc::new(TestHandler);

        let pc = PeerConnectionBuilder::new()
            .with_configuration(config)
            .with_handler(handler)
            .with_udp_addrs(vec!["127.0.0.1:0"])
            .build()
            .await
            .unwrap();

        // Create and set local description
        let offer = pc.create_offer(None).await.expect("Failed to create offer");
        pc.set_local_description(offer.clone())
            .await
            .expect("Failed to set local description");

        // Verify local description was set
        let local_desc = pc
            .local_description()
            .await
            .expect("Local description should be set");
        assert_eq!(local_desc.sdp_type, RTCSdpType::Offer);
        assert_eq!(local_desc.sdp, offer.sdp);

        pc.close().await.expect("Failed to close peer connection");
    })
}

#[test]
fn test_offer_answer_exchange() {
    block_on(async {
        // Create two peer connections to simulate offer/answer exchange
        let config1 = RTCConfigurationBuilder::new().build();
        let handler1 = Arc::new(TestHandler);
        let pc1 = PeerConnectionBuilder::new()
            .with_configuration(config1)
            .with_handler(handler1)
            .with_udp_addrs(vec!["127.0.0.1:0"])
            .build()
            .await
            .unwrap();

        let config2 = RTCConfigurationBuilder::new().build();
        let handler2 = Arc::new(TestHandler);
        let pc2 = PeerConnectionBuilder::new()
            .with_configuration(config2)
            .with_handler(handler2)
            .with_udp_addrs(vec!["127.0.0.1:0"])
            .build()
            .await
            .unwrap();

        // PC1 creates an offer
        let _offer = pc1
            .create_offer(None)
            .await
            .expect("Failed to create offer");

        // Verify we can create an answer (even if it fails due to missing ICE setup)
        // The important thing is that the API works
        let answer_result = pc2.create_answer(None).await;

        // We expect this to fail without setting remote description first
        // but the API should not panic
        assert!(
            answer_result.is_err(),
            "create_answer should fail without remote description"
        );

        // Cleanup
        pc1.close().await.expect("Failed to close PC1");
        pc2.close().await.expect("Failed to close PC2");
    })
}