webrtc/peerconnection_observer.go at master · fd/webrtc · GitHub

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
157
158
159
160
161
162
163
164
165
166
167
168
169
package webrtc

/*
#include "wrapper.h"
#include "data_channel.h"
#include "ref.h"
*/
import "C"

import (
	"runtime"
	"unsafe"
)

type PeerConnectionObserver interface {
	OnError()
	OnSignalingChange(state SignalingState)
	OnAddStream()
	OnRemoveStream()
	OnDataChannel(dataChannel *DataChannel)
	OnRenegotiationNeeded()
	OnIceConnectionChange(state IceConnectionState)
	OnIceGatheringChange(state IceGatheringState)
	OnIceCandidate(candidate *IceCandidate)
}

type SignalingState uint8

const (
	SignalingStable SignalingState = iota
	SignalingHaveLocalOffer
	SignalingHaveLocalPrAnswer
	SignalingHaveRemoteOffer
	SignalingHaveRemotePrAnswer
	SignalingClosed
)

var signalingStateStrings = map[SignalingState]string{
	SignalingStable:             "stable",
	SignalingHaveLocalOffer:     "have-local-offer",
	SignalingHaveLocalPrAnswer:  "have-local-pranswer",
	SignalingHaveRemoteOffer:    "have-remote-offer",
	SignalingHaveRemotePrAnswer: "have-remote-pranswer",
	SignalingClosed:             "closed",
}

func (s SignalingState) String() string {
	return signalingStateStrings[s]
}

type IceGatheringState uint8

const (
	IceGatheringNew IceGatheringState = iota
	IceGatheringGathering
	IceGatheringComplete
)

var iceGatheringStateStrings = map[IceGatheringState]string{
	IceGatheringNew:       "new",
	IceGatheringGathering: "gathering",
	IceGatheringComplete:  "complete",
}

func (s IceGatheringState) String() string {
	return iceGatheringStateStrings[s]
}

type IceConnectionState uint8

const (
	IceConnectionNew IceConnectionState = iota
	IceConnectionChecking
	IceConnectionConnected
	IceConnectionCompleted
	IceConnectionFailed
	IceConnectionDisconnected
	IceConnectionClosed
)

var iceConnectionStateStrings = map[IceConnectionState]string{
	IceConnectionNew:          "new",
	IceConnectionChecking:     "checking",
	IceConnectionConnected:    "connected",
	IceConnectionCompleted:    "completed",
	IceConnectionFailed:       "failed",
	IceConnectionDisconnected: "disconnected",
	IceConnectionClosed:       "closed",
}

func (s IceConnectionState) String() string {
	return iceConnectionStateStrings[s]
}

//export c_RTCPeerConnectionObserver_OnError
func c_RTCPeerConnectionObserver_OnError(ref C.Ref) {
	observer, ok := resolve(ref).(PeerConnectionObserver)
	if ok && observer != nil {
		observer.OnError()
	}
}

//export c_RTCPeerConnectionObserver_OnSignalingChange
func c_RTCPeerConnectionObserver_OnSignalingChange(ref C.Ref, s C.int) {
	observer, ok := resolve(ref).(PeerConnectionObserver)
	if ok && observer != nil {
		observer.OnSignalingChange(SignalingState(s))
	}
}

//export c_RTCPeerConnectionObserver_OnAddStream
func c_RTCPeerConnectionObserver_OnAddStream(ref C.Ref) {
	observer, ok := resolve(ref).(PeerConnectionObserver)
	if ok && observer != nil {
		observer.OnAddStream()
	}
}

//export c_RTCPeerConnectionObserver_OnRemoveStream
func c_RTCPeerConnectionObserver_OnRemoveStream(ref C.Ref) {
	observer, ok := resolve(ref).(PeerConnectionObserver)
	if ok && observer != nil {
		observer.OnRemoveStream()
	}
}

//export c_RTCPeerConnectionObserver_OnDataChannel
func c_RTCPeerConnectionObserver_OnDataChannel(ref C.Ref, ptr unsafe.Pointer) {
	observer, ok := resolve(ref).(PeerConnectionObserver)
	if ok && observer != nil {
		outer := &DataChannel{ptr: ptr}
		C.c_DataChannel_Accept(ptr, register(outer))
		runtime.SetFinalizer(outer, (*DataChannel).free)

		observer.OnDataChannel(outer)
	}
}

//export c_RTCPeerConnectionObserver_OnRenegotiationNeeded
func c_RTCPeerConnectionObserver_OnRenegotiationNeeded(ref C.Ref) {
	observer, ok := resolve(ref).(PeerConnectionObserver)
	if ok && observer != nil {
		observer.OnRenegotiationNeeded()
	}
}

//export c_RTCPeerConnectionObserver_OnIceConnectionChange
func c_RTCPeerConnectionObserver_OnIceConnectionChange(ref C.Ref, state C.int) {
	observer, ok := resolve(ref).(PeerConnectionObserver)
	if ok && observer != nil {
		observer.OnIceConnectionChange(IceConnectionState(state))
	}
}

//export c_RTCPeerConnectionObserver_OnIceGatheringChange
func c_RTCPeerConnectionObserver_OnIceGatheringChange(ref C.Ref, state C.int) {
	observer, ok := resolve(ref).(PeerConnectionObserver)
	if ok && observer != nil {
		observer.OnIceGatheringChange(IceGatheringState(state))
	}
}

//export c_RTCPeerConnectionObserver_OnIceCandidate
func c_RTCPeerConnectionObserver_OnIceCandidate(ref C.Ref, candidate unsafe.Pointer) {
	observer, ok := resolve(ref).(PeerConnectionObserver)
	if ok && observer != nil && candidate != nil {
		observer.OnIceCandidate((*IceCandidate)(candidate))
	}
}