public async Task CreateTurnClient()
{
var turnUri = new Uri(
Environment.GetEnvironmentVariable(
FactOnlyTurnAvailableAttribute.TurnUrlVarName));
var userInfo = turnUri.UserInfo.Split(':');
await Assert.ThrowsAsync <ArgumentException>(
async() =>
{
await IceServer.CreateTurnClient(
new[] { new IceServer(new[] { "stun://stun.l.google.com:19302" }) }
);
}
);
var servers = new List <IceServer>()
{
new IceServer(new[] { "turn://turn.does-not-exists.org" }),
};
await Assert.ThrowsAsync <IceServerException>(
async() => { await IceServer.CreateTurnClient(servers); });
servers.Add(new IceServer(new[] { turnUri }, userInfo[0], userInfo[1]));
var turnClient = await IceServer.CreateTurnClient(servers);
Assert.Equal(userInfo[0], turnClient.Username);
Assert.Equal(userInfo[1], turnClient.Password);
}
public IceServerViewModel(IceServer iceServer)
{
IceServer = iceServer;
Url = iceServer.Url;
Username = iceServer.Username;
Password = iceServer.Password;
}
public static void AddDefaultIceServersList(WebRtcAdapter.Call.Call call)
{
if (_localSettings.DeserializeIceServersList() == null ||
!(_localSettings.DeserializeIceServersList()).Any())
{
List <IceServer> iceServersList = new List <IceServer>();
ObservableCollection <IceServerModel> iceServerModelList = new ObservableCollection <IceServerModel>();
foreach (IceServer iceServer in AddDefaultIceServers)
{
IceServerModel iceServerModel = new IceServerModel();
iceServerModel.Urls = iceServer.Urls;
iceServerModel.Username = iceServer.Username;
iceServerModel.Credential = iceServer.Credential;
iceServerModelList.Add(iceServerModel);
}
_localSettings.SerializeIceServersList(iceServerModelList);
foreach (var ice in iceServerModelList)
{
IceServer iceServer = new IceServer();
iceServer.Urls = ice.Urls;
iceServer.Username = ice.Username;
iceServer.Credential = ice.Credential;
iceServersList.Add(iceServer);
}
call.AddIceServers(iceServersList);
call.SetIceServers(iceServersList);
}
else
{
List <IceServer> iceServersList = new List <IceServer>();
ObservableCollection <IceServerModel> iceServerModelList = _localSettings.DeserializeIceServersList();
foreach (var ice in iceServerModelList)
{
IceServer iceServer = new IceServer();
iceServer.Urls = ice.Urls;
iceServer.Username = ice.Username;
iceServer.Credential = ice.Credential;
iceServersList.Add(iceServer);
}
call.AddIceServers(iceServersList);
call.SetIceServers(iceServersList);
}
}
/// <summary>
/// Factory method used to create a new IceServer object.
/// </summary>
/// <param name="uri">The uri of the ice server.</param>
/// <param name="userName">The username to log into the ice server.</param>
/// <param name="password">The password to log into the ice server.</param>
/// <returns>An ice candidate object with the given handle.</returns>
public static IceServer Create(string uri, string userName = null, string password = null)
{
IceServer iceServer = new IceServer()
{
Uri = uri,
UserName = userName,
Password = password,
};
return(iceServer);
}
public IceServerViewModel(IceServer iceServer)
{
if (iceServer == null)
{
throw new ArgumentNullException();
}
IceServer = iceServer;
Url = iceServer.Url;
Username = iceServer.Username;
Password = iceServer.Password;
}
public static PeerConnection.IceServer ToNative(this IceServer self)
{
var builder = PeerConnection.IceServer.InvokeBuilder(self.Urls)
.SetTlsCertPolicy(self.TlsCertPolicy.ToNative());
if (!string.IsNullOrEmpty(self.Username))
{
builder.SetUsername(self.Username)
.SetPassword(self.Password);
}
return(builder.CreateIceServer());
}
private static IEnumerable <IceServer> LoadFromConfigAllTURN()
{
Regex turn_regex = new Regex(@"[T,t][u, U][r, R][n, N]");
// Adding all turn servers. To use turn servers you should
// add to WebRTC_Remote_FPGA_stand.dll.config
// TurnPassword and UserName
return(ConfigurationManager.AppSettings.AllKeys.Where((key) => turn_regex.IsMatch(key)).Select((key) => {
IceServer turnServer = new IceServer();
string Value = ConfigurationManager.AppSettings.Get(key);
turnServer.Urls.Add(ReadTurnParametr(Value, "Url"));
turnServer.TurnUserName = ReadTurnParametr(Value, "UserName");
turnServer.TurnPassword = ReadTurnParametr(Value, "Password");
return turnServer;
}));
}
public async Task CreateTurnClient()
{
var turnUri = FactOnlyTurnAvailableAttribute.GetTurnUri();
var userInfo = turnUri.UserInfo.Split(':');
await Assert.ThrowsAsync <ArgumentException>(
async() =>
{
await IceServer.CreateTurnClient(
new[] { new IceServer(new[] { "stun://stun.l.google.com:19302" }) }
);
}
);
var servers = new List <IceServer>()
{
new IceServer(new[] { "turn://turn.does-not-exists.org" }),
};
await Assert.ThrowsAsync <IceServerException>(
async() => { await IceServer.CreateTurnClient(servers); });
servers.Add(new IceServer(new[] { turnUri }, userInfo[0], userInfo[1]));
for (int i = 3; i > 0; i--)
{
TurnClient turnClient;
try
{
turnClient = await IceServer.CreateTurnClient(servers);
}
catch (IceServerException)
{
// Try up to 3 times, as the servers are not well operational.
if (i > 1)
{
await Task.Delay(1000);
continue;
}
throw;
}
Assert.Equal(userInfo[0], turnClient.Username);
Assert.Equal(userInfo[1], turnClient.Password);
}
}
public static bool IsCompatible(this ScanTestScenario scenario, IceServer iceServer)
{
if (scenario == ScanTestScenario.Stun)
{
return(iceServer.IsStun);
}
if (scenario == ScanTestScenario.TurnUdp)
{
return(iceServer.IsTurn && iceServer.IsUdp);
}
if (scenario == ScanTestScenario.TurnTcp)
{
return(iceServer.IsTurn && iceServer.IsTcp && !iceServer.IsSecure);
}
if (scenario == ScanTestScenario.Turns)
{
return(iceServer.IsTurn && iceServer.IsTcp && iceServer.IsSecure);
}
return(false);
}
public static IReadOnlyList <IceServer> GetIceServers()
{
var list = new IceServer[_iceServers.Length];
Array.Copy(_iceServers, list, list.Length);
// Fisher–Yates shuffle
int n = list.Length;
while (n > 1)
{
n--;
int k = _random.Next(n + 1);
IceServer value = list[k];
list[k] = list[n];
list[n] = value;
}
return(list);
}
public static PeerConnectionConfiguration GetPeerConnectionConfiguration(CommunicationRelayConfiguration relayConfiguration)
{
IReadOnlyList <CommunicationIceServer> iceServers = (IReadOnlyList <CommunicationIceServer>)relayConfiguration.IceServers;
var webRTCIceServers = new List <IceServer>();
foreach (CommunicationIceServer iceServer in iceServers)
{
var webRTCIceServer = new IceServer();
webRTCIceServer.Urls = (List <string>)iceServer.Urls;
webRTCIceServer.TurnUserName = iceServer.Username;
webRTCIceServer.TurnPassword = iceServer.Credential;
webRTCIceServers.Add(webRTCIceServer);
}
PeerConnectionConfiguration configuration = new PeerConnectionConfiguration();
configuration.IceServers = webRTCIceServers;
return(configuration);
}
private void AddDefaultIceServersList()
{
if (_localSettings.DeserializeIceServersList() == null ||
!(_localSettings.DeserializeIceServersList()).Any())
{
ObservableCollection <IceServerModel> iceServersList = new ObservableCollection <IceServerModel>();
foreach (IceServer iceServer in DefaultSettings.AddDefaultIceServers)
{
IceServerModel iceServerModel = new IceServerModel();
iceServerModel.Urls = iceServer.Urls;
iceServerModel.Username = iceServer.Username;
iceServerModel.Credential = iceServer.Credential;
iceServersList.Add(iceServerModel);
}
_localSettings.SerializeIceServersList(iceServersList);
}
else
{
List <IceServer> iceServersList = new List <IceServer>();
ObservableCollection <IceServerModel> list = _localSettings.DeserializeIceServersList();
foreach (var ice in list)
{
IceServer iceServer = new IceServer();
iceServer.Urls = ice.Urls;
iceServer.Username = ice.Username;
iceServer.Credential = ice.Credential;
iceServersList.Add(iceServer);
}
_call.AddIceServers(iceServersList);
_call.SetIceServers(iceServersList);
}
}
public MainWindow()
{
InitializeComponent();
messages = new List <string>();
textBoxServerArgs.Text = "SimpleMessenger: default -h localhost -p 5050 -t 5000";
buttonStartServer.IsEnabled = true;
buttonStopServer.IsEnabled = false;
buttonRestartServer.IsEnabled = false;
textBoxClientArgs.Text = "SimpleMessenger: default -h localhost -p 5050 -t 2000";
buttonStartClient.IsEnabled = true;
buttonIdleClient.IsEnabled = false;
buttonStopClient.IsEnabled = false;
buttonRestartClient.IsEnabled = false;
textBoxServerRestartInterval.Text = "1000";
textBoxClientRestartInterval.Text = "1000";
textBoxContentSize.Text = "2";
checkBoxAsync.IsChecked = false;
buttonClearLogs.IsEnabled = false;
buttonExportLogs.IsEnabled = false;
textBoxContentSize.IsEnabled = false;
iceServer = new IceServer();
iceClient = new IceClient();
iceServer.OnStatusChanged += IceServer_OnStatusChanged;
iceServer.OnMethodInvoked += IceServer_OnMethodInvoked;
iceServer.OnExceptionOccured += IceServer_OnExceptionOccured;
iceClient.OnStatusChanged += IceClient_OnStatusChanged;
iceClient.OnMethodInvoked += IceClient_OnMethodInvoked;
iceClient.OnExceptionOccured += IceClient_OnExceptionOccured;
IceServer_OnStatusChanged(iceServer.Status);
IceClient_OnStatusChanged(iceClient.Status);
if (App.IsNewInstance)
{
groupServer.Visibility = Visibility.Hidden;
Title += " [Client ONLY]";
}
}
private void BtnRestartServer_Click(object sender, RoutedEventArgs e)
{
buttonRestartServer.IsEnabled = false;
buttonStartServer.IsEnabled = false;
buttonStopServer.IsEnabled = false;
AddMessage("User Restart Server: " + serverArgs);
Task.Run(delegate
{
iceServer.OnStatusChanged -= IceServer_OnStatusChanged;
iceServer.OnExceptionOccured -= IceServer_OnExceptionOccured;
iceServer.OnMethodInvoked -= IceServer_OnMethodInvoked;
iceServer.Exit();
Thread.Sleep(serverRestartIntervalMS);
iceServer = new IceServer();
iceServer.OnStatusChanged += IceServer_OnStatusChanged;
iceServer.OnExceptionOccured += IceServer_OnExceptionOccured;
iceServer.OnMethodInvoked += IceServer_OnMethodInvoked;
Application.Current.Dispatcher.Invoke(delegate
{
buttonStopServer.IsEnabled = true;
buttonRestartServer.IsEnabled = true;
});
var acmClose = Bundle.ACMCloseFlag.CloseOff;
var acmHeartbeat = Bundle.ACMHeartbeatFlag.HeartbeatOff;
App.Current.Dispatcher.Invoke(() =>
{
Enum.TryParse("Close" + cbServerClose.Text, out acmClose);
Enum.TryParse("Heartbeat" + cbServerHeartbeat.Text, out acmHeartbeat);
});
Thread.Sleep(1);
Task.Run(() =>
{
iceServer.Start(serverArgs, acmClose, acmHeartbeat);
});
});
}
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Logger log = Logger.Instance;
IceServer server = new IceServer();
server.StartServer();
try
{
ClientController ctrl = new ClientController(server);
Application.Run(new MainForm(ctrl));
}
catch (Exception ex)
{
log.Error("Failed to start the program: " + ex.ToString());
}
server.StopServer();
log.Close();
}
public void RemoveIceServer(IceServer server)
{
_iceServersList.Remove(server);
}
public void AddIceServer(IceServer server)
{
_iceServersList.Add(server);
}
async Task LoadSettings()
{
// Default values:
var configTraceServerIp = new ValidableNonEmptyString("127.0.0.1");
StorageFile configFile = await StorageFile.GetFileFromApplicationUriAsync(
new Uri(_configFilePath))
.AsTask()
.ConfigureAwait(false);
string content = await FileIO.ReadTextAsync(configFile)
.AsTask()
.ConfigureAwait(false);
JsonValue json = JsonValue.Parse(content);
// Parses server info.
_server = json.GetObject().GetNamedString("server");
int startId = 0;
if (_server.StartsWith("http://"))
{
startId = 7;
}
else if (_server.StartsWith("https://"))
{
startId = 8;
// TODO: Supports SSL
}
_server = _server.Substring(startId);
_port = new ValidableIntegerString(
(int)json.GetObject().GetNamedNumber("port"), 0, 65535);
_heartbeat = new ValidableIntegerString(
(int)json.GetObject().GetNamedNumber("heartbeat"), 0, 65535);
var configIceServers = new ObservableCollection <IceServer>();
// Parses turn server.
if (json.GetObject().ContainsKey("turnServer"))
{
JsonValue turnServer = json.GetObject().GetNamedValue("turnServer");
string uri = turnServer.GetObject().GetNamedString("uri");
IceServer iceServer = new IceServer(
uri.Substring(uri.IndexOf("turn:") + 5),
IceServer.ServerType.TURN);
iceServer.Credential = turnServer.GetObject().GetNamedString("username");
iceServer.Username = turnServer.GetObject().GetNamedString("password");
configIceServers.Add(iceServer);
}
// Parses stun server.
if (json.GetObject().ContainsKey("stunServer"))
{
JsonValue stunServer = json.GetObject().GetNamedValue("stunServer");
string uri = stunServer.GetObject().GetNamedString("uri");
IceServer iceServer = new IceServer(
uri.Substring(uri.IndexOf("stun:") + 5),
IceServer.ServerType.STUN);
iceServer.Credential = stunServer.GetObject().GetNamedString("username");
iceServer.Username = stunServer.GetObject().GetNamedString("password");
configIceServers.Add(iceServer);
}
// Default ones.
configIceServers.Add(new IceServer("stun.l.google.com:19302", IceServer.ServerType.STUN));
configIceServers.Add(new IceServer("stun1.l.google.com:19302", IceServer.ServerType.STUN));
configIceServers.Add(new IceServer("stun2.l.google.com:19302", IceServer.ServerType.STUN));
configIceServers.Add(new IceServer("stun3.l.google.com:19302", IceServer.ServerType.STUN));
configIceServers.Add(new IceServer("stun4.l.google.com:19302", IceServer.ServerType.STUN));
Conductor.Instance.ConfigureIceServers(configIceServers);
var ntpServerAddress = new ValidableNonEmptyString("time.windows.com");
RunOnUiThread(() =>
{
IceServers = configIceServers;
NtpServer = ntpServerAddress;
NtpServer = ntpServerAddress;
Port = _port;
Ip = new ValidableNonEmptyString(_server);
HeartBeat = _heartbeat;
ReevaluateHasServer();
});
Conductor.Instance.ConfigureIceServers(configIceServers);
}
public async Task <string> InitiateCallRTC()
{
var list = new List <string>();
list.Add(this.Configuration.GetSection("Key")["iceServer"]);
AudioTrackSource microphoneSource = null;
LocalAudioTrack localAudioTrack = null;
Transceiver audioTransceiver = null;
var iceServer = new IceServer
{
Urls = list,
TurnPassword = this.Configuration.GetSection("Key")["turnPwd"],
TurnUserName = this.Configuration.GetSection("Key")["turnUser"]
};
var serverList = new List <IceServer>();
serverList.Add(iceServer);
var connectionConfig = new PeerConnectionConfiguration {
IceServers = serverList,
IceTransportType = IceTransportType.All,
BundlePolicy = BundlePolicy.Balanced,
SdpSemantic = SdpSemantic.UnifiedPlan
};
var connection = new PeerConnection();
await connection.InitializeAsync(connectionConfig);
microphoneSource = await DeviceAudioTrackSource.CreateAsync();
var audioTrackConfig = new LocalAudioTrackInitConfig
{
trackName = "microphone_track"
};
localAudioTrack = LocalAudioTrack.CreateFromSource(microphoneSource, audioTrackConfig);
audioTransceiver = connection.AddTransceiver(MediaKind.Audio);
audioTransceiver.LocalAudioTrack = localAudioTrack;
audioTransceiver.DesiredDirection = Transceiver.Direction.SendReceive;
var signaler = new NamedPipeSignaler.NamedPipeSignaler(connection, "testpipe");
connection.Connected += () => {
Console.WriteLine("PeerConnection: connected.");
};
signaler.SdpMessageReceived += async(SdpMessage message) =>
{
// Note: we use 'await' to ensure the remote description is applied
// before calling CreateAnswer(). Failing to do so will prevent the
// answer from being generated, and the connection from establishing.
await connection.SetRemoteDescriptionAsync(message);
if (message.Type == SdpMessageType.Offer)
{
connection.CreateAnswer();
}
};
await signaler.StartAsync();
signaler.IceCandidateReceived += (IceCandidate candidate) => {
connection.AddIceCandidate(candidate);
};
connection.IceStateChanged += (IceConnectionState newState) => {
Console.WriteLine($"ICE state: {newState}");
};
if (signaler.IsClient)
{
Console.WriteLine("Connecting to remote peer...");
connection.CreateOffer();
}
else
{
Console.WriteLine("Waiting for offer from remote peer...");
}
return(connection.IsConnected + "-" + connection.Name + "-");
}
async Task LoadSettings()
{
// Default values:
var configTraceServerIp = new ValidableNonEmptyString("127.0.0.1");
StorageFile configFile = await StorageFile.GetFileFromApplicationUriAsync(
new Uri(_configFilePath))
.AsTask()
.ConfigureAwait(false);
string content = await FileIO.ReadTextAsync(configFile)
.AsTask()
.ConfigureAwait(false);
JsonValue json = JsonValue.Parse(content);
// Parses server info.
var server = json.GetObject().GetNamedString("server");
var parsed = new Uri(server);
// if we don't have an explicit port in server, and we do have a port value
if (parsed.IsDefaultPort && json.GetObject().ContainsKey("port"))
{
// use that port value in place of the default port
var b = new UriBuilder(parsed);
b.Port = (int)json.GetObject().GetNamedNumber("port");
parsed = b.Uri;
}
// down-convert back to a string
this.Uri = new ValidableNonEmptyString(parsed.ToString());
HeartBeat = new ValidableIntegerString(
(int)json.GetObject().GetNamedNumber("heartbeat"), 0, 65535);
// parse auth
if (json.GetObject().ContainsKey("authentication"))
{
var authNode = json.GetObject().GetNamedObject("authentication").GetObject();
AuthCodeUri = authNode.ContainsKey("codeUri") ? authNode.GetNamedString("codeUri") : null;
AuthPollUri = authNode.ContainsKey("pollUri") ? authNode.GetNamedString("pollUri") : null;
}
var configIceServers = new ObservableCollection <IceServer>();
// Parses turn server.
if (json.GetObject().ContainsKey("turnServer"))
{
JsonValue turnServer = json.GetObject().GetNamedValue("turnServer");
string uri = turnServer.GetObject().GetNamedString("uri");
IceServer iceServer = new IceServer(
uri.Substring(uri.IndexOf("turn:") + 5),
IceServer.ServerType.TURN);
if (turnServer.GetObject().ContainsKey("provider"))
{
// if we do this, we need to ensure we set the username and credential
// in the future - we'll do this in ConnectToServer() by wiring up
// an event to the Conductor.TurnClient
TempTurnUri = turnServer.GetObject().GetNamedString("provider");
}
else
{
iceServer.Username = turnServer.GetObject().GetNamedString("username");
iceServer.Credential = turnServer.GetObject().GetNamedString("password");
}
configIceServers.Add(iceServer);
}
// Parses stun server.
if (json.GetObject().ContainsKey("stunServer"))
{
JsonValue stunServer = json.GetObject().GetNamedValue("stunServer");
string uri = stunServer.GetObject().GetNamedString("uri");
IceServer iceServer = new IceServer(
uri.Substring(uri.IndexOf("stun:") + 5),
IceServer.ServerType.STUN);
iceServer.Username = stunServer.GetObject().GetNamedString("username");
iceServer.Credential = stunServer.GetObject().GetNamedString("password");
configIceServers.Add(iceServer);
}
// Default ones.
configIceServers.Add(new IceServer("stun.l.google.com:19302", IceServer.ServerType.STUN));
configIceServers.Add(new IceServer("stun1.l.google.com:19302", IceServer.ServerType.STUN));
configIceServers.Add(new IceServer("stun2.l.google.com:19302", IceServer.ServerType.STUN));
configIceServers.Add(new IceServer("stun3.l.google.com:19302", IceServer.ServerType.STUN));
configIceServers.Add(new IceServer("stun4.l.google.com:19302", IceServer.ServerType.STUN));
Conductor.Instance.ConfigureIceServers(configIceServers);
var ntpServerAddress = new ValidableNonEmptyString("time.windows.com");
RunOnUiThread(() =>
{
IceServers = configIceServers;
NtpServer = ntpServerAddress;
NtpServer = ntpServerAddress;
ReevaluateHasServer();
});
Conductor.Instance.ConfigureIceServers(configIceServers);
}
public void Initialize()
{
WebRTC.Initialize(_uiDispatcher);
Conductor.Instance.ETWStatsEnabled = false;
Cameras = new ObservableCollection <MediaDevice>();
Microphones = new ObservableCollection <MediaDevice>();
AudioPlayoutDevices = new ObservableCollection <MediaDevice>();
// WebRTCUWP M58 library does not support audio capture/playout devices
//foreach (MediaDevice audioCaptureDevice in Conductor.Instance.Media.GetAudioCaptureDevices())
//{
// Microphones.Add(audioCaptureDevice);
//}
//foreach (MediaDevice audioPlayoutDevice in Conductor.Instance.Media.GetAudioPlayoutDevices())
//{
// AudioPlayoutDevices.Add(audioPlayoutDevice);
//}
// HACK Remove Automatic Device Assignment
if (SelectedCamera == null && Cameras.Count > 0)
{
SelectedCamera = Cameras.First();
}
if (SelectedMicrophone == null && Microphones.Count > 0)
{
SelectedMicrophone = Microphones.First();
}
Debug.WriteLine("Device Status: SelectedCamera: {0} - SelectedMic: {1}", SelectedCamera == null ? "NULL" : "OK", SelectedMicrophone == null ? "NULL" : "OK");
if (SelectedAudioPlayoutDevice == null && AudioPlayoutDevices.Count > 0)
{
SelectedAudioPlayoutDevice = AudioPlayoutDevices.First();
}
Conductor.Instance.Media.OnMediaDevicesChanged += OnMediaDevicesChanged;
Conductor.Instance.Signaller.OnPeerConnected += (peerId, peerName) =>
{
RunOnUiThread(() =>
{
if (Peers == null)
{
Peers = new ObservableCollection <Peer>();
Conductor.Instance.Peers = Peers;
}
Peers.Add(new Peer {
Id = peerId, Name = peerName
});
});
};
Conductor.Instance.Signaller.OnPeerDisconnected += peerId =>
{
RunOnUiThread(() =>
{
var peerToRemove = Peers?.FirstOrDefault(p => p.Id == peerId);
if (peerToRemove != null)
{
Peers.Remove(peerToRemove);
}
});
};
Conductor.Instance.Signaller.OnSignedIn += () =>
{
RunOnUiThread(() =>
{
IsConnected = true;
IsMicrophoneEnabled = false;
IsCameraEnabled = false;
IsConnecting = false;
OnStatusMessageUpdate?.Invoke("Signed-In");
});
};
Conductor.Instance.Signaller.OnServerConnectionFailure += (Exception ex) =>
{
RunOnUiThread(() =>
{
IsConnecting = false;
OnStatusMessageUpdate?.Invoke("Server Connection Failure: " + ex.Message + "\n" + ex.StackTrace);
});
};
Conductor.Instance.Signaller.OnDisconnected += () =>
{
RunOnUiThread(() =>
{
IsConnected = false;
IsMicrophoneEnabled = false;
IsCameraEnabled = false;
IsDisconnecting = false;
Peers?.Clear();
OnStatusMessageUpdate?.Invoke("Disconnected");
});
};
Conductor.Instance.Signaller.OnMessageFromPeer += (id, message) =>
{
RunOnUiThread(() =>
{
// TODO: Handles All Peer Messages (Signal Channel)
});
};
Conductor.Instance.Signaller.OnPeerConnected += (id, name) =>
{
RunOnUiThread(() =>
{
SelectedPeer = Peers.First(x => x.Id == id);
OnStatusMessageUpdate?.Invoke(string.Format("Connected Peer: {0}-{1}", SelectedPeer.Id, SelectedPeer.Name));
});
};
// TODO: Restore Event Handler in Utility Wrapper
// Implemented in Unity Consumer due to Event Handling Issue
// Conductor.Instance.OnAddRemoteStream += Conductor_OnAddRemoteStream does not propagate
Conductor.Instance.OnRemoveRemoteStream += Conductor_OnRemoveRemoteStream;
Conductor.Instance.OnAddLocalStream += Conductor_OnAddLocalStream;
Conductor.Instance.OnConnectionHealthStats += Conductor_OnPeerConnectionHealthStats;
Conductor.Instance.OnPeerConnectionCreated += () =>
{
RunOnUiThread(() =>
{
IsReadyToConnect = false;
IsConnectedToPeer = true;
IsReadyToDisconnect = false;
IsMicrophoneEnabled = false;
OnStatusMessageUpdate?.Invoke("Peer Connection Created");
});
};
Conductor.Instance.OnPeerConnectionClosed += () =>
{
RunOnUiThread(() =>
{
IsConnectedToPeer = false;
_peerVideoTrack = null;
_selfVideoTrack = null;
IsMicrophoneEnabled = false;
IsCameraEnabled = false;
// TODO: Clean-up References
//GC.Collect(); // Ensure all references are truly dropped.
OnStatusMessageUpdate?.Invoke("Peer Connection Closed");
});
};
Conductor.Instance.OnPeerMessageDataReceived += (peerId, message) =>
{
OnPeerMessageDataReceived?.Invoke(peerId, message);
};
// DATA Channel Setup
Conductor.Instance.OnPeerMessageDataReceived += (i, s) =>
{
};
Conductor.Instance.OnReadyToConnect += () => { RunOnUiThread(() => { IsReadyToConnect = true; }); };
IceServers = new ObservableCollection <IceServer>();
NewIceServer = new IceServer();
AudioCodecs = new ObservableCollection <CodecInfo>();
var audioCodecList = WebRTC.GetAudioCodecs();
string[] incompatibleAudioCodecs = new string[] { "CN32000", "CN16000", "CN8000", "red8000", "telephone-event8000" };
VideoCodecs = new ObservableCollection <CodecInfo>();
// TODO: REMOVE DISPLAY LIST SUPPORT
var videoCodecList = WebRTC.GetVideoCodecs().OrderBy(codec =>
{
switch (codec.Name)
{
case "VP8": return(1);
case "VP9": return(2);
case "H264": return(3);
default: return(99);
}
});
RunOnUiThread(() =>
{
foreach (var audioCodec in audioCodecList)
{
if (!incompatibleAudioCodecs.Contains(audioCodec.Name + audioCodec.ClockRate))
{
AudioCodecs.Add(audioCodec);
}
}
if (AudioCodecs.Count > 0)
{
SelectedAudioCodec = AudioCodecs.FirstOrDefault(x => x.Name.Contains("PCMU"));
}
foreach (var videoCodec in videoCodecList)
{
VideoCodecs.Add(videoCodec);
}
if (VideoCodecs.Count > 0)
{
SelectedVideoCodec = VideoCodecs.FirstOrDefault(x => x.Name.Contains("H264"));
}
});
RunOnUiThread(() =>
{
OnInitialized?.Invoke();
});
}
public ClientController(IceServer server)
{
this.server = server;
this.server.ClientsChangedCallback = ClientsListChanged;
}
public static RTCIceServer ToNative(this IceServer self)
{
return(new RTCIceServer(self.Urls, self.Username, self.Password, self.TlsCertPolicy.ToNative()));
}
async Task LoadSettings()
{
StorageFile configFile = await StorageFile.GetFileFromApplicationUriAsync(
new Uri("ms-appx:///webrtcConfig.json"));
string content = await FileIO.ReadTextAsync(configFile);
JsonValue json = JsonValue.Parse(content);
// Parses server info.
_server = json.GetObject().GetNamedString("server");
int startId = 0;
if (_server.StartsWith("http://"))
{
startId = 7;
}
else if (_server.StartsWith("https://"))
{
startId = 8;
// TODO: Supports SSL
}
_server = _server.Substring(startId);
_port = json.GetObject().GetNamedNumber("port").ToString();
_heartbeat = json.GetObject().GetNamedNumber("heartbeat").ToString();
var configIceServers = new ObservableCollection <IceServer>();
bool useDefaultIceServers = true;
if (useDefaultIceServers)
{
// Clears all values.
configIceServers.Clear();
// Parses turn server.
if (json.GetObject().ContainsKey("turnServer"))
{
JsonValue turnServer = json.GetObject().GetNamedValue("turnServer");
string uri = turnServer.GetObject().GetNamedString("uri");
IceServer iceServer = new IceServer(
uri.Substring(uri.IndexOf("turn:") + 5),
IceServer.ServerType.TURN);
iceServer.Credential = turnServer.GetObject().GetNamedString("username");
iceServer.Username = turnServer.GetObject().GetNamedString("password");
configIceServers.Add(iceServer);
}
// Parses stun server.
if (json.GetObject().ContainsKey("stunServer"))
{
JsonValue stunServer = json.GetObject().GetNamedValue("stunServer");
string uri = stunServer.GetObject().GetNamedString("uri");
IceServer iceServer = new IceServer(
uri.Substring(uri.IndexOf("stun:") + 5),
IceServer.ServerType.STUN);
iceServer.Credential = stunServer.GetObject().GetNamedString("username");
iceServer.Username = stunServer.GetObject().GetNamedString("password");
configIceServers.Add(iceServer);
}
// Default ones.
configIceServers.Add(new IceServer("stun.l.google.com:19302", IceServer.ServerType.STUN));
configIceServers.Add(new IceServer("stun1.l.google.com:19302", IceServer.ServerType.STUN));
configIceServers.Add(new IceServer("stun2.l.google.com:19302", IceServer.ServerType.STUN));
configIceServers.Add(new IceServer("stun3.l.google.com:19302", IceServer.ServerType.STUN));
configIceServers.Add(new IceServer("stun4.l.google.com:19302", IceServer.ServerType.STUN));
}
Conductor.Instance.ConfigureIceServers(configIceServers);
}
