private void StartUDPCommandListener()
{
_udpCommandListener = new UdpClient();
_udpCommandListener.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
_udpCommandListener.ExclusiveAddressUse = false; // only if you want to send/receive on same machine.
var localEp = new IPEndPoint(IPAddress.Any, _settings.GetNetworkSetting(SettingsKeys.CommandListenerUDP));
_udpCommandListener.Client.Bind(localEp);
Task.Factory.StartNew(() =>
{
using (_udpCommandListener)
{
while (!_stop)
{
try
{
var groupEp = new IPEndPoint(IPAddress.Any,
_settings.GetNetworkSetting(SettingsKeys.CommandListenerUDP));
var bytes = _udpCommandListener.Receive(ref groupEp);
//Logger.Info("Recevied Message from UDP COMMAND INTERFACE: "+ Encoding.UTF8.GetString(
// bytes, 0, bytes.Length));
var message =
JsonConvert.DeserializeObject <UDPInterfaceCommand>(Encoding.UTF8.GetString(
bytes, 0, bytes.Length));
if (message?.Command == UDPInterfaceCommand.UDPCommandType.FREQUENCY)
{
RadioHelper.UpdateRadioFrequency(message.Frequency, message.RadioId);
}
else if (message?.Command == UDPInterfaceCommand.UDPCommandType.ACTIVE_RADIO)
{
RadioHelper.SelectRadio(message.RadioId);
}
else if (message?.Command == UDPInterfaceCommand.UDPCommandType.TOGGLE_GUARD)
{
RadioHelper.ToggleGuard(message.RadioId);
}
else if (message?.Command == UDPInterfaceCommand.UDPCommandType.CHANNEL_UP)
{
RadioHelper.RadioChannelUp(message.RadioId);
}
else if (message?.Command == UDPInterfaceCommand.UDPCommandType.CHANNEL_DOWN)
{
RadioHelper.RadioChannelDown(message.RadioId);
}
else
{
Logger.Error("Unknown UDP Command!");
}
}
catch (SocketException e)
{
// SocketException is raised when closing app/disconnecting, ignore so we don't log "irrelevant" exceptions
if (!_stop)
{
Logger.Error(e, "SocketException Handling DCS Message");
}
}
catch (Exception e)
{
Logger.Error(e, "Exception Handling DCS Message");
}
}
try
{
_udpCommandListener.Close();
}
catch (Exception e)
{
Logger.Error(e, "Exception stoping DCS listener ");
}
}
});
}
public void Start()
{
_lotATCPositionListener = new UdpClient();
_lotATCPositionListener.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress,
true);
_lotATCPositionListener.ExclusiveAddressUse = false; // only if you want to send/receive on same machine.
var localEp = new IPEndPoint(IPAddress.Any,
_settings.GetNetworkSetting(SettingsKeys.LotATCIncomingUDP));
_lotATCPositionListener.Client.Bind(localEp);
Task.Factory.StartNew(() =>
{
using (_lotATCPositionListener)
{
while (!_stop)
{
try
{
var groupEp = new IPEndPoint(IPAddress.Any,
_settings.GetNetworkSetting(SettingsKeys.LotATCIncomingUDP));
var bytes = _lotATCPositionListener.Receive(ref groupEp);
var lotAtcPositionWrapper =
JsonConvert.DeserializeObject <LotATCMessageWrapper>(Encoding.UTF8.GetString(
bytes, 0, bytes.Length));
if (lotAtcPositionWrapper != null)
{
if (lotAtcPositionWrapper.los != null)
{
HandleLOSResponse(lotAtcPositionWrapper.los);
}
else if (lotAtcPositionWrapper.controller != null)
{
HandleLotATCUpdate(lotAtcPositionWrapper.controller);
}
}
}
catch (SocketException e)
{
if (!_stop)
{
Logger.Error(e, "SocketException Handling LotATC UDP Message");
}
}
catch (Exception e)
{
Logger.Error(e, "Exception Handling LotATC UDP Message");
}
}
try
{
_lotATCPositionListener.Close();
}
catch (Exception e)
{
Logger.Error(e, "Exception stoping LotATC UDP listener");
}
}
});
StartLotATCLOSSender();
}
//used for the result
private void StartDCSLOSBroadcastListener()
{
_dcsLOSListener = new UdpClient();
_dcsLOSListener.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress,
true);
_dcsLOSListener.ExclusiveAddressUse = false; // only if you want to send/receive on same machine.
var localEp = new IPEndPoint(IPAddress.Any, _settings.GetNetworkSetting(SettingsKeys.DCSLOSIncomingUDP));
_dcsLOSListener.Client.Bind(localEp);
Task.Factory.StartNew(() =>
{
using (_dcsLOSListener)
{
// var count = 0;
while (!_stop)
{
try
{
var groupEp = new IPEndPoint(IPAddress.Any,
_settings.GetNetworkSetting(SettingsKeys.DCSLOSIncomingUDP));
var bytes = _dcsLOSListener.Receive(ref groupEp);
/* Logger.Debug(Encoding.UTF8.GetString(
* bytes, 0, bytes.Length));*/
var playerInfo =
JsonConvert.DeserializeObject <DCSLosCheckResult[]>(Encoding.UTF8.GetString(
bytes, 0, bytes.Length));
foreach (var player in playerInfo)
{
SRClient client;
if (_clients.TryGetValue(player.id, out client))
{
client.LineOfSightLoss = player.los;
// Logger.Debug(client.ToString());
}
}
}
catch (SocketException e)
{
// SocketException is raised when closing app/disconnecting, ignore so we don't log "irrelevant" exceptions
if (!_stop)
{
Logger.Error(e, "SocketException Handling DCS Los Result Message");
}
}
catch (Exception e)
{
Logger.Error(e, "Exception Handling DCS Los Result Message");
}
}
try
{
_dcsLOSListener.Close();
}
catch (Exception e)
{
Logger.Error(e, "Exception stoping DCS LOS Result listener ");
}
}
});
}
public void Start()
{
_dcsGameGuiUdpListener = new UdpClient();
_dcsGameGuiUdpListener.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress,
true);
_dcsGameGuiUdpListener.ExclusiveAddressUse = false; // only if you want to send/receive on same machine.
// var multicastaddress = IPAddress.Parse("239.255.50.10");
// _dcsGameGuiUdpListener.JoinMulticastGroup(multicastaddress);
var localEp = new IPEndPoint(IPAddress.Any,
_settings.GetNetworkSetting(SettingsKeys.DCSIncomingGameGUIUDP));
_dcsGameGuiUdpListener.Client.Bind(localEp);
// activeRadioUdpClient.Client.ReceiveTimeout = 10000;
Task.Factory.StartNew(() =>
{
using (_dcsGameGuiUdpListener)
{
// var count = 0;
while (!_stop)
{
try
{
var groupEp = new IPEndPoint(IPAddress.Any,
_settings.GetNetworkSetting(SettingsKeys.DCSIncomingGameGUIUDP));
var bytes = _dcsGameGuiUdpListener.Receive(ref groupEp);
var updatedPlayerInfo =
JsonConvert.DeserializeObject <DCSPlayerSideInfo>(Encoding.UTF8.GetString(
bytes, 0, bytes.Length));
if (updatedPlayerInfo != null)
{
var currentInfo = _clientStateSingleton.PlayerCoaltionLocationMetadata;
//copy the bits we need - leave position
currentInfo.name = updatedPlayerInfo.name;
currentInfo.side = updatedPlayerInfo.side;
//this will clear any stale positions if nothing is currently connected
_clientStateSingleton.ClearPositionsIfExpired();
_clientSideUpdate();
// count = 0;
_clientStateSingleton.DcsGameGuiLastReceived = DateTime.Now.Ticks;
}
}
catch (SocketException e)
{
// SocketException is raised when closing app/disconnecting, ignore so we don't log "irrelevant" exceptions
if (!_stop)
{
Logger.Error(e, "SocketException Handling DCS GameGUI Message");
}
}
catch (Exception e)
{
Logger.Error(e, "Exception Handling DCS GameGUI Message");
}
}
try
{
_dcsGameGuiUdpListener.Close();
}
catch (Exception e)
{
Logger.Error(e, "Exception stoping DCS listener ");
}
}
});
}
public void Start()
{
_dcsUdpListener = new UdpClient();
_dcsUdpListener.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
_dcsUdpListener.ExclusiveAddressUse = false; // only if you want to send/receive on same machine.
// var multicastaddress = IPAddress.Parse("239.255.50.10");
// _dcsUdpListener.JoinMulticastGroup(multicastaddress);
var localEp = new IPEndPoint(IPAddress.Any, _settings.GetNetworkSetting(SettingsKeys.DCSIncomingUDP));
_dcsUdpListener.Client.Bind(localEp);
// activeRadioUdpClient.Client.ReceiveTimeout = 10000;
//reset last sent
_clientStateSingleton.LastSent = 0;
Task.Factory.StartNew(() =>
{
using (_dcsUdpListener)
{
while (!_stop)
{
try
{
var groupEp = new IPEndPoint(IPAddress.Any,
_settings.GetNetworkSetting(SettingsKeys.DCSIncomingUDP));
var bytes = _dcsUdpListener.Receive(ref groupEp);
var str = Encoding.UTF8.GetString(
bytes, 0, bytes.Length).Trim();
var message =
JsonConvert.DeserializeObject <DCSPlayerRadioInfo>(str);
Logger.Debug($"Recevied Message from DCS {str}");
if (!string.IsNullOrWhiteSpace(message.name) && message.name != "Unknown" && message.name != _clientStateSingleton.LastSeenName)
{
_clientStateSingleton.LastSeenName = message.name;
}
_clientStateSingleton.DcsExportLastReceived = DateTime.Now.Ticks;
//sync with others
//Radio info is marked as Stale for FC3 aircraft after every frequency change
ProcessRadioInfo(message);
}
catch (SocketException e)
{
// SocketException is raised when closing app/disconnecting, ignore so we don't log "irrelevant" exceptions
if (!_stop)
{
Logger.Error(e, "SocketException Handling DCS Message");
}
}
catch (Exception e)
{
Logger.Error(e, "Exception Handling DCS Message");
}
}
try
{
_dcsUdpListener.Close();
}
catch (Exception e)
{
Logger.Error(e, "Exception stoping DCS listener ");
}
}
});
}
