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;
}
}
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>
/// 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);
}
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!");
}
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);
}
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));
}
}
