public async Task <bool> DoInAppPairing() { Debug.WriteLine("Trying in app pairing"); // BT_Code: Pair the currently selected device. DevicePairingResult result = await DeviceInfo.Pairing.PairAsync(); CanPair = DeviceInfo.Pairing.CanPair; IsPaired = DeviceInfo.Pairing.IsPaired; Debug.WriteLine($"Pairing result: {result.Status.ToString()}"); if (result.Status == DevicePairingResultStatus.Paired || result.Status == DevicePairingResultStatus.AlreadyPaired) { return(true); } else { MessageDialog d = new MessageDialog("Pairing error", result.Status.ToString()); await d.ShowAsync(); return(false); } }
private async Task<int> pair_ganglion_async () { if (ganglion_info == null) { return (int) CustomExitCodes.GANGLION_NOT_FOUND_ERROR; } if (ganglion_device == null) { return (int) CustomExitCodes.GANGLION_IS_NOT_OPEN_ERROR; } DevicePairingResult result = null; DeviceInformationPairing pairing_information = ganglion_device.DeviceInformation.Pairing; try { if ((pairing_information.CanPair) && (!pairing_information.IsPaired)) { result = await ganglion_device.DeviceInformation.Pairing.PairAsync (pairing_information.ProtectionLevel).AsTask ().TimeoutAfter (timeout); } else { return (int) CustomExitCodes.GANGLION_ALREADY_PAIR_ERROR; } } catch (TimeoutException e) { return (int) CustomExitCodes.TIMEOUT_ERROR; } catch (Exception e) { return (int) CustomExitCodes.GENERAL_ERROR; } return (int) CustomExitCodes.STATUS_OK; }
private async void PairDevice() { try { var bleDeviceDisplay = SelectedDevice as BLEDeviceInfo; if (bleDeviceDisplay == null) { NotifyStatusMessage?.Invoke("Please select a device."); return; } DevicePairingResult result = await bleDeviceDisplay.DeviceInfo.Pairing.PairAsync(); if (result.Status == DevicePairingResultStatus.AlreadyPaired) { NotifyStatusMessage?.Invoke("Device already paired."); } else if (result.Status == DevicePairingResultStatus.Paired) { NotifyStatusMessage?.Invoke("Device already paired."); } else { NotifyStatusMessage?.Invoke("Paired Result: " + result.ToString()); } }catch (Exception ex) { NotifyStatusMessage?.Invoke("Exception: " + ex.Message); } }
private async void PairButton_Click() { // Do not allow a new Pair operation to start if an existing one is in progress. if (isBusy) { return; } isBusy = true; rootPage.NotifyUser("Pairing started. Please wait...", NotifyType.StatusMessage); // For more information about device pairing, including examples of // customizing the pairing process, see the DeviceEnumerationAndPairing sample. // Capture the current selected item in case the user changes it while we are pairing. var bleDeviceDisplay = ResultsListView.SelectedItem as BluetoothLEDeviceDisplay; // BT_Code: Pair the currently selected device. DevicePairingResult result = await bleDeviceDisplay.DeviceInformation.Pairing.PairAsync(); rootPage.NotifyUser($"Pairing result = {result.Status}", result.Status == DevicePairingResultStatus.Paired || result.Status == DevicePairingResultStatus.AlreadyPaired ? NotifyType.StatusMessage : NotifyType.ErrorMessage); isBusy = false; }
private async Task <DeviceInformation> PairWithDevice(BluetoothLEDevice _dev) { if (isPairing) { return(null); } isPairing = true; DeviceInformation devInfo; DevicePairingResult result = await _dev.DeviceInformation.Pairing.PairAsync(DevicePairingProtectionLevel.None); if (result.Status == DevicePairingResultStatus.Paired || result.Status == DevicePairingResultStatus.AlreadyPaired) { devInfo = _dev.DeviceInformation; } else if (result.Status == DevicePairingResultStatus.AlreadyPaired) { devInfo = _dev.DeviceInformation; } else { devInfo = null; } isPairing = false; return(devInfo); }
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; }
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(); } } }
private static async Task <bool> Pair(DeviceInformation device, string pin) { device.Pairing.Custom.PairingRequested += (s, a) => PairingRequestedHandler(s, a, pin); // DeviceInformation.Pairing.PairAsync function doesn't work for non UWP applications. Thus, DeviceInformation.Pairing.Custom.PairAsync is used. // https://stackoverflow.com/questions/45191412/deviceinformation-pairasync-not-working-in-wpf // DevicePairingKinds.DisplayPin option conflicts with DevicePairingKinds.ProvidePin: I used "Bluetooth Module HC 05" to test pairing with PIN code. // This device requires pin code "1234" to be paired. When both DevicePairingKinds.DisplayPin and DevicePairingKinds.ProvidePin flags were used in PairAsync function, // the PairingRequestedHandler was called with PairingKind equal to DevicePairingKinds.DisplayPin instead of DevicePairingKinds.ProvidePin, which made pairing fail. // Therefore, I decided not to use DevicePairingKinds.DisplayPin flag. // DevicePairingResult res = await device.Pairing.PairAsync(); DevicePairingResult res = await device.Pairing.PairAsync(); if (res.Status != DevicePairingResultStatus.Paired) /* * DevicePairingResult res = await device.Pairing.Custom * .PairAsync(DevicePairingKinds.ConfirmOnly | DevicePairingKinds.ProvidePin | DevicePairingKinds.ConfirmPinMatch, DevicePairingProtectionLevel.None) * ; * if (res.Status != DevicePairingResultStatus.Paired) */ { Debug.WriteLine($"Failed to pair device. Status = {res.Status}"); // throw new Exception($"Failed to pair device. Status = {res.Status}"); return(false); } return(true); }
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 async void BtPair() { rootPage.StatusBar("Paring Started Please Wait...", BarStatus.Warnning); Btdevice deviceInfoDisp = resultListView.SelectedItem as Btdevice; DevicePairingResult dpr = await deviceInfoDisp.DeviceInformation.Pairing.PairAsync(); rootPage.StatusBar("Paring Result" + dpr.Status.ToString(), dpr.Status == DevicePairingResultStatus.Paired ? BarStatus.Sucess : BarStatus.Error); }
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 PairButton_Click(object sender, RoutedEventArgs e) { DeviceInformationDisplay deviceInfoDisp = resultsListView.SelectedItem as DeviceInformationDisplay; pairButton.IsEnabled = false; DevicePairingResult dpr = await deviceInfoDisp.DeviceInformation.Pairing.PairAsync(); rootPage.NotifyUser( "Pairing result = " + dpr.Status.ToString(), dpr.Status == DevicePairingResultStatus.Paired ? NotifyType.StatusMessage : NotifyType.ErrorMessage); }
public async Task <bool> PairingDeviceAsync(string deviceId) { var device = FindKnownBluetoothDevice(deviceId); // do pairing DevicePairingResult pairingResult = await device.DeviceInformation.Pairing.PairAsync(); if (pairingResult.Status == DevicePairingResultStatus.Paired) { return(true); } return(false); }
static async void PairBluetooth(string param) { DevicePairingResult result = null; DeviceInformationPairing pairingInformation = _selectedDevice.DeviceInformation.Pairing; await _selectedDevice.DeviceInformation.Pairing.UnpairAsync(); if (pairingInformation.CanPair) { result = await _selectedDevice.DeviceInformation.Pairing.PairAsync(pairingInformation.ProtectionLevel); } }
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); }
public static async Task <GattDeviceService> GetServiceAsync(string deviceId) { BluetoothLEDevice device = null; try { Debug.WriteLine("Connecting to Bluetooth LE device."); device = await BluetoothLEDevice.FromIdAsync(deviceId); } catch (Exception ex) when(ex.HResult == E_DEVICE_NOT_AVAILABLE) { throw new InvalidOperationException("Bluetooth radio is not on.", ex); } if (device == null) { throw new InvalidOperationException("Failed to connect to device."); } if (device.DeviceInformation.Pairing.CanPair && !device.DeviceInformation.Pairing.IsPaired) { DevicePairingResult dpr = await device.DeviceInformation.Pairing.PairAsync(DevicePairingProtectionLevel.EncryptionAndAuthentication); if (dpr == null) { throw new InvalidOperationException("Failed to pair with device"); } if (!(dpr.Status == DevicePairingResultStatus.Paired || dpr.Status == DevicePairingResultStatus.AlreadyPaired)) { throw new InvalidOperationException($"Failed to pair with device with result: '{dpr.Status}'"); } } Debug.WriteLine("Requesting 'Wi-Fi config message protocol' service for device."); GattDeviceServicesResult result = await device.GetGattServicesAsync(BluetoothCacheMode.Uncached); if (result.Status != GattCommunicationStatus.Success) { throw new InvalidOperationException("Device unreachable."); } GattDeviceService service = result.Services.FirstOrDefault(s => s.Uuid == MessageProtocolServiceId); if (service == null) { throw new InvalidOperationException("This device does not support the Message Protocol."); } Debug.WriteLine("Connected to Bluetooth LE device."); return(service); }
private async void PairAsync() { // We must update the collection on the UI thread await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, async() => { if (this.CanPair && !this.Pairing) { DevicePairingResult res = await information.Pairing.PairAsync(); if (res.Status == DevicePairingResultStatus.Paired) { OnDevicePaired?.Invoke(this); } } }); }
private async void Initialize() { Console.WriteLine(tag, "Connecting..."); this.Device = await BluetoothLEDevice.FromBluetoothAddressAsync(this.DeviceAddress); DevicePairingResult result = await this.Device.DeviceInformation.Pairing.PairAsync(); if (result.Status != DevicePairingResultStatus.AlreadyPaired && result.Status != DevicePairingResultStatus.Paired) { Console.WriteLine(tag, "Failed to pair:" + result.Status); this.Device.Dispose(); return; } EnableUpgradeMode(); }
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; } }
public bool DoInAppPairing(DevicePairingProtectionLevel minProtectionLevel, IDevicePairingSettings devicePairingSettings) { Debug.WriteLine("Trying in app pairing"); // BT_Code: Pair the currently selected device. DevicePairingResult result = DeviceInfo.Pairing.PairAsync(minProtectionLevel, devicePairingSettings).GetAwaiter().GetResult(); Debug.WriteLine($"Pairing result: {result.Status}"); if (result.Status != DevicePairingResultStatus.Paired || result.Status != DevicePairingResultStatus.AlreadyPaired) { Debug.WriteLine("Pairing error: " + result.Status.ToString()); return(false); } return(true); }
public async Task pairlingFirstAsync() { if (DeviceMap.Count == 0) { return; } var deviceMap = DeviceMap.First(); var deviceInfo = deviceMap.Value; DevicePairingResult result = await deviceInfo.Pairing.PairAsync(); if (result.Status == DevicePairingResultStatus.Paired || result.Status == DevicePairingResultStatus.AlreadyPaired) { } else { // fail } }
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); DeviceInformationDisplay deviceInfoDisp = resultsListView.SelectedItem as DeviceInformationDisplay; DevicePairingResult dpr = await deviceInfoDisp.DeviceInformation.Pairing.PairAsync(); rootPage.NotifyUser( "Pairing result = " + dpr.Status.ToString(), dpr.Status == DevicePairingResultStatus.Paired ? NotifyType.StatusMessage : NotifyType.ErrorMessage); UpdatePairingButtons(); resultsListView.IsEnabled = true; }
public bool DoInAppPairing() { Debug.WriteLine("Trying in app pairing"); // BT_Code: Pair the currently selected device. DevicePairingResult result = DeviceInfo.Pairing.PairAsync().GetAwaiter().GetResult(); bool returnResult = true; Debug.WriteLine($"Pairing result: {result.Status}"); if (result.Status != DevicePairingResultStatus.Paired || result.Status != DevicePairingResultStatus.AlreadyPaired) { Debug.WriteLine("Pairing error " + result.Status.ToString()); returnResult = false; } return(returnResult); }
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); }
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); }
private async Task <bool> Pair() { Console.WriteLine("Pairing started. Please wait..."); // For more information about device pairing, including examples of // customizing the pairing process, see the DeviceEnumerationAndPairing sample. // Capture the current selected item in case the user changes it while we are pairing. Debug.Assert(KnownDevices.Count == 1, "We shouldn't have more than one known device."); var bleDeviceDisplay = KnownDevices[0]; // BT_Code: Pair the currently selected device. DevicePairingResult result = await bleDeviceDisplay.DeviceInformation.Pairing.PairAsync(); //Debug.Assert(result.Status == DevicePairingResultStatus.AlreadyPaired || // result.Status == DevicePairingResultStatus.Paired); Console.WriteLine($"Pairing result = {result.Status}"); return(result.Status == DevicePairingResultStatus.AlreadyPaired || result.Status == DevicePairingResultStatus.Paired); }
/// <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}] すでにペアリング済み"); } }