//---------------------------------------------------------------------
// 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) { }
}
}
