public void DiscoverDevice(IDevice device)
{
var args = new DeviceDiscoveredEventArgs();
args.Device = device;
DeviceDiscovered?.Invoke(this, args);
}
private void _bleAdapter_DeviceDiscovered(object sender, DeviceDiscoveredEventArgs e)
{
var msg = string.Format(@"Device found: {0}
{1} - {2}", e.Device.Name, e.Device.ID, e.Device.Rssi);
DisplayInformation(msg);
}
private void AdapterOnDeviceDiscovered(object sender, DeviceDiscoveredEventArgs deviceDiscoveredEventArgs)
{
if (Devices.All(x => x.Device != deviceDiscoveredEventArgs.Device))
{
Devices.Add(new DeviceViewModel(deviceDiscoveredEventArgs.Device));
_adapter.ConnectToDevice(deviceDiscoveredEventArgs.Device);
RaisePropertyChanged(() => Devices);
}
}
async void _adapter_DeviceDiscovered(object sender, DeviceDiscoveredEventArgs e)
{
if (e.Device.Name.Contains("Nexus"))
{
_adapter.StopScanningForDevices();
_adapter.ConnectToDevice(e.Device);
await Task.Delay(3000);
//_button.Text = "Connected";
// await _adapter.BondAsync(e.Device);
}
}
void Adapter_DeviceDiscovered(object sender, DeviceDiscoveredEventArgs e)
{
Debug.WriteLine("SyncHandler: Device Discovered.");
if (e.Device.Name != null)
{
if (Utils.isValidDevice(e.Device.Name))
{
Debug.WriteLine("Found Valid Device");
this.StopScan();
this.Connect(e.Device);
}
}
}
/// <summary>
/// Notifies the given discovery listeners that a device was discovered.
/// </summary>
/// <param name="remoteDevice">The remote device discovered.</param>
private void NotifyDeviceDiscovered(RemoteXBeeDevice remoteDevice)
{
logger.DebugFormat("{0}Device discovered: {1}.", xbeeDevice, remoteDevice);
if (DeviceDiscovered == null)
{
lock (deviceList)
{
if (deviceList != null)
{
if (!deviceList.Any(d => d.XBee64BitAddr == remoteDevice.XBee64BitAddr))
{
deviceList.Add(remoteDevice);
}
}
}
return;
}
XBeeNetwork network = localDevice.GetNetwork();
RemoteXBeeDevice addedDev = network.AddRemoteDevice(remoteDevice);
if (addedDev != null)
{
try
{
lock (DeviceDiscovered)
{
var handler = DeviceDiscovered;
if (handler != null)
{
var args = new DeviceDiscoveredEventArgs(addedDev);
handler.GetInvocationList().AsParallel().ForAll((action) =>
{
action.DynamicInvoke(this, args);
});
}
}
}
catch (Exception e)
{
logger.Error(e.Message, e);
}
}
else
{
string error = "Error adding device '" + remoteDevice + "' to the network.";
NotifyDiscoveryError(error);
}
}
void Adapter_DeviceDiscovered(object sender, DeviceDiscoveredEventArgs e)
{
Debug.WriteLine("SyncHandler: Device Discovered.");
if (e.Device.Name != null)
{
if (!this.ProcessingDevice && Utils.isValidDevice(e.Device.Name))
{
Debug.WriteLine("Found Valid Device");
this.StopScan();
this.Connect(e.Device);
}
else if (this.ProcessingDevice)
{
Debug.WriteLine("Currently processing valid device.");
}
}
}
public override void OnScanResult(ScanCallbackType callbackType, ScanResult result)
{
base.OnScanResult(callbackType, result);
var device = new Device(result.Device, null, null, result.Rssi);
if (result.ScanRecord != null)
{
device.AdvertismentData = ProcessData(result.ScanRecord);
if (result.ScanRecord.ServiceUuids != null)
{
device.AdvertisedServiceUuids = result.ScanRecord.ServiceUuids.Select(x => Guid.Parse(x.Uuid.ToString())).ToList();
}
}
var eventArgs = new DeviceDiscoveredEventArgs(device);
DeviceDiscovered?.Invoke(this, eventArgs);
}
void Adapter_DeviceDiscovered(object sender, DeviceDiscoveredEventArgs e)
{
Debug.WriteLine("Device discovered");
Device.BeginInvokeOnMainThread(() => {
//devices.Add (e.Device);
//Debug.WriteLine ("Found device: "+e.Device.Name+")");
int numLines = this.lblDevice.Text.Split('\n').Length;
if (numLines > 8)
{
this.lblDevice.Text = "";
}
String c = this.lblDevice.Text;
c += "\nName: " + e.Device.Name + " RSSI:" + e.RSSI;
this.lblDevice.Text = c;
});
//this.ConnectDevice(e.Device,e.RSSI);
}
private void DeviceDiscovered(object sender, DeviceDiscoveredEventArgs e)
{
bool NewDevice = true;
foreach (IDevice dev in KnownDevices)
{
if (dev.ID == e.Device.ID)
{
NewDevice = false;
break;
}
}
if (NewDevice)
{
KnownDevices.Add(e.Device);
}
devices.Add(e.Device);
VM.DetectedDevicesList.Add(e.Device.ID + "-" + (VM.DetectedDevicesList.Count + 1).ToString());
}
public override void OnBatchScanResults(IList <ScanResult> results)
{
base.OnBatchScanResults(results);
foreach (var result in results)
{
var device = new Device(result.Device, null, null, result.Rssi);
if (result.ScanRecord != null)
{
device.AdvertismentData = ProcessData(result.ScanRecord);
if (result.ScanRecord.ServiceUuids != null)
{
device.AdvertisedServiceUuids = result.ScanRecord.ServiceUuids.Select(x => Guid.Parse(x.Uuid.ToString())).ToList();
}
}
var eventArgs = new DeviceDiscoveredEventArgs(device);
DeviceDiscovered?.Invoke(this, eventArgs);
}
}
public async Task DiscoverDevicesAsync(Func <HttpDiscoveredDeviceContext, Task <bool> > onDeviceDiscovered, CancellationToken cancellationToken = default(CancellationToken))
{
string discoverRequest =
"M-SEARCH * HTTP/1.1\n" +
"Host: 239.255.255.250:1900\n" +
"Man: \"ssdp:discover\"\n" +
"ST: roku:ecp\n" +
"";
var bytes = Encoding.UTF8.GetBytes(discoverRequest);
using (var udpClient = new UdpClient(endPoint)) {
await udpClient.SendAsync(bytes, bytes.Length, "239.255.255.250", 1900).ConfigureAwait(false);
while (!cancellationToken.IsCancellationRequested)
{
var receiveTask = Task.Run(
async() => {
try {
return(await udpClient.ReceiveAsync().ConfigureAwait(false));
} catch (ObjectDisposedException) {
// NOTE: We assume that a disposal exception is an attempt to cancel an
// outstanding ReceiveAsync() by closing the socket (disposing the
// UdpClient).
throw new OperationCanceledException();
}
});
var cancellationTask = Task.Delay(TimeSpan.FromMilliseconds(-1), cancellationToken);
var completedTask = await Task.WhenAny(receiveTask, cancellationTask).ConfigureAwait(false);
if (completedTask == cancellationTask)
{
// NOTE: We allow the OperationCanceledException to bubble up, causing disposal of the
// UdpClient which would force any pending ReceiveAsync() to throw an
// ObjectDisposedException.
await cancellationTask.ConfigureAwait(false);
return;
}
var rawResponse = await receiveTask.ConfigureAwait(false);
var response = await ParseResponseAsync(rawResponse.Buffer).ConfigureAwait(false);
if (response.StatusCode == 200 &&
response.Headers.TryGetValue("ST", out string stHeader) &&
stHeader == "roku:ecp" &&
response.Headers.TryGetValue("LOCATION", out string location) &&
Uri.TryCreate(location, UriKind.Absolute, out Uri locationUri) &&
response.Headers.TryGetValue("USN", out string usn))
{
var serialNumber = usn.StartsWith("uuid:roku:ecp:")
? usn.Substring("uuid:roku:ecp:".Length)
: usn;
var device = new HttpRokuDevice(serialNumber, locationUri, this.handler);
bool cancelDiscovery = false;
var context = new HttpDiscoveredDeviceContext(device, serialNumber);
if (onDeviceDiscovered != null)
{
cancelDiscovery = await onDeviceDiscovered(context).ConfigureAwait(false);
}
var args = new HttpDeviceDiscoveredEventArgs(context)
{
CancelDiscovery = cancelDiscovery
};
this.DeviceDiscovered?.Invoke(this, args);
cancelDiscovery = args.CancelDiscovery;
var baseArgs = new DeviceDiscoveredEventArgs(context)
{
CancelDiscovery = cancelDiscovery
};
this.baseDeviceDiscovered?.Invoke(this, baseArgs);
cancelDiscovery = baseArgs.CancelDiscovery;
if (cancelDiscovery)
{
return;
}
}
}
}
}
void DeviceDiscovered(object sender, DeviceDiscoveredEventArgs e)
{
DiscoveredDevices.Add(e.Device);
}
private void ScanCallbackOnDeviceDiscovered(object sender, DeviceDiscoveredEventArgs deviceDiscoveredEventArgs)
{
DeviceDiscovered(this, new DeviceDiscoveredEventArgs(deviceDiscoveredEventArgs.Device));
}
