internal static async Task <IBleResult> ExecuteWithBleAvailabilityCheckAsync(this IBleAvailability bleAvailability, Func <Task <IBleResult> > executionProvider)
{
IBleResult result;
try
{
switch (bleAvailability.BleState)
{
case BluetoothState.On:
result = await executionProvider.Invoke().ConfigureAwait(false);
break;
case BluetoothState.Unavailable:
result = BleResult.Failure(BleFailure.BleNotAvailable);
break;
case BluetoothState.Unauthorized:
result = BleResult.Failure(BleFailure.NoBluetoothPermissions);
break;
default:
result = BleResult.Failure(BleFailure.BluetoothNotEnabled);
break;
}
}
catch (Exception e)
{
result = BleResult.Failure(e);
}
return(result);
}
private async Task <IBleResult> EnsureDeviceIsFoundAsync(CancellationToken cancellationToken)
{
IBleResult result;
if (IsFound)
{
result = BleResult.Success();
}
else
{
var searchResult = await _bleInfrastructure.SearchManager.SearchForFirstDeviceAsync(_deviceSearchFilter, cancellationToken).ConfigureAwait(false);
if (searchResult.IsOperationCompleted)
{
_device = searchResult.Data;
result = _device != null?BleResult.Success() : BleResult.Failure(BleFailure.DeviceNotFound);
}
else
{
result = BleResult.Failure(BleFailure.DeviceNotFound, searchResult);
}
}
return(result);
}
public async Task <IBleResult <TOut> > ReadAsync(IParametrizedReaderBehavior <TIn, TOut> parametrizedReader, TIn parameter, CancellationToken cancellationToken)
{
IBleResult <TOut> result;
try
{
if (_connector.IsConnected)
{
result = await parametrizedReader.ReadAsync(parameter, cancellationToken).ConfigureAwait(false);
}
else
{
var connectionResult = await _connector.ConnectAsync(cancellationToken);
if (connectionResult.IsOperationCompleted)
{
cancellationToken.ThrowIfCancellationRequested();
result = await parametrizedReader.ReadAsync(parameter, cancellationToken);
}
else
{
result = BleResult.Failure <TOut>(BleFailure.DeviceNotConnected, connectionResult);
}
}
}
catch (OperationCanceledException)
{
result = BleResult.Failure <TOut>(BleFailure.OperationCancelled);
}
return(result);
}
internal static IBleResult <T> ExecuteWithBleAvailabilityCheck <T>(this IBleAvailability bleAvailability, Func <IBleResult <T> > executionProvider)
{
IBleResult <T> result;
try
{
switch (bleAvailability.BleState)
{
case BluetoothState.On:
result = executionProvider.Invoke();
break;
case BluetoothState.Unavailable:
result = BleResult.Failure <T>(BleFailure.BleNotAvailable);
break;
case BluetoothState.Unauthorized:
result = BleResult.Failure <T>(BleFailure.NoBluetoothPermissions);
break;
default:
result = BleResult.Failure <T>(BleFailure.BluetoothNotEnabled);
break;
}
}
catch (Exception e)
{
result = BleResult.Failure <T>(e);
}
return(result);
}
private async Task <IBleResult> ConnectWithPolicyAsync(bool connectWhenAvailable, CancellationToken cancellationToken)
{
IBleResult result;
var stopwatch = new Stopwatch();
stopwatch.Start();
try
{
var deviceSearchResult = await EnsureDeviceIsFoundAsync(cancellationToken).ConfigureAwait(false);
_bleInfrastructure.Logger.Log(LogSender, $"Search completed after {stopwatch.Elapsed}");
if (deviceSearchResult.IsOperationCompleted)
{
cancellationToken.ThrowIfCancellationRequested();
var deviceConnectedResult = await EnsureDeviceIsConnectedAsync(connectWhenAvailable, cancellationToken);
_bleInfrastructure.Logger.Log(LogSender, $"Connection completed after {stopwatch.Elapsed}");
if (deviceConnectedResult.IsOperationCompleted)
{
cancellationToken.ThrowIfCancellationRequested();
var initializationResult = await InitializeProtocolAsync(cancellationToken);
_bleInfrastructure.Logger.Log(LogSender, $"Initialization completed after {stopwatch.Elapsed}");
result = initializationResult.IsOperationCompleted ? BleResult.Success() : BleResult.Failure(BleFailure.DeviceNotInitialized, initializationResult);
}
else
{
result = deviceConnectedResult;
}
}
else
{
result = deviceSearchResult;
}
}
catch (OperationCanceledException)
{
result = BleResult.Failure(BleFailure.OperationCancelled);
}
catch (Exception e)
{
result = BleResult.Failure(e);
}
finally
{
stopwatch.Stop();
}
return(result);
}
public async Task <IBleResult> InitializeAsync(IDevice device, CancellationToken cancellationToken)
{
IBleResult result;
try
{
if (_bleCharacteristic != null)
{
_bleCharacteristic.ValueUpdated -= OnValueUpdated;
_bleCharacteristic = null;
}
var service = await device.GetServiceAsync(_serviceId, cancellationToken).ConfigureAwait(false);
if (service != null)
{
cancellationToken.ThrowIfCancellationRequested();
_bleCharacteristic = await service.GetCharacteristicAsync(_characteristicId);
if (_bleCharacteristic != null)
{
_bleCharacteristic.ValueUpdated += OnValueUpdated;
result = BleResult.Success();
}
else
{
throw new CharacteristicNotFoundException(_characteristicId);
}
}
else
{
throw new ServiceNotFoundException(_serviceId);
}
}
catch (OperationCanceledException)
{
result = BleResult.Failure(BleFailure.OperationCancelled);
}
catch (Exception e)
{
result = BleResult.Failure(e);
}
return(result);
}
internal static async Task <IBleResult> TimeoutBleOperationAsync(this IExecutor executor, Func <CancellationToken, Task <IBleResult> > taskProvider,
TimeSpan timeout, CancellationToken cancellationToken = default)
{
IBleResult result;
try
{
result = await executor.CancelAfterTimeoutAsync(taskProvider, timeout, true, cancellationToken).ConfigureAwait(false);
}
catch (TimeoutException ex)
{
result = BleResult.Failure(BleFailure.OperationTimeout, ex);
}
catch (Exception ex)
{
result = BleResult.Failure(ex);
}
return(result);
}
public async Task <IBleResult> WriteAsync(IWriterBehavior <TIn> writer, TOut value, CancellationToken cancellationToken)
{
IBleResult result;
try
{
var convertedValue = _valueConverter.Invoke(value);
cancellationToken.ThrowIfCancellationRequested();
result = await writer.WriteAsync(convertedValue, cancellationToken).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
result = BleResult.Failure(BleFailure.OperationCancelled);
}
catch (Exception e)
{
result = BleResult.Failure(e);
}
return(result);
}
public async Task <IBleResult> StopObservingAsync()
{
IBleResult result;
try
{
if (_bleCharacteristic == null)
{
result = BleResult.Failure(BleFailure.DeviceNotInitialized);
}
else if (!_bleCharacteristic.CanUpdate)
{
result = BleResult.Failure(BleFailure.UpdateNotSupported);
}
else
{
if (IsObserving)
{
await _bleCharacteristic.StopUpdatesAsync().ConfigureAwait(false);
IsObserving = false;
NotifyObservationCompleted();
}
result = BleResult.Success();
}
}
catch (TimeoutException)
{
result = BleResult.Failure(BleFailure.OperationTimeout);
}
catch (Exception e)
{
result = BleResult.Failure(e);
}
return(result);
}
public async Task <IBleResult <byte[]> > ReadRawAsync(CancellationToken cancellationToken)
{
IBleResult <byte[]> result;
try
{
if (_bleCharacteristic == null)
{
result = BleResult.Failure <byte[]>(BleFailure.DeviceNotInitialized);
}
else if (!_bleCharacteristic.CanRead)
{
result = BleResult.Failure <byte[]>(BleFailure.ReadNotSupported);
}
else
{
var rawData = await _bleCharacteristic.ReadAsync(cancellationToken).ConfigureAwait(false);
result = BleResult.Success(rawData);
}
}
catch (TimeoutException)
{
result = BleResult.Failure <byte[]>(BleFailure.OperationTimeout);
}
catch (OperationCanceledException)
{
result = BleResult.Failure <byte[]>(BleFailure.OperationCancelled);
}
catch (Exception e)
{
result = BleResult.Failure <byte[]>(e);
}
return(result);
}
public async Task <IBleResult> WriteRawAsync(byte[] data, CancellationToken cancellationToken)
{
IBleResult result;
try
{
if (_bleCharacteristic == null)
{
result = BleResult.Failure(BleFailure.DeviceNotInitialized);
}
else if (!_bleCharacteristic.CanWrite)
{
result = BleResult.Failure(BleFailure.WriteNotSupported);
}
else
{
var completed = await _bleExecutionProvider.ExecuteAsync(() => _bleCharacteristic.WriteAsync(data, cancellationToken)).ConfigureAwait(false);
result = completed ? BleResult.Success() : BleResult.Failure(BleFailure.WriteFailed);
}
}
catch (TimeoutException)
{
result = BleResult.Failure(BleFailure.OperationTimeout);
}
catch (OperationCanceledException)
{
result = BleResult.Failure(BleFailure.OperationCancelled);
}
catch (Exception e)
{
result = BleResult.Failure(e);
}
return(result);
}
