// GattServiceProvider private void OnAdvertisementStatusChanged(GattServiceProvider serviceProvider, GattServiceProviderAdvertisementStatusChangedEventArgs args) { Utils.Info("AdvertisementStatusChanged error: {0} status: {1}", args.Error.ToString(), args.Status.ToString()); if (mStatus != Status.Advertise) { return; } if (args.Status == GattServiceProviderAdvertisementStatus.Started) { Utils.Info("advertising.."); } else if (args.Error != BluetoothError.Success) { Utils.Error("error: {0}", args.Error.ToString()); if (args.Error == BluetoothError.RadioNotAvailable) { mCallback.OnBluetoothRequire(); } mServiceProvider.StopAdvertising(); SetStatus(Status.Ready); mCallback.OnFail(); } }
private async void PublishButton_ClickAsync() { // Server not initialized yet - initialize it and start publishing if (serviceProvider == null) { var serviceStarted = await ServiceProviderInitAsync(); if (serviceStarted) { rootPage.NotifyUser("Service successfully started", NotifyType.StatusMessage); PublishButton.Content = "Stop Service"; } else { rootPage.NotifyUser("Service not started", NotifyType.ErrorMessage); } } else { // BT_Code: Stops advertising support for custom GATT Service serviceProvider.StopAdvertising(); serviceProvider = null; PublishButton.Content = "Start Service"; } }
private async Task CreateCharacteristics(GattServiceProvider gattServiceProvider) { var statusCharacteristicParams = new GattLocalCharacteristicParameters { CharacteristicProperties = GattCharacteristicProperties.Read | GattCharacteristicProperties.Notify, WriteProtectionLevel = GattProtectionLevel.Plain, UserDescription = "Status Characteristic" }; statusCharacteristicParams.PresentationFormats.Add(GattPresentationFormat.FromParts(GattPresentationFormatTypes.Utf8, GattPresentationFormatExponent, GattPresentationFormatUnitless, GattPresentationFormatNamespaceId, GattPresentationFormatDescription)); var statusCharacteristicResult = await gattServiceProvider.Service.CreateCharacteristicAsync( BluetoothConstants.StatusCharacteristicUuid, statusCharacteristicParams); if (statusCharacteristicResult.Error != BluetoothError.Success) { throw new InvalidOperationException($"Failed to create GATT status characteristic with error {statusCharacteristicResult.Error}"); } _statusCharacteristic = statusCharacteristicResult.Characteristic; var commandCharacteristicResult = await gattServiceProvider.Service.CreateCharacteristicAsync( BluetoothConstants.CommandCharacteristicUuid, new GattLocalCharacteristicParameters { CharacteristicProperties = GattCharacteristicProperties.Write | GattCharacteristicProperties.WriteWithoutResponse, WriteProtectionLevel = GattProtectionLevel.Plain, UserDescription = "Command Characteristic" }); if (commandCharacteristicResult.Error != BluetoothError.Success) { throw new InvalidOperationException($"Failed to create GATT command characteristic with error {commandCharacteristicResult.Error}"); } var brightnessCharacteristicResult = await gattServiceProvider.Service.CreateCharacteristicAsync( BluetoothConstants.BrightnessCharacteristicUuid, new GattLocalCharacteristicParameters { CharacteristicProperties = GattCharacteristicProperties.Write | GattCharacteristicProperties.WriteWithoutResponse, WriteProtectionLevel = GattProtectionLevel.Plain, UserDescription = "Brightness Characteristic" }); if (brightnessCharacteristicResult.Error != BluetoothError.Success) { throw new InvalidOperationException($"Failed to create GATT brightness characteristic with error {brightnessCharacteristicResult.Error}"); } _statusCharacteristic.ReadRequested += StatusCharacteristic_ReadRequested; commandCharacteristicResult.Characteristic.WriteRequested += CommandCharacteristic_WriteRequested; brightnessCharacteristicResult.Characteristic.WriteRequested += BrightnessCharacteristic_WriteRequested; }
private void ServiceProvider_AdvertisementStatusChanged(GattServiceProvider sender, GattServiceProviderAdvertisementStatusChangedEventArgs args) { if (args.Status != GattServiceProviderAdvertisementStatus.Started) { IsPublishing = false; } }
public void Dispose() { // Windows BLE seems to get unreliable if services etc aren't disposed correctly. if (continueButtonCharacteristic != null) { continueButtonCharacteristic.ReadRequested -= readContinueButtonValue; continueButtonCharacteristic.SubscribedClientsChanged -= subscribedClientsChanged; continueButtonCharacteristic = null; } if (stopButtonCharacteristic != null) { stopButtonCharacteristic.ReadRequested -= readStopButtonValue; stopButtonCharacteristic = null; } if (remoteCanContinueCharacteristic != null) { remoteCanContinueCharacteristic.WriteRequested -= writeRemoteCanContinue; remoteCanContinueCharacteristic = null; } if (remoteCanStopCharacteristic != null) { remoteCanStopCharacteristic.WriteRequested -= writeRemoteCanStop; remoteCanStopCharacteristic = null; } if (userMessageCharacteristic != null) { userMessageCharacteristic.WriteRequested -= writeUserMessage; userMessageCharacteristic = null; } if (cascableService != null) { cascableService.StopAdvertising(); cascableService = null; } }
private void CleanupInternal() { if (mStatus == Status.Advertise) { mServiceProvider.StopAdvertising(); } SetStatus(Status.Invalid); if (mInitializationCancelTokenSource != null) { mInitializationCancelTokenSource.Dispose(); mInitializationCancelTokenSource = null; } mUploadCharacteristic = null; mDownloadCharacteristic = null; mServiceProvider = null; mSubscribedCentrals.Clear(); // TODO mCallback = null; mFinished = true; }
private void HandleError() { mUploadCharacteristic = null; mDownloadCharacteristic = null; mServiceProvider = null; mCallback.OnFail(); }
internal async Task <bool> Initialize() { try { GattServiceProviderResult result = await GattServiceProvider.CreateAsync(_serviceId); if (result.Error != BluetoothError.Success) { Robot.Message("can't create GATT BlueTooth service with id " + _serviceId.ToString(), MessageType.Error); Robot.Message("without bluetooth service, remote controller won't work", MessageType.Warning); return(_init); } _service = result.ServiceProvider; byte[] value = new byte[] { 0x21 }; var constantParameters = new GattLocalCharacteristicParameters { CharacteristicProperties = (GattCharacteristicProperties.Read), StaticValue = value.AsBuffer(), ReadProtectionLevel = GattProtectionLevel.Plain, }; GattLocalCharacteristicResult characteristicResult = await _service.Service.CreateCharacteristicAsync(_notifyId, new GattLocalCharacteristicParameters { CharacteristicProperties = GattCharacteristicProperties.Notify, ReadProtectionLevel = GattProtectionLevel.Plain, StaticValue = value.AsBuffer() }); if (characteristicResult.Error != BluetoothError.Success) { Robot.Message("can't create GATT BlueTooth service with id " + _serviceId.ToString(), MessageType.Error); Robot.Message("without bluetooth service, remote controller won't work", MessageType.Warning); return(_init); } _notifyCharacteristic = characteristicResult.Characteristic; //_notifyCharacteristic.SubscribedClientsChanged += _btNotify_SubscribedClientsChanged; GattServiceProviderAdvertisingParameters advParameters = new GattServiceProviderAdvertisingParameters { IsDiscoverable = true, IsConnectable = true }; _service.StartAdvertising(advParameters); Robot.Message("created Bluetooth GATT service with id " + _serviceId.ToString(), MessageType.Success); _init = true; } catch (Exception x) { while (x != null) { Robot.Message(x.Message, MessageType.Error); x = x.InnerException; } Robot.Message("without bluetooth service, remote controller won't work", MessageType.Warning); } return(_init); }
private async void createServiceProvider() { var result = await GattServiceProvider.CreateAsync(serviceUuid); if (result.Error == BluetoothError.Success) { serviceProvider = result.ServiceProvider; } }
private void ServiceProvider_AdvertisementStatusChanged(GattServiceProvider sender, GattServiceProviderAdvertisementStatusChangedEventArgs args) { // Created - The default state of the advertisement, before the service is published for the first time. // Stopped - Indicates that the application has canceled the service publication and its advertisement. // Started - Indicates that the system was successfully able to issue the advertisement request. // Aborted - Indicates that the system was unable to submit the advertisement request, or it was canceled due to resource contention. rootPage.NotifyUser($"New Advertisement Status: {sender.AdvertisementStatus}", NotifyType.StatusMessage); }
// Assumes that the lock is being held. private void PublishService(GattServiceProvider provider) { var advertisingParameters = new GattServiceProviderAdvertisingParameters { IsDiscoverable = true, IsConnectable = true // Peripheral role support is required for Windows to advertise as connectable. }; provider.StartAdvertising(advertisingParameters); }
protected override void OnNavigatedFrom(NavigationEventArgs e) { if (serviceProvider != null) { if (serviceProvider.AdvertisementStatus != GattServiceProviderAdvertisementStatus.Stopped) { serviceProvider.StopAdvertising(); } serviceProvider = null; } }
//--------------------------------------------------------------------- // Method to create the GATT service provider //--------------------------------------------------------------------- // <param name="uuid"> The UUID of the service to create </param> protected async Task CreateServiceProvider(Guid uuid) { GattServiceProviderResult creationResult = await GattServiceProvider.CreateAsync(uuid); if (creationResult.Error != BluetoothError.Success) { throw new CreateServiceException(creationResult); } ServiceProvider = creationResult.ServiceProvider; }
/// <summary> /// Creates the Gatt Service provider /// </summary> /// <param name="uuid">UUID of the Service to create</param> protected async Task CreateServiceProvider(Guid uuid) { // Create Service Provider - similar to RFCOMM APIs GattServiceProviderResult result = await GattServiceProvider.CreateAsync(uuid); if (result.Error != BluetoothError.Success) { throw new CreateServiceException(result); } ServiceProvider = result.ServiceProvider; }
/// <summary> /// Creates the Gatt Service provider /// </summary> /// <param name="uuid">UUID of the Service to create</param> protected async Task CreateServiceProvider(Guid uuid) { // Create Service Provider - similar to RFCOMM APIs GattServiceProviderResult result = await GattServiceProvider.CreateAsync(uuid); if (result.Error != BluetoothError.Success) { throw new System.Exception(string.Format($"Error occured while creating the BLE service provider, Error Code:{result.Error}")); } ServiceProvider = result.ServiceProvider; }
private void ServiceProvider_AdvertisementStatusChanged(GattServiceProvider sender, GattServiceProviderAdvertisementStatusChangedEventArgs args) { if ((args.Status == GattServiceProviderAdvertisementStatus.Stopped) || (args.Status == GattServiceProviderAdvertisementStatus.Aborted)) { IsAdvertising = false; } else { IsAdvertising = true; } }
/// <summary> /// 创建服务 /// </summary> private async Task CreateService() { GattServiceProviderResult result = await GattServiceProvider.CreateAsync(remoteGuid); if (result.Error == BluetoothError.Success) { serviceProvider = result.ServiceProvider; } else { throw new Exception(); } CreateCharacteristics(); }
public async Task Build() { this.native = await GattServiceProvider.CreateAsync(this.Uuid); foreach (var ch in this.characteristics) { await ch.Build(this.native); } this.native.ServiceProvider.StartAdvertising(new GattServiceProviderAdvertisingParameters { IsConnectable = true, IsDiscoverable = true }); }
private void ServiceProvider_AdvertisementStatusChanged(GattServiceProvider sender, GattServiceProviderAdvertisementStatusChangedEventArgs args) { Debug.WriteLine($"ServiceProvider ({this.Name}) advertisementstatuschanged : {args.Status}"); if (args.Status == GattServiceProviderAdvertisementStatus.Started) { isPublishing = true; } else { Debug.WriteLine($"ServiceProvider ({this.Name}) advertisementstatuschanged - ERROR!"); IsPublishing = false; OnPropertyChanged(new PropertyChangedEventArgs("ServiceStartError")); } }
private void UnpublishService(GattServiceProvider provider) { try { if ((provider.AdvertisementStatus == GattServiceProviderAdvertisementStatus.Started) || (provider.AdvertisementStatus == GattServiceProviderAdvertisementStatus.Aborted)) { provider.StopAdvertising(); SubscribedHidClientsChanged?.Invoke(null); } } catch (Exception e) { Debug.WriteLine("Failed to stop advertising due to: " + e.Message); } }
/// <summary> /// Start up the bl;uetooth listeners, set UUIDs/ble-specific information. /// </summary> /// <returns></returns> private async Task MainAsync() { // Check if adapter supports peripheral and bluetooth low energy peripheralSupported = await CheckPeripheralRoleSupportAsync(); if (!peripheralSupported) { Environment.Exit(1); } if (serviceProvider == null) { ServiceProviderInitAsync().Wait(); if (serviceStarted) { // Advertising server as connectable and discoverable. advParameters = new GattServiceProviderAdvertisingParameters { // IsConnectable determines whether a call to publish will attempt to start advertising and // put the service UUID in the ADV packet (best effort) IsConnectable = peripheralSupported, IsDiscoverable = true }; // Start server serviceProvider.StartAdvertising(advParameters); this.hasStarted = true; if (this.setIndicate == true) { this.setIndicate = false; Indicate(); } } } else { // Stops advertising support serviceProvider.StopAdvertising(); serviceProvider = null; } }
public async Task Init() { this.native = await GattServiceProvider.CreateAsync(this.Uuid); if (this.native.Error != BluetoothError.Success) { throw new ArgumentException(); } foreach (var ch in this.Characteristics.OfType <IUwpGattCharacteristic>()) { await ch.Init(this.native.ServiceProvider.Service); } this.native.ServiceProvider.StartAdvertising(new GattServiceProviderAdvertisingParameters { IsConnectable = true, IsDiscoverable = true }); }
public async Task Initialize() { var cellaGatService = await GattServiceProvider.CreateAsync(_serviceId); if (cellaGatService.Error == BluetoothError.RadioNotAvailable) { throw new Exception("BLE not enabled"); } ; if (cellaGatService.Error == BluetoothError.Success) { _gattServiceProvider = cellaGatService.ServiceProvider; } _gattServiceProvider.AdvertisementStatusChanged += async(sender, args) => { await _logger.LogMessageAsync( sender.AdvertisementStatus == GattServiceProviderAdvertisementStatus.Started? "GATT server started." : "GATT server stopped."); }; }
private async void SetupGatt() { var ba = await BluetoothAdapter.GetDefaultAsync(); if (ba == null) { notifyIcon.Text = String.Format("{0} (No Bluetooth adapter found!)", Application.ProductName); return; } if (!ba.IsPeripheralRoleSupported) { notifyIcon.Text = String.Format("{0} (Peripheral mode not supported!)", Application.ProductName); return; } var sr = await GattServiceProvider.CreateAsync(SVC_UUID); if (sr.Error != BluetoothError.Success) { notifyIcon.Text = String.Format("{0} (Error creating service!)", Application.ProductName); return; } serviceProvider = sr.ServiceProvider; var cr = await serviceProvider.Service.CreateCharacteristicAsync(CHR_UUID, CHR_PARAMS); if (cr.Error != BluetoothError.Success) { notifyIcon.Text = String.Format("{0} (Error creating characteristic!)", Application.ProductName); return; } localCharacteristic = cr.Characteristic; localCharacteristic.WriteRequested += CharacteristicWriteRequested; serviceProvider.StartAdvertising(ADV_PARAMS); }
internal async Task StartAsync() { if (_gattServiceProvider == null) { var serviceProviderResult = await GattServiceProvider.CreateAsync(BluetoothConstants.ServiceUuid); if (serviceProviderResult.Error != BluetoothError.Success) { throw new InvalidOperationException($"Failed to create GATT service with error {serviceProviderResult.Error}"); } _gattServiceProvider = serviceProviderResult.ServiceProvider; await CreateCharacteristics(_gattServiceProvider); } var advertisingParameters = new GattServiceProviderAdvertisingParameters { IsConnectable = (await BluetoothAdapter.GetDefaultAsync())?.IsPeripheralRoleSupported ?? false, IsDiscoverable = true }; _gattServiceProvider.StartAdvertising(advertisingParameters); }
/// <summary> /// Check that the service has started, start up the characteristics required for the BLE Service /// </summary> /// <returns></returns> private async Task ServiceProviderInitAsync() { // Initialize and starting a custom GATT Service MainService = await GattServiceProvider.CreateAsync(Constants.serviceProviderUuid); if (MainService.Error == BluetoothError.Success) { serviceProvider = MainService.ServiceProvider; } else { // An error occurred. serviceStarted = false; } characteristicResult = await serviceProvider.Service.CreateCharacteristicAsync(Constants.ReadCharacteristicUuid, Constants.gattReadParameters); if (characteristicResult.Error != BluetoothError.Success) { // An error occurred. serviceStarted = false; } readCharacteristic = characteristicResult.Characteristic; readCharacteristic.ReadRequested += ReadCharacteristic_ReadRequested; characteristicResult = await serviceProvider.Service.CreateCharacteristicAsync(Constants.WriteCharacteristicUuid, Constants.gattWriteParameters); if (characteristicResult.Error != BluetoothError.Success) { // An error occurred. serviceStarted = false; } writeCharacteristic = characteristicResult.Characteristic; writeCharacteristic.WriteRequested += WriteCharacteristic_WriteRequested; }
protected async override void OnNavigatedTo(NavigationEventArgs e) { var adapter = await BluetoothAdapter.GetDefaultAsync(); var serviceResult = await GattServiceProvider.CreateAsync(Guid.Parse(SensorUUIDs.UUID_ACC_SERV)); accService = serviceResult.ServiceProvider; accService.AdvertisementStatusChanged += AccService_AdvertisementStatusChanged; var param = new GattLocalCharacteristicParameters(); param.CharacteristicProperties = GattCharacteristicProperties.Indicate | GattCharacteristicProperties.Read; param.WriteProtectionLevel = GattProtectionLevel.Plain; param.UserDescription = "accelerometer"; var charResult = await accService.Service.CreateCharacteristicAsync(Guid.Parse(SensorUUIDs.UUID_ACC_DATA), param); accData = charResult.Characteristic; accData.ReadRequested += AccData_ReadRequested; accService.StartAdvertising(new GattServiceProviderAdvertisingParameters() { IsDiscoverable = true, IsConnectable = true }); serviceResult = await GattServiceProvider.CreateAsync(Guid.Parse(SensorUUIDs.UUID_ENV_SERV)); envService = serviceResult.ServiceProvider; param = new GattLocalCharacteristicParameters(); param.CharacteristicProperties = GattCharacteristicProperties.Indicate | GattCharacteristicProperties.Read; param.UserDescription = "temperature"; charResult = await envService.Service.CreateCharacteristicAsync(Guid.Parse(SensorUUIDs.UUID_ENV_TEMP), param); tempData = charResult.Characteristic; tempData.ReadRequested += TempData_ReadRequested; param = new GattLocalCharacteristicParameters(); param.CharacteristicProperties = GattCharacteristicProperties.Indicate | GattCharacteristicProperties.Read; param.UserDescription = "pressure"; charResult = await envService.Service.CreateCharacteristicAsync(Guid.Parse(SensorUUIDs.UUID_ENV_PRES), param); pressData = charResult.Characteristic; pressData.ReadRequested += PressData_ReadRequested; envService.StartAdvertising(new GattServiceProviderAdvertisingParameters() { IsDiscoverable = true, IsConnectable = true }); timer = new DispatcherTimer(); timer.Interval = new TimeSpan(0, 0, 1); timer.Tick += Timer_Tick; //timer.Start(); base.OnNavigatedTo(e); }
private async void setup() { var result = await GattServiceProvider.CreateAsync(cascableBasicUserInputServiceGuid); if (result.Error != BluetoothError.Success) { Debug.WriteLine("Failed to create BLE service!!"); return; } cascableService = result.ServiceProvider; var continueButtonResult = await cascableService.Service.CreateCharacteristicAsync(continueButtonDownCharacteristicGuid, readAndNotifyParameters); if (continueButtonResult.Error != BluetoothError.Success) { Debug.WriteLine("Failed to create Continue Button Characteristic!!"); return; } continueButtonCharacteristic = continueButtonResult.Characteristic; continueButtonCharacteristic.ReadRequested += readContinueButtonValue; continueButtonCharacteristic.SubscribedClientsChanged += subscribedClientsChanged; var stopButtonResult = await cascableService.Service.CreateCharacteristicAsync(stopButtonDownCharacteristicGuid, readAndNotifyParameters); if (stopButtonResult.Error != BluetoothError.Success) { Debug.WriteLine("Failed to create Stop Button Characteristic!!"); return; } stopButtonCharacteristic = stopButtonResult.Characteristic; stopButtonCharacteristic.ReadRequested += readStopButtonValue; var remoteCanContinueResult = await cascableService.Service.CreateCharacteristicAsync(remoteCanContinueCharacteristicGuid, writeParameters); if (remoteCanContinueResult.Error != BluetoothError.Success) { Debug.WriteLine("Failed to create Remote Can Continue Characteristic!!"); return; } remoteCanContinueCharacteristic = remoteCanContinueResult.Characteristic; remoteCanContinueCharacteristic.WriteRequested += writeRemoteCanContinue; var remoteCanStopResult = await cascableService.Service.CreateCharacteristicAsync(remoteCanStopCharacteristicGuid, writeParameters); if (remoteCanStopResult.Error != BluetoothError.Success) { Debug.WriteLine("Failed to create Remote Can Stop Characteristic!!"); return; } remoteCanStopCharacteristic = remoteCanStopResult.Characteristic; remoteCanStopCharacteristic.WriteRequested += writeRemoteCanStop; var userMessageResult = await cascableService.Service.CreateCharacteristicAsync(userMessageCharacteristicGuid, writeParameters); if (userMessageResult.Error != BluetoothError.Success) { Debug.WriteLine("Failed to create User Message Characteristic!!"); return; } userMessageCharacteristic = userMessageResult.Characteristic; userMessageCharacteristic.WriteRequested += writeUserMessage; cascableService.StartAdvertising(advertisingParameters); Debug.WriteLine("Service is now advertising!"); }
private void AccService_AdvertisementStatusChanged(GattServiceProvider sender, GattServiceProviderAdvertisementStatusChangedEventArgs args) { Debug.WriteLine(args.Status); }
/// <summary> /// Uses the relevant Service/Characteristic UUIDs to initialize, hook up event handlers and start a service on the local system. /// </summary> /// <returns></returns> private async Task <bool> ServiceProviderInitAsync() { // BT_Code: Initialize and starting a custom GATT Service using GattServiceProvider. GattServiceProviderResult serviceResult = await GattServiceProvider.CreateAsync(Constants.CalcServiceUuid); if (serviceResult.Error == BluetoothError.Success) { serviceProvider = serviceResult.ServiceProvider; } else { rootPage.NotifyUser($"Could not create service provider: {serviceResult.Error}", NotifyType.ErrorMessage); return(false); } GattLocalCharacteristicResult result = await serviceProvider.Service.CreateCharacteristicAsync(Constants.Op1CharacteristicUuid, Constants.gattOperandParameters); if (result.Error == BluetoothError.Success) { op1Characteristic = result.Characteristic; } else { rootPage.NotifyUser($"Could not create operand1 characteristic: {result.Error}", NotifyType.ErrorMessage); return(false); } op1Characteristic.WriteRequested += Op1Characteristic_WriteRequestedAsync; result = await serviceProvider.Service.CreateCharacteristicAsync(Constants.Op2CharacteristicUuid, Constants.gattOperandParameters); if (result.Error == BluetoothError.Success) { op2Characteristic = result.Characteristic; } else { rootPage.NotifyUser($"Could not create operand2 characteristic: {result.Error}", NotifyType.ErrorMessage); return(false); } op2Characteristic.WriteRequested += Op2Characteristic_WriteRequestedAsync; result = await serviceProvider.Service.CreateCharacteristicAsync(Constants.OperatorCharacteristicUuid, Constants.gattOperatorParameters); if (result.Error == BluetoothError.Success) { operatorCharacteristic = result.Characteristic; } else { rootPage.NotifyUser($"Could not create operator characteristic: {result.Error}", NotifyType.ErrorMessage); return(false); } operatorCharacteristic.WriteRequested += OperatorCharacteristic_WriteRequestedAsync; // Add presentation format - 32-bit unsigned integer, with exponent 0, the unit is unitless, with no company description GattPresentationFormat intFormat = GattPresentationFormat.FromParts( GattPresentationFormatTypes.UInt32, PresentationFormats.Exponent, Convert.ToUInt16(PresentationFormats.Units.Unitless), Convert.ToByte(PresentationFormats.NamespaceId.BluetoothSigAssignedNumber), PresentationFormats.Description); Constants.gattResultParameters.PresentationFormats.Add(intFormat); result = await serviceProvider.Service.CreateCharacteristicAsync(Constants.ResultCharacteristicUuid, Constants.gattResultParameters); if (result.Error == BluetoothError.Success) { resultCharacteristic = result.Characteristic; } else { rootPage.NotifyUser($"Could not create result characteristic: {result.Error}", NotifyType.ErrorMessage); return(false); } resultCharacteristic.ReadRequested += ResultCharacteristic_ReadRequestedAsync; resultCharacteristic.SubscribedClientsChanged += ResultCharacteristic_SubscribedClientsChanged; // BT_Code: Indicate if your sever advertises as connectable and discoverable. GattServiceProviderAdvertisingParameters advParameters = new GattServiceProviderAdvertisingParameters { // IsConnectable determines whether a call to publish will attempt to start advertising and // put the service UUID in the ADV packet (best effort) IsConnectable = peripheralSupported, // IsDiscoverable determines whether a remote device can query the local device for support // of this service IsDiscoverable = true }; serviceProvider.AdvertisementStatusChanged += ServiceProvider_AdvertisementStatusChanged; serviceProvider.StartAdvertising(advParameters); return(true); }