Struct RTCConfigurationBuilder 

pub struct RTCConfigurationBuilder(/* private fields */);

Builder for creating RTCConfiguration instances.

This registry provides a fluent API for configuring WebRTC peer connection settings:

• ICE servers (STUN/TURN) for NAT traversal
• Transport policies (which ICE candidates to use)
• Bundle and RTCP mux policies
• Custom DTLS certificates
• ICE candidate pool size

Examples

Basic configuration with STUN

use rtc::peer_connection::configuration::{RTCConfigurationBuilder, RTCIceServer};

let config = RTCConfigurationBuilder::new()
    .with_ice_servers(vec![
        RTCIceServer {
            urls: vec!["stun:stun.l.google.com:19302".to_string()],
            ..Default::default()
        }
    ])
    .build();

TURN server with credentials

use rtc::peer_connection::configuration::{RTCConfigurationBuilder, RTCIceServer};

let config = RTCConfigurationBuilder::new()
    .with_ice_servers(vec![
        RTCIceServer {
            urls: vec!["turn:turn.example.com:3478".to_string()],
            username: "user".to_string(),
            credential: "password".to_string(),
            ..Default::default()
        }
    ])
    .build();

Relay-only (privacy mode)

use rtc::peer_connection::configuration::{
    RTCConfigurationBuilder,
    RTCIceServer,
    RTCIceTransportPolicy
};

let config = RTCConfigurationBuilder::new()
    .with_ice_servers(vec![
        RTCIceServer {
            urls: vec!["turn:turn.example.com:3478".to_string()],
            username: "user".to_string(),
            credential: "password".to_string(),
            ..Default::default()
        }
    ])
    .with_ice_transport_policy(RTCIceTransportPolicy::Relay)
    .build();

Custom certificate

use rtc::peer_connection::configuration::RTCConfigurationBuilder;
use rtc::peer_connection::certificate::RTCCertificate;
use rtc::crypto::{self, SignatureScheme};
use rtc::peer_connection::certificate::CertificateParams;

    let provider = crypto::default_provider()?;
let certificate = RTCCertificate::generate(
    provider.crypto(),
    SignatureScheme::EcdsaP256Sha256,
    CertificateParams::new(vec!["localhost".to_owned()])?,
)?;

let config = RTCConfigurationBuilder::new()
    .with_certificates(vec![certificate])
    .build();

Implementations

impl RTCConfigurationBuilder

pub fn new() -> RTCConfigurationBuilder

Creates a new RTCConfigurationBuilder with default settings.

Default values:

• No ICE servers (local candidates only)
• All ICE candidate types allowed
• Balanced bundle policy
• Required RTCP mux policy
• No peer identity
• Auto-generated certificates
• ICE candidate pool size of 0

Examples

use rtc::peer_connection::configuration::RTCConfigurationBuilder;

let config = RTCConfigurationBuilder::new().build();

pub fn with_ice_servers( self, ice_servers: Vec<RTCIceServer>, ) -> RTCConfigurationBuilder

Sets the ICE servers for STUN and TURN.

ICE servers are used for NAT traversal to establish peer-to-peer connectivity. Multiple servers can be provided for redundancy.

Examples

use rtc::peer_connection::configuration::{RTCConfigurationBuilder, RTCIceServer};

let config = RTCConfigurationBuilder::new()
    .with_ice_servers(vec![
        RTCIceServer {
            urls: vec!["stun:stun.l.google.com:19302".to_string()],
            ..Default::default()
        },
        RTCIceServer {
            urls: vec!["turn:turn.example.com:3478".to_string()],
            username: "user".to_string(),
            credential: "pass".to_string(),
            ..Default::default()
        }
    ])
    .build();

pub fn with_ice_transport_policy( self, ice_transport_policy: RTCIceTransportPolicy, ) -> RTCConfigurationBuilder

Sets the ICE transport policy.

Controls which types of ICE candidates are allowed:

• All (default): Use all candidate types (host, srflx, relay)
• Relay: Only use TURN relay candidates (hides IP addresses)

Examples

use rtc::peer_connection::configuration::{RTCConfigurationBuilder, RTCIceTransportPolicy};

// Privacy mode - only use TURN relays
let config = RTCConfigurationBuilder::new()
    .with_ice_transport_policy(RTCIceTransportPolicy::Relay)
    .build();

pub fn with_bundle_policy( self, bundle_policy: RTCBundlePolicy, ) -> RTCConfigurationBuilder

Sets the bundle policy.

Controls how media tracks are bundled onto transports:

• Balanced (default): Bundle audio/video separately if peer doesn’t support bundling
• MaxCompat: Separate transports for each track (maximum compatibility)
• MaxBundle: Single transport for all media (best performance)

Examples

use rtc::peer_connection::configuration::{RTCConfigurationBuilder, RTCBundlePolicy};

let config = RTCConfigurationBuilder::new()
    .with_bundle_policy(RTCBundlePolicy::MaxBundle)
    .build();

pub fn with_rtcp_mux_policy( self, rtcp_mux_policy: RTCRtcpMuxPolicy, ) -> RTCConfigurationBuilder

Sets the RTCP multiplexing policy.

Controls whether RTCP is multiplexed with RTP:

• Negotiate: Try to multiplex, fall back to separate ports
• Require (default): Require multiplexing (standard for WebRTC)

Examples

use rtc::peer_connection::configuration::{RTCConfigurationBuilder, RTCRtcpMuxPolicy};

let config = RTCConfigurationBuilder::new()
    .with_rtcp_mux_policy(RTCRtcpMuxPolicy::Require)
    .build();

pub fn with_peer_identitys( self, peer_identity: String, ) -> RTCConfigurationBuilder

Sets the target peer identity.

If set, the peer connection will only connect to a remote peer that can be successfully authenticated with this identity.

Examples

use rtc::peer_connection::configuration::RTCConfigurationBuilder;

let config = RTCConfigurationBuilder::new()
    .with_peer_identitys("peer@example.com".to_string())
    .build();

pub fn with_certificates( self, certificates: Vec<RTCCertificate>, ) -> RTCConfigurationBuilder

Sets custom DTLS certificates.

If not provided, certificates are auto-generated. Providing certificates allows for consistent peer identity across connections.

Examples

use rtc::peer_connection::configuration::RTCConfigurationBuilder;
use rtc::peer_connection::certificate::RTCCertificate;
use rtc::crypto::{self, SignatureScheme};
use rtc::peer_connection::certificate::CertificateParams;

    let provider = crypto::default_provider()?;
let certificate = RTCCertificate::generate(
    provider.crypto(),
    SignatureScheme::EcdsaP256Sha256,
    CertificateParams::new(vec!["localhost".to_owned()])?,
)?;

let config = RTCConfigurationBuilder::new()
    .with_certificates(vec![certificate])
    .build();

pub fn with_ice_candidate_pool_size( self, ice_candidate_pool_size: u8, ) -> RTCConfigurationBuilder

Sets the ICE candidate pool size.

Specifies the number of ICE candidates to gather before needed. Pre-gathering candidates can reduce connection establishment time.

Examples

use rtc::peer_connection::configuration::RTCConfigurationBuilder;

let config = RTCConfigurationBuilder::new()
    .with_ice_candidate_pool_size(5)
    .build();

pub fn build(self) -> RTCConfiguration

Builds the RTCConfiguration.

Creates an immutable configuration that can be used to create a peer connection.

Examples

use rtc::peer_connection::configuration::RTCConfigurationBuilder;

let config = RTCConfigurationBuilder::new().build();

Trait Implementations

impl Default for RTCConfigurationBuilder

fn default() -> RTCConfigurationBuilder

Returns the “default value” for a type.