public ExternalDeviceService()
{
_deviceWatcher = DeviceInformation.CreateWatcher(DeviceClass.PortableStorageDevice);
_deviceWatcher.Added += DeviceAdded;
_deviceWatcher.Removed += DeviceRemoved;
_deviceWatcher.Start();
}
static public void StartSearch()
{
// Additional properties we would like about the device.
// Property strings are documented here https://msdn.microsoft.com/en-us/library/windows/desktop/ff521659(v=vs.85).aspx
string[] requestedProperties = { "System.Devices.Aep.DeviceAddress", "System.Devices.Aep.IsConnected", "System.Devices.Aep.Bluetooth.Le.IsConnectable", "System.Devices.Aep.AepId", "System.Devices.Aep.Category" };
// BT_Code: Example showing paired and non-paired in a single query.
string aqsAllBluetoothLEDevices = "(System.Devices.Aep.ProtocolId:=\"{bb7bb05e-5972-42b5-94fc-76eaa7084d49}\")";
deviceWatcher =
DeviceInformation.CreateWatcher(
aqsAllBluetoothLEDevices,
requestedProperties,
DeviceInformationKind.AssociationEndpoint);
// Register event handlers before starting the watcher.
deviceWatcher.Added -= DeviceWatcher_Added;
deviceWatcher.Updated -= DeviceWatcher_Updated;
deviceWatcher.Removed -= DeviceWatcher_Removed;
deviceWatcher.EnumerationCompleted -= DeviceWatcher_EnumerationCompleted;
deviceWatcher.Stopped -= DeviceWatcher_Stopped;
deviceWatcher.Added += DeviceWatcher_Added;
deviceWatcher.Updated += DeviceWatcher_Updated;
deviceWatcher.Removed += DeviceWatcher_Removed;
deviceWatcher.EnumerationCompleted += DeviceWatcher_EnumerationCompleted;
deviceWatcher.Stopped += DeviceWatcher_Stopped;
// Start the watcher.
deviceWatcher.Start();
if (_searchMethod == 0)
{
_autoEvent.WaitOne();
}
}
//public ObservableCollection<clsDevType> DevTypes = new ObservableCollection<clsDevType>();
async void WatchDevices_Click(object sender, RoutedEventArgs eventArgs)
{
if (watcher != null)
{
watcher = null;
}
count = 0;
isEnumerationComplete = false;
StopStatus = null;
//DeviceInterfacesOutputList.Items.Clear();
try
{
dispatcher = Window.Current.CoreWindow.Dispatcher;
watcher = DeviceInformation.CreateWatcher();
// Add event handlers
watcher.Added += watcher_Added;
watcher.Removed += watcher_Removed;
watcher.Updated += watcher_Updated;
watcher.EnumerationCompleted += watcher_EnumerationCompleted;
watcher.Stopped += watcher_Stopped;
watcher.Start();
OutputText.Text = "Enumeration started.";
this.btnWatchDevices.IsEnabled = false;
this.btnStop.IsEnabled = !(this.btnWatchDevices.IsEnabled);
}
catch (ArgumentException)
{
//The ArgumentException gets thrown by FindAllAsync when the GUID isn't formatted properly
//The only reason we're catching it here is because the user is allowed to enter GUIDs without validation
//In normal usage of the API, this exception handling probably wouldn't be necessary when using known-good GUIDs
OutputText.Text = "Caught ArgumentException. Failed to create watcher.";
}
}
public async Task <bool> StartAsync()
{
// only one start allowed on the object
lock (this)
{
if (_started)
{
return(false);
}
_started = true;
}
if (await WiFiAdapter.RequestAccessAsync() != WiFiAccessStatus.Allowed)
{
return(false);
}
_started = true;
// enumerate and monitor WiFi devices in the system
string deviceSelector = WiFiAdapter.GetDeviceSelector();
_watcher = Windows.Devices.Enumeration.DeviceInformation.CreateWatcher(deviceSelector);
_watcher.Added += _watcher_Added;
_watcher.Removed += _watcher_Removed;
_watcher.Start();
return(true);
}
public UsbScopeDevice()
{
var usbScopeSelector = HidDevice.GetDeviceSelector(UsagePage, UsageId, Vid, Pid);
ScopeDeviceWatcher = DeviceInformation.CreateWatcher(usbScopeSelector);
ScopeDeviceWatcher.Added += new TypedEventHandler<DeviceWatcher, DeviceInformation>(OnDeviceAdded);
ScopeDeviceWatcher.Removed += new TypedEventHandler<DeviceWatcher, DeviceInformationUpdate>(OnDeviceRemoved);
ScopeDeviceWatcher.Start();
}
public Scenario4_BackgroundProximitySensor()
{
this.InitializeComponent();
watcher = DeviceInformation.CreateWatcher(ProximitySensor.GetDeviceSelector());
watcher.Added += OnProximitySensorAdded;
watcher.Start();
}
public NetworkPresenter()
{
WiFiAdaptersWatcher = DeviceInformation.CreateWatcher(WiFiAdapter.GetDeviceSelector());
WiFiAdaptersWatcher.EnumerationCompleted += AdaptersEnumCompleted;
WiFiAdaptersWatcher.Added += AdaptersAdded;
WiFiAdaptersWatcher.Removed += AdaptersRemoved;
WiFiAdaptersWatcher.Start();
}
protected async override void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
watcher = DeviceInformation.CreateWatcher(ProximitySensor.GetDeviceSelector());
watcher.Added += OnProximitySensorAdded;
watcher.Start();
timer = new Timer(TimerCallBack, null, Timeout.Infinite, 4000);
await InitializeCameraAsync();
}
private void StartListeningForSerialPortChanges()
{
serialPortWatcher = DeviceInformation.CreateWatcher(SerialDevice.GetDeviceSelector());
serialPortWatcher.Added += SerialPortWatcher_Added;
serialPortWatcher.Removed += SerialPortWatcher_Removed;
serialPortWatcher.Updated += SerialPortWatcher_Updated;
serialPortWatcher.Start();
}
static HidGamepad()
{
var deviceSelector = HidDevice.GetDeviceSelector(0x01, 0x05);
_watcher = DeviceInformation.CreateWatcher(deviceSelector);
_watcher.Added += HandleDeviceAdded;
_watcher.Updated += HandleDeviceUpdated;
_watcher.Removed += HandleDeviceRemoved;
_watcher.EnumerationCompleted += HandleEnumerationCompleted;
_watcher.Start();
}
public ConnectedDevicePresenter(CoreDispatcher dispatcher)
{
this.dispatcher = dispatcher;
usbConnectedDevicesWatcher = DeviceInformation.CreateWatcher(usbDevicesSelector);
usbConnectedDevicesWatcher.EnumerationCompleted += DevicesEnumCompleted;
usbConnectedDevicesWatcher.Updated += DevicesAdded;
usbConnectedDevicesWatcher.Removed += DevicesRemoved;
usbConnectedDevicesWatcher.Start();
}
public Scenario2_Polling()
{
String customSensorSelector = "";
this.InitializeComponent();
customSensorSelector = CustomSensor.GetDeviceSelector(GUIDCustomSensorDeviceVendorDefinedTypeID);
watcher = DeviceInformation.CreateWatcher(customSensorSelector);
watcher.Added += OnCustomSensorAdded;
watcher.Start();
}
static Blink1()
{
var selector = HidDevice.GetDeviceSelector(0xFF00, 0x0001, 0x27B8, 0x01ED);
_watcher = DeviceInformation.CreateWatcher(selector);
_watcher.Added += HandleDeviceAdded;
_watcher.Updated += HandleDeviceUpdated;
_watcher.Removed += HandleDeviceRemoved;
_watcher.EnumerationCompleted += HandleEnumerationCompleted;
_watcher.Start();
}
private void btnWatcher_Click(object sender, RoutedEventArgs e)
{
if (_fWatcherStarted == false)
{
_publisher.Start();
if (_publisher.Status != WiFiDirectAdvertisementPublisherStatus.Started)
{
rootPage.NotifyUser("Failed to start advertisement.", NotifyType.ErrorMessage);
return;
}
DiscoveredDevices.Clear();
rootPage.NotifyUser("Finding Devices...", NotifyType.StatusMessage);
String deviceSelector = WiFiDirectDevice.GetDeviceSelector(
Utils.GetSelectedItemTag<WiFiDirectDeviceSelectorType>(cmbDeviceSelector));
_deviceWatcher = DeviceInformation.CreateWatcher(deviceSelector, new string[] { "System.Devices.WiFiDirect.InformationElements" });
_deviceWatcher.Added += OnDeviceAdded;
_deviceWatcher.Removed += OnDeviceRemoved;
_deviceWatcher.Updated += OnDeviceUpdated;
_deviceWatcher.EnumerationCompleted += OnEnumerationCompleted;
_deviceWatcher.Stopped += OnStopped;
_deviceWatcher.Start();
btnWatcher.Content = "Stop Watcher";
_fWatcherStarted = true;
}
else
{
_publisher.Stop();
btnWatcher.Content = "Start Watcher";
_fWatcherStarted = false;
_deviceWatcher.Added -= OnDeviceAdded;
_deviceWatcher.Removed -= OnDeviceRemoved;
_deviceWatcher.Updated -= OnDeviceUpdated;
_deviceWatcher.EnumerationCompleted -= OnEnumerationCompleted;
_deviceWatcher.Stopped -= OnStopped;
_deviceWatcher.Stop();
rootPage.NotifyUser("Device watcher stopped.", NotifyType.StatusMessage);
}
}
public Scenario2_Polling()
{
String customSensorSelector = "";
this.InitializeComponent();
customSensorSelector = CustomSensor.GetDeviceSelector(GUIDCustomSensorDeviceVendorDefinedTypeID);
watcher = DeviceInformation.CreateWatcher(customSensorSelector);
watcher.Added += OnCustomSensorAdded;
watcher.Start();
// Register to be notified when the user disables access to the custom sensor through privacy settings.
deviceAccessInformation = DeviceAccessInformation.CreateFromDeviceClassId(GUIDCustomSensorDeviceVendorDefinedTypeID);
deviceAccessInformation.AccessChanged += new TypedEventHandler<DeviceAccessInformation, DeviceAccessChangedEventArgs>(OnAccessChanged);
}
/// <summary>
/// Initializes a new instance of the MainForm form class.
/// </summary>
public MainForm()
{
LocRM = new ResourceManager("win81FactoryTest.AppResources.Res", typeof(win81FactoryTest.TestForm).Assembly);
InitializeComponent();
SetString();
this.FormBorderStyle = FormBorderStyle.None;//Full screen and no title
this.WindowState = FormWindowState.Maximized;
//Initialize device watcher
watcher = Windows.Devices.Enumeration.DeviceInformation.CreateWatcher(Windows.Devices.Enumeration.DeviceClass.PortableStorageDevice);
watcher.Added += watcher_Added;
watcher.Removed += watcher_Removed;
watcher.EnumerationCompleted += watcher_EnumerationCompleted;
watcher.Start();
}
//public ObservableCollection<clsDevType> DevTypes = new ObservableCollection<clsDevType>();
async void WatchDevices_Click(object sender, RoutedEventArgs eventArgs)
{
if (watcher != null)
{
watcher = null;
}
count = 0;
isEnumerationComplete = false;
StopStatus = null;
//DeviceInterfacesOutputList.Items.Clear();
try
{
dispatcher = Window.Current.CoreWindow.Dispatcher;
watcher = DeviceInformation.CreateWatcher();
// Add event handlers
watcher.Added += watcher_Added;
watcher.Removed += watcher_Removed;
watcher.Updated += watcher_Updated;
watcher.EnumerationCompleted += watcher_EnumerationCompleted;
watcher.Stopped += watcher_Stopped;
watcher.Start();
OutputText.Text = "Enumeration started.";
this.btnWatchDevices.IsEnabled = false;
this.btnStop.IsEnabled = !(this.btnWatchDevices.IsEnabled);
}
catch (ArgumentException)
{
//The ArgumentException gets thrown by FindAllAsync when the GUID isn't formatted properly
//The only reason we're catching it here is because the user is allowed to enter GUIDs without validation
//In normal usage of the API, this exception handling probably wouldn't be necessary when using known-good GUIDs
OutputText.Text = "Caught ArgumentException. Failed to create watcher.";
}
}
private void StartUnpairedDeviceWatcher()
{
// Request additional properties
string[] requestedProperties = new string[] { "System.Devices.Aep.DeviceAddress", "System.Devices.Aep.IsConnected" };
deviceWatcher = DeviceInformation.CreateWatcher("(System.Devices.Aep.ProtocolId:=\"{e0cbf06c-cd8b-4647-bb8a-263b43f0f974}\")",
requestedProperties,
DeviceInformationKind.AssociationEndpoint);
// Hook up handlers for the watcher events before starting the watcher
deviceWatcher.Added += new TypedEventHandler<DeviceWatcher, DeviceInformation>(async (watcher, deviceInfo) =>
{
// Since we have the collection databound to a UI element, we need to update the collection on the UI thread.
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
// Make sure device name isn't blank
if(deviceInfo.Name != "")
{
ResultCollection.Add(new RfcommChatDeviceDisplay(deviceInfo));
rootPage.NotifyUser(
String.Format("{0} devices found.", ResultCollection.Count),
NotifyType.StatusMessage);
}
});
});
deviceWatcher.Updated += new TypedEventHandler<DeviceWatcher, DeviceInformationUpdate>(async (watcher, deviceInfoUpdate) =>
{
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
foreach (RfcommChatDeviceDisplay rfcommInfoDisp in ResultCollection)
{
if (rfcommInfoDisp.Id == deviceInfoUpdate.Id)
{
rfcommInfoDisp.Update(deviceInfoUpdate);
break;
}
}
});
});
deviceWatcher.EnumerationCompleted += new TypedEventHandler<DeviceWatcher, Object>(async (watcher, obj) =>
{
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
rootPage.NotifyUser(
String.Format("{0} devices found. Enumeration completed. Watching for updates...", ResultCollection.Count),
NotifyType.StatusMessage);
});
});
deviceWatcher.Removed += new TypedEventHandler<DeviceWatcher, DeviceInformationUpdate>(async (watcher, deviceInfoUpdate) =>
{
// Since we have the collection databound to a UI element, we need to update the collection on the UI thread.
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
// Find the corresponding DeviceInformation in the collection and remove it
foreach (RfcommChatDeviceDisplay rfcommInfoDisp in ResultCollection)
{
if (rfcommInfoDisp.Id == deviceInfoUpdate.Id)
{
ResultCollection.Remove(rfcommInfoDisp);
break;
}
}
rootPage.NotifyUser(
String.Format("{0} devices found.", ResultCollection.Count),
NotifyType.StatusMessage);
});
});
deviceWatcher.Stopped += new TypedEventHandler<DeviceWatcher, Object>(async (watcher, obj) =>
{
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
rootPage.NotifyUser(
String.Format("{0} devices found. Watcher {1}.",
ResultCollection.Count,
DeviceWatcherStatus.Aborted == watcher.Status ? "aborted" : "stopped"),
NotifyType.StatusMessage);
ResultCollection.Clear();
RunButton.IsEnabled = true;
});
});
deviceWatcher.Start();
}
/// <summary>
/// Starts a device watcher that looks for all nearby BT devices (paired or unpaired). Attaches event handlers and
/// populates the collection of devices.
/// </summary>
private void StartBleDeviceWatcher()
{
EnumerateButton.Content = "Stop enumerating";
// Additional properties we would like about the device.
string[] requestedProperties = { "System.Devices.Aep.DeviceAddress", "System.Devices.Aep.IsConnected" };
// BT_Code: Currently Bluetooth APIs don't provide a selector to get ALL devices that are both paired and non-paired.
deviceWatcher =
DeviceInformation.CreateWatcher(
"(System.Devices.Aep.ProtocolId:=\"{bb7bb05e-5972-42b5-94fc-76eaa7084d49}\")",
requestedProperties,
DeviceInformationKind.AssociationEndpoint);
// Register event handlers before starting the watcher.
deviceWatcher.Added += DeviceWatcher_Added;
deviceWatcher.Updated += DeviceWatcher_Updated;
deviceWatcher.Removed += DeviceWatcher_Removed;
deviceWatcher.EnumerationCompleted += DeviceWatcher_EnumerationCompleted;
deviceWatcher.Stopped += DeviceWatcher_Stopped;
// Start over with an empty collection.
ResultCollection.Clear();
// Start the watcher.
deviceWatcher.Start();
}
/// <summary>
/// Start the Device Watcher and set callbacks to handle devices appearing and disappearing
/// </summary>
private void StartWatcher()
{
//ProtocolSelectorInfo protocolSelectorInfo;
string aqsFilter = @"System.Devices.Aep.ProtocolId:=""{e0cbf06c-cd8b-4647-bb8a-263b43f0f974}"" OR System.Devices.Aep.ProtocolId:=""{bb7bb05e-5972-42b5-94fc-76eaa7084d49}"""; //Bluetooth + BluetoothLE
// Request the IsPaired property so we can display the paired status in the UI
string[] requestedProperties = { "System.Devices.Aep.IsPaired" };
//// Get the device selector chosen by the UI, then 'AND' it with the 'CanPair' property
//protocolSelectorInfo = (ProtocolSelectorInfo)selectorComboBox.SelectedItem;
//aqsFilter = protocolSelectorInfo.Selector + " AND System.Devices.Aep.CanPair:=System.StructuredQueryType.Boolean#True";
deviceWatcher = DeviceInformation.CreateWatcher(
aqsFilter,
requestedProperties,
DeviceInformationKind.AssociationEndpoint
);
// Hook up handlers for the watcher events before starting the watcher
handlerAdded = new TypedEventHandler<DeviceWatcher, DeviceInformation>(async (watcher, deviceInfo) =>
{
// Since we have the collection databound to a UI element, we need to update the collection on the UI thread.
await MainPage.Current.UIThreadDispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
bluetoothDeviceObservableCollection.Add(new BluetoothDeviceInformationDisplay(deviceInfo));
});
});
deviceWatcher.Added += handlerAdded;
handlerUpdated = new TypedEventHandler<DeviceWatcher, DeviceInformationUpdate>(async (watcher, deviceInfoUpdate) =>
{
// Since we have the collection databound to a UI element, we need to update the collection on the UI thread.
await MainPage.Current.UIThreadDispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
// Find the corresponding updated DeviceInformation in the collection and pass the update object
// to the Update method of the existing DeviceInformation. This automatically updates the object
// for us.
foreach (BluetoothDeviceInformationDisplay deviceInfoDisp in bluetoothDeviceObservableCollection)
{
if (deviceInfoDisp.Id == deviceInfoUpdate.Id)
{
deviceInfoDisp.Update(deviceInfoUpdate);
break;
}
}
});
});
deviceWatcher.Updated += handlerUpdated;
handlerRemoved = new TypedEventHandler<DeviceWatcher, DeviceInformationUpdate>(async (watcher, deviceInfoUpdate) =>
{
// Since we have the collection databound to a UI element, we need to update the collection on the UI thread.
await MainPage.Current.UIThreadDispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
// Find the corresponding DeviceInformation in the collection and remove it
foreach (BluetoothDeviceInformationDisplay deviceInfoDisp in bluetoothDeviceObservableCollection)
{
if (deviceInfoDisp.Id == deviceInfoUpdate.Id)
{
bluetoothDeviceObservableCollection.Remove(deviceInfoDisp);
break;
}
}
});
});
deviceWatcher.Removed += handlerRemoved;
handlerEnumCompleted = new TypedEventHandler<DeviceWatcher, Object>(async (watcher, obj) =>
{
await MainPage.Current.UIThreadDispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
// Finished enumerating
});
});
deviceWatcher.EnumerationCompleted += handlerEnumCompleted;
handlerStopped = new TypedEventHandler<DeviceWatcher, Object>(async (watcher, obj) =>
{
await MainPage.Current.UIThreadDispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
// Device watcher stopped
});
});
deviceWatcher.Stopped += handlerStopped;
// Start the Device Watcher
deviceWatcher.Start();
}
public IDisposable Connect()
{
watcher.Start();
return(Disposable.Create(() => watcher.Stop()));
}
void StartWatcher()
{
//deviceWatcher = DeviceInformation.CreateWatcher(UsbDevice.GetDeviceSelector(0x04d8, 0xf426));
deviceWatcher = DeviceInformation.CreateWatcher(UsbDevice.GetDeviceSelector(TreehopperUsb.Settings.Vid, TreehopperUsb.Settings.Pid));
// Hook up handlers for the watcher events before starting the watcher
handlerAdded = new TypedEventHandler<DeviceWatcher, DeviceInformation>(async (watcher, deviceInfo) =>
{
Debug.WriteLine("Device added: " + deviceInfo.Name);
UsbConnection newConnection = new UsbConnection(deviceInfo);
TreehopperUsb newBoard = new TreehopperUsb(newConnection);
await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
connectedDevices.Add(newBoard);
});
try
{
if (boardAddedSignal.CurrentCount == 0)
boardAddedSignal.Release();
}
catch { }
});
deviceWatcher.Added += handlerAdded;
handlerUpdated = new TypedEventHandler<DeviceWatcher, DeviceInformationUpdate>((watcher, deviceInfoUpdate) =>
{
Debug.WriteLine("Device updated");
});
deviceWatcher.Updated += handlerUpdated;
handlerRemoved = new TypedEventHandler<DeviceWatcher, DeviceInformationUpdate>(async (watcher, deviceInfoUpdate) =>
{
Debug.WriteLine("Device removed");
await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
connectedDevices.Where(board => ((UsbConnection)(board.Connection)).DevicePath == deviceInfoUpdate.Id).ToList().All(i =>
{
i.Disconnect();
connectedDevices.Remove(i);
return true;
}
);
});
});
deviceWatcher.Removed += handlerRemoved;
handlerEnumCompleted = new TypedEventHandler<DeviceWatcher, Object>((watcher, obj) =>
{
Debug.WriteLine("Enum completed");
});
deviceWatcher.EnumerationCompleted += handlerEnumCompleted;
handlerStopped = new TypedEventHandler<DeviceWatcher, Object>((watcher, obj) =>
{
Debug.WriteLine("Device or something stopped");
});
deviceWatcher.Stopped += handlerStopped;
Debug.WriteLine("Starting the wutchah");
deviceWatcher.Start();
}
private void Start()
{
ScenarioCleanup();
m_busAttachment = new AllJoynBusAttachment();
m_busAttachment.StateChanged += BusAttachment_StateChanged;
m_busAttachment.AuthenticationMechanisms.Clear();
m_busAttachment.AuthenticationMechanisms.Add(AllJoynAuthenticationMechanism.EcdheSpeke);
m_busAttachment.AuthenticationComplete += BusAttachment_AuthenticationComplete;
m_busAttachment.CredentialsRequested += BusAttachment_CredentialsRequested;
// Initialize a watcher object to listen for about interfaces.
m_watcher = AllJoynBusAttachment.GetWatcher(new List<string> { "com.microsoft.Samples.SecureInterface" });
// Subscribing to the added event that will be raised whenever a producer for this service is found.
m_watcher.Added += Watcher_Added;
UpdateStatusAsync("Searching...", NotifyType.StatusMessage);
// Start watching for producers advertising this service.
m_watcher.Start();
}
private void ScanForOnboardingInterfaces()
{
ScenarioCleanup();
// Allow re-joining of a new session
Interlocked.Exchange(ref m_onboardSessionAlreadyJoined, 0);
m_busAttachment = new AllJoynBusAttachment();
m_busAttachment.StateChanged += BusAttachment_StateChanged;
m_busAttachment.AuthenticationMechanisms.Clear();
// EcdhePsk authentication is deprecated as of the AllJoyn 16.04 release.
// Newly added EcdheSpeke should be used instead. EcdhePsk authentication is
// added here to maintain compatibility with devices running older AllJoyn versions.
m_busAttachment.AuthenticationMechanisms.Add(AllJoynAuthenticationMechanism.EcdheNull);
m_busAttachment.AuthenticationMechanisms.Add(AllJoynAuthenticationMechanism.EcdhePsk);
m_busAttachment.AuthenticationMechanisms.Add(AllJoynAuthenticationMechanism.EcdheSpeke);
m_busAttachment.AuthenticationComplete += BusAttachment_AuthenticationComplete;
m_busAttachment.CredentialsRequested += BusAttachment_CredentialsRequested;
m_watcher = AllJoynBusAttachment.GetWatcher(new List<string> { "org.alljoyn.Onboarding" });
m_watcher.Added += Watcher_Added;
UpdateStatusAsync("Searching for onboarding interface...", NotifyType.StatusMessage);
m_watcher.Start();
}
/// <summary>
/// Uses a device watcher to monitor for available DSN-SD instances.
/// </summary>
public override async Task<bool> StartListeningAsync()
{
bool status = false;
if (_watcher == null)
{
_watcher = DeviceInformation.CreateWatcher(
_aqsQueryString,
_propertyKeys,
DeviceInformationKind.AssociationEndpointService);
_watcher.Added += async (s, a) => await OnFoundDnssdServiceAsync(a.Properties);
_watcher.Updated += async (s, a) => await OnFoundDnssdServiceAsync(a.Properties);
_watcher.Start();
status = true;
}
await Task.CompletedTask;
return status;
}
private void StartWatcher()
{
ProtocolSelectorInfo protocolSelectorInfo;
string aqsFilter;
startWatcherButton.IsEnabled = false;
ResultCollection.Clear();
// Request the IsPaired property so we can display the paired status in the UI
string[] requestedProperties = {"System.Devices.Aep.IsPaired"};
// Get the device selector chosen by the UI, then 'AND' it with the 'CanPair' property
protocolSelectorInfo = (ProtocolSelectorInfo)selectorComboBox.SelectedItem;
aqsFilter = protocolSelectorInfo.Selector + " AND System.Devices.Aep.CanPair:=System.StructuredQueryType.Boolean#True";
deviceWatcher = DeviceInformation.CreateWatcher(
aqsFilter,
requestedProperties,
DeviceInformationKind.AssociationEndpoint
);
// Hook up handlers for the watcher events before starting the watcher
handlerAdded = new TypedEventHandler<DeviceWatcher, DeviceInformation>(async (watcher, deviceInfo) =>
{
// Since we have the collection databound to a UI element, we need to update the collection on the UI thread.
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
ResultCollection.Add(new DeviceInformationDisplay(deviceInfo));
rootPage.NotifyUser(
String.Format("{0} devices found.", ResultCollection.Count),
NotifyType.StatusMessage);
});
});
deviceWatcher.Added += handlerAdded;
handlerUpdated = new TypedEventHandler<DeviceWatcher, DeviceInformationUpdate>(async (watcher, deviceInfoUpdate) =>
{
// Since we have the collection databound to a UI element, we need to update the collection on the UI thread.
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
// Find the corresponding updated DeviceInformation in the collection and pass the update object
// to the Update method of the existing DeviceInformation. This automatically updates the object
// for us.
foreach (DeviceInformationDisplay deviceInfoDisp in ResultCollection)
{
if (deviceInfoDisp.Id == deviceInfoUpdate.Id)
{
deviceInfoDisp.Update(deviceInfoUpdate);
break;
}
}
});
});
deviceWatcher.Updated += handlerUpdated;
handlerRemoved = new TypedEventHandler<DeviceWatcher, DeviceInformationUpdate>(async (watcher, deviceInfoUpdate) =>
{
// Since we have the collection databound to a UI element, we need to update the collection on the UI thread.
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
// Find the corresponding DeviceInformation in the collection and remove it
foreach (DeviceInformationDisplay deviceInfoDisp in ResultCollection)
{
if (deviceInfoDisp.Id == deviceInfoUpdate.Id)
{
ResultCollection.Remove(deviceInfoDisp);
break;
}
}
rootPage.NotifyUser(
String.Format("{0} devices found.", ResultCollection.Count),
NotifyType.StatusMessage);
});
});
deviceWatcher.Removed += handlerRemoved;
handlerEnumCompleted = new TypedEventHandler<DeviceWatcher, Object>(async (watcher, obj) =>
{
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
rootPage.NotifyUser(
String.Format("{0} devices found. Enumeration completed. Watching for updates...", ResultCollection.Count),
NotifyType.StatusMessage);
});
});
deviceWatcher.EnumerationCompleted += handlerEnumCompleted;
handlerStopped = new TypedEventHandler<DeviceWatcher, Object>(async (watcher, obj) =>
{
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
rootPage.NotifyUser(
String.Format("{0} devices found. Watcher {1}.",
ResultCollection.Count,
DeviceWatcherStatus.Aborted == watcher.Status ? "aborted" : "stopped"),
NotifyType.StatusMessage);
});
});
deviceWatcher.Stopped += handlerStopped;
rootPage.NotifyUser("Starting Watcher...", NotifyType.StatusMessage);
deviceWatcher.Start();
stopWatcherButton.IsEnabled = true;
}
public async void Start()
{
try
{
_iconFile = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///IoTOnboardingService/icon72x72.png"));
var connectionProfiles = NetworkInformation.GetConnectionProfiles();
foreach (var profile in connectionProfiles)
{
if (profile.IsWlanConnectionProfile)
{
lock (_stateLock)
{
_state = OnboardingState.ConfiguredValidated;
}
break;
}
}
if (_softAccessPoint == null)
{
_softAccessPoint = new OnboardingAccessPoint(string.Format(_resourceLoader.GetString("SoftApSsidTemplate"), _onboardingInstanceId), _resourceLoader.GetString("SoftApPassword"));
}
if (_busAttachment == null)
{
_busAttachment = new AllJoynBusAttachment();
_busAttachment.AboutData.DefaultDescription = string.Format(_resourceLoader.GetString("DefaultDescriptionTemplate"), _onboardingInstanceId);
_busAttachment.AboutData.DefaultManufacturer = _resourceLoader.GetString("DefaultManufacturer");
_busAttachment.AboutData.ModelNumber = _resourceLoader.GetString("ModelNumber");
_onboardingProducer = new OnboardingProducer(_busAttachment);
_onboardingProducer.Service = this;
_iconProducer = new IconProducer(_busAttachment);
_iconProducer.Service = this;
}
if (_deviceWatcher == null)
{
var accessStatus = await WiFiAdapter.RequestAccessAsync();
if (accessStatus == WiFiAccessStatus.Allowed)
{
_deviceWatcher = DeviceInformation.CreateWatcher(WiFiAdapter.GetDeviceSelector());
_deviceWatcher.Added += this.HandleAdapterAdded;
_deviceWatcher.Removed += this.HandleAdapterRemoved;
_deviceWatcher.Start();
}
}
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
}
}
private void InitDiscovery()
{
discoverTask = null;
deviceWatcher = DeviceInformation.CreateWatcher(DeviceClass.PortableStorageDevice);
if (deviceWatcher != null)
{
deviceWatcher.Added += DeviceAdded;
deviceWatcher.Removed += DeviceRemoved;
deviceWatcher.Start();
}
}
public SourceGroupCollection(CoreDispatcher uiDispatcher)
{
_dispatcher = uiDispatcher;
_sourceCollection = new ObservableCollection<FrameSourceGroupModel>();
// Only listen to devices with type of MediaFrameSourceGroup
var deviceSelector = MediaFrameSourceGroup.GetDeviceSelector();
_watcher = DeviceInformation.CreateWatcher(deviceSelector);
_watcher.Added += Watcher_Added;
_watcher.Removed += Watcher_Removed;
_watcher.Updated += Watcher_Updated;
_watcher.Start();
}
private void StartWatcher()
{
aqsFilterTextBox.IsEnabled = false;
startWatcherButton.IsEnabled = false;
ResultCollection.Clear();
// Request some additional properties. In this saample, these extra properties are just used in the ResultsListViewTemplate.
// Take a look there in the XAML. Also look at the coverter used by the XAML GeneralPropertyValueConverter. In general you just use
// DeviceInformation.Properties["<property name>"] to get a property. e.g. DeviceInformation.Properties["System.Devices.InterfaceClassGuid"].
string[] requestedProperties = new string[] {
"System.Devices.InterfaceClassGuid",
"System.ItemNameDisplay"
};
// Use AQS string filter from the text box
deviceWatcher = DeviceInformation.CreateWatcher(
aqsFilterTextBox.Text,
requestedProperties
);
// Hook up handlers for the watcher events before starting the watcher
handlerAdded = new TypedEventHandler<DeviceWatcher, DeviceInformation>(async (watcher, deviceInfo) =>
{
// Since we have the collection databound to a UI element, we need to update the collection on the UI thread.
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
ResultCollection.Add(new DeviceInformationDisplay(deviceInfo));
rootPage.NotifyUser(
String.Format("{0} devices found.", ResultCollection.Count),
NotifyType.StatusMessage);
});
});
deviceWatcher.Added += handlerAdded;
handlerUpdated = new TypedEventHandler<DeviceWatcher, DeviceInformationUpdate>(async (watcher, deviceInfoUpdate) =>
{
// Since we have the collection databound to a UI element, we need to update the collection on the UI thread.
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
// Find the corresponding updated DeviceInformation in the collection and pass the update object
// to the Update method of the existing DeviceInformation. This automatically updates the object
// for us.
foreach (DeviceInformationDisplay deviceInfoDisp in ResultCollection)
{
if (deviceInfoDisp.Id == deviceInfoUpdate.Id)
{
deviceInfoDisp.Update(deviceInfoUpdate);
break;
}
}
});
});
deviceWatcher.Updated += handlerUpdated;
handlerRemoved = new TypedEventHandler<DeviceWatcher, DeviceInformationUpdate>(async (watcher, deviceInfoUpdate) =>
{
// Since we have the collection databound to a UI element, we need to update the collection on the UI thread.
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
// Find the corresponding DeviceInformation in the collection and remove it
foreach (DeviceInformationDisplay deviceInfoDisp in ResultCollection)
{
if (deviceInfoDisp.Id == deviceInfoUpdate.Id)
{
ResultCollection.Remove(deviceInfoDisp);
break;
}
}
rootPage.NotifyUser(
String.Format("{0} devices found.", ResultCollection.Count),
NotifyType.StatusMessage);
});
});
deviceWatcher.Removed += handlerRemoved;
handlerEnumCompleted = new TypedEventHandler<DeviceWatcher, Object>(async (watcher, obj) =>
{
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
rootPage.NotifyUser(
String.Format("{0} devices found. Enumeration completed. Watching for updates...", ResultCollection.Count),
NotifyType.StatusMessage);
});
});
deviceWatcher.EnumerationCompleted += handlerEnumCompleted;
handlerStopped = new TypedEventHandler<DeviceWatcher, Object>(async (watcher, obj) =>
{
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
rootPage.NotifyUser(
String.Format("{0} devices found. Watcher {1}.",
ResultCollection.Count,
DeviceWatcherStatus.Aborted == watcher.Status ? "aborted" : "stopped"),
NotifyType.StatusMessage);
});
});
deviceWatcher.Stopped += handlerStopped;
rootPage.NotifyUser("Starting Watcher...", NotifyType.StatusMessage);
deviceWatcher.Start();
stopWatcherButton.IsEnabled = true;
stopWatcherButton.Focus(FocusState.Keyboard);
aqsFilterTextBox.IsEnabled = true;
}
private void btnWatcher_Click(object sender, Windows.UI.Xaml.RoutedEventArgs e)
{
if (_fWatcherStarted == false)
{
btnWatcher.Content = "Stop Watcher";
_fWatcherStarted = true;
_discoveredDevices.Clear();
rootPage.NotifyUser("Finding Devices...", NotifyType.StatusMessage);
_deviceWatcher = null;
String deviceSelector = WiFiDirectDevice.GetDeviceSelector((cmbDeviceSelector.ToString().Equals("Device Interface") == true) ?
WiFiDirectDeviceSelectorType.DeviceInterface : WiFiDirectDeviceSelectorType.AssociationEndpoint);
_deviceWatcher = DeviceInformation.CreateWatcher(deviceSelector, new string[] { "System.Devices.WiFiDirect.InformationElements" });
_deviceWatcher.Added += OnDeviceAdded;
_deviceWatcher.Removed += OnDeviceRemoved;
_deviceWatcher.Updated += OnDeviceUpdated;
_deviceWatcher.EnumerationCompleted += OnEnumerationCompleted;
_deviceWatcher.Stopped += OnStopped;
_deviceWatcher.Start();
}
else
{
btnWatcher.Content = "Start Watcher";
_fWatcherStarted = false;
_deviceWatcher.Added -= OnDeviceAdded;
_deviceWatcher.Removed -= OnDeviceRemoved;
_deviceWatcher.Updated -= OnDeviceUpdated;
_deviceWatcher.EnumerationCompleted -= OnEnumerationCompleted;
_deviceWatcher.Stopped -= OnStopped;
_deviceWatcher.Stop();
}
}
