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>
/// 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);
}
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 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);
}
async void ResolveClick(object sender, RoutedEventArgs e)
{
var domains = await ZeroconfResolver.BrowseDomainsAsync();
var responses = await ZeroconfResolver.ResolveAsync(domains.Select(g => g.Key));
foreach (var resp in responses)
{
WriteLogLine(resp.ToString());
}
}
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();
}
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 async void ProbeForNetworkAirplayDevices()
{
var domains = await ZeroconfResolver.BrowseDomainsAsync();
var results =
await ZeroconfResolver.ResolveAsync(domains.Where(x => x.Key.Contains("airplay")).Select(g => g.Key));
foreach (var result in results)
{
AirplayServiceFound?.Invoke(result);
}
}
private static async Task ResolveDomains()
{
var domains = await ZeroconfResolver.BrowseDomainsAsync();
var responses = await ZeroconfResolver.ResolveAsync(new string[] { "esp8266.local." }, scanTime : TimeSpan.FromSeconds(20));
// var responses = await ZeroconfResolver.ResolveAsync("_http._tcp.local.");
//ZeroconfResolver.
foreach (var resp in responses)
{
Console.WriteLine(resp.ToString());
}
}
async void Browse_Click(object sender, RoutedEventArgs e)
{
var responses = await ZeroconfResolver.BrowseDomainsAsync();
foreach (var service in responses)
{
WriteLogLine(service.Key);
foreach (var host in service)
{
WriteLogLine("\tIP: " + host);
}
}
}
private async void ResolveClick(object sender, RoutedEventArgs e)
{
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);
}
}
public static async Task <string> DiscoverHost(LogConfiguration logconfig = null)
{
var domains = await ZeroconfResolver.BrowseDomainsAsync();
var responses = await ZeroconfResolver.ResolveAsync(domains.Select(g => g.Key));
foreach (var response in responses)
{
Logger.WriteInfo(response.ToString());
}
return(responses.Where(d => d.DisplayName.StartsWith("FP", StringComparison.OrdinalIgnoreCase))
.Select(d => $"{d.DisplayName}.local").FirstOrDefault());
}
public static async Task Scan(CancellationToken token, Action <Device> deviceFoundCallback, Action finishedCallback)
{
ILookup <string, string> domains = await ZeroconfResolver.BrowseDomainsAsync();
var responses = await ZeroconfResolver.ResolveAsync(domains.Select(g => g.Key), TimeSpan.FromMinutes(1), 2, 2000, host => {
string name = GetShellyName(host);
if (name != null)
{
Device device = CreateDevice(host, name);
deviceFoundCallback.Invoke(device);
}
}, token);
finishedCallback.Invoke();
}
async void Resolve_Click(object sender, RoutedEventArgs e)
{
//Action<IZeroconfRecord> onMessage = record => Console.WriteLogLine("On Message: {0}", record);
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)
{
WriteLogLine(resp.ToString());
}
}
public static async Task <string> GetDeviceIPAddress()
{
var domains = await ZeroconfResolver.BrowseDomainsAsync();
var responses = await ZeroconfResolver.ResolveAsync(domains.Select(g => g.Key));
foreach (var resp in responses)
{
if (resp.DisplayName.StartsWith(DEVICE_NAME))
{
return(resp.IPAddress);
}
}
throw new Exception($"No ${DEVICE_NAME} found!");
}
#pragma warning disable RECS0165 // Asynchronous methods should return a Task instead of void
static async void ResolveOnClicked(Label output)
#pragma warning restore RECS0165 // Asynchronous methods should return a Task instead of void
{
IReadOnlyList <IZeroconfHost> responses = null;
//await Task.Run(async () =>
//{
//});
output.Text += Environment.NewLine;
IReadOnlyList <string> domains;
if (ZeroconfResolver.IsiOSWorkaroundEnabled)
{
// Xamarin.iOS only, running on iOS 14.5+
//
// Demonstrates how using ZeroconfResolver.GetiOSInfoPlistServices() is much faster than ZeroconfResolver.BrowseDomainsAsync()
//
// In real life, you'd only query the domains if you were planning on presenting the user with a choice of domains to browse,
// or the app knows in advance there will be a choice and what the domain names would be
//
// This code assumes there will only be one domain returned ("local.") In general, if you don't have a requirement to handle domains,
// just call GetiOSInfoPlistServices() with zero arguments
var iosDomains = await ZeroconfResolver.GetiOSDomains();
string selectedDomain = (iosDomains.Count > 0) ? iosDomains[0] : null;
domains = ZeroconfResolver.GetiOSInfoPlistServices(selectedDomain);
}
else
{
var browseDomains = await ZeroconfResolver.BrowseDomainsAsync();
domains = browseDomains.Select(g => g.Key).ToList();
}
responses = await ZeroconfResolver.ResolveAsync(domains);
foreach (var resp in responses)
{
output.Text += (resp + Environment.NewLine);
}
}
private async System.Threading.Tasks.Task GetIPAddressFromBonjourAsync()
{
Console.WriteLine("===== IPアドレス探索開始 =====");
//var sd = new ServiceDiscovery();
//sd.ServiceInstanceDiscovered += (s, e) => { Console.WriteLine(e); };
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.DisplayName);
Console.WriteLine(resp.IPAddress);
}
Console.WriteLine("=============================");
}
private async void StartDiscovery()
{
var domains = await ZeroconfResolver.BrowseDomainsAsync();
var responses = await ZeroconfResolver.ResolveAsync(domains.Select(g => g.Key));
responses.ToList().ForEach(r =>
{
r.Services.ToList().ForEach(s =>
{
var service = new DiscoveryDevice()
{
IpAddress = r.IPAddress,
Service = s.Key.Split('.')[0],
Name = s.Key,
Port = s.Value.Port,
Ttl = s.Value.Ttl
};
s.Value.Properties.ToList().ForEach(k =>
{
foreach (var(key, value) in k.ToList())
{
if (!service.Properties.ContainsKey(key))
{
service.Properties.Add(key, value);
}
}
});
var existService = DiscoveredDevices.FirstOrDefault(srvc =>
srvc.IpAddress == service.IpAddress && srvc.Name == service.Name);
if (existService == null)
{
DiscoveredDevices.Add(service);
}
});
});
_logger.LogInformation($"Found {DiscoveredDevices.Count} services on network");
}
public static async void Start()
{
var zeroConfDomains = await ZeroconfResolver.BrowseDomainsAsync();
foreach (var serviceType in zeroConfDomains)
{
foreach (var domain in serviceType)
{
var parts = domain.Split(':');
Domains.Add(new ZeroConfigDomain()
{
Service = serviceType.Key,
DomainName = parts[1],
IPAddress = parts[0],
});
}
}
Hosts = await ZeroconfResolver.ResolveAsync(zeroConfDomains.Select(g => g.Key));
}
private static async void ResolveOnClicked(Label output)
{
IReadOnlyList <IZeroconfHost> responses = null;
//await Task.Run(async () =>
//{
//});
var domains = await ZeroconfResolver.BrowseDomainsAsync();
responses = await ZeroconfResolver.ResolveAsync(domains.Select(g => g.Key));
foreach (var resp in responses)
{
output.Text += (resp + Environment.NewLine);
}
}
#pragma warning disable RECS0165 // Asynchronous methods should return a Task instead of void
static async void ResolveOnClicked(Label output)
#pragma warning restore RECS0165 // Asynchronous methods should return a Task instead of void
{
IReadOnlyList <IZeroconfHost> responses = null;
//await Task.Run(async () =>
//{
//});
var domains = await ZeroconfResolver.BrowseDomainsAsync();
responses = await ZeroconfResolver.ResolveAsync(domains.Select(g => g.Key));
foreach (var resp in responses)
{
output.Text += (resp + Environment.NewLine);
}
}
private static async void BrowseOnClicked(Label output)
{
ILookup <string, string> responses = null;
//await Task.Run(async () =>
//{
//});
responses = await ZeroconfResolver.BrowseDomainsAsync();
foreach (var service in responses)
{
output.Text += (service.Key + Environment.NewLine);
foreach (var host in service)
{
output.Text += (("\tIP: " + host) + Environment.NewLine);
}
}
}
async void ResolveClick(object sender, RoutedEventArgs e)
{
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();;
});
}
#pragma warning disable RECS0165 // Asynchronous methods should return a Task instead of void
static async void BrowseOnClicked(Label output)
#pragma warning restore RECS0165 // Asynchronous methods should return a Task instead of void
{
ILookup <string, string> responses = null;
//await Task.Run(async () =>
//{
//});
responses = await ZeroconfResolver.BrowseDomainsAsync();
foreach (var service in responses)
{
output.Text += (service.Key + Environment.NewLine);
foreach (var host in service)
{
output.Text += (("\tIP: " + host) + Environment.NewLine);
}
}
}
private async void BrowseClick(object sender, RoutedEventArgs e)
{
//var protocol = string.IsNullOrEmpty(Protocol) ? ProtocolPicker.SelectedItem : Protocol;
//var responses = await ZeroconfResolver.ResolveAsync(protocol + ".local.", TimeSpan.FromSeconds(5));
//foreach (var resp in responses)
//{
// Servers.Add(resp);
// Debug.WriteLine(resp);
//}
var domains = await ZeroconfResolver.BrowseDomainsAsync();
var responses = await ZeroconfResolver.ResolveAsync(domains.Select(g => g.Key));
foreach (var resp in responses)
{
Servers.Add(resp);
Debug.WriteLine(resp);
}
}
async void ResolveContinuous_OnClickListener_Click(object sender, RoutedEventArgs e)
{
try
{
ResolveContinuous.IsChecked = false;
if (listenSubscription != null)
{
listenSubscription.Dispose();
listenSubscription = null;
}
else
{
var domains = await ZeroconfResolver.BrowseDomainsAsync();
var sub = ZeroconfResolver.ResolveContinuous(domains.Select(g => g.Key));
listenSubscription = sub.Subscribe(resp => WriteLogLine(resp.ToString()));
}
}
finally
{
ResolveContinuous.IsChecked = true;
}
}
private async Task LoadAsync()
{
try
{
LoadingRing.Visibility = Visibility.Visible;
var domains = await ZeroconfResolver.BrowseDomainsAsync();
var results = await ZeroconfResolver.ResolveAsync(domains.Where(x => x.Key.Contains("airplay")).Select(g => g.Key));
CastingDevices.Clear();
foreach (var receiver in results)
{
CastingDevices.Add(receiver);
}
NoDevicesTextBlock.Visibility = CastingDevices.Count == 0 ? Visibility.Visible : Visibility.Collapsed;
}
finally
{
LoadingRing.Visibility = Visibility.Collapsed;
}
}
/// <summary>
/// Uses mDNS to enumerate the machines on the network eligible to stream from
/// </summary>
/// <returns></returns>
private async Task EnumerateEligibleMachines()
{
// Make a local copy of the computer list
// The UI thread will populate the listbox with computerList whenever it pleases, so we don't want it to take the one we're modifying
List <Computer> computerListLocal = new List <Computer>(computerList);
bool modifiedList = false;
// Make sure we have the manually added PCs in here
foreach (var pc in addedPCs)
{
if (!computerListLocal.Exists(x => x.IpAddress == pc.IpAddress))
{
computerListLocal.Add(pc);
modifiedList = true;
}
}
Debug.WriteLine("Enumerating machines...");
// If there's no network, save time and don't do the time-consuming mDNS
if (!InternetAvailable)
{
if (computerListLocal.Count == 0 && !computerListLocal.Contains(noNetwork))
{
computerListLocal.Add(noNetwork);
modifiedList = true;
}
Debug.WriteLine("Network not available - skipping mDNS");
}
else
{
// Remove the placeholder
if (computerListLocal.Contains(noNetwork))
{
Debug.WriteLine("Removing \"no network\" placeholder");
computerListLocal.Remove(noNetwork);
modifiedList = true;
}
// Let Zeroconf do its magic and find everything it can with mDNS
ILookup <string, string> domains = null;
try
{
domains = await ZeroconfResolver.BrowseDomainsAsync();
}
catch (Exception e)
{
Debug.WriteLine("Browse Domains Async threw exception: " + e.Message);
}
IReadOnlyList <IZeroconfHost> responses = null;
if (domains != null)
{
try
{
responses = await ZeroconfResolver.ResolveAsync(domains.Select(g => g.Key));
}
catch (Exception e)
{
Debug.WriteLine("Exception in ZeroconfResolver.ResolverAsyc (Expected if BrowseDomainsAsync excepted): " + e.Message);
}
}
if (responses != null)
{
// Remove the "not found" placeholder
if (computerList.Contains(notFound))
{
Debug.WriteLine("Removing \"not found\" placeholder");
computerList.Remove(notFound);
modifiedList = true;
}
// Go through every response we received and grab only the ones running nvstream
foreach (var resp in responses)
{
if (resp.Services.ContainsKey("_nvstream._tcp.local."))
{
Computer toAdd = new Computer(resp.DisplayName, resp.IPAddress);
// If we don't have the computer already, add it
if (!computerListLocal.Exists(x => x.IpAddress == resp.IPAddress))
{
computerListLocal.Add(toAdd);
Debug.WriteLine(resp);
modifiedList = true;
}
}
}
}
// We're done messing with the list - it's okay for the UI thread to update it now
Computer last = LoadComputer();
if (last != null)
{
// If we don't have the computer already, add it
if (!computerListLocal.Exists(x => x.IpAddress == last.IpAddress))
{
modifiedList = true;
computerListLocal.Add(last);
}
}
// If no computers at all, say none are found.
if (computerListLocal.Count == 0)
{
Debug.WriteLine("Not Found");
modifiedList = true;
computerListLocal.Add(notFound);
}
}
if (modifiedList)
{
computerList = computerListLocal;
if (computerPicker.SelectedIndex == -1)
{
computerPicker.ItemsSource = computerList;
}
}
}
public async void MdnsSearch()
{
ILookup <string, string> domains = await ZeroconfResolver.BrowseDomainsAsync(scanTime : new TimeSpan(1000000000), retries : 5, callback : mdnsCallback);
}
public static async Task <IReadOnlyList <Zeroconf.IZeroconfHost> > EnumerateAllServicesFromAllHosts()
{
ILookup <string, string> domains = await ZeroconfResolver.BrowseDomainsAsync();
return(await ZeroconfResolver.ResolveAsync(domains.Select(g => g.Key)));
}
