public void OnConnectionStateChanged(ReceivingPeer peer, RTCPeerConnectionState connectionState)
{
switch (connectionState)
{
case RTCPeerConnectionState.closed:
// TODO
break;
}
}
static void PCOnConnectionStateChange(IntPtr ptr, RTCPeerConnectionState state)
{
WebRTC.Sync(ptr, () =>
{
if (WebRTC.Table[ptr] is RTCPeerConnection connection)
{
connection.OnConnectionStateChange?.Invoke(state);
}
});
}
void OnConnectionStateChange(string connectionId, RTCPeerConnectionState state)
{
switch (state)
{
case RTCPeerConnectionState.Connected:
onConnect?.Invoke(connectionId);
break;
case RTCPeerConnectionState.Disconnected:
onDisconnect?.Invoke(connectionId);
break;
}
}
public override void DidChangeConnectionState(RTCPeerConnection peerConnection, RTCPeerConnectionState newState)
{
_listener?.OnConnectionChange(newState.ToNet());
}
public IEnumerator PeerConnectionStateChange()
{
RTCConfiguration config = default;
config.iceServers = new[] { new RTCIceServer {
urls = new[] { "stun:stun.l.google.com:19302" }
} };
var peer1 = new RTCPeerConnection(ref config);
var peer2 = new RTCPeerConnection(ref config);
RTCPeerConnectionState state1 = default;
RTCPeerConnectionState state2 = default;
RTCIceConnectionState iceState1 = default;
RTCIceConnectionState iceState2 = default;
peer1.OnIceCandidate = candidate => { peer2.AddIceCandidate(candidate); };
peer2.OnIceCandidate = candidate => { peer1.AddIceCandidate(candidate); };
peer1.OnConnectionStateChange = state => { state1 = state; };
peer2.OnConnectionStateChange = state => { state2 = state; };
peer1.OnIceConnectionChange = state => { iceState1 = state; };
peer2.OnIceConnectionChange = state => { iceState2 = state; };
Assert.That(state1, Is.EqualTo(RTCPeerConnectionState.New));
Assert.That(state2, Is.EqualTo(RTCPeerConnectionState.New));
var obj = new GameObject("audio");
var source = obj.AddComponent <AudioSource>();
source.clip = AudioClip.Create("test", 480, 2, 48000, false);
AudioStreamTrack track1 = new AudioStreamTrack(source);
peer1.AddTrack(track1);
var op1 = peer1.CreateOffer();
yield return(op1);
var desc = op1.Desc;
var op2 = peer1.SetLocalDescription(ref desc);
yield return(op2);
var op3 = peer2.SetRemoteDescription(ref desc);
yield return(op3);
var op4 = peer2.CreateAnswer();
yield return(op4);
desc = op4.Desc;
var op5 = peer2.SetLocalDescription(ref desc);
yield return(op5);
var op6 = peer1.SetRemoteDescription(ref desc);
yield return(op6);
var op7 = new WaitUntilWithTimeout(() =>
state1 == RTCPeerConnectionState.Connected &&
state2 == RTCPeerConnectionState.Connected, 5000);
yield return(op7);
Assert.That(op7.IsCompleted, Is.True);
var op8 = new WaitUntilWithTimeout(() =>
(iceState1 == RTCIceConnectionState.Connected || iceState1 == RTCIceConnectionState.Completed) &&
(iceState2 == RTCIceConnectionState.Connected || iceState2 == RTCIceConnectionState.Completed)
, 5000);
yield return(op8);
Assert.That(op8.IsCompleted, Is.True);
peer1.Close();
var op9 = new WaitUntilWithTimeout(() =>
state1 == RTCPeerConnectionState.Closed &&
iceState2 == RTCIceConnectionState.Disconnected, 5000);
yield return(op9);
Assert.That(op9.IsCompleted, Is.True);
track1.Dispose();
peer2.Close();
Object.DestroyImmediate(source.clip);
Object.DestroyImmediate(obj);
}
public static PeerConnectionState ToNativePort(this RTCPeerConnectionState platformNative) => (PeerConnectionState)platformNative;
private async void OnConnectionStateChanged(RTCPeerConnectionState state)
{
if (state == RTCPeerConnectionState.failed)
{
if (!_connectionCompleted)
{
if (!_rolesReversed)
{
Logger.LogInformation("First connection attempt failed. Reversing roles...");
_rolesReversed = true;
_canSendIceCandidates = false;
DisposeConnection();
InitConnection();
if (Role == WebRTCAdapterRole.Accept)
{
try
{
Logger.LogInformation("Creating offer...");
RTCSessionDescriptionInit offer = _connection.createOffer(new RTCOfferOptions());
Logger.LogInformation("Setting local description...");
await _connection.setLocalDescription(offer);
Logger.LogInformation("Sending offer request...");
var response = await _signalingTransporter.SendRequestAsync <WebRTCOfferRequest, WebRTCOfferResponse>(new WebRTCOfferRequest()
{
ChannelName = ChannelName,
Offer = WebRTCSessionDescription.FromSessionDescription(offer)
}, new ResonanceRequestConfig()
{
Timeout = TimeSpan.FromSeconds(10)
});
if (response.Answer.InternalType == RTCSdpType.answer)
{
var result = _connection.setRemoteDescription(response.Answer.ToSessionDescription());
if (result != SetDescriptionResultEnum.OK)
{
throw new Exception("Error setting the remote description.");
}
}
else
{
Logger.LogError($"Invalid answer type received '{response.Answer.InternalType}'.");
}
FlushIceCandidates();
}
catch (Exception ex)
{
FailConnection(ex);
}
}
}
else
{
FailConnection(new Exception("Second connection attempt failed."));
}
}
else
{
OnFailed(new ResonanceWebRTCChannelClosedException("The WebRTC connection has failed."));
}
}
}
public void DidChangeConnectionState(RTCPeerConnection peerConnection, RTCPeerConnectionState newState)
{
Console.WriteLine("ICE+DTLS state changed:{0} ({1})", newState, (int)newState);
}
private async Task <RTCPeerConnection> DoSetup(bool polite, Task <RTCPeerConnection> pcTask)
{
var pc = await pcTask.ConfigureAwait(false);
pc.addTrack(new MediaStreamTrack(
audioSource.GetAudioSourceFormats(),
MediaStreamStatusEnum.SendRecv));
pc.OnAudioFormatsNegotiated += (formats) =>
audioSource.SetAudioSourceFormat(formats[0]);
// audioSink.SetAudioSinkFormat(formats[0]);
audioSource.OnAudioSourceEncodedSample += pc.SendAudio;
pc.onconnectionstatechange += (state) =>
{
mainThreadActions.Enqueue(() =>
{
peerConnectionState = state;
OnPeerConnectionStateChanged.Invoke(state);
Debug.Log($"Peer connection state change to {state}.");
});
if (state == RTCPeerConnectionState.connected)
{
// audioSource.OnAudioSourceEncodedSample += pc.SendAudio;
}
else if (state == RTCPeerConnectionState.closed || state == RTCPeerConnectionState.failed)
{
// audioSource.OnAudioSourceEncodedSample -= pc.SendAudio;
}
};
pc.onicecandidate += (iceCandidate) =>
{
if (pc.signalingState == RTCSignalingState.have_remote_offer ||
pc.signalingState == RTCSignalingState.stable)
{
mainThreadActions.Enqueue(() => Send("IceCandidate", iceCandidate.toJSON()));
}
};
pc.OnRtpPacketReceived += (IPEndPoint rep, SDPMediaTypesEnum media, RTPPacket rtpPkt) =>
{
if (media == SDPMediaTypesEnum.audio)
{
audioSink.GotAudioRtp(rep, rtpPkt.Header.SyncSource, rtpPkt.Header.SequenceNumber, rtpPkt.Header.Timestamp, rtpPkt.Header.PayloadType, rtpPkt.Header.MarkerBit == 1, rtpPkt.Payload);
}
};
// Diagnostics.
pc.OnReceiveReport += (re, media, rr) => mainThreadActions.Enqueue(
() => Debug.Log($"RTCP Receive for {media} from {re}\n{rr.GetDebugSummary()}"));
pc.OnSendReport += (media, sr) => mainThreadActions.Enqueue(
() => Debug.Log($"RTCP Send for {media}\n{sr.GetDebugSummary()}"));
pc.GetRtpChannel().OnStunMessageReceived += (msg, ep, isRelay) => mainThreadActions.Enqueue(
() => Debug.Log($"STUN {msg.Header.MessageType} received from {ep}."));
pc.oniceconnectionstatechange += (state) => mainThreadActions.Enqueue(() =>
{
iceConnectionState = state;
OnIceConnectionStateChanged.Invoke(state);
Debug.Log($"ICE connection state change to {state}.");
});
if (!polite)
{
var offer = pc.createOffer();
await pc.setLocalDescription(offer).ConfigureAwait(false);
mainThreadActions.Enqueue(() => Send("Offer", offer.toJSON()));
}
return(pc);
}
public static PeerConnectionState ToNet(this RTCPeerConnectionState self)
{
return((PeerConnectionState)self);
}
public IEnumerator PeerConnectionStateChange()
{
RTCConfiguration config = default;
config.iceServers = new[] { new RTCIceServer {
urls = new[] { "stun:stun.l.google.com:19302" }
} };
var peer1 = new RTCPeerConnection(ref config);
var peer2 = new RTCPeerConnection(ref config);
RTCPeerConnectionState state1 = default;
RTCPeerConnectionState state2 = default;
RTCIceConnectionState iceState1 = default;
RTCIceConnectionState iceState2 = default;
peer1.OnIceCandidate = candidate => { peer2.AddIceCandidate(candidate); };
peer2.OnIceCandidate = candidate => { peer1.AddIceCandidate(candidate); };
peer1.OnConnectionStateChange = state => { state1 = state; };
peer2.OnConnectionStateChange = state => { state2 = state; };
peer1.OnIceConnectionChange = state => { iceState1 = state; };
peer2.OnIceConnectionChange = state => { iceState2 = state; };
Assert.That(state1, Is.EqualTo(RTCPeerConnectionState.New));
Assert.That(state2, Is.EqualTo(RTCPeerConnectionState.New));
MediaStream stream = Audio.CaptureStream();
peer1.AddTrack(stream.GetTracks().First());
var op1 = peer1.CreateOffer();
yield return(op1);
var desc = op1.Desc;
var op2 = peer1.SetLocalDescription(ref desc);
yield return(op2);
var op3 = peer2.SetRemoteDescription(ref desc);
yield return(op3);
var op4 = peer2.CreateAnswer();
yield return(op4);
desc = op4.Desc;
var op5 = peer2.SetLocalDescription(ref desc);
yield return(op5);
var op6 = peer1.SetRemoteDescription(ref desc);
yield return(op6);
var op7 = new WaitUntilWithTimeout(() =>
state1 == RTCPeerConnectionState.Connected &&
state2 == RTCPeerConnectionState.Connected, 5000);
yield return(op7);
Assert.That(op7.IsCompleted, Is.True);
var op8 = new WaitUntilWithTimeout(() =>
(iceState1 == RTCIceConnectionState.Connected || iceState1 == RTCIceConnectionState.Completed) &&
(iceState2 == RTCIceConnectionState.Connected || iceState2 == RTCIceConnectionState.Completed)
, 5000);
yield return(op8);
Assert.That(op8.IsCompleted, Is.True);
peer1.Close();
var op9 = new WaitUntilWithTimeout(() =>
state1 == RTCPeerConnectionState.Closed &&
iceState2 == RTCIceConnectionState.Disconnected, 5000);
yield return(op9);
Assert.That(op9.IsCompleted, Is.True);
stream.Dispose();
peer2.Close();
}
