//--------------------------------------------------------------------- // Methods to start and stop the service //--------------------------------------------------------------------- // Starts the service. // <param name="connectable"> // Starts the service as Connectable if set to true, starts the // service as only Discoverable if set to false. // </param> public virtual void Start(bool connectable) { // // Setting IsDiscoverable to true ensures that remote devices can // query support for this service from the local device. // IsConnectable is for the Peripheral role and advertises whether // this service is connectable, and best-effort populates the // advertising packet with the service ID. // GattServiceProviderAdvertisingParameters advertisingParams = new GattServiceProviderAdvertisingParameters { IsDiscoverable = true, IsConnectable = connectable }; // Start advertising try { ServiceProvider.StartAdvertising(advertisingParams); IsPublishing = true; OnPropertyChanged(new PropertyChangedEventArgs("IsPublishing")); } catch (Exception) { Debug.WriteLine($"An error occurred while starting advertising" + $"for service {ServiceProvider.Service.Uuid}"); IsPublishing = false; throw; } }
bool IWcfPeripheralHost.StartAdvertising(string deviceName) { Utils.Info("StartAdvertising: {0}", deviceName); // ただしWindows10ではdeviceNameは反映できないのであった lock (mLockObject) { if (mStatus == Status.Advertise) { Utils.Error("already advertising"); return(false); } if (mStatus != Status.Ready) { Utils.Error("invalid status: {0}", mStatus.ToString()); return(false); } var advertisingParameters = new GattServiceProviderAdvertisingParameters { IsDiscoverable = true, IsConnectable = true, }; mServiceProvider.StartAdvertising(advertisingParameters); SetStatus(Status.Advertise); } return(true); }
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); }
// 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); }
public async void PublishService() { await CreateService(); GattServiceProviderAdvertisingParameters advParameters = new GattServiceProviderAdvertisingParameters { IsDiscoverable = true, IsConnectable = true }; serviceProvider.StartAdvertising(advParameters); }
/// <summary> /// Start GATT Server /// </summary> public void Start() { if (_gattServiceProvider.AdvertisementStatus == GattServiceProviderAdvertisementStatus.Created || _gattServiceProvider.AdvertisementStatus == GattServiceProviderAdvertisementStatus.Stopped) { var advParameters = new GattServiceProviderAdvertisingParameters { IsDiscoverable = true, IsConnectable = true }; _gattServiceProvider.StartAdvertising(advParameters); } }
/// <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; } }
/// <summary> /// Starts the Gatt Service /// </summary> /// <param name="connectable">True, Starts the Service as connectable. False, starts the Service as only Discoverable</param> public virtual void Start(bool connectable) { // MakeDiscoverable ensures that remote devices can query support for the service from the local device. MakeConnectable is PeripheralRole and advertises connectably // and best-effort populates the ADV packet with the service ID GattServiceProviderAdvertisingParameters advParameters = new GattServiceProviderAdvertisingParameters { IsDiscoverable = true, IsConnectable = connectable }; try { ServiceProvider.StartAdvertising(advParameters); IsPublishing = true; OnPropertyChanged(new PropertyChangedEventArgs("IsPublishing")); } catch (Exception) { Debug.WriteLine($"Exception while start Advertising {ServiceProvider.Service.Uuid}"); IsPublishing = false; throw; } }
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> /// 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); }
public async Task StartAsync(CancellationToken cancellationToken) { // FitnessMachine service var gattServiceFitnessMachineRequest = await GattServiceProvider.CreateAsync(FitnessMachineServiceUuid); if (gattServiceFitnessMachineRequest.Error != BluetoothError.Success) { throw new Exception("Cannot create Gatt Service Provider"); } _gattServiceProviderFitnessMachine = gattServiceFitnessMachineRequest.ServiceProvider; // Fitness Machine Feature characteristic var fitnessMachineFeatureData = new byte[] { 0x08, 0x00, 0x00, 0x00 }; var targetSettingsData = new byte[] { 0x00, 0x00, 0x00, 0x00 }; var fitnessMachineFeatureDataFull = fitnessMachineFeatureData.Concat(targetSettingsData).ToArray(); var fitnessMachineFeatureCharacteristicRequest = new GattLocalCharacteristicParameters { CharacteristicProperties = GattCharacteristicProperties.Read, StaticValue = fitnessMachineFeatureDataFull.AsBuffer(), ReadProtectionLevel = GattProtectionLevel.Plain, }; var characteristicResult = await _gattServiceProviderFitnessMachine.Service.CreateCharacteristicAsync( FitnessMachineFeatureCharacteristicUuid, fitnessMachineFeatureCharacteristicRequest); if (characteristicResult.Error != BluetoothError.Success) { throw new Exception("Cannot create Characteristic"); } // Treadmill Data characteristic var treadmillDataCharacteristicRequest = new GattLocalCharacteristicParameters { CharacteristicProperties = GattCharacteristicProperties.Read | GattCharacteristicProperties.Notify, ReadProtectionLevel = GattProtectionLevel.Plain }; characteristicResult = await _gattServiceProviderFitnessMachine.Service.CreateCharacteristicAsync(TreadmillDataCharacteristicUuid, treadmillDataCharacteristicRequest); if (characteristicResult.Error != BluetoothError.Success) { throw new Exception("Cannot create Characteristic"); } _treadmillDataCharacteristic = characteristicResult.Characteristic; _treadmillDataCharacteristic.ReadRequested += TreadmillDataCharacteristic_ReadRequestedAsync; // Advertising byte[] flagsData = { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; byte[] fitnessMachineTypeData = { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; var serviceData = flagsData.Concat(fitnessMachineTypeData).ToArray(); var advParameters = new GattServiceProviderAdvertisingParameters { IsDiscoverable = true, IsConnectable = true, ServiceData = serviceData.AsBuffer() }; // Go _gattServiceProviderFitnessMachine.StartAdvertising(advParameters); while (true) { await Task.Delay(1000, cancellationToken); await _treadmillDataCharacteristic.NotifyValueAsync(GetTreadmillDataPackage(_currentSpeed)); } }
/// <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() { var requestStatus = await Windows.ApplicationModel.Background.BackgroundExecutionManager.RequestAccessAsync(); if (requestStatus == BackgroundAccessStatus.Denied || requestStatus == BackgroundAccessStatus.DeniedByUser || requestStatus == BackgroundAccessStatus.DeniedBySystemPolicy) { rootPage.NotifyUser("BackgroundTask cannot to be registered", NotifyType.ErrorMessage); return(false); } // Depending on the value of requestStatus, provide an appropriate response // such as notifying the user which functionality won't work as expected //await RegisterBlAdvertisementTask(); await RegisterAppTriggeredTask(); await RegisterTimeTriggeredTask(); // BT_Code: Initialize and starting a custom GATT Service using GattServiceProvider. //GattServiceProviderResult serviceResult = await GattServiceProvider.CreateAsync(Constants.CalcServiceUuid); var serviceResultTriggerResult = await GattServiceProviderTrigger.CreateAsync(TaskName, Constants.CalcServiceUuid); if (serviceResultTriggerResult.Error == BluetoothError.Success) { serviceProviderTrigger = serviceResultTriggerResult.Trigger; } else { rootPage.NotifyUser($"Could not create service provider: {serviceResultTriggerResult.Error}", NotifyType.ErrorMessage); return(false); } GattLocalCharacteristicResult result = await serviceProviderTrigger.Service.CreateCharacteristicAsync(Constants.Op1CharacteristicUuid, Constants.gattOperand1Parameters); if (result.Error == BluetoothError.Success) { op1Characteristic = result.Characteristic; } else { rootPage.NotifyUser($"Could not create operand1 characteristic: {result.Error}", NotifyType.ErrorMessage); return(false); } 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 }; //serviceProviderTrigger.AdvertisementStatusChanged += ServiceProvider_AdvertisementStatusChanged; //serviceProvider.StartAdvertising(advParameters); //var triggerResult = await GattServiceProviderTrigger.CreateAsync("ttt", Constants.CalcServiceUuid); serviceProviderTrigger.AdvertisingParameters = advParameters; RegistarGattServerBgTaskTrigger(); return(true); }
private async void Init(MessageAccount account) { foreach (var msg in account.GetMessages()) { queue.Add(msg.Binary); } var result = await GattServiceProvider.CreateAsync(ServiceId); if (result.Error == BluetoothError.Success) { var serviceProvider = result.ServiceProvider; var prm = new GattLocalCharacteristicParameters() { CharacteristicProperties = GattCharacteristicProperties.WriteWithoutResponse, UserDescription = "DMsg" }; var characteristicResult = await serviceProvider.Service.CreateCharacteristicAsync(cServiceId, prm); if (characteristicResult.Error != BluetoothError.Success) { // An error occurred. return; } var _readCharacteristic = characteristicResult.Characteristic; _readCharacteristic.WriteRequested += OnWriteMessage; var advParameters = new GattServiceProviderAdvertisingParameters { IsDiscoverable = true, //IsConnectable = true }; serviceProvider.StartAdvertising(advParameters); } string[] requestedProperties = { "System.Devices.Aep.DeviceAddress", "System.Devices.Aep.IsConnected" }; var deviceWatcher = DeviceInformation.CreateWatcher(BluetoothLEDevice.GetDeviceSelectorFromPairingState(false), requestedProperties, DeviceInformationKind.AssociationEndpoint); deviceWatcher.Added += OnAddDevice; deviceWatcher.Start(); var udp = new UdpClient(AddressFamily.InterNetworkV6); udp.EnableBroadcast = true; udp.Client.SetSocketOption(SocketOptionLevel.IPv6, SocketOptionName.IPv6Only, 0); udp.Client.Bind(new IPEndPoint(IPAddress.IPv6Any, 24680)); MessageBroadcast(udp); while (true) { var ures = await udp.ReceiveAsync(); try { account.AddMessage(ures.Buffer); } catch (Exception) { } } }