private async void PairButton_Click(object sender, RoutedEventArgs e)
{
// Gray out the pair button and results view while pairing is in progress.
resultsListView.IsEnabled = false;
pairButton.IsEnabled = false;
rootPage.NotifyUser("Pairing started. Please wait...", NotifyType.StatusMessage);
// Get the device selected for pairing
DeviceInformationDisplay deviceInfoDisp = resultsListView.SelectedItem as DeviceInformationDisplay;
// Get ceremony type and protection level selections
DevicePairingKinds ceremoniesSelected = GetSelectedCeremonies();
ProtectionLevelSelectorInfo protectionLevelInfo = (ProtectionLevelSelectorInfo)protectionLevelComboBox.SelectedItem;
DevicePairingProtectionLevel protectionLevel = protectionLevelInfo.ProtectionLevel;
DeviceInformationCustomPairing customPairing = deviceInfoDisp.DeviceInformation.Pairing.Custom;
customPairing.PairingRequested += PairingRequestedHandler;
DevicePairingResult result = await customPairing.PairAsync(ceremoniesSelected, protectionLevel);
customPairing.PairingRequested -= PairingRequestedHandler;
rootPage.NotifyUser(
"Pairing result = " + result.Status.ToString(),
result.Status == DevicePairingResultStatus.Paired ? NotifyType.StatusMessage : NotifyType.ErrorMessage);
HidePairingPanel();
UpdatePairingButtons();
resultsListView.IsEnabled = true;
}
/// <summary>
/// Called when custom pairing is initiated so that we can handle the custom ceremony
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
private async void PairingRequestedHandler(
DeviceInformationCustomPairing sender,
DevicePairingRequestedEventArgs args)
{
// Save the args for use in ProvidePin case
pairingRequestedHandlerArgs = args;
// Save the deferral away and complete it where necessary.
if (args.PairingKind != DevicePairingKinds.DisplayPin)
{
deferral = args.GetDeferral();
}
string confirmationMessage;
switch (args.PairingKind)
{
case DevicePairingKinds.ConfirmOnly:
// Windows itself will pop the confirmation dialog as part of "consent" if this is running on Desktop or Mobile
// If this is an App for Athens where there is no Windows Consent UX, you may want to provide your own confirmation.
{
confirmationMessage = string.Format(bluetoothConfirmOnlyFormatString, args.DeviceInformation.Name, args.DeviceInformation.Id);
DisplayMessagePanelAsync(confirmationMessage, MessageType.InformationalMessage);
// Accept the pairing which also completes the deferral
AcceptPairing();
}
break;
case DevicePairingKinds.DisplayPin:
// We just show the PIN on this side. The ceremony is actually completed when the user enters the PIN
// on the target device
{
confirmationMessage = string.Format(bluetoothDisplayPinFormatString, args.Pin);
DisplayMessagePanelAsync(confirmationMessage, MessageType.OKMessage);
}
break;
case DevicePairingKinds.ProvidePin:
// A PIN may be shown on the target device and the user needs to enter the matching PIN on
// this Windows device.
await MainPage.Current.UIThreadDispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
// PIN Entry
inProgressPairButton.Flyout = savedPairButtonFlyout;
inProgressPairButton.Flyout.ShowAt(inProgressPairButton);
});
break;
case DevicePairingKinds.ConfirmPinMatch:
// We show the PIN here and the user responds with whether the PIN matches what they see
// on the target device. Response comes back and we set it on the PinComparePairingRequestedData
// then complete the deferral.
{
confirmationMessage = string.Format(bluetoothConfirmPinMatchFormatString, args.Pin);
DisplayMessagePanelAsync(confirmationMessage, MessageType.YesNoMessage);
}
break;
}
}
private void CustomOnPairingRequested(
DeviceInformationCustomPairing sender,
DevicePairingRequestedEventArgs args)
{
Console.WriteLine("Done Pairing");
args.Accept("0");
}
private static void PairingRequestedHandler(DeviceInformationCustomPairing sender, DevicePairingRequestedEventArgs args, string pin)
{
switch (args.PairingKind)
{
case DevicePairingKinds.ConfirmOnly:
Console.WriteLine("Pairing mode: ConfirmOnly");
args.Accept();
return;
case DevicePairingKinds.ProvidePin:
Console.WriteLine("Pairing mode: ProvidePin");
Console.WriteLine($"Pin is requested by the device. Using '{pin}' as a pin code");
args.Accept(pin);
return;
case DevicePairingKinds.ConfirmPinMatch:
Console.WriteLine("Pairing mode: ConfirmPinMatch");
Console.WriteLine($"The device's pin code: '{args.Pin}'");
Console.WriteLine("Waiting for the target device to accept the pairing (you probably need to follow the instructions on the target device's screen)");
args.Accept();
return;
}
Console.WriteLine($"Unexpected pairing type: {args.PairingKind}");
throw new Exception();
}
private async void DeviceDiscovered(BluetoothLEAdvertisementWatcher sender, BluetoothLEAdvertisementReceivedEventArgs advertisement)
{
var isNew = false;
lock (this)
{
if (false == advertisedDevices.Contains(advertisement.BluetoothAddress))
{
this.advertisedDevices.Add(advertisement.BluetoothAddress);
isNew = true;
}
}
if (true == isNew)
{
var device = await BluetoothLEDevice.FromBluetoothAddressAsync(advertisement.BluetoothAddress);
DevicePairingKinds ceremoniesSelected = DevicePairingKinds.ConfirmOnly;
DevicePairingProtectionLevel protectionLevel = DevicePairingProtectionLevel.None;
DeviceInformationCustomPairing customPairing = device.DeviceInformation.Pairing.Custom;
customPairing.PairingRequested += PairingRequestedHandler;
DevicePairingResult result = await customPairing.PairAsync(ceremoniesSelected, protectionLevel);
customPairing.PairingRequested -= PairingRequestedHandler;
if ((result.Status == DevicePairingResultStatus.AlreadyPaired) || (result.Status == DevicePairingResultStatus.Paired))
{
sender.Stop();
}
}
}
public async Task <bool> ConnectWithPin()
{
ulong address = this.Address;
DeviceInformation deviceInformation = bluetoothLEDevice.DeviceInformation;
if (deviceInformation.Pairing.CanPair)
{
DeviceInformationCustomPairing customPairing = deviceInformation.Pairing.Custom;
customPairing.PairingRequested += OnCustomPairingRequested;
DevicePairingResult result = await customPairing.PairAsync(DevicePairingKinds.ProvidePin);
customPairing.PairingRequested -= OnCustomPairingRequested;
if ((result.Status == DevicePairingResultStatus.Paired) || (result.Status == DevicePairingResultStatus.AlreadyPaired))
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
/// <summary>
/// Called to pair a targeted device
/// </summary>
/// <param name="pairButton">Pair button</param>
/// <param name="currentDevice">Displayable information for the targeted device</param>
public async Task PairingRequestedAsync(Button pairButton, BluetoothDeviceInfo currentDevice)
{
try
{
_deviceInfo = currentDevice;
_inProgressPairButton = pairButton;
// Display confirmation message panel
string deviceIdentifier = _deviceInfo.Name != BluetoothDeviceNameUnknownText ? _deviceInfo.Name : _deviceInfo.IdWithoutProtocolPrefix;
string confirmationMessage = string.Format(BluetoothAttemptingToPairFormat, _deviceInfo.Name, _deviceInfo.IdWithoutProtocolPrefix);
await DisplayMessagePanel(confirmationMessage, MessageType.InformationalMessage);
// Save the flyout and set to null so it doesn't appear without explicitly being called
_savedPairButtonFlyout = pairButton.Flyout;
_inProgressPairButton.Flyout = null;
pairButton.IsEnabled = false;
// Specify custom pairing with all ceremony types and protection level EncryptionAndAuthentication
DevicePairingKinds ceremoniesSelected = GetSelectedCeremonies();
DevicePairingProtectionLevel protectionLevel = DevicePairingProtectionLevel.Default;
// Setup a custom pairing and handler, then get the results of the request
DeviceInformationCustomPairing customPairing = _deviceInfo.DeviceInformation.Pairing.Custom;
customPairing.PairingRequested += PairingRequestedHandlerAsync;
DevicePairingResult result = await customPairing.PairAsync(ceremoniesSelected, protectionLevel);
if (result.Status == DevicePairingResultStatus.Paired)
{
confirmationMessage = string.Format(BluetoothPairingSuccessFormat, deviceIdentifier, result.Status.ToString());
}
else
{
confirmationMessage = string.Format(BluetoothPairingFailureFormat, deviceIdentifier, result.Status.ToString());
}
// Display the result of the pairing attempt
await DisplayMessagePanel(confirmationMessage, MessageType.InformationalMessage);
// If the watcher toggle is on, clear any devices in the list and stop and restart the watcher to ensure their current state is reflected
if (BluetoothWatcherEnabled)
{
BluetoothDeviceCollection.Clear();
StopWatcher();
StartWatcherAsync();
}
else
{
// If the watcher is off, this is an inbound request so we only need to clear the list
BluetoothDeviceCollection.Clear();
}
_inProgressPairButton = null;
pairButton.IsEnabled = true;
}
catch (Exception ex)
{
LogService.Write(ex.ToString(), LoggingLevel.Error);
}
}
private void OnCustomPairingRequested(DeviceInformationCustomPairing sender, DevicePairingRequestedEventArgs args)
{
while (pin == null)
{
Thread.Sleep(500);
}
args.Accept(pin);
pin = null;
}
/// <summary>
/// ペアリング要求時のハンドラ
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
private static void PairingRequestedHandler(DeviceInformationCustomPairing sender, DevicePairingRequestedEventArgs args)
{
switch (args.PairingKind)
{
case DevicePairingKinds.ConfirmOnly:
args.Accept();
break;
}
}
private void handlerPairingReq(DeviceInformationCustomPairing CP, DevicePairingRequestedEventArgs DPR)
{
//so we get here for custom pairing request.
//this is the magic place where your pin goes.
//my device actually does not require a pin but
//windows requires at least a "0". So this solved
//it. This does not pull up the Windows UI either.
DPR.Accept("0");
}
private async void CustomPairInfo_PairingRequested(DeviceInformationCustomPairing sender, DevicePairingRequestedEventArgs args)
{
Deferral PairDeferral = args.GetDeferral();
try
{
PairConfirmaion = new TaskCompletionSource <bool>();
switch (args.PairingKind)
{
case DevicePairingKinds.ConfirmPinMatch:
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Tips.Text = $"{Globalization.GetString("BluetoothUI_Tips_Text_5")}{Environment.NewLine}{args.Pin}";
Tips.Visibility = Visibility.Visible;
PinConfirm.Visibility = Visibility.Visible;
PinRefuse.Visibility = Visibility.Visible;
});
if (await PairConfirmaion.Task)
{
args.Accept(args.Pin);
}
break;
}
case DevicePairingKinds.ConfirmOnly:
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Tips.Text = Globalization.GetString("BluetoothUI_Tips_Text_6");
Tips.Visibility = Visibility.Visible;
PinConfirm.Visibility = Visibility.Visible;
PinRefuse.Visibility = Visibility.Visible;
});
if (await PairConfirmaion.Task)
{
args.Accept();
}
break;
}
}
}
catch (Exception ex)
{
LogTracer.Log(ex, $"An exception was threw in {nameof(CustomPairInfo_PairingRequested)}, pair with bluetooth failed");
}
finally
{
PairDeferral.Complete();
}
}
/// <summary>
/// Called when a custom pairing is initiated so that we can handle its custom ceremony
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
public async void PairingRequestedHandlerAsync(DeviceInformationCustomPairing sender, DevicePairingRequestedEventArgs args)
{
LogService.Write((Enum.GetName(typeof(DevicePairingKinds), args.PairingKind)), LoggingLevel.Information);
BluetoothDeviceInfo currentDevice = new BluetoothDeviceInfo(args.DeviceInformation);
// Save the args for use in ProvidePin case
_pairingRequestedArgs = args;
// Save the deferral away and complete it where necessary.
if (args.PairingKind != DevicePairingKinds.DisplayPin)
{
_deferral = args.GetDeferral();
}
switch (args.PairingKind)
{
// Windows itself will pop the confirmation dialog as part of "consent" depending on which operating OS is running
case DevicePairingKinds.ConfirmOnly:
{
var confirmationMessage = string.Format(BluetoothConfirmOnlyText, args.DeviceInformation.Name, args.DeviceInformation.Id);
if (await DisplayMessagePanel(confirmationMessage, MessageType.InformationalMessage))
{
AcceptPairing();
}
}
break;
// We only show the PIN on this side. The ceremony is actually completed when the user enters the PIN on the target device.
case DevicePairingKinds.DisplayPin:
{
var confirmationMessage = string.Format(BluetoothDisplayPINText, args.Pin);
await DisplayMessagePanel(confirmationMessage, MessageType.OKMessage);
}
break;
// A PIN may be shown on the target device and the user needs to enter the matching PIN on the originating device.
case DevicePairingKinds.ProvidePin:
{
_inProgressPairButton.Flyout = _savedPairButtonFlyout;
_inProgressPairButton.Flyout.ShowAt(_inProgressPairButton);
}
break;
// We show the PIN here and the user responds with whether the PIN matches what is displayed on the target device.
case DevicePairingKinds.ConfirmPinMatch:
{
var confirmationMessage = string.Format(BluetoothConfirmPINMatchText, args.Pin);
if (await DisplayMessagePanel(confirmationMessage, MessageType.YesNoMessage))
{
AcceptPairing();
}
}
break;
}
}
public async void Connect()
{
// Repair the device if needed
if (!devInfo.Pairing.IsPaired)
{
Debug.WriteLine("Pairing...");
DeviceInformationCustomPairing customPairing = devInfo.Pairing.Custom;
customPairing.PairingRequested += PairingRequested;
DevicePairingResult result = await customPairing.PairAsync(DevicePairingKinds.ProvidePin, DevicePairingProtectionLevel.None);
customPairing.PairingRequested -= PairingRequested;
Debug.WriteLine("Pair status: " + result.Status);
}
else
{
Debug.WriteLine("Already Paired");
}
// Get the actual device
try {
device = await BluetoothDevice.FromIdAsync(devInfo.Id);
device.ConnectionStatusChanged += ConnectionStatusChanged;
} catch (Exception ex) {
Debug.WriteLine("Bluetooth Not Available");
return;
}
//try {
var services = await device.GetRfcommServicesAsync();
if (services.Services.Count > 0)
{
var service = services.Services[0];
stream = new StreamSocket();
//try {
await stream.ConnectAsync(service.ConnectionHostName, service.ConnectionServiceName);
//} catch (Exception ex) {
//Debug.WriteLine("Could not connect to device");
//}
Debug.WriteLine("Stream Connected");
rx = new DataReader(stream.InputStream);
rx.InputStreamOptions = InputStreamOptions.Partial;
tx = new DataWriter(stream.OutputStream);
OnConnected();
}
/*} catch (Exception ex) {
* Debug.WriteLine("Failed to get services");
* return;
* }*/
}
private async Task <bool> TryToPairDevice(DeviceInformation deviceInfo)
{
bool paired = false;
if (deviceInfo != null)
{
if (deviceInfo.Pairing.IsPaired != true)
{
paired = false;
DevicePairingKinds ceremoniesSelected = DevicePairingKinds.ConfirmOnly | DevicePairingKinds.DisplayPin | DevicePairingKinds.ProvidePin | DevicePairingKinds.ConfirmPinMatch;
DevicePairingProtectionLevel protectionLevel = DevicePairingProtectionLevel.Default;
// Specify custom pairing with all ceremony types and protection level EncryptionAndAuthentication
DeviceInformationCustomPairing customPairing = deviceInfo.Pairing.Custom;
customPairing.PairingRequested += PairingRequestedHandler;
DevicePairingResult result = await customPairing.PairAsync(ceremoniesSelected, protectionLevel);
customPairing.PairingRequested -= PairingRequestedHandler;
if (result.Status == DevicePairingResultStatus.Paired)
{
paired = true;
}
else
{
StatusText.Text = "Pairing Failed " + result.Status.ToString();
EnableRetry();
}
}
else
{
paired = true;
}
if (paired)
{
// device is paired, set up the sensor Tag
StatusText.Text = "Verbunden, pairing versuch...";
DeviceInfoConnected = deviceInfo;
//Start watcher for Bluetooth LE Services
StartBLEWatcher();
}
else
{
}
}
else
{
} //Null device
return(paired);
}
private async void TryPair(string val)
{
DeviceInformationDisplay _deviceInformationDisplayConnect = ResultCollection.Where(r => r.Id == val).FirstOrDefault();
DevicePairingKinds ceremoniesSelected = DevicePairingKinds.ConfirmOnly;
// ProtectionLevelSelectorInfo protectionLevelInfo = (ProtectionLevelSelectorInfo)protectionLevelComboBox.SelectedItem;
DevicePairingProtectionLevel protectionLevel = DevicePairingProtectionLevel.Default;
DeviceInformationCustomPairing customPairing = _deviceInformationDisplayConnect.DeviceInformation.Pairing.Custom;
customPairing.PairingRequested += PairingRequestedHandler;
DevicePairingResult result = await customPairing.PairAsync(ceremoniesSelected, protectionLevel);
customPairing.PairingRequested -= PairingRequestedHandler;
StopWatcher();
var bleDevice = await BluetoothLEDevice.FromIdAsync(_deviceInformationDisplayConnect.Id);
var accService = await GattDeviceService.FromIdAsync(_deviceInformationDisplayConnect.Id);
//Get the accelerometer data characteristic
var accData = accService.GetCharacteristics(new Guid("151c0000-4580-4111-9ca1-5056f3454fbc"))[0];
//Subcribe value changed
//accData.ValueChanged += AccData_ValueChanged;
accData.ValueChanged += test;
//Set configuration to notify
await accData.WriteClientCharacteristicConfigurationDescriptorAsync(GattClientCharacteristicConfigurationDescriptorValue.Notify);
//Get the accelerometer configuration characteristic
var accConfig = accService.GetCharacteristics(new Guid("151c0000-4580-4111-9ca1-5056f3454fbc"))[0];
GattReadResult Resultat = await accConfig.ReadValueAsync();
var Output = Resultat.Value.ToArray();
Debug.WriteLine("Acc: " + Output.Count());
Debug.WriteLine("Registre 0:" + Output[0].ToString());
Debug.WriteLine("Registre 1:" + Output[1].ToString());
Output[0] = 0x7F;
await accConfig.WriteValueAsync(Output.AsBuffer());
}
static async Task <bool> Pair(AnkiBLE.anki_vehicle vehicle)
{
BluetoothLEDevice device = await BluetoothLEDevice.FromBluetoothAddressAsync(vehicle.mac_address);
DeviceInformationCustomPairing customPairing = device.DeviceInformation.Pairing.Custom;
customPairing.PairingRequested += PairingRequestedHandler;
DevicePairingResult result = await customPairing.PairAsync(DevicePairingKinds.ConfirmOnly, DevicePairingProtectionLevel.None);
customPairing.PairingRequested -= PairingRequestedHandler;
return(result.Status == DevicePairingResultStatus.Paired || result.Status == DevicePairingResultStatus.AlreadyPaired);
}
private async void OnPairingRequested(DeviceInformationCustomPairing sender, DevicePairingRequestedEventArgs args)
{
switch (args.PairingKind)
{
case DevicePairingKinds.ConfirmOnly:
// Windows itself will pop the confirmation dialog as part of "consent" if this is running on Desktop or Mobile
// If this is an App for 'Windows IoT Core' where there is no Windows Consent UX, you may want to provide your own confirmation.
args.Accept();
break;
case DevicePairingKinds.DisplayPin:
// We just show the PIN on this side. The ceremony is actually completed when the user enters the PIN
// on the target device. We automatically except here since we can't really "cancel" the operation
// from this side.
args.Accept();
// No need for a deferral since we don't need any decision from the user
Debug.WriteLine("Please enter this PIN on the device you are pairing with: {0}", args.Pin);
break;
case DevicePairingKinds.ProvidePin:
// A PIN may be shown on the target device and the user needs to enter the matching PIN on
// this Windows device. Get a deferral so we can perform the async request to the user.
var collectPinDeferral = args.GetDeferral();
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
// NOT IMPLEMENTED - Make ASYNC
// GET PIN FROM USER
collectPinDeferral.Complete();
});
break;
case DevicePairingKinds.ConfirmPinMatch:
// We show the PIN here and the user responds with whether the PIN matches what they see
// on the target device. Response comes back and we set it on the PinComparePairingRequestedData
// then complete the deferral.
var displayMessageDeferral = args.GetDeferral();
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
// NOT IMPLEMENTED - Make ASYNC
// CONFIRM PIN MATCH
displayMessageDeferral.Complete();
});
break;
}
}
private void OnPairRequestedAsyncCallback(
DeviceInformationCustomPairing sender,
DevicePairingRequestedEventArgs args)
{
this.log.Info("OnPairRequested", () => string.Format("Paring kind {0}", args.PairingKind.ToString()));
BT_PairInfoRequest pairInfo = new BT_PairInfoRequest();
pairInfo.DeviceName = args.DeviceInformation.Name;
switch (args.PairingKind)
{
case DevicePairingKinds.ConfirmOnly:
// Windows itself will pop the confirmation dialog as part of "consent" if this is running on Desktop or Mobile
// If this is an App for 'Windows IoT Core' or a Desktop and Console application
// where there is no Windows Consent UX, you may want to provide your own confirmation.
args.Accept();
break;
case DevicePairingKinds.ProvidePin:
// A PIN may be shown on the target device and the user needs to enter the matching PIN on
// this Windows device. Get a deferral so we can perform the async request to the user.
using (Windows.Foundation.Deferral collectPinDeferral = args.GetDeferral()) {
pairInfo.PinRequested = true;
if (this.BT_PairInfoRequested != null)
{
this.BT_PairInfoRequested(this, pairInfo);
}
else
{
this.log.Error(9999, "No subscriber to pin request");
}
this.log.Info("OnPairRequested",
() => string.Format("Pin '{0}' Response:{1}",
pairInfo.Pin, pairInfo.Response));
if (pairInfo.Response)
{
// TODO Check for the result to see if you go ahead
}
if (!string.IsNullOrEmpty(pairInfo.Pin))
{
args.Accept(pairInfo.Pin);
}
// TODO - needs to be disposed
collectPinDeferral.Complete();
};
break;
}
}
private void Custom_PairingRequested(DeviceInformationCustomPairing sender, DevicePairingRequestedEventArgs args)
{
if (args.PairingKind == DevicePairingKinds.ProvidePin)
{
// add reference: Microsoft.VisualBasic.dll
string result = Microsoft.VisualBasic.Interaction.InputBox("Pin?", "Pairing...", "");
if (string.IsNullOrEmpty(result) == false)
{
args.Accept(result);
}
}
else
{
args.Accept();
}
}
private void PairingRequestedHandler(DeviceInformationCustomPairing sender, DevicePairingRequestedEventArgs arguments)
{
switch (arguments.PairingKind)
{
case DevicePairingKinds.ConfirmOnly:
arguments.Accept();
break;
case DevicePairingKinds.ProvidePin:
var collectPinDeferral = arguments.GetDeferral();
string pin = "000000";
arguments.Accept(pin);
collectPinDeferral.Complete();
break;
}
}
private async void PairButton_Click(object sender, RoutedEventArgs e)
{
DeviceInformationDisplay deviceInfoDisp = resultsListView.SelectedItem as DeviceInformationDisplay;
if (deviceInfoDisp != null)
{
PairButton.IsEnabled = false;
bool paired = true;
//if (deviceInfoDisp.IsPaired != true)
//{
paired = false;
DevicePairingKinds ceremoniesSelected = DevicePairingKinds.ConfirmOnly | DevicePairingKinds.DisplayPin | DevicePairingKinds.ProvidePin | DevicePairingKinds.ConfirmPinMatch;
DevicePairingProtectionLevel protectionLevel = DevicePairingProtectionLevel.Default;
// Specify custom pairing with all ceremony types and protection level EncryptionAndAuthentication
DeviceInformationCustomPairing customPairing = deviceInfoDisp.DeviceInformation.Pairing.Custom;
customPairing.PairingRequested += PairingRequestedHandler;
DevicePairingResult result = await customPairing.PairAsync(ceremoniesSelected, protectionLevel);
customPairing.PairingRequested -= PairingRequestedHandler;
if (result.Status == DevicePairingResultStatus.Paired)
{
paired = true;
}
else
{
//UserOut.Text = "Pairing Failed " + result.Status.ToString();
}
//UpdatePairingButtons();
//}
if (paired)
{
// device is paired, set up the sensor Tag
//UserOut.Text = "Setting up SensorTag";
//DeviceInfoConnected = deviceInfoDisp;
//Start watcher for Bluetooth LE Services
//StartBLEWatcher();
}
PairButton.IsEnabled = true;
}
}
private async void CustomPairInfo_PairingRequested(DeviceInformationCustomPairing sender, DevicePairingRequestedEventArgs args)
{
Deferral PairDeferral = args.GetDeferral();
switch (args.PairingKind)
{
case DevicePairingKinds.ConfirmPinMatch:
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Tips.Text = "请确认PIN码与配对设备一致\r" + args.Pin;
Tips.Visibility = Visibility.Visible;
PinConfirm.Visibility = Visibility.Visible;
PinRefuse.Visibility = Visibility.Visible;
});
break;
}
case DevicePairingKinds.ConfirmOnly:
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Tips.Text = "请确认是否与配对设备配对";
Tips.Visibility = Visibility.Visible;
PinConfirm.Visibility = Visibility.Visible;
PinRefuse.Visibility = Visibility.Visible;
});
break;
}
}
await Task.Run(() =>
{
PinLock.WaitOne();
if (IsPinConfirm)
{
args.Accept();
}
});
PairDeferral.Complete();
}
private async void CustomPairInfo_PairingRequested(DeviceInformationCustomPairing sender, DevicePairingRequestedEventArgs args)
{
Deferral PairDeferral = args.GetDeferral();
switch (args.PairingKind)
{
case DevicePairingKinds.ConfirmPinMatch:
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Tips.Text = $"{Globalization.GetString("BluetoothUI_Tips_Text_5")}{Environment.NewLine}{args.Pin}";
Tips.Visibility = Visibility.Visible;
PinConfirm.Visibility = Visibility.Visible;
PinRefuse.Visibility = Visibility.Visible;
});
break;
}
case DevicePairingKinds.ConfirmOnly:
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Tips.Text = Globalization.GetString("BluetoothUI_Tips_Text_6");
Tips.Visibility = Visibility.Visible;
PinConfirm.Visibility = Visibility.Visible;
PinRefuse.Visibility = Visibility.Visible;
});
break;
}
}
await Task.Run(() =>
{
PinLock.WaitOne();
if (IsPinConfirm)
{
args.Accept();
}
}).ConfigureAwait(false);
PairDeferral.Complete();
}
public async Task <bool> RequestPairDeviceAsync(DeviceInformationPairing pairing)
{
WiFiDirectConnectionParameters connectionParams = new WiFiDirectConnectionParameters();
short?groupOwnerIntent = Utils.GetSelectedItemTag <short?>(cmbGOIntent);
if (groupOwnerIntent.HasValue)
{
connectionParams.GroupOwnerIntent = groupOwnerIntent.Value;
}
DevicePairingKinds devicePairingKinds = DevicePairingKinds.None;
if (_supportedConfigMethods.Count > 0)
{
// If specific configuration methods were added, then use them.
foreach (var configMethod in _supportedConfigMethods)
{
connectionParams.PreferenceOrderedConfigurationMethods.Add(configMethod);
devicePairingKinds |= WiFiDirectConnectionParameters.GetDevicePairingKinds(configMethod);
}
}
else
{
// If specific configuration methods were not added, then we'll use these pairing kinds.
devicePairingKinds = DevicePairingKinds.ConfirmOnly | DevicePairingKinds.DisplayPin | DevicePairingKinds.ProvidePin;
}
connectionParams.PreferredPairingProcedure = Utils.GetSelectedItemTag <WiFiDirectPairingProcedure>(cmbPreferredPairingProcedure);
DeviceInformationCustomPairing customPairing = pairing.Custom;
customPairing.PairingRequested += OnPairingRequested;
DevicePairingResult result = await customPairing.PairAsync(devicePairingKinds, DevicePairingProtectionLevel.Default, connectionParams);
if (result.Status != DevicePairingResultStatus.Paired)
{
//rootPage.NotifyUser($"PairAsync failed, Status: {result.Status}", NotifyType.ErrorMessage);
return(false);
}
return(true);
}
public async Task <bool> RequestPairDeviceAsync(DeviceInformationPairing pairing)
{
WiFiDirectConnectionParameters connectionParams = new WiFiDirectConnectionParameters();
short?groupOwnerIntent = 1;
if (groupOwnerIntent.HasValue)
{
connectionParams.GroupOwnerIntent = groupOwnerIntent.Value;
}
DevicePairingKinds devicePairingKinds = DevicePairingKinds.None;
//if (_supportedConfigMethods.Count > 0)
//{
// // If specific configuration methods were added, then use them.
// foreach (var configMethod in _supportedConfigMethods)
// {
// connectionParams.PreferenceOrderedConfigurationMethods.Add(configMethod);
// devicePairingKinds |= WiFiDirectConnectionParameters.GetDevicePairingKinds(configMethod);
// }
//}
//else
{
// If specific configuration methods were not added, then we'll use these pairing kinds.
devicePairingKinds = DevicePairingKinds.ConfirmOnly;// | DevicePairingKinds.DisplayPin | DevicePairingKinds.ProvidePin;
}
connectionParams.PreferredPairingProcedure = WiFiDirectPairingProcedure.GroupOwnerNegotiation;
DeviceInformationCustomPairing customPairing = pairing.Custom;
customPairing.PairingRequested += OnPairingRequested;
DevicePairingResult result = await customPairing.PairAsync(devicePairingKinds, DevicePairingProtectionLevel.Default, connectionParams);
if (result.Status != DevicePairingResultStatus.Paired)
{
StatusBlock.Text = $"PairAsync failed, Status: {result.Status}";
return(false);
}
return(true);
}
/// <summary>
/// ペアリング実施
/// </summary>
/// <param name="devInfo"></param>
private async void DoPairing(DeviceInformation devInfo)
{
if (devInfo == null)
{
return;
}
if (devInfo.Pairing.IsPaired == false)
{
DeviceInformationCustomPairing customPairing = devInfo.Pairing.Custom;
customPairing.PairingRequested += PairingRequestedHandler;
DevicePairingResult result = await customPairing.PairAsync(DevicePairingKinds.ConfirmOnly, DevicePairingProtectionLevel.Default);
customPairing.PairingRequested -= PairingRequestedHandler;
Console.WriteLine("result is : " + result.Status);
Debug.WriteLine($"[{/*MethodBase.GetCurrentMethod().Name*/0}] ペアリング結果：{result.Status}");
}
else
{
Debug.WriteLine($"[{/*MethodBase.GetCurrentMethod().Name*/0}] すでにペアリング済み");
}
}
private async void ResultsListView_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
resultsListView.IsEnabled = false;
string val = resultsListView.SelectedValue.ToString();
deviceInfoDisp = ResultCollection.Where(r => r.Id == val).FirstOrDefault();
this.NotifyUser("Unpairing started. Please wait...", NotifyType.StatusMessage);
DevicePairingKinds ceremoniesSelected = DevicePairingKinds.ConfirmOnly;
// ProtectionLevelSelectorInfo protectionLevelInfo = (ProtectionLevelSelectorInfo)protectionLevelComboBox.SelectedItem;
DevicePairingProtectionLevel protectionLevel = DevicePairingProtectionLevel.Default;
DeviceInformationCustomPairing customPairing = deviceInfoDisp.DeviceInformation.Pairing.Custom;
Debug.WriteLine("Is Paired -- " + deviceInfoDisp.IsPaired);
customPairing.PairingRequested += PairingRequestedHandler;
DevicePairingResult result = await customPairing.PairAsync(ceremoniesSelected, protectionLevel);
customPairing.PairingRequested -= PairingRequestedHandler;
if (result.Status == DevicePairingResultStatus.Paired || result.Status == DevicePairingResultStatus.AlreadyPaired)
{
Debug.WriteLine("Paired..");
}
deviceInfoDisp = ResultCollection.Where(r => r.Id == val).FirstOrDefault();
Debug.WriteLine("Is Paired -- " + deviceInfoDisp.IsPaired);
//this.NotifyUser(
// "Unpairing result = " + result.Status.ToString(),
// result.Status == DeviceUnpairingResultStatus.Unpaired ? NotifyType.StatusMessage : NotifyType.ErrorMessage);
UpdateButtons(deviceInfoDisp);
resultsListView.IsEnabled = true;
}
/// <summary>
/// 异步启动蓝牙的配对过程
/// </summary>
/// <param name="DeviceInfo"></param>
/// <returns></returns>
private async Task PairAsync(DeviceInformation DeviceInfo)
{
DevicePairingKinds PairKinds = DevicePairingKinds.ConfirmOnly | DevicePairingKinds.ConfirmPinMatch;
DeviceInformationCustomPairing CustomPairing = DeviceInfo.Pairing.Custom;
CustomPairing.PairingRequested += CustomPairInfo_PairingRequested;
DevicePairingResult PairResult = await CustomPairing.PairAsync(PairKinds, DevicePairingProtectionLevel.EncryptionAndAuthentication);
CustomPairing.PairingRequested -= CustomPairInfo_PairingRequested;
if (PairResult.Status == DevicePairingResultStatus.Paired)
{
BluetoothWatcher.Stop();
BluetoothDeviceCollection.Clear();
BluetoothWatcher.Start();
}
else
{
Tips.Text = "配对失败";
}
}
/// <summary>
/// 异步启动蓝牙的配对过程
/// </summary>
/// <param name="DeviceInfo"></param>
/// <returns></returns>
private async Task PairAsync(BluetoothDeivceData Device)
{
try
{
if (Device.DeviceInfo.Pairing.CanPair)
{
DeviceInformationCustomPairing CustomPairing = Device.DeviceInfo.Pairing.Custom;
CustomPairing.PairingRequested += CustomPairInfo_PairingRequested;
DevicePairingResult PairResult = await CustomPairing.PairAsync(DevicePairingKinds.ConfirmOnly | DevicePairingKinds.ConfirmPinMatch, DevicePairingProtectionLevel.EncryptionAndAuthentication);
CustomPairing.PairingRequested -= CustomPairInfo_PairingRequested;
if (PairResult.Status == DevicePairingResultStatus.Paired)
{
Device.Update();
}
else
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
Tips.Text = Globalization.GetString("BluetoothUI_Tips_Text_4");
Tips.Visibility = Visibility.Visible;
});
}
}
else
{
LogTracer.Log($"Unable pair with Bluetooth device: \"{Device.Name}\", reason: CanPair property return false");
}
}
catch (Exception ex)
{
LogTracer.Log(ex, $"Unable pair with Bluetooth device: \"{Device.Name}\"");
}
}
/// <summary>
/// User wants to use custom pairing with the selected ceremony types and Default protection level
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private async void PairButton_Click(object sender, RoutedEventArgs e)
{
// Use the pair button on the bluetoothDeviceListView.SelectedItem to get the data context
BluetoothDeviceInformationDisplay deviceInfoDisp =
((Button)sender).DataContext as BluetoothDeviceInformationDisplay;
string formatString = BluetoothDeviceInformationDisplay.GetResourceString("BluetoothAttemptingToPairFormat");
string confirmationMessage = string.Format(formatString, deviceInfoDisp.Name, deviceInfoDisp.Id);
DisplayMessagePanelAsync(confirmationMessage, MessageType.InformationalMessage);
// Save the pair button
Button pairButton = sender as Button;
inProgressPairButton = pairButton;
// Save the flyout and set to null so it doesn't pop up unless we want it
savedPairButtonFlyout = pairButton.Flyout;
inProgressPairButton.Flyout = null;
// Disable the pair button until we are done
pairButton.IsEnabled = false;
// Get ceremony type and protection level selections
DevicePairingKinds ceremoniesSelected = GetSelectedCeremonies();
// Get protection level
DevicePairingProtectionLevel protectionLevel = DevicePairingProtectionLevel.Default;
// Specify custom pairing with all ceremony types and protection level EncryptionAndAuthentication
DeviceInformationCustomPairing customPairing = deviceInfoDisp.DeviceInformation.Pairing.Custom;
customPairing.PairingRequested += PairingRequestedHandler;
DevicePairingResult result = await customPairing.PairAsync(ceremoniesSelected, protectionLevel);
if (result.Status == DevicePairingResultStatus.Paired)
{
formatString = BluetoothDeviceInformationDisplay.GetResourceString("BluetoothPairingSuccessFormat");
confirmationMessage = string.Format(formatString, deviceInfoDisp.Name, deviceInfoDisp.Id);
}
else
{
formatString = BluetoothDeviceInformationDisplay.GetResourceString("BluetoothPairingFailureFormat");
confirmationMessage = string.Format(formatString, result.Status.ToString(), deviceInfoDisp.Name,
deviceInfoDisp.Id);
}
// Display the result of the pairing attempt
DisplayMessagePanelAsync(confirmationMessage, MessageType.InformationalMessage);
// If the watcher toggle is on, clear any devices in the list and stop and restart the watcher to ensure state is reflected in list
if (BluetoothToggle.IsOn)
{
bluetoothDeviceObservableCollection.Clear();
StopWatcher();
StartWatcher();
}
else
{
// If the watcher is off this is an inbound request so just clear the list
bluetoothDeviceObservableCollection.Clear();
}
// Re-enable the pair button
inProgressPairButton = null;
pairButton.IsEnabled = true;
}
private static void OnPairingRequested(DeviceInformationCustomPairing pairing, DevicePairingRequestedEventArgs args)
{
args.Accept("0");
}
private async void PairingRequestedHandler(
DeviceInformationCustomPairing sender,
DevicePairingRequestedEventArgs args)
{
switch (args.PairingKind)
{
case DevicePairingKinds.ConfirmOnly:
// Windows itself will pop the confirmation dialog as part of "consent" if this is running on Desktop or Mobile
// If this is an App for 'Windows IoT Core' where there is no Windows Consent UX, you may want to provide your own confirmation.
args.Accept();
break;
case DevicePairingKinds.DisplayPin:
// We just show the PIN on this side. The ceremony is actually completed when the user enters the PIN
// on the target device. We automatically except here since we can't really "cancel" the operation
// from this side.
args.Accept();
// No need for a deferral since we don't need any decision from the user
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
ShowPairingPanel(
"Please enter this PIN on the device you are pairing with: " + args.Pin,
args.PairingKind);
});
break;
case DevicePairingKinds.ProvidePin:
// A PIN may be shown on the target device and the user needs to enter the matching PIN on
// this Windows device. Get a deferral so we can perform the async request to the user.
var collectPinDeferral = args.GetDeferral();
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async () =>
{
string pin = await GetPinFromUserAsync();
if (!string.IsNullOrEmpty(pin))
{
args.Accept(pin);
}
collectPinDeferral.Complete();
});
break;
case DevicePairingKinds.ConfirmPinMatch:
// We show the PIN here and the user responds with whether the PIN matches what they see
// on the target device. Response comes back and we set it on the PinComparePairingRequestedData
// then complete the deferral.
var displayMessageDeferral = args.GetDeferral();
await rootPage.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async () =>
{
bool accept = await GetUserConfirmationAsync(args.Pin);
if (accept)
{
args.Accept();
}
displayMessageDeferral.Complete();
});
break;
}
}
private void OnPairingRequested(DeviceInformationCustomPairing sender, DevicePairingRequestedEventArgs args)
{
Utils.HandlePairing(Dispatcher, args);
}
/// <summary>
/// Called when custom pairing is initiated so that we can handle the custom ceremony
/// </summary>
/// <param name="sender"></param>
/// <param name="args"></param>
private async void PairingRequestedHandler(
DeviceInformationCustomPairing sender,
DevicePairingRequestedEventArgs args)
{
// Save the args for use in ProvidePin case
pairingRequestedHandlerArgs = args;
// Save the deferral away and complete it where necessary.
if (args.PairingKind != DevicePairingKinds.DisplayPin)
{
deferral = args.GetDeferral();
}
string confirmationMessage;
switch (args.PairingKind)
{
case DevicePairingKinds.ConfirmOnly:
// Windows itself will pop the confirmation dialog as part of "consent" if this is running on Desktop or Mobile
// If this is an App for Athens where there is no Windows Consent UX, you may want to provide your own confirmation.
{
confirmationMessage = string.Format(bluetoothConfirmOnlyFormatString, args.DeviceInformation.Name, args.DeviceInformation.Id);
DisplayMessagePanel(confirmationMessage, MessageType.InformationalMessage);
// Accept the pairing which also completes the deferral
AcceptPairing();
}
break;
case DevicePairingKinds.DisplayPin:
// We just show the PIN on this side. The ceremony is actually completed when the user enters the PIN
// on the target device
{
confirmationMessage = string.Format(bluetoothDisplayPinFormatString, args.Pin);
DisplayMessagePanel(confirmationMessage, MessageType.OKMessage);
}
break;
case DevicePairingKinds.ProvidePin:
// A PIN may be shown on the target device and the user needs to enter the matching PIN on
// this Windows device.
await MainPage.Current.UIThreadDispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
{
// PIN Entry
inProgressPairButton.Flyout = savedPairButtonFlyout;
inProgressPairButton.Flyout.ShowAt(inProgressPairButton);
});
break;
case DevicePairingKinds.ConfirmPinMatch:
// We show the PIN here and the user responds with whether the PIN matches what they see
// on the target device. Response comes back and we set it on the PinComparePairingRequestedData
// then complete the deferral.
{
confirmationMessage = string.Format(bluetoothConfirmPinMatchFormatString, args.Pin);
DisplayMessagePanel(confirmationMessage, MessageType.YesNoMessage);
}
break;
}
}
