protected override async void OnHandleIntent(Intent intent)
{
//UDP Receiver
var listenPort = 15000;
var receiver = new UdpSocketReceiver();
receiver.MessageReceived += (sender, args) =>
{
//Daten und Senderadresse auswerten
var from = String.Format("{0}:{1}", args.RemoteAddress, args.RemotePort);
var data = Encoding.UTF8.GetString(args.ByteData, 0, args.ByteData.Length);
//Falls Link übermittelt
if (string.IsNullOrEmpty(data) == false)
{
//Starte MainActivity (mit erhaltener URI)
Intent i = new Intent(this, typeof(MainActivity));
i.SetData(Uri.Parse(data));
//i.AddFlags(ActivityFlags.NewTask);
this.StartActivity(i);
}
};
//Abhören am UDP Port starten
await receiver.StartListeningAsync(listenPort);
}
public async void Listen(int listenPort)
{
var receiver = new UdpSocketReceiver();
receiver.MessageReceived += (sender, args) =>
{
// get the remote endpoint details and convert the received data into a string
var from = String.Format("{0}:{1}", args.RemoteAddress, args.RemotePort);
var data = Encoding.UTF8.GetString(args.ByteData, 0, args.ByteData.Length);
string messageReceived = string.Format("{0} - {1}", from, data);
Console.WriteLine(messageReceived);
InvokeMessageReceived(args.RemoteAddress, int.Parse(args.RemotePort), messageReceived);
//receiver.SendToAsync(args.ByteData, args.RemoteAddress, 5001);
//receiver.SendToAsync(args.ByteData, args.RemoteAddress, int.Parse(args.RemotePort));
//receiver.SendToAsync(args.ByteData, args.RemoteAddress, 5002);
};
// listen for udp traffic on listenPort
await receiver.StartListeningAsync(listenPort);
Console.WriteLine("Listening on " + listenPort);
}
// Connect to the time server and update system time
private async Task StartAsync()
{
if (isBusy == false)
{
isBusy = true;
Debug.WriteLine($"Syncing Timer with SNTP {TimeServer}");
// Initialize data structure
Initialize();
var tcs = new TaskCompletionSource <byte[]>();
using (var socket = new UdpSocketReceiver())
{
socket.MessageReceived += async(sender, args) =>
{
await socket.StopListeningAsync();
tcs.SetResult(args.ByteData);
};
await socket.StartListeningAsync();
await socket.SendToAsync(SNTPData, TimeServer, 123);
SNTPData = await tcs.Task;
}
DestinationTimestamp = DateTime.Now;
SetTime();
isBusy = false;
}
}
public static async System.Threading.Tasks.Task <byte[]> Send(string host, int port, byte[] request)
{
var listenPort = 56800;
var receiver = new UdpSocketReceiver();
TaskCompletionSource <byte[]> responseReceived = new TaskCompletionSource <byte[]>();
receiver.MessageReceived += (sender, args) =>
{
responseReceived.SetResult(args.ByteData);
receiver.StopListeningAsync();
};
//var client = new UdpSocketClient();
await receiver.StartListeningAsync(listenPort);
await receiver.SendToAsync(request, host, port);
// listen for udp traffic on listenPort
await responseReceived.Task;
return(responseReceived.Task.Result);
}
public static async Task <DateTime> GetNetworkTimeAsync()
{
Debug.WriteLine("Entro in GetNTP " + DateTime.Now);
//default Windows time server
const string ntpServer = "time.windows.com";
//const string ntpServer = "pool.ntp.org";
//const string ntpServer = "time.nist.gov";
// NTP message size - 16 bytes of the digest (RFC 2030)
var ntpData = new byte[48];
//Setting the Leap Indicator, Version Number and Mode values
ntpData[0] = 0x1B; //LI = 0 (no warning), VN = 3 (IPv4 only), Mode = 3 (Client Mode)
var tcs = new TaskCompletionSource <byte[]>();
using (var socket = new UdpSocketReceiver())
{
socket.MessageReceived += async(sender, args) =>
{
await socket.StopListeningAsync();
tcs.SetResult(args.ByteData);
};
Debug.WriteLine("StartListening " + DateTime.Now);
await socket.StartListeningAsync(); // any free port >1000 will do
Debug.WriteLine("SendTo " + DateTime.Now);
await socket.SendToAsync(ntpData, ntpServer, 123).ContinueWith(_ => Task.FromResult(true)).TimeoutAfter(TimeSpan.FromSeconds(3)); //.TimeoutAfter(TimeSpan.FromSeconds(3));
Debug.WriteLine("SendTo conclusa");
ntpData = await tcs.Task.TimeoutAfter(TimeSpan.FromSeconds(3));
}
//Offset to get to the "Transmit Timestamp" field (time at which the reply
//departed the server for the client, in 64-bit timestamp format."
const byte serverReplyTime = 40;
//Get the seconds part
ulong intPart = BitConverter.ToUInt32(ntpData, serverReplyTime);
//Get the seconds fraction
ulong fractPart = BitConverter.ToUInt32(ntpData, serverReplyTime + 4);
//Convert From big-endian to little-endian
intPart = SwapEndianness(intPart);
fractPart = SwapEndianness(fractPart);
var milliseconds = (intPart * 1000) + ((fractPart * 1000) / 0x100000000L);
//**UTC** time
var networkDateTime = (new DateTime(1900, 1, 1, 0, 0, 0, DateTimeKind.Utc)).AddMilliseconds((long)milliseconds);
Debug.WriteLine("Esco da GetNTP " + DateTime.Now + " - " + networkDateTime + " - LOCALTIME: " + networkDateTime.ToLocalTime() + " - UTC: " + networkDateTime.ToUniversalTime());
return(networkDateTime.ToLocalTime());
}
public SocketService()
{
ServiceEnabled = false;
ServiceAvailable = true;
Listening = false;
_UdpSocketReceiver = new UdpSocketReceiver();
_UdpSocketReceiver.MessageReceived += _UdpSocketReceiver_MessageReceived;
}
//constructor
public Listener(int mPortNum)
{
isListening = false;
this.listenerUDP = new UdpSocketReceiver();
this.listenerTCP = new TcpSocketListener();
this.portNum = mPortNum;
}
public MainViewModel(ISomeService someService)
{
receiver = new UdpSocketReceiver();
receiver.MessageReceived += OnMessageReceived;
Messages = new ObservableCollection <UDPMessage>();
Task.Run(() => Init().Wait());
}
private async Task <IObservable <IHttpRequestReponse> > GetUdpRequestResponseObservable(
int port,
ICommunicationInterface communicationInterface = null,
bool allowMultipleBindToSamePort = false)
{
IUdpSocketReceiver udpListener = new UdpSocketReceiver();
var observeUdpRequest = await udpListener.ObservableUnicastListener(
port,
communicationInterface,
allowMultipleBindToSamePort);
var observable = Observable.Create <IHttpRequestReponse>(
obs =>
{
var disp = observeUdpRequest.Subscribe(
udpSocket =>
{
var stream = new MemoryStream(udpSocket.ByteData);
var requestHandler = new HttpParserDelegate
{
HttpRequestReponse =
{
RemoteAddress = udpSocket.RemoteAddress,
RemotePort = int.Parse(udpSocket.RemotePort),
RequestType = RequestType.UDP
}
};
var result = _httpStreamParser.Parse(requestHandler, stream, Timeout);
obs.OnNext(result);
},
ex =>
{
Cleanup();
obs.OnError(ex);
},
() =>
{
Cleanup();
obs.OnCompleted();
});
return(disp);
void Cleanup()
{
_udpReceiverPortToObservable.Remove(port);
udpListener.Dispose();
}
});
return(observable);
}
//constructor
public Listener(int mPortNum, bool mTcpOnly = false)
{
isListening = false;
if (!mTcpOnly)
{
this.listenerUDP = new UdpSocketReceiver();
}
this.listenerTCP = new TcpSocketListener();
this.portNum = mPortNum;
}
public static async void GetListOfLocalHosts(string ipAddr)
{
receiveSocket = new UdpSocketReceiver();
await receiveSocket.StartListeningAsync(RxPort);
await StartDiscovery(OnServerDiscovered, ipAddr);
// Wait until the control thread is done before proceeding.
// This keeps the inactivity timers from overlapping.
}
public async void Connect()
{
try
{
if (this.UdpClient != null)
{
try
{
await this.UdpClient.StopListeningAsync();
this.UdpClient.Dispose();
}
catch (Exception ex)
{
if (this.IsDebug)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
}
}
}
this.UdpClient = new UdpSocketReceiver();
this.UdpClient.MessageReceived += OnMessageReceived;
}
catch (SocketException ex)
{
if (this.IsDebug)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
return;
}
}
await this.UdpClient.StartListeningAsync(this.LocalEndpoint.Port);
try
{
this.ConnectRequest();
}
catch (Exception ex)
{
if (this.IsDebug)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
}
}
}
public WifiScanViewModel(INavigationService navigation) : base(navigation)
{
Devices = new ObservableCollection <string>();
wifiManager = DependencyService.Get <IWiFiManager>();
IsPairing = false;
Connect = new Command(StartConnect);
Title = IoTCentral.Current.Device.Name;
ProgressText = "Searching for compatible devices...";
PairingCompleted = false;
PairingResult = new Result();
MessagingCenter.Subscribe <IWiFiManager, string>(this, "FOUND", async(manager, ssid) =>
{
Associate(ssid);
await Pair();
});
MessagingCenter.Subscribe <IWiFiManager, string>(this, "REGISTERED", async(manager, msg) =>
{
var ssid = msg.Split(':')[0];
if (ssid.Equals(deviceName, StringComparison.CurrentCultureIgnoreCase))
{
ProgressText = $"Device registered on the network with ip: {msg.Split(':')[1]}";
PairingResult.Text = ((char)0x2713).ToString();
PairingResult.Color = Color.Green;
}
else
{
ProgressText = $"Failed to register device";
PairingResult.Text = "X";
PairingResult.Color = Color.Red;
}
PairingCompleted = true;
OnPropertyChanged("ProgressText");
OnPropertyChanged("PairingCompleted");
OnPropertyChanged("PairingResult");
//await Navigation.NavigateTo(new DeviceViewModel(Navigation));
});
WiFIInstruction = ImageSource.FromResource("iotc_xamarin_ble.Resources.wifi_2.jpg");
udpClient = new UdpSocketClient();
udpReceiver = new UdpSocketReceiver();
skipScan = false;
if (Device.RuntimePlatform == Device.iOS)
{
IsiOS = true;
((App)App.Current).ApplicationResumed += ResumeWifi;
}
}
public static async Task <DnsServer> Create(string ip, int port, IRecordResolver recordResolver, IAuthority areWeAuthority, IExceptionHandler onError)
{
var networkInterface = Network.Interfaces.FirstOrDefault(x => x.IpAddress == ip);
var udpReceiver = new UdpSocketReceiver();
var observerUdpReceiver = await udpReceiver.ObservableUnicastListener(
port : port,
communicationInterface : networkInterface,
allowMultipleBindToSamePort : false);
var subscriberUpdReceiver = observerUdpReceiver.Subscribe(
async udpMsg =>
{
var req = Reader.ReadRequest(new MemoryStream(udpMsg.ByteData));
var response = new Response(req);
foreach (var q in req)
{
var record = recordResolver.Resolve(q.Class, q.Type, q.Name);
if (record == null)
{
continue;
}
if (areWeAuthority?.AreWeAuthority(q.Name) ?? false)
{
response.Authorities.Add(record);
}
else
{
response.Answers.Add(record);
}
}
await udpReceiver.SendToAsync(Writer.Serialize(response), udpMsg.RemoteAddress, int.Parse(udpMsg.RemotePort));
},
x => onError?.OnError(x));
return(new UDPServer
{
udpReceiver = udpReceiver,
observerUdpReceiver = observerUdpReceiver,
subscriberUpdReceiver = subscriberUpdReceiver,
RecordResolver = recordResolver
});
}
public Listener()
{
Console.WriteLine("Starting Server");
var udpReceived = new UdpSocketReceiver();
udpReceived.StartListeningAsync(8888);
udpReceived.MessageReceived += (sender, args) =>
{
System.Console.WriteLine($"Remote adrres: {args.RemoteAddress}");
System.Console.WriteLine($"Remote port: {args.RemotePort}");
var str = System.Text.Encoding.UTF8.GetString(args.ByteData);
System.Console.WriteLine($"Messsage: {str}");
MainWindow._current.AddMessage(str, true);
MainWindow._current.SentenceAnalyzer.Analyze(str);
};
}
public async Task StartAsync()
{
List <CommsInterface> interfaces = await CommsInterface.GetAllInterfacesAsync();
this.receiver = new UdpSocketReceiver();
receiver.MessageReceived += this.ReceiverOnMessageReceived;
try {
// listen for udp traffic on listenPort
await receiver.StartListeningAsync(this.listenPort);
this.log($"listening on port {this.listenPort}");
}
catch (Exception e) {
this.log($"failed to listen on port {this.listenPort}.{Environment.NewLine}{e}");
}
}
public async Task <byte[]> Receive(IPEndPoint remoteHost)
{
var receiver = new UdpSocketReceiver();
byte[] data = new byte[1];
receiver.MessageReceived += (sender, args) =>
{
// get the remote endpoint details and convert the received data into a string
data = args.ByteData;
};
await receiver.StartListeningAsync(remoteHost.Port);
System.Console.WriteLine(System.DateTime.Now.ToString() + "<<< " + remoteHost);
System.Console.WriteLine(FormatterHelper.Deserialize(data).ToString());
System.Console.WriteLine();
return(data);
}
async protected override void OnStart()
{
var receiver = new UdpSocketReceiver();
receiver.MessageReceived += (sender, args) =>
{
var data = System.Text.Encoding.UTF8.GetString(args.ByteData, 0, args.ByteData.Length);
if (data.StartsWith(MAPLE_HOSTNAME, System.StringComparison.CurrentCultureIgnoreCase))
{
var address = data.Split(new char[] { '=' })[1];
if (string.Compare(address, DehydratorHostAddress) != 0)
{
DehydratorHostAddress = address;
Debug.WriteLine("HostAddress updated: " + DehydratorHostAddress);
}
}
};
await receiver.StartListeningAsync(MAPLE_SERVER_BROADCAST_PORT);
}
private async void StartSending()
{
this.BackingReceiver = new UdpSocketReceiver();
this.BackingReceiver.MessageReceived += this.BackingReceiverOnMessageReceived;
await this.BackingReceiver.StartListeningAsync(11010);
while (true)
{
//List<CommsInterface> interfaces = await CommsInterface.GetAllInterfacesAsync();
//interfaces = interfaces.Where(i => i.IsUsable && !i.IsLoopback).ToList();
//foreach (CommsInterface ci in interfaces) {
// await this.BackingReceiver.SendToAsync(new byte[0], ci.BroadcastAddress, 11011);
//}
await this.BackingReceiver.SendToAsync(new byte[0], "255.255.255.255", 11011);
await Task.Delay(500);
}
}
public OscReceiver()
{
AddressOnMessageReceived = new Dictionary <string, EventHandler <OSCMessageReceivedArgs> >();
receiver = new UdpSocketReceiver();
receiver.MessageReceived += (sender, args) =>
{
OscPacket packet = OscPacket.Parse(args.ByteData);
if (packet is OscBundle)
{
OscBundle bundle = packet as OscBundle;
OnBundleReceived(bundle);
}
else
{
OscMessage message = packet as OscMessage;
OnMessageReceived(message);
}
};
}
private static async void UdpListener()
{
var udpReceived = new UdpSocketReceiver();
await udpReceived.StartListeningAsync(1234, allowMultipleBindToSamePort : true);
var udpMessageSubscriber = udpReceived.ObservableMessages.Subscribe(
msg =>
{
System.Console.WriteLine($"Remote adrres: {msg.RemoteAddress}");
System.Console.WriteLine($"Remote port: {msg.RemotePort}");
var str = System.Text.Encoding.UTF8.GetString(msg.ByteData);
System.Console.WriteLine($"Messsage: {str}");
},
ex =>
{
// Exceptions received here;
});
udpMessageSubscriber.Dispose();
}
public UdpSocketReceiverPage()
{
_receiver = new UdpSocketReceiver();
_messagesSub = new Subject <Message>();
_messagesObs = _messagesSub.AsObservable();
_receiver.MessageReceived += (sender, args) =>
{
var data = args.ByteData.ToStringFromUTF8Bytes();
var from = String.Format("{0}:{1}", args.RemoteAddress, args.RemotePort);
var msg = new Message
{
Text = data,
DetailText = String.Format("<Received from {1} at {0}>", DateTime.Now.ToString("HH:mm:ss"), from)
};
_messagesSub.OnNext(msg);
};
InitView();
}
public async Task WaitForCompanion()
{
Serializer = new ProtobufNetworkSerializer();
var tcs = new TaskCompletionSource <bool>();
listener = new UdpSocketReceiver();
listener.MessageReceived += (s, e) =>
{
remoteAddress = e.RemoteAddress;
remotePort = e.RemotePort;
var dto = Serializer.Deserialize <BaseDto>(e.ByteData);
var handshakeDto = dto as PingDto;
if (handshakeDto != null)
{
var msg = handshakeDto.Message;
}
tcs.TrySetResult(true);
};
await listener.StartListeningAsync(Port);
await tcs.Task;
}
async public static Task <ServerList> BrowseForNoahServers(string friendlyName, string ipAddress)
{
var client = new UdpSocketClient();
var receiver = new UdpSocketReceiver();
try
{
var address = GetIpAddressForBroadcast(ipAddress);
//// convert our greeting message into a byte array
string clientGUID = "{B0BE0E7D-F70B-40BE-91AB-14125863B0B7}";
System.Text.Encoding enc = System.Text.Encoding.UTF8;
byte[] sendBuffer = enc.GetBytes(clientGUID);
receiver.MessageReceived += (sender, args) =>
{
try
{
var from = String.Format("{0}:{1}", args.RemoteAddress, args.RemotePort);
var fromIp = args.RemoteAddress;
var data = Encoding.UTF8.GetString(args.ByteData, 0, args.ByteData.Length);
try
{
LocalRemoteHostInfo payload =
Helpers.Deserialize <LocalRemoteHostInfo>(Encoding.UTF8.GetString(args.ByteData, 0,
args.ByteData.Length));
string guid = payload.LocalNoahServerGuid;
if (guid.Equals("{5FE140D5-1D3F-4E46-8892-15FA89DAE9F4}"))
{
bool duplicate = false;
foreach (ServerData servData in ServerCollection)
{
if (servData.ServerIp.Equals(fromIp))
{
duplicate = true; //The adress is allready in the list
break;
}
}
if (duplicate == false) //No need to list Gatteway IP
{
if (string.IsNullOrEmpty(friendlyName))
{
ServerCollection.Add(new ServerData
{
ServerName = payload.HostName,
FriendlyName = payload.FriendlyName,
ServerIp = payload.LocalHostIpAddress,
RemoteHostId = payload.RemoteHostId
});
}
else
{
if (friendlyName == payload.FriendlyName)
{
receiver.StopListeningAsync();
ServerCollection.Add(new ServerData
{
ServerName = payload.HostName,
FriendlyName = payload.FriendlyName,
ServerIp = payload.LocalHostIpAddress,
RemoteHostId = payload.RemoteHostId
});
//client.Dispose();
//receiver.Dispose();
waitTime = false;
}
}
}
}
}
catch { }
}
catch { }
};
try
{
receiver.StartListeningAsync(listenPort);
}
catch (Exception e)
{
}
client.ConnectAsync(address, port);
client.SendAsync(sendBuffer);
DateTime now = DateTime.Now;
DateTime stop = now + new TimeSpan(0, 0, 0, 5);
while (waitTime)
{
if (DateTime.Now > stop)
{
waitTime = false;
}
}
}
catch (Exception e)
{
Log.ErrorFormat("Himsa.Noah.MobileAccessLayer.NoahServerUdpBrowser::BrowseForNoahServers(): {0}", e);
throw;
}
finally
{
client.DisconnectAsync();
receiver.StopListeningAsync();
receiver.Dispose();
}
return(new ServerList
{
Servers = ServerCollection.ToArray()
});
}
public ReceiverViewRenderer()
{
_receiver = new UdpSocketReceiver();
_receiver.MessageReceived += HandleMessageReceived;
iniReceiver();
}
public PacketsPage()
{
InitializeComponent();
tcpPort = SettingsPage.TCPPort;
udpPort = SettingsPage.UDPPort;
tcpServer = new TcpSocketListener();
udpServer = new UdpSocketReceiver();
tcpServer.ConnectionReceived += TcpConnection;
udpServer.MessageReceived += UdpConnection;
Task.Run(async() =>
{
await tcpServer.StartListeningAsync(tcpPort);
await udpServer.StartListeningAsync(udpPort);
SettingsPage.TCPPort = tcpServer.LocalPort;
MessagingCenter.Send(this, Events.BOUND_PORTS_CHANGED, 0);
});
//udpServer.StartListeningAsync(udpPort);
/*
+= async (sender, args) =>
* {
* var client = args.SocketClient;
*
* var bytesRead = -1;
* var buf = new byte[1];
*
* while (bytesRead != 0)
* {
* bytesRead = await args.SocketClient.ReadStream.ReadAsync(buf, 0, 1);
* //if (bytesRead > 0)
* // Debug.Write(buf[0]);
* }
* };
*/
_connection = DependencyService.Get <ISQLiteDb>().GetConnection();
/*
* var demopackets = Packet.GetDemoPackets();
* for (int i = 0; i < demopackets.Count(); i++) {
* _thepackets.Add(demopackets[i]);
* }
* packetListView.ItemsSource = _thepackets;
*/
tcp = new TcpSocketClient();
udp = new UdpSocketClient();
thepacket = new Packet();
MessagingCenter.Subscribe <LoginPage, List <Packet> >(this, Events.NEW_PACKET_LIST, OnNewPacketListAsync);
MessagingCenter.Subscribe <ImportCloud, List <Packet> >(this, Events.NEW_PACKET_LIST, OnNewPacketListAsyncIC);
MessagingCenter.Subscribe <PacketEditPage, Packet>(this, Events.PACKET_MODIFIED, OnPacketModified);
}
