private void StartBluetoothDeviceWatcher()
        {
            //// 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" };

            //// 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);

            //var selector = BluetoothDevice.GetDeviceSelector();
            var selector = BluetoothDevice.GetDeviceSelectorFromPairingState(true);

            DeviceWatcher = DeviceInformation.CreateWatcher(selector, null, 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.
            KnownDeviceList.Clear();

            // Start the watcher.
            DeviceWatcher.Start();
        }
Exemple #2
0
        public MainPage()
        {
            this.InitializeComponent();

            //deviceWatcher =
            //  DeviceInformation.CreateWatcher(
            //     BluetoothDevice.GetDeviceSelectorFromPairingState(true),
            //      requestedProperties,
            //      DeviceInformationKind.AssociationEndpoint);

            deviceWatcher =
                DeviceInformation.CreateWatcher(
                    BluetoothDevice.GetDeviceSelectorFromPairingState(true));

            //deviceWatcher =
            //     DeviceInformation.CreateWatcher(
            //             BluetoothLEDevice.GetDeviceSelectorFromPairingState(false),
            //             requestedProperties,
            //             DeviceInformationKind.AssociationEndpoint);
            deviceWatcher.Added   += DeviceWatcher_Added;
            deviceWatcher.Removed += DeviceWatcher_Removed;
            deviceWatcher.Updated += DeviceWatcher_Updated;
            deviceWatcher.EnumerationCompleted += DeviceWatcher_EnumerationCompleted;
            deviceWatcher.Stopped += DeviceWatcher_Stopped;
        }
Exemple #3
0
        public void SearchBluetoothDevice(TextBlock textBlock)
        {
            /*string[] requestedProperties = new string[] { "System.Devices.Aep.DeviceAddress", "System.Devices.Aep.IsConnected" };
             *
             * DeviceWatcher deviceWatcher = DeviceInformation.CreateWatcher("(System.Devices.Aep.ProtocolId:=\"{e0cbf06c-cd8b-4647-bb8a-263b43f0f974}\")",
             *                                              requestedProperties,
             *                                              DeviceInformationKind.AssociationEndpoint);*/

            DeviceWatcher deviceWatcher = DeviceInformation.CreateWatcher(BluetoothDevice.GetDeviceSelectorFromPairingState(false));

            textBlock.Text = "Available Device List";

            deviceWatcher.Added += async(DeviceWatcher sender, DeviceInformation device) =>
            {
                ListBluetoothID.Add(device.Id);
                // To update textBlock on UI thread
                await Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync
                    (CoreDispatcherPriority.Normal, () =>
                {
                    // Your UI update code goes here!
                    textBlock.Text += "\n" + device.Id + "     " + device.Name;
                }
                    );
            };

            deviceWatcher.EnumerationCompleted += (DeviceWatcher sender, object args) =>
            {
                IsWatchingBluetoothDeviceCompleted = true;
            };

            deviceWatcher.Start();
        }
Exemple #4
0
        public static AsqFilter NonPairedBluetoothDevicesFilter()
        {
            var bNonPaired   = BluetoothDevice.GetDeviceSelectorFromPairingState(false);
            var bleNonPaired = BluetoothLEDevice.GetDeviceSelectorFromPairingState(false);

            return(new AsqFilter($"({bNonPaired}) OR ({bleNonPaired})"));
        }
Exemple #5
0
        /// <summary>Discover devices</summary>
        /// <param name="paired">If discovery limited to paired or non paired devices</param>
        private async void DoDiscovery(bool paired)
        {
            try {
                DeviceInformationCollection devices = await DeviceInformation.FindAllAsync(
                    BluetoothDevice.GetDeviceSelectorFromPairingState(paired));

                foreach (DeviceInformation info in devices)
                {
                    try {
                        this.log.Info("DoDiscovery", () => string.Format("Found device {0}", info.Name));

                        BTDeviceInfo deviceInfo = new BTDeviceInfo()
                        {
                            Name      = info.Name,
                            Connected = false,
                            Address   = info.Id,
                        };

                        using (BluetoothDevice device = await BluetoothDevice.FromIdAsync(info.Id)) {
                            deviceInfo.Connected = device.ConnectionStatus == BluetoothConnectionStatus.Connected;
                            deviceInfo.CanPair   = this.GetBoolProperty(device.DeviceInformation.Properties, KEY_CAN_PAIR, false);
                            deviceInfo.IsPaired  = this.GetBoolProperty(device.DeviceInformation.Properties, KEY_IS_PAIRED, false);
                            // Container Id also
                            //device.DeviceAccessInformation.CurrentStatus == DeviceAccessStatus. // Allowed, denied by user, by system, unspecified
                            //device.DeviceInformation.EnclosureLocation.; // Dock, lid, panel, etc
                            //device.DeviceInformation.IsDefault;
                            //device.DeviceInformation.IsEnabled;
                            //device.DeviceInformation.Kind == //AssociationEndpoint, Device, etc
                            //device.DeviceInformation.Properties

                            if (device.ClassOfDevice != null)
                            {
                                deviceInfo.DeviceClassInt  = (uint)device.ClassOfDevice.MajorClass;
                                deviceInfo.DeviceClassName = string.Format("{0}:{1}",
                                                                           device.ClassOfDevice.MajorClass.ToString(),
                                                                           device.ClassOfDevice.MinorClass.ToString());
                                //device.ClassOfDevice.ServiceCapabilities == BluetoothServiceCapabilities.ObjectTransferService, etc
                            }

                            // Serial port service name
                            // Bluetooth#Bluetooth10:08:b1:8a:b0:02-20:16:04:07:61:01#RFCOMM:00000000:{00001101-0000-1000-8000-00805f9b34fb}
                            // TODO - determine if all the info in device is disposed by the device.Dispose
                        } // end of using (device)

                        this.DeviceDiscovered?.Invoke(this, deviceInfo);
                    }
                    catch (Exception ex2) {
                        this.log.Exception(9999, "", ex2);
                    }
                }
                this.DiscoveryComplete?.Invoke(this, true);
            }
            catch (Exception e) {
                this.log.Exception(9999, "", e);
                this.DiscoveryComplete?.Invoke(this, false);
            }
        }
 public static IAsyncOperation <IEnumerable <DeviceInfo> > GetDevices()
 {
     return(AsyncInfo.Run(async(cancel) =>
     {
         var selector = BluetoothDevice.GetDeviceSelectorFromPairingState(true);
         var devices = await DeviceInformation.FindAllAsync(selector);
         return devices.Select(d => new DeviceInfo {
             Name = d.Name, Device = d
         });
     }));
 }
Exemple #7
0
 private void StartWatcher()
 {
     RunButton.IsEnabled = false;
     ResultCollection.Clear();
     deviceWatcher          = DeviceInformation.CreateWatcher(BluetoothDevice.GetDeviceSelectorFromPairingState(true));
     deviceWatcher.Added   += OnWatcherDeviceAdded;
     deviceWatcher.Updated += OnWatcherUpdated;
     deviceWatcher.Removed += OnWatcherRemoved;
     deviceWatcher.Stopped += OnWatcherStopped;
     deviceWatcher.Start();
     StopButton.IsEnabled = true;
 }
Exemple #8
0
        IReadOnlyCollection <BluetoothDeviceInfo> DoDiscoverDevices(int maxDevices)
        {
            List <BluetoothDeviceInfo> results = new List <BluetoothDeviceInfo>();

            var devices = DeviceInformation.FindAllAsync(BluetoothDevice.GetDeviceSelectorFromPairingState(false)).GetResults();

            foreach (var device in devices)
            {
                var bluetoothDevice = BluetoothDevice.FromIdAsync(device.Id).GetResults();
                results.Add(bluetoothDevice);
            }
            return(results.AsReadOnly());
        }
Exemple #9
0
        IEnumerable <BluetoothDeviceInfo> GetPairedDevices()
        {
            var t = DeviceInformation.FindAllAsync(BluetoothDevice.GetDeviceSelectorFromPairingState(true));

            t.AsTask().ConfigureAwait(false);
            t.AsTask().Wait();
            var devices = t.GetResults();

            foreach (var device in devices)
            {
                var td = BluetoothDevice.FromIdAsync(device.Id).AsTask();
                td.Wait();
                var bluetoothDevice = td.Result;
                yield return(bluetoothDevice);
            }

            yield break;
        }
Exemple #10
0
        private async void Button1_Click(object sender, EventArgs e)
        {
            var picker = new DevicePicker();

            picker.DeviceSelected += Picker_DeviceSelected;
            picker.Filter.SupportedDeviceSelectors.Add(
                BluetoothDevice.GetDeviceSelectorFromPairingState(false));

            // sync
            // picker.Show(new Windows.Foundation.Rect(100, 100, 500, 500));

            // async
            DeviceInformation di = await picker.PickSingleDeviceAsync(new Windows.Foundation.Rect(0, 0, 0, 0), Windows.UI.Popups.Placement.Default);

            if (di == null)
            {
                return;
            }

            if (di.Pairing.IsPaired == false)
            {
                di.Pairing.Custom.PairingRequested += Custom_PairingRequested;

                if (di.Pairing.CanPair == true)
                {
                    var pairResult = await di.Pairing.PairAsync();

                    if (pairResult.Status == DevicePairingResultStatus.Paired)
                    {
                        // do something
                    }
                }
                else
                {
                    var pairResult = await di.Pairing.Custom.PairAsync(DevicePairingKinds.ProvidePin);

                    if (pairResult.Status == DevicePairingResultStatus.Paired)
                    {
                        // do something
                    }
                }
            }
        }
        public void StartSearchingForDevice()
        {
#if WINDOWS_UWP
            var requestedProperties = new string[] { "System.Devices.Aep.DeviceAddress", "System.Devices.Aep.IsConnected" };
            // var aqs = BluetoothLEDevice.GetDeviceSelectorFromPairingState(false);
            var aqs = BluetoothDevice.GetDeviceSelectorFromPairingState(false);

            m_deviceWatcher = DeviceInformation.CreateWatcher(
                aqs,
                requestedProperties,
                DeviceInformationKind.AssociationEndpoint);

            m_deviceWatcher.Added   += OnDeviceAdded;
            m_deviceWatcher.Removed += OnDeviceLost;
            m_deviceWatcher.Updated += OnDeviceUpdated;
            m_deviceWatcher.EnumerationCompleted += OnInitialEnumerationCompleted;
            m_deviceWatcher.Stopped += OnStopped;

            m_deviceWatcher.Start();
#endif
        }
Exemple #12
0
        public async void IsPhoneDetected(string btId)
        {
            phoneIsDetected = false;
            var btDevices = await DeviceInformation.FindAllAsync(BluetoothDevice.GetDeviceSelectorFromPairingState(false));

            foreach (var d in btDevices)
            {
                if (d.Id == btId)
                {
                    phoneIsDetected = true;
                }
            }
            if (phoneIsDetected)
            {
                startCaptureProcess();
            }
            else
            {
                stopCaptureProcess();
            }
        }
        public void When_GetSelector()
        {
            string testSelector;

            testSelector = _deviceSelectorPrefix + "(System.Devices.Aep.IsPaired:=System.StructuredQueryType.Boolean#True OR " + _deviceSelectorIssueInquiry + "#False)";
            Assert.AreEqual(testSelector, BluetoothDevice.GetDeviceSelector());

            testSelector = _deviceSelectorPrefix + "(System.Devices.Aep.IsPaired:=System.StructuredQueryType.Boolean#True OR " + _deviceSelectorIssueInquiry + "#False)";
            Assert.AreEqual(testSelector, BluetoothDevice.GetDeviceSelectorFromPairingState(true));
            testSelector = _deviceSelectorPrefix + "(System.Devices.Aep.IsPaired:=System.StructuredQueryType.Boolean#False OR " + _deviceSelectorIssueInquiry + "#True)";
            Assert.AreEqual(testSelector, BluetoothDevice.GetDeviceSelectorFromPairingState(false));

            testSelector = _deviceSelectorPrefix + "(System.Devices.Aep.IsConnected:=System.StructuredQueryType.Boolean#True OR " + _deviceSelectorIssueInquiry + "#False)";
            Assert.AreEqual(testSelector, BluetoothDevice.GetDeviceSelectorFromConnectionStatus(BluetoothConnectionStatus.Connected));
            testSelector = _deviceSelectorPrefix + "(System.Devices.Aep.IsConnected:=System.StructuredQueryType.Boolean#False OR " + _deviceSelectorIssueInquiry + "#True)";
            Assert.AreEqual(testSelector, BluetoothDevice.GetDeviceSelectorFromConnectionStatus(BluetoothConnectionStatus.Disconnected));

            string deviceName = "TESTNAME";

            testSelector = _deviceSelectorPrefix + "(System.ItemNameDisplay:=\"" + deviceName + "\" OR " + _deviceSelectorIssueInquiry + "#True)";
            Assert.AreEqual(testSelector, BluetoothDevice.GetDeviceSelectorFromDeviceName(deviceName));
        }
        private void StartWatcher()
        {
            string aqsFilter;

            ResultCollection.Clear();

            // Request the IsPaired property so we can display the paired status in the UI
            string[] requestedProperties = { "System.Devices.Aep.IsPaired" };

            //for bluetooth LE Devices
            //aqsFilter = "System.Devices.Aep.ProtocolId:=\"{bb7bb05e-5972-42b5-94fc-76eaa7084d49}\"";
            Debug.WriteLine(BluetoothDevice.GetDeviceSelectorFromPairingState(false));
            aqsFilter = "System.Devices.Aep.ProtocolId:=\"{e0cbf06c-cd8b-4647-bb8a263b43f0f974}\"";
            try {
                deviceWatcher = DeviceInformation.CreateWatcher(DeviceClass.All);

                //BluetoothDevice.GetDeviceSelectorFromPairingState(false),
                //requestedProperties,
                //DeviceInformationKind.AssociationEndpoint
                //);
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.Message);
            }

            // 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 this.Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
                {
                    ResultCollection.Add(new DeviceInformationDisplay(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 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 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;
                        }
                    }
                });
            });
            deviceWatcher.Removed += handlerRemoved;

            handlerEnumCompleted = new TypedEventHandler <DeviceWatcher, Object>(async(watcher, obj) =>
            {
                await Dispatcher.RunAsync(CoreDispatcherPriority.Low, () =>
                {
                    string dbg = "Found " + ResultCollection.Count.ToString() + " Bluetooth LE Devices";
                    Debug.WriteLine(dbg);
                    resultsListView.ItemsSource = ResultCollection;
                });
            });

            deviceWatcher.EnumerationCompleted += handlerEnumCompleted;

            deviceWatcher.Start();
        }
Exemple #15
0
        public async void ConnectToWiimote()
        {
            var found = false;
            BluetoothAdapter bluetoothAdapter = await BluetoothAdapter.GetDefaultAsync();

            do
            {
                if (bluetoothAdapter == null)
                {
                    viewModel.ConsoleLog = "Please connect a bluetooth adapter.\r\n";
                    await Task.Delay(1000);
                }
                bluetoothAdapter = await BluetoothAdapter.GetDefaultAsync();
            } while (bluetoothAdapter == null);
            var bluetoothAddress = BitConverter.GetBytes(bluetoothAdapter.BluetoothAddress);

            password[0] = bluetoothAddress[0];
            password[1] = bluetoothAddress[1];
            password[2] = bluetoothAddress[2];
            password[3] = bluetoothAddress[3];
            password[4] = bluetoothAddress[4];
            password[5] = bluetoothAddress[5];


            //            int i = 0;
            //            char[] g = new char[6];
            //            foreach (var pSection in password)
            //            {
            //                g[i] = (char) pSection;
            //                i++;
            //            }
            //            var h = g.ToString();
            //var selector = BluetoothDevice.GetDeviceSelector();
            // Checks for synced/paired wiidevices
            var selector = BluetoothDevice.GetDeviceSelectorFromPairingState(true);

            ConsoleWriteLine("Checking for paired wii devices.");
            var devices = await DeviceInformation.FindAllAsync(selector);

            {
                if (devices.Count != 0)
                {
                    foreach (var device in devices)
                    {
                        if (device.Name.Contains("Nintendo"))
                        {
                            var result = await device.Pairing.UnpairAsync();

                            if (result.Status != DeviceUnpairingResultStatus.Unpaired)
                            {
                                ConsoleWriteLine("There was a error unpairing a wii device");
                            }
                            else
                            {
                                ConsoleWriteLine("Succesfully unpaired a wii device");
                            }
                        }
                    }
                }
            }
            // Checks for new devices
            selector = BluetoothDevice.GetDeviceSelectorFromPairingState(false);
            while (!found)
            {
                ConsoleWriteLine("Searching for devices");
                devices =
                    await DeviceInformation.FindAllAsync(selector);

                if (devices.Count != 0)
                {
                    ConsoleWriteLine($"Found {devices.Count} devices.");
                    foreach (var device in devices)
                    {
                        if (device.Name.Contains("Nintendo"))
                        {
                            ConsoleWriteLine("One device is a Wiimote.");
                            device.Pairing.Custom.PairingRequested += Custom_PairingRequested;
                            var pairingResult = await device.Pairing.Custom.PairAsync(DevicePairingKinds.ProvidePin);

                            if (pairingResult.Status != DevicePairingResultStatus.Paired)
                            {
                                ConsoleWriteLine($"Error: {pairingResult.Status.ToString()}");
                            }
                            else
                            {
                                var blDevice = await BluetoothDevice.FromIdAsync(device.Id);

                                blDevice.ConnectionStatusChanged += BlDevice_ConnectionStatusChanged;
                                ConsoleWriteLine("Waiting 20 seconds in the hope that the device will be installed by then and the connection is not dropped");
                                await Task.Delay(TimeSpan.FromSeconds(20));

                                var hidDevice = await HidDevice.FromIdAsync(blDevice.DeviceId, FileAccessMode.ReadWrite);
                            }
                        }
                    }
                }
                else
                {
                    ConsoleWriteLine("Nothing Found.");
                }
                await Task.Delay(1000);
            }
        }
        private async void AppBarButton_Click_1(object sender, RoutedEventArgs e)
        {
            try
            {
                StoreServicesCustomEventLogger logger = StoreServicesCustomEventLogger.GetDefault();
                logger.Log("AddBluetooth");
                string[] requestedProperties = { "System.Devices.Aep.DeviceAddress", "System.Devices.Aep.IsConnected" };

                DeviceWatcher deviceWatcher =
                    DeviceInformation.CreateWatcher(
                        BluetoothLEDevice.GetDeviceSelectorFromPairingState(false),
                        requestedProperties,
                        DeviceInformationKind.AssociationEndpoint);

                // Register event handlers before starting the watcher.
                // Added, Updated and Removed are required to get all nearby devices
                //  deviceWatcher.Added += DeviceWatcher_Added;
                //   deviceWatcher.Updated += DeviceWatcher_Updated;
                //  deviceWatcher.Removed += DeviceWatcher_Removed;

                // EnumerationCompleted and Stopped are optional to implement.
                //    deviceWatcher.EnumerationCompleted += DeviceWatcher_EnumerationCompleted;
                //   deviceWatcher.Stopped += DeviceWatcher_Stopped;

                // Start the watcher.
                //deviceWatcher.Start();
                var    displayInformation = Windows.Graphics.Display.DisplayInformation.GetForCurrentView();
                double ScreenWidth        = 100;
                double ScreenHeight       = 100;
                if (displayInformation.CurrentOrientation == Windows.Graphics.Display.DisplayOrientations.Portrait)
                {
                    ScreenWidth  = Math.Round(Window.Current.Bounds.Width * displayInformation.RawPixelsPerViewPixel, 0);
                    ScreenHeight = Math.Round(Window.Current.Bounds.Height * displayInformation.RawPixelsPerViewPixel, 0);
                }
                if (displayInformation.CurrentOrientation == Windows.Graphics.Display.DisplayOrientations.Landscape)
                {
                    ScreenWidth  = Math.Round(Window.Current.Bounds.Height * displayInformation.RawPixelsPerViewPixel, 0);
                    ScreenHeight = Math.Round(Window.Current.Bounds.Width * displayInformation.RawPixelsPerViewPixel, 0);
                }
                // For devices with software buttons instead hardware
                else if (displayInformation.CurrentOrientation == Windows.Graphics.Display.DisplayOrientations.LandscapeFlipped)
                {
                    ScreenWidth  = Math.Round(Window.Current.Bounds.Height * displayInformation.RawPixelsPerViewPixel, 0);
                    ScreenHeight = Math.Round(Window.Current.Bounds.Width * displayInformation.RawPixelsPerViewPixel, 0);
                }
                Rect         rect         = new Rect(new Point(ScreenHeight, ScreenWidth), new Point(100, 100));
                DevicePicker devicePicker = new DevicePicker();
                //devicePicker.Filter.SupportedDeviceSelectors.Add(BluetoothLEDevice.GetDeviceSelectorFromPairingState(false));
                //   devicePicker.Filter.SupportedDeviceSelectors.Add(BluetoothLEDevice.GetDeviceSelectorFromPairingState(true));
                devicePicker.Filter.SupportedDeviceSelectors.Add(BluetoothDevice.GetDeviceSelectorFromPairingState(false));
                devicePicker.Filter.SupportedDeviceSelectors.Add(BluetoothDevice.GetDeviceSelectorFromPairingState(true));

                var s = await devicePicker.PickSingleDeviceAsync(rect);

                if (s != null)
                {
                    var sd = await s.Pairing.PairAsync();

                    // await new MessageDialog(sd.ToString()+"\n"+ DevicePairingResultStatus.Paired).ShowAsync();
                    if (sd.Status == DevicePairingResultStatus.Paired || sd.Status == DevicePairingResultStatus.AlreadyPaired || sd.Status == DevicePairingResultStatus.AccessDenied)
                    {
                        //var rfcommServices = await ClassBluetoothDeviceSelect.bluetoothDeviced.GetRfcommServicesForIdAsync(RfcommServiceId.FromUuid(RfcommServiceId.SerialPort.Uuid), BluetoothCacheMode.Uncached);
                        var bluetoothDevice = await BluetoothDevice.FromIdAsync(s.Id);

                        Frame.Navigate(typeof(BlankPageBluettotchDevice), new ClassBluetoothDevice()
                        {
                            namea = s.Name, bluetoothDeviced = bluetoothDevice
                        });
                    }
                }
            }
            catch (Exception ex)
            {
                await new MessageDialog(ex.Message).ShowAsync();
            }
        }
        private void uiCreate_Click(object sender, RoutedEventArgs e)
        {
            uiResultMsg.Text = "Creating query...";
            bool bBLE = (uiBTtype.SelectedValue as ComboBoxItem).Content.ToString().Contains("LE");

            switch ((uiQuery.SelectedValue as ComboBoxItem).Content.ToString())
            {
            case "GetDeviceSelector":
                if (bBLE)
                {
                    uiResultMsg.Text = BluetoothLEDevice.GetDeviceSelector();
                }
                else
                {
                    uiResultMsg.Text = BluetoothDevice.GetDeviceSelector();
                }
                break;

            case "GetDeviceSelectorFromPairingState(true)":
                if (bBLE)
                {
                    uiResultMsg.Text = BluetoothLEDevice.GetDeviceSelectorFromPairingState(true);
                }
                else
                {
                    uiResultMsg.Text = BluetoothDevice.GetDeviceSelectorFromPairingState(true);
                }
                break;

            case "GetDeviceSelectorFromPairingState(false)":
                if (bBLE)
                {
                    uiResultMsg.Text = BluetoothLEDevice.GetDeviceSelectorFromPairingState(false);
                }
                else
                {
                    uiResultMsg.Text = BluetoothDevice.GetDeviceSelectorFromPairingState(false);
                }
                break;

            case "GetDeviceSelectorFromConnectionStatus(Connected)":
                if (bBLE)
                {
                    uiResultMsg.Text = BluetoothLEDevice.GetDeviceSelectorFromConnectionStatus(BluetoothConnectionStatus.Connected);
                }
                else
                {
                    uiResultMsg.Text = BluetoothDevice.GetDeviceSelectorFromConnectionStatus(BluetoothConnectionStatus.Connected);
                }
                break;

            case "GetDeviceSelectorFromConnectionStatus(Disconnected)":
                if (bBLE)
                {
                    uiResultMsg.Text = BluetoothLEDevice.GetDeviceSelectorFromConnectionStatus(BluetoothConnectionStatus.Disconnected);
                }
                else
                {
                    uiResultMsg.Text = BluetoothDevice.GetDeviceSelectorFromConnectionStatus(BluetoothConnectionStatus.Disconnected);
                }
                break;

            default:
                uiResultMsg.Text = "Unknown value in second ComboBox";
                break;
            }
        }
        private async void RefreshBT(object sender, RoutedEventArgs e)
        {
            BtDevices.Items.Clear();
            BluetoothDevices.Clear();
            Log.Information("Refreshing bluetooth devices.");
            try
            {
                DeviceInformationCollection PairedDevices = await DeviceInformation.FindAllAsync(BluetoothDevice.GetDeviceSelectorFromPairingState(true));

                Log.Information($"Found {PairedDevices.Count} bluetooth devices.");
                foreach (var i in PairedDevices)
                {
                    BluetoothDevices.Add(new BluetoothDevices {
                        DeviceID = i.Id, DeviceName = i.Name, DeviceType = DeviceTypes.Bluetooth
                    });
                    BtDevices.Items.Add($"{i.Name} ({i.Id})");
                    Log.Information($"Adding bluetooth device {i.Name} ({i.Id}) into the list.");
                }
                btName.Text = "";

                if (PairedDevices.Count < 1)
                {
                    Log.Error("Unable to find any bluetooth devices.");
                    Helper.Error("Error", "Unable to find any bluetooth devices. Make sure you have paired your devices with this computer before and try again.");
                }
            }
            catch (Exception ex)
            {
                Log.Error(ex, "Error scanning for bluetooth devices.");
                Helper.Error("Error", "There was a unknown error scanning for bluetooth devices. Contact the developer");
            }
        }
Exemple #19
0
        private void RunButton_Click(object sender, RoutedEventArgs e)
        {
            Status.Text = "Looking for nearby devices";

            deviceWatcher = DeviceInformation.CreateWatcher(BluetoothDevice.GetDeviceSelectorFromPairingState(false), null);
            // Hook up handlers for the watcher events before starting the watcher
            deviceWatcher.Added += new TypedEventHandler <DeviceWatcher, DeviceInformation>(async(watcher, deviceInfo) =>
            {
                await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
                {
                    // Make sure device name isn't blank
                    if (deviceInfo.Name != "")
                    {
                        ResultCollection.Add(new AvatarDeviceDisplay(deviceInfo));
                        System.Diagnostics.Debug.WriteLine(resultsListView.Items.Count);
                    }
                });
            });

            deviceWatcher.Updated += new TypedEventHandler <DeviceWatcher, DeviceInformationUpdate>(async(watcher, deviceInfoUpdate) =>
            {
                await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
                {
                    foreach (AvatarDeviceDisplay avatarInfoDisp in ResultCollection)
                    {
                        if (avatarInfoDisp.Id == deviceInfoUpdate.Id)
                        {
                            avatarInfoDisp.Update(deviceInfoUpdate);
                            break;
                        }
                    }
                });
            });

            deviceWatcher.EnumerationCompleted += new TypedEventHandler <DeviceWatcher, Object>((watcher, obj) =>
            {
            });

            deviceWatcher.Removed += new TypedEventHandler <DeviceWatcher, DeviceInformationUpdate>(async(watcher, deviceInfoUpdate) =>
            {
                await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
                {
                    // Find the corresponding DeviceInformation in the collection and remove it
                    foreach (AvatarDeviceDisplay avatarInfoDisp in ResultCollection)
                    {
                        if (avatarInfoDisp.Id == deviceInfoUpdate.Id)
                        {
                            ResultCollection.Remove(avatarInfoDisp);
                            break;
                        }
                    }
                });
            });

            deviceWatcher.Stopped += new TypedEventHandler <DeviceWatcher, Object>(async(watcher, obj) =>
            {
                await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
                {
                    // Find the corresponding DeviceInformation in the collection and remove it
                    ResultCollection.Clear();
                    Status.Text         = "Watcher Stopped";
                    RunButton.IsEnabled = true;
                });
            });

            deviceWatcher.Start();
        }
Exemple #20
0
        private static async Task <string> SelectDevice()
        {
            DeviceInformationCollection devices = await DeviceInformation.FindAllAsync(BluetoothDevice.GetDeviceSelectorFromPairingState(true));

            for (int i = 0; i < devices.Count; i++)
            {
                Console.WriteLine(i + " #:    " + devices[i].Name + "    " + devices[i].Id);
            }

            Console.WriteLine("Please input device id to select or 'i' for iPhone or 'q' to quit: ");

            string ent = Console.ReadLine();

            if (ent == "i")
            {
                return(await SelectiPhone());
            }
            else if (ent == "q")
            {
                return("q");
            }
            else
            {
                if (int.TryParse(ent, out int s))
                {
                    if (s >= 0 && s < devices.Count)
                    {
                        Console.WriteLine("Selected: " + devices[s].Name + "    " + devices[s].Id);
                        return(devices[s].Id);
                    }
                }
            }

            return("");
        }
Exemple #21
0
        private static async Task <string> SelectiPhone()
        {
            DeviceInformationCollection devices = await DeviceInformation.FindAllAsync(BluetoothDevice.GetDeviceSelectorFromPairingState(true));

            for (int i = 0; i < devices.Count; i++)
            {
                if (devices[i].Name.IndexOf("iphone", StringComparison.CurrentCultureIgnoreCase) != -1)
                {
                    Console.WriteLine("Selected: " + devices[i].Name + "    " + devices[i].Id);
                    return(devices[i].Id);
                }
            }

            Console.WriteLine("No iPhone found.");
            return(string.Empty);
        }