public static async Task <IReadOnlyList <Device> > Discover()
{
var l = new List <Device>();
var results = await ZeroconfResolver.ResolveAsync(DiscoveryId);
foreach (var host in results)
{
var infoDict = new Dictionary <string, string>();
var service = host.Services[DiscoveryId];
foreach (var z in host.Services) // should be just the one...
{
foreach (var valueProperty in z.Value.Properties)
{
foreach (var keyValuePair in valueProperty)
{
infoDict[keyValuePair.Key] = keyValuePair.Value;
}
}
}
l.Add(new Device(host.IPAddress, service.Port.ToString(), infoDict[ServiceId], infoDict[ServiceVersion], infoDict[ServiceModel], host.DisplayName));
}
// default port: 16021, not recommended to hardcode
// md: model name
// srcvers: firmware version
// id: device id randomly generated, changes if user resets the device + removes auth
return(l);
}
public static async Task <IList <string> > FindAuroras()
{
IReadOnlyList <IZeroconfHost> results = await
ZeroconfResolver.ResolveAsync("_nanoleafapi._tcp.local.").ConfigureAwait(false);
return(results.Select(zc => zc.IPAddress).ToList());
}
public static IObservable <Uri> ResolveEndpoints(TimeSpan scanTime)
{
return(ZeroconfResolver
.Resolve("_musc._tcp.local.", scanTime)
.Where(element => element.IPAddress != null)
.Select(host => GetEndpoint(host)));
}
public async Task ProbeForNetworkServers() //Asynchroniczna metoda służacą do wyszukiwania usług w sieci lokalnej z wykorzystaniem zeroconf
{
CancelButton.IsEnabled = false; //Deaktywacja przycisku Wstecz do czasu zakończenia działania wątku
if (IPAdresses != null)
{
IPAdresses.Clear(); //Czyszczenie listy adresów IP
}
IReadOnlyList <IZeroconfHost> results = await
ZeroconfResolver.ResolveAsync("_pilotServer._tcp.local."); //Wyszukiwanie usług o nazwie "_pilotServer._tcp.local." z wykorzystaniem zeroconf
IPAdresses = new ObservableCollection <FoundServer>();
foreach (var item in results)
{
IPAdresses.Add(new FoundServer()
{
IPAddress = item.IPAddress,
port = (short)item.Services["_pilotServer._tcp.local."].Port,
name = item.DisplayName
}); //Dodawanie znalezionych adresów IP do listy
}
if (IPAdresses.Count == 0)
{
Text.Text = AppResources.NotFoundSearchPage; //Wyświetlenie komunikatu o nieznalezieniu serwerów w seci lokalnej
}
else
{
Text.IsVisible = false; //Ukrycie komunikatu o wyszukiwaniu serwerów
IPAddressesListView.IsVisible = true; //Wyświetlenie listy
IPAddressesListView.ItemsSource = null;
IPAddressesListView.ItemsSource = IPAdresses; //Podpięcie nowej listy adresów IP z uruchomioną usługą serwera aplikacji Pilot do kontrolki ListView
}
CancelButton.IsEnabled = true; //Aktywacja przycisku Wstecz
}
public async Task <NEEOBrain> DiscoverOneBrain()
{
var lookup = await ZeroconfResolver.BrowseDomainsAsync(_options);
var found = lookup.FirstOrDefault((l) => l.Key.StartsWith(_neeoKey));
if (found == null)
{
return(null);
}
var brain = new NEEOBrain();
var hosts = await ZeroconfResolver.ResolveAsync(found.Key);
foreach (var host in hosts)
{
brain.IpArray = host.IPAddresses.ToList().ToArray();
foreach (var service in host.Services)
{
brain.Name = host.DisplayName;
brain.Host = brain.IpArray[0];
brain.Port = service.Value.Port;
foreach (var dict in service.Value.Properties)
{
brain.Version = dict["rel"];
brain.Region = dict["reg"];
}
}
}
return(brain);
}
private static void resolverAsync()
{
while (true)
{
try
{
var results = ZeroconfResolver.ResolveAsync("_rtsp._udp.local.");
if (results != null)
{
foreach (var zeroconfHost in results.Result)
{
Console.WriteLine("Stream " + zeroconfHost);
if (!Hosts.Contains(zeroconfHost))
{
Hosts.Add(zeroconfHost);
}
}
}
}
catch
{
}
Thread.Sleep(30000);
}
}
static async void Connect()
{
Console.Clear();
Console.WriteLine("---=[ Central server ]=---\n");
Console.WriteLine("Searching for central server with ZeroConf...");
IReadOnlyList <IZeroconfHost> results = await
ZeroconfResolver.ResolveAsync("_crt._tcp.local.");
Console.Clear();
Console.WriteLine("---=[ Central server ]=---\n");
if (results.Count == 0)
{
Console.WriteLine("Could not locate a master server");
Console.ReadLine();
}
else if (results.Count == 1)
{
Connect(results[0]);
}
else
{
int index = 1;
foreach (var host in results)
{
Console.Write(index.ToString() + ". " + host.IPAddress + " (" + host.DisplayName + ")");
}
Console.WriteLine("\nEnter number to continue: ");
var choise = Console.ReadKey();
int serverIndex = Int32.Parse(choise.KeyChar.ToString());
Connect(results[serverIndex]);
}
Console.ReadLine();
}
/// <summary>
/// IRKitのIPアドレスを取得する
/// </summary>
/// <returns>IPアドレス（取得失敗の場合は空文字列）</returns>
private async Task <string> GetIPAddressAsync()
{
Console.WriteLine("===== IPアドレス探索開始 =====");
//var sd = new ServiceDiscovery();
//sd.ServiceInstanceDiscovered += (s, e) => { Console.WriteLine(e); };
string ip = "";
for (int i = 0; i < MAX_RETRY_COUNT; i++)
{
ILookup <string, string> domains = await ZeroconfResolver.BrowseDomainsAsync();
var responses = await ZeroconfResolver.ResolveAsync(domains.Select(g => g.Key));
var response = responses.Where(x => x.DisplayName.ToUpper().Contains("IRKIT")).FirstOrDefault();
if (response != null && response.IPAddress != string.Empty)
{
ip = response.IPAddress;
Console.WriteLine(ip);
break;
}
}
return(ip);
}
private static void resolverMavlinkAsync(object obj)
{
while (true)
{
try
{
var results = ZeroconfResolver.ResolveAsync("_mavlink._udp.local.");
if (results != null)
{
foreach (var zeroconfHost in results.Result)
{
Console.WriteLine("Mavlink " + zeroconfHost);
var service = zeroconfHost.Services.Where(a => a.Key == "_mavlink._udp.local.");
if (service.Any())
{
StartUDPMavlink?.Invoke(zeroconfHost);
}
}
}
}
catch
{
}
Thread.Sleep(30000);
}
}
private static async Task resolverAsync()
{
await Task.Delay(6000).ConfigureAwait(false);
while (true)
{
try
{
var results = await ZeroconfResolver.ResolveAsync("_rtsp._udp.local.").ConfigureAwait(false);
if (results != null)
{
foreach (var zeroconfHost in results)
{
Console.WriteLine("Stream " + zeroconfHost);
if (!RtspHosts.Contains(zeroconfHost))
{
RtspHosts.Add(zeroconfHost);
}
}
}
}
catch
{
}
await Task.Delay(30000).ConfigureAwait(false);
}
}
private static async Task resolverMavlinkAsync()
{
while (true)
{
try
{
var results = await ZeroconfResolver.ResolveAsync("_mavlink._udp.local.").ConfigureAwait(false);
if (results != null)
{
foreach (var zeroconfHost in results)
{
Console.WriteLine("Mavlink " + zeroconfHost);
var service = zeroconfHost.Services.Where(a => a.Key == "_mavlink._udp.local.");
if (service.Any())
{
StartUDPMavlink?.Invoke(zeroconfHost);
}
}
}
}
catch
{
}
await Task.Delay(30000).ConfigureAwait(false);
}
}
private IEnumerable <ISpeaker> GetSpeakersViaZeroconf()
{
var results = new Collection <ISpeaker>();
var wifi = (WifiManager)ApplicationContext.GetSystemService(Context.WifiService);
var multicastLock = wifi.CreateMulticastLock("Zeroconf lock");
try
{
multicastLock.Acquire();
var zeroconfHosts = ZeroconfResolver.ResolveAsync("_soundtouch._tcp.local.").Result;
var boseConnection = new BoseConnection(new HttpClient());
foreach (var zeroconfHost in zeroconfHosts)
{
results.Add(new Speaker(zeroconfHost.DisplayName, zeroconfHost.IPAddress, boseConnection));
}
}
finally
{
multicastLock.Release();
}
return(results);
}
public static async Task ProbeForRTSP()
{
//while (Application.OpenForms.Count > 0)
{
IReadOnlyList <IZeroconfHost> results = await ZeroconfResolver.ResolveAsync("rtsp._udp");
}
}
async void ResolveClick(object sender, RoutedEventArgs e)
{
try
{
var domains = await ZeroconfResolver.BrowseDomainsAsync();
// var responses = await ZeroconfResolver.ResolveAsync(domains.Select(g => g.Key));
// var responses = await ZeroconfResolver.ResolveAsync("_http._tcp.local.");
//foreach (var resp in responses)
// Debug.WriteLine(resp);
var sub = ZeroconfResolver.Resolve(domains.Select(g => g.Key));
IDisposable disp = null;
disp = sub.Subscribe(h => Debug.WriteLine(h), () =>
{
Debug.WriteLine("Completed");
disp.Dispose();;
});
}
catch (Exception)
{
Debug.WriteLine("Exception was thrown... most likely the port is already in use, unfortunatly WinRT does not allow re-use of ports.");
}
}
/// <summary>
/// Discover Nanoleafs in Local Network
/// </summary>
/// <returns>List of Founded auroras in Network</returns>
private static async Task <List <AuroraSearchResults> > FindAuroras()
{
try
{
List <AuroraSearchResults> lasr = new List <AuroraSearchResults>();
IReadOnlyList <IZeroconfHost> results = await ZeroconfResolver.ResolveAsync("_nanoleafapi._tcp.local.", new TimeSpan(0, 0, 0, 5)).ConfigureAwait(true);
if (results.Count == 0)
{
return(lasr);
}
foreach (IZeroconfHost host in results)
{
AuroraSearchResults asr = new AuroraSearchResults(host.IPAddress,
host.Services.First().Value.Properties.First().First().Value, host.Services.First().Value.Port);
lasr.Add(asr);
}
return(lasr);
}
catch (Exception ex)
{
if (errorEventHandler != null)
{
errorEventHandler.Invoke("error in private FindAurora Method: " + ex.Message, EventArgs.Empty);
}
return(null);
}
}
public static async Task <IPAddress> FindRobotAddress(string robotName, int timeout = Robot.DefaultConnectionTimeout)
{
if (string.IsNullOrEmpty(robotName))
{
throw new ArgumentException("Robot name must be provided.", nameof(robotName));
}
if (!RobotNameIsValid(robotName))
{
throw new ArgumentException("Robot name is not in the correct format.", nameof(robotName));
}
robotName = robotName.ToLowerInvariant();
var resultSource = new TaskCompletionSource <IPAddress>();
// Run the resolver in the background to completion because stopping it early causes errors
// But will set the result source and return the first matching IP address as soon as it's found
// and complete this async method.
_ = ZeroconfResolver.ResolveAsync(
"_ankivector._tcp.local.",
new TimeSpan(0, 0, 0, 0, timeout),
callback: host =>
{
if (host.DisplayName.ToLowerInvariant() != robotName)
{
return;
}
resultSource.TrySetResult(IPAddress.Parse(host.IPAddress));
}
).ContinueWith((results) => resultSource.TrySetResult(null), TaskScheduler.Current).ConfigureAwait(false);
return(await resultSource.Task.ConfigureAwait(false));
}
private IpAddress FindServer()
{
Task <IReadOnlyList <IZeroconfHost> > t = ZeroconfResolver.ResolveAsync("_mediadisplay._tcp.local.", scanTime: new TimeSpan(0, 0, 6));
t.Wait();
return(IsMediaDisplayServer(t.Result));
}
public async Task <IZeroconfHost> ProbeForAuroras()
{
IReadOnlyList <IZeroconfHost> results = await
ZeroconfResolver.ResolveAsync("_nanoleafapi._tcp.local.").ConfigureAwait(false);
return(results.FirstOrDefault());
}
public async Task <List <SmartMirrorModel> > SearchForSmartMirrors()
{
List <SmartMirrorModel> mirrors = new List <SmartMirrorModel>();
WifiManager wifi = (WifiManager)Android.App.Application.Context.GetSystemService(Context.WifiService);
var wifiLock = wifi.CreateMulticastLock("Zeroconf lock");
try
{
wifiLock.Acquire();
ILookup <string, string> domains = await ZeroconfResolver.BrowseDomainsAsync();
var responses = await ZeroconfResolver.ResolveAsync(domains.Select(g => g.Key));
foreach (var domain in responses)
{
if (domain.DisplayName.Contains("smartmirror"))
{
mirrors.Add(new SmartMirrorModel()
{
HostName = domain.DisplayName,
IP = IPAddress.Parse(domain.IPAddress)
});
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
finally
{
wifiLock.Release();
}
return(mirrors);
}
public Observer(ListBox listToFill, List <MachineInfo> boards)
{
list = listToFill;
boardList = boards;
ZeroconfResolver.ResolveContinuous(HttpService).Subscribe(this);
}
private void stateToolStripMenuItem_Click(object sender, EventArgs e)
{
List <string> ls = new List <string>();
ls.Add("Monitor: " + (Service.Running ? "started" : "stopped"));
ls.Add("(The values are fresh and may differ from those used by Service last time.)");
ls.Add("Logged in user: "******"_printer._tcp.local.");//worked for server: "_printer._tcp"
string service = Settings.General.GetServiceName();
IReadOnlyList <IZeroconfHost> zhs = ZeroconfResolver.ResolveAsync(service, TimeSpan.FromSeconds(3), 1, 10).Result;
string server_ip;
if (zhs.Count < 1)
{
server_ip = Settings.General.TcpClientDefaultIp.ToString();
ls.Add("Service '" + service + "' could not be resolved. Using default ip: " + server_ip);
}
else if (zhs.Where(x => x.IPAddress != null).FirstOrDefault() == null)
{
server_ip = Settings.General.TcpClientDefaultIp.ToString();
ls.Add("Resolution of service '" + service + "' has no IP defined. Using default ip: " + server_ip);
}
else
{
ls.Add("Service '" + service + "' has been resolved to: " + zhs.Where(x => x.IPAddress != null).FirstOrDefault().IPAddress);
}
if (!TcpServer.Running)
{
ls.Add("Tcp listening: -");
}
else
{
ls.Add("Tcp listening on: " + TcpServer.LocalIp + ":" + TcpServer.LocalPort);
}
if (TcpServer.Connection == null)
{
ls.Add("Tcp connection: -");
}
else
{
ls.Add("Tcp connection to: " + TcpServer.Connection.RemoteIp + ":" + TcpServer.Connection.RemotePort);
}
if (!MpegStream.Running)
{
ls.Add("Mpeg stream: -");
}
else
{
ls.Add("Mpeg stream: " + MpegStream.CommandLine);
}
Message.Inform(string.Join("\r\n", ls));
}
public static async Task <List <IReceiver> > FindReceiversAsync(TimeSpan scanTime)
{
var devices = await ZeroconfResolver
.ResolveAsync(PROTOCOL, scanTime : scanTime, retries : 1, retryDelayMilliseconds : 100)
.ConfigureAwait(false);
return(devices.Select(CreateReceiver).ToList());
}
public Observer(RadioButton searchNetwork, ListBox listToFill, List <MachineInfo> boards)
{
this.searchNetwork = searchNetwork;
list = listToFill;
boardList = boards;
ZeroconfResolver.ResolveContinuous(HttpService).Subscribe(this);
}
public Observer(CheckBox manualSetup, ListBox listToFill, List <MachineInfo> boards)
{
manualConfig = manualSetup;
list = listToFill;
boardList = boards;
ZeroconfResolver.ResolveContinuous(HttpService).Subscribe(this);
}
private static async Task <IZeroconfHost> InternalResolveServerHost()
{
var options = new ResolveOptions("_http._tcp.local.");
var responses = await ZeroconfResolver.ResolveAsync(options);
var serverHost = responses.FirstOrDefault(x => x.DisplayName == DnsDiscoveryName);
return(serverHost);
}
public async static Task <ServerInfo> FindServerAsync(TimeSpan timeout, CancellationToken token)
{
string guid;
CancellationTokenSource serverFoundSource;
IZeroconfHost server = null;
ServerInfo serverInfo;
Settings.GetGuid(out guid);
serverFoundSource = new CancellationTokenSource();
using (CancellationTokenSource linkedCts =
CancellationTokenSource.CreateLinkedTokenSource(token, serverFoundSource.Token))
{
try
{
#if __ANDROID__
RemoteScreen.Droid.MainActivity.mlock.Acquire();
#endif
await ZeroconfResolver.ResolveAsync("_secalot._tcp.local.", scanTime : timeout, retries : 1, callback : dev =>
{
if (dev.DisplayName == guid)
{
server = dev;
serverFoundSource.Cancel();
}
}, cancellationToken : linkedCts.Token);
}
catch (OperationCanceledException)
{
if (serverFoundSource.Token.IsCancellationRequested)
{
}
else if (token.IsCancellationRequested)
{
token.ThrowIfCancellationRequested();
}
}
#if __ANDROID__
finally
{
RemoteScreen.Droid.MainActivity.mlock.Release();
}
#endif
}
if (server != null)
{
serverInfo.ip = server.Id;
serverInfo.port = server.Services["_secalot._tcp.local."].Port;
return(serverInfo);
}
else
{
throw new Exception("Server not found");
}
}
/// <inheritdoc/>
public async Task <IList <ElgatoLight> > StartDiscoverAsync(int timeout = 30, CancellationToken cancellationToken = default)
{
var lights = new List <ElgatoLight>();
if (NetworkDiscoveryHelper.IsNetworkAvailable() == false)
{
return(lights);
}
// discover the set of available lights
ResolveOptions elgatoKeyOptions = new ResolveOptions(BonjourDiscoveryElgatoKeyLightService)
{
//ScanTime = TimeSpan.FromSeconds(timeout)
};
/*
* ResolveOptions eveKeyOptions = new ResolveOptions(ElgatoEveKeyLightService)
* {
* //ScanTime = TimeSpan.FromSeconds(timeout)
* };
*/
IReadOnlyList <IZeroconfHost> elgatoDiscoveredServices = await ZeroconfResolver.ResolveAsync(elgatoKeyOptions, callback : null, cancellationToken);
// IReadOnlyList<IZeroconfHost> eveDiscoveredServices = await ZeroconfResolver.ResolveAsync(eveKeyOptions, callback: null, cancellationToken);
if (elgatoDiscoveredServices != null)
{
// for each light that is discovered, retrieve details about the keylight by calling the device directly
foreach (var resolvedElgatoLightService in elgatoDiscoveredServices)
{
var light = await RetrieveKeyLightInfoAsync(resolvedElgatoLightService.IPAddress, resolvedElgatoLightService.DisplayName, resolvedElgatoLightService.Services.FirstOrDefault().Value.Port);
if (light != null)
{
await light.UpdateStatusAsync();
await light.UpdateSettings();
lights.Add(light);
}
}
}
/* if (eveDiscoveredServices != null)
* {
* // for each light that is discovered, retrieve details about the keylight by calling the device directly
* foreach (var resolvedEveLightService in eveDiscoveredServices)
* {
* var light = await RetrieveKeyLightInfoAsync(resolvedEveLightService.IPAddress, resolvedEveLightService.DisplayName, resolvedEveLightService.Services.FirstOrDefault().Value.Port);
*
* //lights.Add(light);
* }
* }
*
*/ return(lights);
}
/// <summary>
/// Detect running MPD instances via ZeroConf
/// </summary>
/// <returns></returns>
public static async Task <IEnumerable <KeyValuePair <string, Uri> > > FindByZeroConfAsync()
{
var responses = await ZeroconfResolver.ResolveAsync("_mpd._tcp.local.").ConfigureAwait(false);
return
(from response in responses
from service in response.Services
select new KeyValuePair <string, Uri>(response.DisplayName, new Uri($"http://{response.IPAddress}:{service.Value.Port}")));
}
public static async Task EnumerateAllServicesFromAllHosts()
{
ILookup <string, string> domains = await ZeroconfResolver.BrowseDomainsAsync();
var responses = await ZeroconfResolver.ResolveAsync(domains.Select(g => g.Key));
foreach (var resp in responses)
{
Console.WriteLine(resp);
}
}
public MainViewModel()
{
var browseSub = Observable.Create <string>(async(obs, cancel) =>
{
await ZeroconfResolver.BrowseDomainsAsync(callback: (k, v) => obs.OnNext(k), cancellationToken: cancel);
obs.OnCompleted();
});
DiscoveredDomains = browseSub.Distinct().CreateCollection();
}
