Add CanTrickleICECandidates

w3c CanTrickleICECandidates.

Author: JoeTurki

peerconnection.go

@@ -65,6 +65,8 @@ type PeerConnection struct {
 
 	lastOffer  string
 	lastAnswer string
+	// Whether the remote endpoint can accept trickled ICE candidates.
+	canTrickleICECandidates ICETrickleCapability
 
 	// a value containing the last known greater mid value
 	// we internally generate mids as numbers. Needed since JSEP
@@ -1104,6 +1106,7 @@ func (pc *PeerConnection) SetRemoteDescription(desc SessionDescription) error {
 	if _, err := desc.Unmarshal(); err != nil {
 		return err
 	}
+
 	if err := pc.setDescription(&desc, stateChangeOpSetRemote); err != nil {
 		return err
 	}
@@ -1112,6 +1115,20 @@ func (pc *PeerConnection) SetRemoteDescription(desc SessionDescription) error {
 		return err
 	}
 
+	canTrickle := hasICETrickleOption(desc.parsed)
+	pc.mu.Lock()
+	switch desc.Type {
+	case SDPTypeOffer, SDPTypeAnswer, SDPTypePranswer:
+		if canTrickle {
+			pc.canTrickleICECandidates = ICETrickleCapabilitySupported
+		} else {
+			pc.canTrickleICECandidates = ICETrickleCapabilityUnsupported
+		}
+	default:
+		pc.canTrickleICECandidates = ICETrickleCapabilityUnknown
+	}
+	pc.mu.Unlock()
+
 	// Disable RTX/FEC on RTPSenders if the remote didn't support it
 	for _, sender := range pc.GetSenders() {
 		sender.configureRTXAndFEC()
@@ -2583,6 +2600,15 @@ func (pc *PeerConnection) PendingRemoteDescription() *SessionDescription {
 	return pc.pendingRemoteDescription
 }
 
+// CanTrickleICECandidates reports whether the remote endpoint indicated
+// support for receiving trickled ICE candidates.
+func (pc *PeerConnection) CanTrickleICECandidates() ICETrickleCapability {
+	pc.mu.RLock()
+	defer pc.mu.RUnlock()
+
+	return pc.canTrickleICECandidates
+}
+
 // SignalingState attribute returns the signaling state of the
 // PeerConnection instance.
 func (pc *PeerConnection) SignalingState() SignalingState {

peerconnection_go_test.go

@@ -2203,3 +2203,40 @@ func TestAddICECandidate__DroppingOldGenerationCandidates(t *testing.T) {
 
 	closePairNow(t, pc, remotePC)
 }
+
+func TestPeerConnectionCanTrickleICECandidatesGo(t *testing.T) {
+	offerPC, answerPC, wan := createVNetPair(t, nil)
+	var err error
+	defer func() {
+		assert.NoError(t, wan.Stop())
+		closePairNow(t, offerPC, answerPC)
+	}()
+
+	_, err = offerPC.CreateDataChannel("trickle", nil)
+	assert.NoError(t, err)
+
+	offer, err := offerPC.CreateOffer(&OfferOptions{
+		OfferAnswerOptions: OfferAnswerOptions{ICETricklingSupported: true},
+	})
+	assert.NoError(t, err)
+	assert.NoError(t, offerPC.SetLocalDescription(offer))
+	assert.Equal(t, ICETrickleCapabilityUnknown, answerPC.CanTrickleICECandidates())
+	assert.NoError(t, answerPC.SetRemoteDescription(offer))
+	assert.Equal(t, ICETrickleCapabilitySupported, answerPC.CanTrickleICECandidates())
+
+	noTrickleOfferPC, noTrickleAnswerPC, noTrickleWAN := createVNetPair(t, nil)
+	defer func() {
+		assert.NoError(t, noTrickleWAN.Stop())
+		closePairNow(t, noTrickleOfferPC, noTrickleAnswerPC)
+	}()
+
+	_, err = noTrickleOfferPC.CreateDataChannel("notrickle", nil)
+	assert.NoError(t, err)
+
+	noTrickleOffer, err := noTrickleOfferPC.CreateOffer(nil)
+	assert.NoError(t, err)
+	assert.NoError(t, noTrickleOfferPC.SetLocalDescription(noTrickleOffer))
+	assert.Equal(t, ICETrickleCapabilityUnknown, noTrickleAnswerPC.CanTrickleICECandidates())
+	assert.NoError(t, noTrickleAnswerPC.SetRemoteDescription(noTrickleOffer))
+	assert.Equal(t, ICETrickleCapabilityUnsupported, noTrickleAnswerPC.CanTrickleICECandidates())
+}

peerconnection_js.go

@@ -463,6 +463,21 @@ func (pc *PeerConnection) PendingRemoteDescription() *SessionDescription {
 	return valueToSessionDescription(desc)
 }
 
+// CanTrickleICECandidates reports whether the remote endpoint indicated
+// support for receiving trickled ICE candidates.
+func (pc *PeerConnection) CanTrickleICECandidates() ICETrickleCapability {
+	val := pc.underlying.Get("canTrickleIceCandidates")
+	if val.IsNull() || val.IsUndefined() {
+		return ICETrickleCapabilityUnknown
+	}
+
+	if val.Bool() {
+		return ICETrickleCapabilitySupported
+	}
+
+	return ICETrickleCapabilityUnsupported
+}
+
 // SignalingState returns the signaling state of the PeerConnection instance.
 func (pc *PeerConnection) SignalingState() SignalingState {
 	rawState := pc.underlying.Get("signalingState").String()
@@ -714,6 +729,7 @@ func valueToSessionDescription(descValue js.Value) *SessionDescription {
 	if descValue.IsNull() || descValue.IsUndefined() {
 		return nil
 	}
+
 	return &SessionDescription{
 		Type: NewSDPType(descValue.Get("type").String()),
 		SDP:  descValue.Get("sdp").String(),

peerconnection_js_test.go

@@ -104,3 +104,20 @@ func TestValueToICEServer(t *testing.T) {
 		assert.Equal(t, testCase, s)
 	}
 }
+
+func TestPeerConnectionCanTrickleICECandidatesJS(t *testing.T) {
+	pc := &PeerConnection{
+		underlying: js.ValueOf(map[string]any{
+			"canTrickleIceCandidates": true,
+		}),
+	}
+	assert.Equal(t, ICETrickleCapabilitySupported, pc.CanTrickleICECandidates())
+
+	pc.underlying = js.ValueOf(map[string]any{
+		"canTrickleIceCandidates": false,
+	})
+	assert.Equal(t, ICETrickleCapabilityUnsupported, pc.CanTrickleICECandidates())
+
+	pc.underlying = js.ValueOf(map[string]any{})
+	assert.Equal(t, ICETrickleCapabilityUnknown, pc.CanTrickleICECandidates())
+}

peerconnection_test.go

@@ -806,3 +806,18 @@ func TestPeerConnection_SessionID(t *testing.T) {
 	}
 	closePairNow(t, pcOffer, pcAnswer)
 }
+
+func TestICETrickleCapabilityString(t *testing.T) {
+	tests := []struct {
+		value    ICETrickleCapability
+		expected string
+	}{
+		{ICETrickleCapabilityUnknown, "unknown"},
+		{ICETrickleCapabilitySupported, "supported"},
+		{ICETrickleCapabilityUnsupported, "unsupported"},
+	}
+
+	for _, tt := range tests {
+		assert.Equal(t, tt.expected, tt.value.String())
+	}
+}

sessiondescription.go

@@ -5,10 +5,37 @@ package webrtc
 
 import (
 	"fmt"
+	"slices"
+	"strings"
 
 	"github.com/pion/sdp/v3"
 )
 
+// ICETrickleCapability represents whether the remote endpoint accepts
+// trickled ICE candidates.
+type ICETrickleCapability int
+
+const (
+	// ICETrickleCapabilityUnknown no remote peer has been established.
+	ICETrickleCapabilityUnknown ICETrickleCapability = iota
+	// ICETrickleCapabilitySupported remote peer can accept trickled ICE candidates.
+	ICETrickleCapabilitySupported
+	// ICETrickleCapabilitySupported remote peer didn't state that it can accept trickle ICE candidates.
+	ICETrickleCapabilityUnsupported
+)
+
+// String returns the string representation of ICETrickleCapability.
+func (t ICETrickleCapability) String() string {
+	switch t {
+	case ICETrickleCapabilitySupported:
+		return "supported"
+	case ICETrickleCapabilityUnsupported:
+		return "unsupported"
+	default:
+		return "unknown"
+	}
+}
+
 // SessionDescription is used to expose local and remote session descriptions.
 type SessionDescription struct {
 	Type SDPType `json:"type"`
@@ -28,3 +55,21 @@ func (sd *SessionDescription) Unmarshal() (*sdp.SessionDescription, error) {
 
 	return sd.parsed, nil
 }
+
+func hasICETrickleOption(desc *sdp.SessionDescription) bool {
+	if value, ok := desc.Attribute(sdp.AttrKeyICEOptions); ok && hasTrickleOptionValue(value) {
+		return true
+	}
+
+	for _, media := range desc.MediaDescriptions {
+		if value, ok := media.Attribute(sdp.AttrKeyICEOptions); ok && hasTrickleOptionValue(value) {
+			return true
+		}
+	}
+
+	return false
+}
+
+func hasTrickleOptionValue(value string) bool {
+	return slices.Contains(strings.Fields(value), "trickle")
+}

sessiondescription_test.go

@@ -6,6 +6,7 @@ package webrtc
 import (
 	"encoding/json"
 	"reflect"
+	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -95,3 +96,51 @@ func TestSessionDescription_UnmarshalError(t *testing.T) {
 	_, err := desc.Unmarshal()
 	assert.ErrorIs(t, err, ErrSDPUnmarshalling)
 }
+
+func TestHasICETrickleOption(t *testing.T) {
+	baseSession := strings.Join([]string{
+		"v=0",
+		"o=- 0 0 IN IP4 127.0.0.1",
+		"s=-",
+		"t=0 0",
+	}, "\r\n") + "\r\n"
+
+	baseMedia := strings.Join([]string{
+		"m=audio 9 UDP/TLS/RTP/SAVPF 111",
+		"c=IN IP4 0.0.0.0",
+		"a=mid:0",
+		"a=rtpmap:111 opus/48000/2",
+	}, "\r\n") + "\r\n"
+
+	testCases := []struct {
+		name     string
+		sdp      string
+		expected bool
+	}{
+		{
+			name:     "session level",
+			sdp:      baseSession + "a=ice-options:trickle\r\n" + baseMedia,
+			expected: true,
+		},
+		{
+			name:     "media level",
+			sdp:      baseSession + baseMedia + "a=ice-options:trickle\r\n",
+			expected: true,
+		},
+		{
+			name:     "no trickle",
+			sdp:      baseSession + "a=ice-options:google-ice\r\n" + baseMedia,
+			expected: false,
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			desc := SessionDescription{Type: SDPTypeOffer, SDP: tc.sdp}
+			_, err := desc.Unmarshal()
+			assert.NoError(t, err)
+			assert.Equal(t, tc.expected, hasICETrickleOption(desc.parsed))
+		})
+	}
+}