public IEnumerator OnOffer()
{
bool startRaised1 = false;
bool startRaised2 = false;
bool offerRaised = false;
bool raiseOnDestroy1 = false;
bool raiseOnDestroy2 = false;
string connectionId1 = null;
string connectionId2 = null;
const string _connectionId = "12345";
signaling1.OnStart += s => { startRaised1 = true; };
signaling2.OnStart += s => { startRaised2 = true; };
signaling1.Start();
signaling2.Start();
yield return(new WaitUntil(() => startRaised1 && startRaised2));
signaling1.OnCreateConnection += (s, connectionId, polite) => {
connectionId1 = connectionId;
};
signaling1.OnDestroyConnection += (signaling, id) =>
{
raiseOnDestroy1 = id == connectionId1;
};
signaling1.OpenConnection(_connectionId);
signaling2.OnCreateConnection += (s, connectionId, polite) => {
connectionId2 = connectionId;
};
signaling1.OnDestroyConnection += (signaling, id) =>
{
raiseOnDestroy2 = id == connectionId2;
};
signaling2.OpenConnection(_connectionId);
yield return(new WaitUntil(() =>
!string.IsNullOrEmpty(connectionId1) && !string.IsNullOrEmpty(connectionId2)));
Assert.That(connectionId1, Is.EqualTo(_connectionId));
Assert.That(connectionId2, Is.EqualTo(_connectionId));
signaling2.OnOffer += (s, e) => { offerRaised = true; };
signaling1.SendOffer(connectionId1, m_DescOffer);
yield return(new WaitUntil(() => offerRaised));
signaling1.CloseConnection(connectionId1);
yield return(new WaitUntil(() => raiseOnDestroy1 && raiseOnDestroy2));
Assert.That(raiseOnDestroy1, Is.True);
Assert.That(raiseOnDestroy2, Is.True);
}
public void OnConnect()
{
bool startRaised1 = false;
string connectionId1 = null;
signaling1.Start();
signaling1.OnStart += s => { startRaised1 = true; };
Assert.True(Wait(() => startRaised1));
signaling1.OnCreateConnection += (s, connectionId) => { connectionId1 = connectionId; };
signaling1.CreateConnection();
Assert.True(Wait(() => !string.IsNullOrEmpty(connectionId1)));
Assert.IsNotEmpty(connectionId1);
}
public IEnumerator OnConnect()
{
bool startRaised1 = false;
string connectionId1 = null;
signaling1.OnStart += s => { startRaised1 = true; };
signaling1.Start();
yield return(new WaitUntil(() => startRaised1));
signaling1.OnCreateConnection += (s, connectionId) => { connectionId1 = connectionId; };
signaling1.CreateConnection();
yield return(new WaitUntil(() => !string.IsNullOrEmpty(connectionId1)));
Assert.IsNotEmpty(connectionId1);
}
/// <summary>
///
/// </summary>
/// <param name="dependencies"></param>
public RenderStreamingInternal(ref RenderStreamingDependencies dependencies)
{
if (dependencies.signaling == null)
{
throw new ArgumentException("Signaling instance is null.");
}
if (dependencies.startCoroutine == null)
{
throw new ArgumentException("Coroutine action instance is null.");
}
if (s_list.Count == 0)
{
WebRTC.WebRTC.Initialize(dependencies.encoderType);
}
_config = dependencies.config;
_startCoroutine = dependencies.startCoroutine;
_signaling = dependencies.signaling;
_signaling.OnStart += OnStart;
_signaling.OnCreateConnection += OnCreateConnection;
_signaling.OnDestroyConnection += OnDestroyConnection;
_signaling.OnOffer += OnOffer;
_signaling.OnAnswer += OnAnswer;
_signaling.OnIceCandidate += OnIceCandidate;
_signaling.Start();
s_list.Add(this);
_startCoroutine(WebRTC.WebRTC.Update());
}
public IEnumerator CheckPeerExists()
{
bool startRaised1 = false;
bool startRaised2 = false;
signaling1.OnStart += s => { startRaised1 = true; };
signaling1.Start();
signaling2.OnStart += s => { startRaised2 = true; };
signaling2.Start();
yield return(new WaitUntil(() => startRaised1 && startRaised2));
const string connectionId = "12345";
string receiveConnectionId1 = null;
string receiveConnectionId2 = null;
bool receivePeerExists1 = false;
bool receivePeerExists2 = false;
signaling1.OnCreateConnection += (s, id, peerExists) =>
{
receiveConnectionId1 = id;
receivePeerExists1 = peerExists;
};
signaling1.OpenConnection(connectionId);
yield return(new WaitUntil(() => !string.IsNullOrEmpty(receiveConnectionId1)));
Assert.AreEqual(connectionId, receiveConnectionId1);
Assert.IsFalse(receivePeerExists1);
signaling2.OnCreateConnection += (s, id, peerExists) =>
{
receiveConnectionId2 = id;
receivePeerExists2 = peerExists;
};
signaling2.OpenConnection(connectionId);
yield return(new WaitUntil(() => !string.IsNullOrEmpty(receiveConnectionId2)));
Assert.AreEqual(connectionId, receiveConnectionId2);
Assert.IsTrue(receivePeerExists2);
signaling1.CloseConnection(receiveConnectionId1);
signaling2.CloseConnection(receiveConnectionId2);
signaling1.Stop();
signaling2.Stop();
yield return(new WaitForSeconds(1));
}
public IEnumerator OnOffer()
{
bool startRaised1 = false;
bool startRaised2 = false;
bool offerRaised = false;
string connectionId1 = null;
signaling1.OnStart += s => { startRaised1 = true; };
signaling2.OnStart += s => { startRaised2 = true; };
signaling1.Start();
signaling2.Start();
yield return(new WaitUntil(() => startRaised1 && startRaised2));
signaling1.OnCreateConnection += (s, connectionId) => { connectionId1 = connectionId; };
signaling1.CreateConnection();
yield return(new WaitUntil(() => !string.IsNullOrEmpty(connectionId1)));
signaling2.OnOffer += (s, e) => { offerRaised = true; };
signaling1.SendOffer(connectionId1, m_DescOffer);
yield return(new WaitUntil(() => offerRaised));
}
public void OnOffer()
{
bool startRaised1 = false;
bool startRaised2 = false;
bool offerRaised = false;
string connectionId1 = null;
signaling1.Start();
signaling2.Start();
signaling1.OnStart += s => { startRaised1 = true; };
signaling2.OnStart += s => { startRaised2 = true; };
Assert.True(Wait(() => startRaised1 && startRaised2));
signaling1.OnCreateConnection += (s, connectionId) => { connectionId1 = connectionId; };
signaling1.CreateConnection();
Assert.True(Wait(() => !string.IsNullOrEmpty(connectionId1)));
signaling2.OnOffer += (s, e) => { offerRaised = true; };
signaling1.SendOffer(connectionId1, m_DescOffer);
Assert.True(Wait(() => offerRaised));
}
public IEnumerator OnOffer()
{
bool startRaised1 = false;
bool startRaised2 = false;
bool offerRaised = false;
bool peerExists1 = false;
bool peerExists2 = false;
string connectionId1 = null;
string connectionId2 = null;
const string _connectionId = "12345";
signaling1.OnStart += s => { startRaised1 = true; };
signaling2.OnStart += s => { startRaised2 = true; };
signaling1.Start();
signaling2.Start();
yield return(new WaitUntil(() => startRaised1 && startRaised2));
signaling1.OnCreateConnection += (s, connectionId, peerExists) => {
connectionId1 = connectionId;
peerExists1 = peerExists;
};
signaling1.OpenConnection(_connectionId);
signaling2.OnCreateConnection += (s, connectionId, peerExists) => {
connectionId2 = connectionId;
peerExists2 = peerExists;
};
signaling2.OpenConnection(_connectionId);
yield return(new WaitUntil(() =>
!string.IsNullOrEmpty(connectionId1) && !string.IsNullOrEmpty(connectionId2)));
Assert.That(connectionId1, Is.EqualTo(_connectionId));
Assert.That(connectionId2, Is.EqualTo(_connectionId));
Assert.That(peerExists1, Is.False);
Assert.That(peerExists2, Is.False);
signaling2.OnOffer += (s, e) => { offerRaised = true; };
signaling1.SendOffer(connectionId1, m_DescOffer);
yield return(new WaitUntil(() => offerRaised));
}
public IEnumerator OnConnect()
{
bool startRaised1 = false;
bool startRaised2 = false;
signaling1.OnStart += s => { startRaised1 = true; };
signaling1.Start();
signaling2.OnStart += s => { startRaised2 = true; };
signaling2.Start();
yield return(new WaitUntil(() => startRaised1 && startRaised2));
const string connectionId = "12345";
string receiveConnectionId1 = null;
string receiveConnectionId2 = null;
bool receivePolite1 = false;
bool receivePolite2 = false;
bool raiseOnDestroy1 = false;
bool raiseOnDestroy2 = false;
signaling1.OnCreateConnection += (s, id, polite) =>
{
receiveConnectionId1 = id;
receivePolite1 = polite;
};
signaling1.OnDestroyConnection += (signaling, id) =>
{
raiseOnDestroy1 = id == receiveConnectionId1;
};
signaling1.OpenConnection(connectionId);
yield return(new WaitUntil(() => !string.IsNullOrEmpty(receiveConnectionId1)));
signaling2.OnCreateConnection += (s, id, polite) =>
{
receiveConnectionId2 = id;
receivePolite2 = polite;
};
signaling2.OnDestroyConnection += (signaling, id) =>
{
raiseOnDestroy2 = id == receiveConnectionId2;
};
signaling2.OpenConnection(connectionId);
yield return(new WaitUntil(() => !string.IsNullOrEmpty(receiveConnectionId2)));
Assert.That(receiveConnectionId1, Is.EqualTo(connectionId));
Assert.That(receiveConnectionId2, Is.EqualTo(connectionId));
Assert.That(receivePolite1, Is.False);
Assert.That(receivePolite2, Is.True);
// wait first connection list on http
yield return(new WaitForSeconds(1));
signaling1.CloseConnection(receiveConnectionId1);
yield return(new WaitUntil(() => raiseOnDestroy1 && raiseOnDestroy2));
Assert.That(raiseOnDestroy1, Is.True);
Assert.That(raiseOnDestroy2, Is.True);
signaling2.CloseConnection(receiveConnectionId2);
signaling1.Stop();
signaling2.Stop();
yield return(new WaitForSeconds(1));
}