private void SetConnectState(bool isConnected)
 {
     this.Dispatcher.Invoke(() => {
         this.writeControl.Connected = isConnected;
         if (isConnected)
         {
             this.connectedOff.Collapse();
             this.connectedOn.Show();
             this.btnConnect.Collapse();
             this.btnDisconnect.Show();
             DI.Wrapper.BLE_ConnectionStatusChanged += this.connectionStatusChanged;
         }
         else
         {
             this.connectedOn.Collapse();
             this.connectedOff.Show();
             this.btnDisconnect.Collapse();
             this.btnConnect.Show();
             this.treeServices.ItemsSource = null;
             this.currentDevice            = null;
             this.currentCharacteristic    = null;
             this.writeControl.Reset();
             this.ucCmds.Reset();
             DI.Wrapper.BLE_ConnectionStatusChanged -= this.connectionStatusChanged;
             DI.Wrapper.BLE_Disconnect();
             // Reset title
             //this.lblCmdDataTypeContent.Content = BLE_DataType.Reserved.ToStr();
         }
         this.ResizeOnNormal();
     });
 }
        private void RaiseDeviceDiscovered(BluetoothDevice device)
        {
            if (this.deviceType == BluetoothDeviceType.Classic)
            {
                BTDeviceInfo info = new BTDeviceInfo()
                {
                    IsPaired        = device.BondState == Bond.Bonded,
                    Name            = device.Name,
                    DeviceClassName = device.Class.Name,
                    Address         = device.Address,
                    // TODO - any others as needed
                };

                this.log.Info("RaiseDeviceDiscovered", () => string.Format(
                                  "{0} - {1} - {2}", info.Name, info.DeviceClassName, device.Address));
                this.DiscoveredBTDevice?.Invoke(this, info);
            }
            else if (this.deviceType == BluetoothDeviceType.Le)
            {
                BluetoothLEDeviceInfo info = new BluetoothLEDeviceInfo()
                {
                    // TODO - initialize
                };
                this.DiscoveredBLEDevice?.Invoke(this, info);
            }
            else
            {
                this.log.Error(9999, "", () => string.Format("Unhandled device type:{0}", this.deviceType));
            }
        }
        private void DeviceConnectResultHandler(object sender, BLEGetInfoStatus info)
        {
            this.Dispatcher.Invoke(() => {
                this.IsBusy = false;
                DI.Wrapper.BLE_DeviceConnectResult -= this.DeviceConnectResultHandler;
                this.ResizeOnNormal();
                switch (info.Status)
                {
                case BLEOperationStatus.Failed:
                case BLEOperationStatus.UnhandledError:
                case BLEOperationStatus.UnknownError:
                case BLEOperationStatus.NotFound:
                case BLEOperationStatus.NoServices:
                case BLEOperationStatus.GetServicesFailed:
                    App.ShowMsg(info.Message);
                    break;

                case BLEOperationStatus.Success:
                    this.SetConnectState(true);
                    this.currentDevice            = info.DeviceInfo;
                    this.Title                    = string.Format("(BLE) {0}", this.currentDevice.Name);
                    this.treeServices.ItemsSource = this.currentDevice.Services;
                    break;
                }
            });
        }
Beispiel #4
0
 public BLE_ServicesDisplay(Window parent, BluetoothLEDeviceInfo info)
 {
     this.parent = parent;
     InitializeComponent();
     this.SizeToContent            = SizeToContent.WidthAndHeight;
     this.treeServices.ItemsSource = info.Services;
 }
Beispiel #5
0
 public List <KeyValuePropertyDisplay> BLE_GetDeviceInfoForDisplay(BluetoothLEDeviceInfo info)
 {
     try {
         // TODO - language
         List <KeyValuePropertyDisplay> list = new List <KeyValuePropertyDisplay>();
         list.Add(new KeyValuePropertyDisplay(this.GetText(MsgCode.Name), info.Name));
         list.Add(new KeyValuePropertyDisplay(this.GetText(MsgCode.Id), info.Id));
         list.Add(new KeyValuePropertyDisplay(this.GetText(MsgCode.AccessStatus), info.AccessStatus.ToString().CamelCaseToSpaces()));
         list.Add(new KeyValuePropertyDisplay(this.GetText(MsgCode.Address), info.AddressAsULong.ToString()));
         list.Add(new KeyValuePropertyDisplay(this.GetText(MsgCode.AddressType), info.AddressType.ToString().CamelCaseToSpaces()));
         list.Add(new KeyValuePropertyDisplay(this.GetText(MsgCode.Default), info.IsDefault.ToString()));
         list.Add(new KeyValuePropertyDisplay(this.GetText(MsgCode.Enabled), info.IsEnabled.ToString()));
         list.Add(new KeyValuePropertyDisplay(this.GetText(MsgCode.Kind), info.DeviceKind.ToString().UnderlineToSpaces()));
         list.Add(new KeyValuePropertyDisplay(this.GetText(MsgCode.PairingAllowed), info.CanPair.ToString()));
         list.Add(new KeyValuePropertyDisplay(this.GetText(MsgCode.Paired), info.IsPaired.ToString()));
         list.Add(new KeyValuePropertyDisplay(this.GetText(MsgCode.PairedWithSecureConnection), info.WasPairedUsingSecureConnection.ToString()));
         list.Add(new KeyValuePropertyDisplay(this.GetText(MsgCode.Connected), info.IsConnected.ToString()));
         list.Add(new KeyValuePropertyDisplay(this.GetText(MsgCode.ProtectionLevel), info.ProtectionLevel.ToString().CamelCaseToSpaces()));
         list.Add(new KeyValuePropertyDisplay(string.Format("{0} (Bluetooth)", this.GetText(MsgCode.Kind)), info.TypeBluetooth.ToString().CamelCaseToSpaces()));
         list.Add(new KeyValuePropertyDisplay("Enclosure(Dock)", info.EnclosureLocation.InDock.ToString()));
         list.Add(new KeyValuePropertyDisplay("Enclosure(Lid)", info.EnclosureLocation.InLid.ToString()));
         list.Add(new KeyValuePropertyDisplay("Enclosure(Clockwise Rotation)", info.EnclosureLocation.ClockWiseRotationInDegrees.ToString()));
         list.Add(new KeyValuePropertyDisplay("Enclosure(Panel)", info.EnclosureLocation.Location.ToString()));
         return(list);
     }
     catch (Exception e) {
         this.log.Exception(9999, "", e);
         return(new List <KeyValuePropertyDisplay>());
     }
 }
Beispiel #6
0
        /// <summary>Fired when a device is discovered</summary>
        /// <param name="sender"></param>
        /// <param name="deviceInfo">Info on the discovered device</param>
        private void DevWatcher_Added(DeviceWatcher sender, DeviceInformation deviceInfo)
        {
            if (deviceInfo.Name.Length > 0)
            {
                WrapErr.ToErrReport(9999, () => {
                    // TODO - find out what comes in with no name
                    this.log.Info("DevWatcher_Added", () => string.Format("+++++ {0} : {1}", deviceInfo.Name, deviceInfo.Id));
                    this.DebugDumpDeviceInfo(deviceInfo);

                    if (this.DeviceDiscovered != null)
                    {
                        BluetoothLEDeviceInfo dev = new BluetoothLEDeviceInfo(new BLE_WinPropertyKeys())
                        {
                            Name              = deviceInfo.Name,
                            Id                = deviceInfo.Id,
                            IsDefault         = deviceInfo.IsDefault,
                            CanPair           = deviceInfo?.Pairing.CanPair ?? false,
                            IsPaired          = deviceInfo?.Pairing.IsPaired ?? false,
                            IsConnectable     = deviceInfo.IsConnectable(),
                            IsConnected       = deviceInfo.IsConnected(),
                            ServiceProperties = deviceInfo.CreatePropertiesDictionary(),
                            // This would be the DeviceInformation object. Not required
                            // but handy for updates in Windows
                            OSSpecificObj = deviceInfo,
                        };
                        this.DeviceDiscovered(sender, dev);
                    }
                });
            }
        }
 public DeviceInfo_BLE(Window parent, BluetoothLEDeviceInfo info)
 {
     this.parent = parent;
     this.info   = info;
     InitializeComponent();
     this.PopulateFields();
     this.SizeToContent = SizeToContent.WidthAndHeight;
 }
Beispiel #8
0
        public void BLE_GetInfo(BluetoothLEDeviceInfo device)
        {
            ErrReport report;

            WrapErr.ToErrReport(out report, 200059, "Failure on BluetoothLEDeviceInfo", () => {
                this.bleBluetooth.GetInfo(device);
            });
        }
Beispiel #9
0
        public void BLE_ConnectAsync(BluetoothLEDeviceInfo device)
        {
            ErrReport report;

            WrapErr.ToErrReport(out report, 200058, "Failure on BLE_ConnectAsync", () => {
                this.bleBluetooth.Connect(device);
            });
        }
 private void Wrapper_BLE_DeviceInfoGatheredOnGetInfo(object sender, BluetoothLEDeviceInfo info)
 {
     this.Dispatcher.Invoke(() => {
         this.wrapper.BLE_DeviceInfoGathered -= this.Wrapper_BLE_DeviceInfoGatheredOnGetInfo;
         this.gridWait.Collapse();
         DeviceInfo_BLE.ShowBox(this, info);
     });
 }
 public void GetInfo(BluetoothLEDeviceInfo deviceInfo)
 {
     this.DeviceInfoAssembled?.Invoke(
         this,
         new BLEGetInfoStatus(new BluetoothLEDeviceInfo()
     {
         Name = "NOT IMPLEMENTED"
     }, BLEOperationStatus.NotFound));
 }
Beispiel #12
0
        private void BLE_DeviceDiscoveredHandler(object sender, BluetoothLEDeviceInfo e)
        {
            ErrReport report;

            WrapErr.ToErrReport(out report, 200050, "Failure on BLE_DeviceDiscoveredHandler", () => {
                this.BLE_DeviceDiscovered?.Invoke(this, e);
            });
            this.RaiseIfException(report);
        }
 public void GetInfo(BluetoothLEDeviceInfo deviceDataModel)
 {
     Task.Run(async() => {
         try {
             await this.HarvestDeviceInfo(deviceDataModel);
         }
         catch (Exception e) {
             this.log.Exception(9999, "On Task Run GetInfo", e);
         }
     });
 }
Beispiel #14
0
        /// <summary>Build the GATT service data model</summary>
        /// <param name="service">The OS GATT service object</param>
        /// <param name="deviceDataModel">The portable GATT session data model</param>
        /// <returns>The async task</returns>
        public async Task BuildServiceDataModel(GattDeviceService service, BluetoothLEDeviceInfo deviceDataModel)
        {
            this.log.Info("BuildServiceDataModel", () => string.Format("Gatt Service:{0}  Uid:{1}",
                                                                       BLE_DisplayHelpers.GetServiceName(service), service.Uuid.ToString()));

            // New service data model to add to device info
            BLE_ServiceDataModel serviceDataModel = new BLE_ServiceDataModel()
            {
                Characteristics = new Dictionary <string, BLE_CharacteristicDataModel>(),
                AttributeHandle = service.AttributeHandle,
                DeviceId        = deviceDataModel.Id,
                DisplayName     = BLE_DisplayHelpers.GetServiceName(service),
                Uuid            = service.Uuid,
                SharingMode     = (BLE_SharingMode)service.SharingMode,
            };

            if (service.DeviceAccessInformation != null)
            {
                serviceDataModel.DeviceAccess = (BLE_DeviceAccessStatus)service.DeviceAccessInformation.CurrentStatus;
            }
            this.BuildSessionDataModel(service.Session, serviceDataModel.Session);

            // TODO
            //service.ParentServices

            // Get the characteristics for the service
            GattCharacteristicsResult characteristics = await service.GetCharacteristicsAsync();

            if (characteristics.Status == GattCommunicationStatus.Success)
            {
                if (characteristics.Characteristics != null)
                {
                    if (characteristics.Characteristics.Count > 0)
                    {
                        foreach (GattCharacteristic ch in characteristics.Characteristics)
                        {
                            await this.BuildCharacteristicDataModel(ch, serviceDataModel);
                        }
                    }
                    else
                    {
                        this.log.Info("ConnectToDevice", () => string.Format("No characteristics"));
                    }
                }
            }
            else
            {
                this.log.Error(9999, "HarvestDeviceInfo", () => string.Format("Failed to get Characteristics result {0}", characteristics.Status.ToString()));
            }

            // Add the service data model to the device info data model
            deviceDataModel.Services.Add(serviceDataModel.Uuid.ToString(), serviceDataModel);
        }
Beispiel #15
0
 public void GetInfo(BluetoothLEDeviceInfo deviceDataModel)
 {
     Task.Run(async() => {
         try {
             // Not using the get info anymore so make sure the device is nulled
             this.Disconnect();
             await this.HarvestDeviceInfo(deviceDataModel);
         }
         catch (Exception e) {
             this.log.Exception(9999, "On Task Run GetInfo", e);
         }
     });
 }
Beispiel #16
0
        public DeviceInfo_BLESerial(Window parent, BluetoothLEDeviceInfo info)
        {
            this.parent = parent;
            InitializeComponent();
            this.SizeToContent = SizeToContent.WidthAndHeight;
            this.borderInput.MouseLeftButtonDown  += this.BorderInput_MouseLeftButtonDown;
            this.borderOutput.MouseLeftButtonDown += this.BorderOutput_MouseLeftButtonDown;
            this.widthManager = new ButtonGroupSizeSyncManager(this.btnExit, this.btnSave);
            this.widthManager.PrepForChange();

            this.info = info;
            // TODO - check if any previous selections
            this.treeServices.ItemsSource = this.info.Services;
        }
 public void Connect(BluetoothLEDeviceInfo deviceInfo)
 {
     // TODO - need to have a copy of the BluetoothLEDeviceInfo saved also which subscribes to the BLE OS Device
     //        info and passes those events up to the UI
     this.Disconnect();
     Task.Run(async() => {
         try {
             await this.ConnectToDevice(deviceInfo);
         }
         catch (Exception e) {
             this.log.Exception(9999, "On Task Run ConnectToDevice", e);
         }
     });
 }
        private void selectionChanged(object sender, SelectionChangedEventArgs e)
        {
            BluetoothLEDeviceInfo device = this.listBox_BLE.SelectedItem as BluetoothLEDeviceInfo;

            lock (this.listBox_BLE) {
                if (device != null)
                {
                    this.SelectedBLE = device;
                    this.DisconnectEvents();
                    DI.Wrapper.BLE_CancelDiscover();
                    this.Close();
                }
            }
        }
        /// <summary>Update any previous information from discovery or other connections</summary>
        /// <param name="device">The BLE device returned</param>
        /// <param name="deviceDataModel">The portable data model to receive values</param>
        public void UpdateDeviceOnConnect(BluetoothLEDevice device, BluetoothLEDeviceInfo deviceDataModel)
        {
            if (device.DeviceInformation != null)
            {
                DeviceInformation di = device.DeviceInformation;
                deviceDataModel.IsConnectable = di.IsConnectable();
                deviceDataModel.IsDefault     = di.IsDefault;
                deviceDataModel.IsEnabled     = di.IsEnabled;
                deviceDataModel.Kind          = (BLE_DeviceInfoKind)di.Kind;
                if (di.Pairing != null)
                {
                    deviceDataModel.CanPair         = di.Pairing.CanPair;
                    deviceDataModel.IsPaired        = di.Pairing.IsPaired;
                    deviceDataModel.ProtectionLevel = (BLE_ProtectionLevel)di.Pairing.ProtectionLevel;
                }
                if (di.EnclosureLocation != null)
                {
                    deviceDataModel.EnclosureLocation.InDock   = di.EnclosureLocation.InDock;
                    deviceDataModel.EnclosureLocation.InLid    = di.EnclosureLocation.InLid;
                    deviceDataModel.EnclosureLocation.Location = (BLE_DevicePanelLocation)di.EnclosureLocation.Panel;
                    deviceDataModel.EnclosureLocation.ClockWiseRotationInDegrees = di.EnclosureLocation.RotationAngleInDegreesClockwise;
                }
            }

            if (device.BluetoothDeviceId != null)
            {
                if (device.BluetoothDeviceId.IsClassicDevice)
                {
                    deviceDataModel.TypeBluetooth = BluetoothType.Classic;
                }
                else if (device.BluetoothDeviceId.IsLowEnergyDevice)
                {
                    deviceDataModel.TypeBluetooth = BluetoothType.LowEnergy;
                }
            }

            if (device.DeviceAccessInformation != null)
            {
                deviceDataModel.AccessStatus = (BLE_DeviceAccessStatus)device.DeviceAccessInformation.CurrentStatus;
            }

            deviceDataModel.WasPairedUsingSecureConnection = device.WasSecureConnectionUsedForPairing;
            deviceDataModel.AddressType    = (BLE_AddressType)device.BluetoothAddressType;
            deviceDataModel.IsConnected    = device.ConnectionStatus == BluetoothConnectionStatus.Connected;
            deviceDataModel.AddressAsULong = device.BluetoothAddress;

            // TODO
            //device.Appearance
        }
Beispiel #20
0
        private async Task ConnectToDeviceAsync(BluetoothLEDeviceInfo deviceInfo)
        {
            try {
                this.log.Info("ConnectToDeviceAsync", () =>
                              string.Format("{0} ID:{1}", deviceInfo.Name, deviceInfo.Id));
                BLEGetInfoStatus result = await this.GetBLEDeviceInfo(deviceInfo);

                this.ConnectBTLEDeviceEvents(result.Status);
                this.RaiseConnectAttemptResult(result);
            }
            catch (Exception e) {
                this.log.Exception(9999, "BLE Connect Exception", e);
                this.RaiseConnectAttemptResult(BLEOperationStatus.UnknownError);
            }
        }
Beispiel #21
0
 public List <NetPropertyDataModelDisplay> BLE_GetServiceProperties(BluetoothLEDeviceInfo info)
 {
     try {
         List <NetPropertyDataModelDisplay> list = new List <NetPropertyDataModelDisplay>();
         foreach (var sp in info.ServiceProperties)
         {
             list.Add(new NetPropertyDataModelDisplay(sp.Value));
         }
         return(list);
     }
     catch (Exception e) {
         this.log.Exception(9999, "", e);
         return(new List <NetPropertyDataModelDisplay>());
     }
 }
 public void Translate(BluetoothLEDeviceInfo device)
 {
     try {
         if (device != null)
         {
             foreach (var s in device.Services)
             {
                 this.Translate(s);
             }
         }
     }
     catch (Exception e) {
         this.log.Exception(9000, "Translate(device)", "", e);
     }
 }
 /// <summary>Event handler for Bluetooth LE device discovery. Adds one at a time</summary>
 /// <param name="sender">The sender of event</param>
 /// <param name="info">The information for discovered device</param>
 private void BLE_DeviceDiscoveredHandler(object sender, BluetoothLEDeviceInfo info)
 {
     this.Dispatcher.Invoke(() => {
         WrapErr.ToErrReport(9999, "Failure on BLE Device Discovered", () => {
             lock (this.listBox_BLE) {
                 this.log.Info("BLE_DeviceDiscoveredHandler", () => string.Format("Adding '{0}' '{1}'", info.Name, info.Id));
                 this.RemoveIfFound(info.Id, false, true);
                 this.log.Info("BLE_DeviceDiscoveredHandler", () => string.Format("Adding DONE"));
                 this.listBox_BLE.Add(this.infoList_BLE, info);
                 //this.btnLEConnect.Show();
                 this.btnInfoLE.Show();
                 //this.btnConfigureBLE.Show();
             }
         });
     });
 }
 private void deviceDiscovered(object sender, BluetoothLEDeviceInfo device)
 {
     Log.Info("BLESelect", "deviceDiscovered", () => string.Format("Found {0}", device.Name));
     this.Dispatcher.Invoke(() => {
         WrapErr.ToErrReport(9999, "Failure on BLE Device Discovered", () => {
             lock (this.listBox_BLE) {
                 this.listBox_BLE.SelectionChanged -= this.selectionChanged;
                 this.log.Info("deviceDiscovered", () => string.Format("Adding '{0}' '{1}'", device.Name, device.Id));
                 this.RemoveIfFound(device.Id);
                 this.log.Info("BLE_DeviceDiscoveredHandler", () => string.Format("Adding DONE"));
                 this.listBox_BLE.Add(this.devices, device);
                 this.listBox_BLE.SelectionChanged += this.selectionChanged;
             }
         });
     });
 }
 private void BLE_DeviceUpdatedHandler(object sender, NetPropertiesUpdateDataModel args)
 {
     this.Dispatcher.Invoke(() => {
         WrapErr.ToErrReport(9999, "Failure on BLE Device Updated", () => {
             this.log.Info("", () => string.Format("Updating '{0}'", args.Id));
             // Disconnect the list from control before changing. Maybe change to Observable collection
             this.listBox_BLE.ItemsSource = null;
             BluetoothLEDeviceInfo item   = this.infoList_BLE.Find((x) => x.Id == args.Id);
             if (item != null)
             {
                 // This will raise events on change. How to deal with that. Think only if it is the current on display
                 item.Update(args.ServiceProperties);
             }
             this.listBox_BLE.ItemsSource = this.infoList_BLE;
         });
     });
 }
 private void Wrapper_BLE_DeviceInfoGatheredForConfig(object sender, BluetoothLEDeviceInfo info)
 {
     this.Dispatcher.Invoke(() => {
         WrapErr.ToErrReport(9999, "Failure on BLE Device info gathered Complete", () => {
             this.gridWait.Collapse();
             this.wrapper.BLE_DeviceInfoGathered -= this.Wrapper_BLE_DeviceInfoGatheredForConfig;
             if (info != null)
             {
                 DeviceInfo_BLESerial bleInfo = new DeviceInfo_BLESerial(this, info);
                 bleInfo.ShowDialog();
             }
             else
             {
                 MsgBoxSimple.ShowBox(DI.Wrapper.GetText(MsgCode.Error), DI.Wrapper.GetText(MsgCode.LoadFailed));
             }
         });
     });
 }
        private async Task <BLEGetInfoStatus> GetBLEDeviceInfo(BluetoothLEDeviceInfo deviceDataModel)
        {
            this.log.InfoEntry("GetBLEDeviceInfo");
            BLEGetInfoStatus result = await this.GetDevice(deviceDataModel);

            if (result.Status != BLEOperationStatus.Success)
            {
                return(result);
            }

            try {
                deviceDataModel.Services.Clear();
                GattDeviceServicesResult services = await this.currentDevice.GetGattServicesAsync(BluetoothCacheMode.Cached);

                if (services.Status != GattCommunicationStatus.Success)
                {
                    return(this.BuildConnectFailure(BLEOperationStatus.GetServicesFailed, services.Status.ToString()));
                }

                if (services.Services == null)
                {
                    return(this.BuildConnectFailure(BLEOperationStatus.GetServicesFailed, "Null Services"));
                }

                if (services.Services.Count == 0)
                {
                    return(this.BuildConnectFailure(BLEOperationStatus.NoServices, "No services exposed"));
                }

                result.Status     = BLEOperationStatus.Success;
                result.DeviceInfo = deviceDataModel;
                foreach (GattDeviceService service in services.Services)
                {
                    // TODO make sure status is set in functions
                    await this.BuildServiceDataModel(service, result);
                }

                return(result);
            }
            catch (Exception e) {
                this.log.Exception(9999, "HarvestDeviceInfo", "Failure", e);
                return(this.BuildConnectFailure(BLEOperationStatus.GetServicesFailed, "Exception on getting services"));
            }
        }
        private async Task <BLEGetInfoStatus> GetDevice(BluetoothLEDeviceInfo deviceDataModel)
        {
            this.log.Info("GetBLEDevice", () => string.Format("Attempting to get device for {0}: FromIdAsync({1})",
                                                              deviceDataModel.Name, deviceDataModel.Id));
            try {
                // https://github.com/microsoft/Windows-universal-samples/blob/master/Samples/BluetoothLE/cs/Scenario2_Client.xaml.cs
                this.log.Info("HarvestDeviceInfo", () => string.Format("--------------------------------------------------------------------"));
                this.log.Info("HarvestDeviceInfo", () => string.Format(" Param Device Info ID {0}", deviceDataModel.Id));
                this.currentDevice = await BluetoothLEDevice.FromIdAsync(deviceDataModel.Id);

                deviceDataModel.InfoAttempted = true;
                this.UpdateDeviceInfo(this.currentDevice, deviceDataModel);
                return(new BLEGetInfoStatus(BLEOperationStatus.Success));
            }
            catch (Exception e) {
                this.log.Exception(9999, "On harvest device info", e);
                return(this.BuildConnectFailure(BLEOperationStatus.UnhandledError, "Exception connecting to device"));
            }
        }
 private void btnInfoLE_Click(object sender, RoutedEventArgs e)
 {
     if (this.listBox_BLE.SelectedItem != null)
     {
         BluetoothLEDeviceInfo ble = this.listBox_BLE.SelectedItem as BluetoothLEDeviceInfo;
         if (ble.Services.Count == 0 && !ble.InfoAttempted)
         {
             this.wrapper.BLE_DeviceInfoGathered -= Wrapper_BLE_DeviceInfoGatheredOnGetInfo;
             this.wrapper.BLE_DeviceInfoGathered += Wrapper_BLE_DeviceInfoGatheredOnGetInfo;
             this.gridWait.Show();
             this.wrapper.BLE_GetInfo(ble);
         }
         else
         {
             DeviceInfo_BLE.ShowBox(this, ble);
         }
         //App.ShowMsg("BPIPO");
         //this.wrapper.BLE_GetDbgInfoStringDump(this.listBox_BLE.SelectedItem, App.ShowMsgTitle);
     }
 }
        public static void ShowBox(Window parent, BluetoothLEDeviceInfo info)
        {
            DeviceInfo_BLE win = new DeviceInfo_BLE(parent, info);

            win.ShowDialog();
        }