public async Task InitializeAsync(Func <IHubController, Response, Task> notificationHandler, IGattCharacteristicWrapper gattCharacteristicWrapper)
{
_hubCharacteristic = gattCharacteristicWrapper;
await ToggleSubscribedForNotificationsAsync(notificationHandler);
await ExecuteCommandAsync(new HubTypeCommand());
await ExecuteCommandAsync(new HubFirmwareCommand());
}
public async Task TryReadValueAsync_ForGattCommunicationStatus_SetsProtocolError(
RawValueReader sut,
[Freeze] IBufferReader reader,
IGattReadResultWrapper result,
IGattCharacteristicWrapper characteristic,
byte protocolError)
{
WithTryReadValueResult(reader,
Array.Empty <byte> ( ));
result.Status
.Returns(GattCommunicationStatus.Success);
result.ProtocolError
.Returns(protocolError);
characteristic.WithCharacteristicProperties(GattCharacteristicProperties.Read)
.WithReadValueAsyncResult(result);
_ = await sut.TryReadValueAsync(characteristic);
sut.ProtocolError
.Should( )
.Be(protocolError);
}
public static IGattCharacteristicWrapper WithWriteValueWithResultAsync(
this IGattCharacteristicWrapper characteristic,
IGattWriteResultWrapper result)
{
_ = characteristic.WriteValueWithResultAsync(Arg.Any <IBuffer> ( ))
.Returns(Task.FromResult(result));
return(characteristic);
}
public static IGattCharacteristicWrapper WithReadValueAsyncResult(
this IGattCharacteristicWrapper characteristic,
IGattReadResultWrapper result)
{
_ = characteristic.ReadValueAsync( )
.Returns(Task.FromResult(result));
return(characteristic);
}
public static IGattCharacteristicWrapper WithCharacteristicProperties(
this IGattCharacteristicWrapper characteristic,
GattCharacteristicProperties properties)
{
_ = characteristic.CharacteristicProperties
.Returns(properties);
return(characteristic);
}
public static IGattCharacteristicWrapper WithWriteValueAsyncResult(
this IGattCharacteristicWrapper characteristic,
GattCommunicationStatus status)
{
_ = characteristic.WriteValueAsync(Arg.Any <IBuffer> ( ))
.Returns(Task.FromResult(status));
return(characteristic);
}
TryWriteWithoutResponseAsync_ForCharacteristicDoesNotSupportWrite_DoesNotCallTryWriteValueAsync(
RawValueWriter sut,
[Freeze] IGattCharacteristicWrapper characteristic,
IBuffer buffer)
{
characteristic.WithCharacteristicProperties(GattCharacteristicProperties.None);
await sut.TryWriteValueAsync(characteristic,
buffer);
await characteristic.DidNotReceive( )
.WriteValueAsync(buffer);
}
public async Task TryWriteValueAsync_ForGattCommunicationStatusIsAccessDenied_False(
RawValueWriter sut,
[Freeze] IGattCharacteristicWrapper characteristic,
IBuffer buffer)
{
characteristic.WithCharacteristicProperties(GattCharacteristicProperties.Write)
.WithWriteValueAsyncResult(GattCommunicationStatus.AccessDenied);
var actual = await sut.TryWriteValueAsync(characteristic,
buffer);
actual.Should( )
.BeFalse( );
}
public void TryWriteValueAsync_ForBufferIsNull_Throws(
RawValueWriter sut,
IGattCharacteristicWrapper characteristic)
{
Func <Task> action = async( ) =>
{
await sut.TryWriteValueAsync(characteristic,
null !);
};
action.Should( )
.Throw <ArgumentNullException> ( )
.WithParameter("buffer");
}
public async Task TryWritableAuxiliariesValueAsync_ForGattCommunicationStatusIsProtocolError_False(
RawValueWriter sut,
[Freeze] IGattCharacteristicWrapper characteristic,
IBuffer buffer)
{
characteristic.WithCharacteristicProperties(GattCharacteristicProperties.WritableAuxiliaries)
.WithWriteValueAsyncResult(GattCommunicationStatus.ProtocolError);
var actual = await sut.TryWritableAuxiliariesValueAsync(characteristic,
buffer);
actual.Should( )
.BeFalse( );
}
public async Task TryWritableAuxiliariesValueAsync_ForCharacteristicDoesNotSupportWrite_False(
RawValueWriter sut,
[Freeze] IGattCharacteristicWrapper characteristic,
IBuffer buffer)
{
characteristic.WithCharacteristicProperties(GattCharacteristicProperties.None)
.WithWriteValueAsyncResult(GattCommunicationStatus.AccessDenied);
var actual = await sut.TryWritableAuxiliariesValueAsync(characteristic,
buffer);
actual.Should( )
.BeFalse( );
}
public async Task TryWriteWithoutResponseAsync_ForGattCommunicationStatusIsAccessDenied_False(
RawValueWriter sut,
[Freeze] IGattCharacteristicWrapper characteristic,
IBuffer buffer,
IGattWriteResultWrapper result)
{
characteristic.WithCharacteristicProperties(GattCharacteristicProperties.WriteWithoutResponse)
.WithWriteValueWithResultAsync(result);
var actual = await sut.TryWriteWithoutResponseAsync(characteristic,
buffer);
actual.Should( )
.Be(result);
}
TryWriteWithoutResponseAsync_ForCharacteristicDoesNotWriteWithoutResponse_GattWriteResultNotSupported(
RawValueWriter sut,
[Freeze] IGattCharacteristicWrapper characteristic,
IBuffer buffer,
IGattWriteResultWrapper result)
{
characteristic.WithCharacteristicProperties(GattCharacteristicProperties.None)
.WithWriteValueWithResultAsync(result);
var actual = await sut.TryWriteWithoutResponseAsync(characteristic,
buffer);
actual.Should( )
.Be(GattWriteResultWrapper.NotSupported);
}
public async Task TryReadValueAsync_ForSupportsNotifyTrue_False(
RawValueReader sut,
[Freeze] IBufferReader reader,
IGattReadResultWrapper result,
IGattCharacteristicWrapper characteristic)
{
WithTryReadValueResult(reader,
Array.Empty <byte> ( ));
result.Status
.Returns(GattCommunicationStatus.Success);
characteristic.WithCharacteristicProperties(GattCharacteristicProperties.Notify)
.WithReadValueAsyncResult(result);
var(success, _) = await sut.TryReadValueAsync(characteristic);
success.Should( )
.BeFalse( );
}
public async Task TryReadValueAsync_ForNotSupportingRead_Empty(
RawValueReader sut,
[Freeze] IBufferReader reader,
IGattReadResultWrapper result,
IGattCharacteristicWrapper characteristic)
{
WithTryReadValueResult(reader,
Array.Empty <byte> ( ));
result.Status
.Returns(GattCommunicationStatus.Success);
characteristic.WithCharacteristicProperties(GattCharacteristicProperties.None)
.WithReadValueAsyncResult(result);
var(_, bytes) = await sut.TryReadValueAsync(characteristic);
bytes.Should( )
.BeEmpty( );
}
private async Task <(bool, byte [])> ReadValue(
[NotNull] IGattCharacteristicWrapper characteristic)
{
Guard.ArgumentNotNull(characteristic,
nameof(characteristic));
var readValue = await characteristic.ReadValueAsync( );
ProtocolError = readValue.ProtocolError;
Status = readValue.Status;
if (GattCommunicationStatus.Success != Status)
{
return(false, ArrayEmpty);
}
return(_reader.TryReadValue(readValue.Value,
out var bytes)
? (true, bytes)
: (false, ArrayEmpty));
}
public async Task TryReadValueAsync_ForGattCommunicationStatusIsSuccess_Bytes(
RawValueReader sut,
[Freeze] IBufferReader reader,
IGattReadResultWrapper result,
IGattCharacteristicWrapper characteristic,
byte [] bytes)
{
WithTryReadValueResult(reader,
bytes);
result.Status
.Returns(GattCommunicationStatus.Success);
characteristic.WithCharacteristicProperties(GattCharacteristicProperties.Read)
.WithReadValueAsyncResult(result);
var(_, value) = await sut.TryReadValueAsync(characteristic);
value.Should( )
.BeEquivalentTo(bytes);
}
public async Task <bool> TryWritableAuxiliariesValueAsync(
[NotNull] IGattCharacteristicWrapper characteristic,
[NotNull] IBuffer buffer)
{
Guard.ArgumentNotNull(characteristic,
nameof(characteristic));
Guard.ArgumentNotNull(buffer,
nameof(buffer));
if (SupportsWritableAuxiliaries(characteristic))
{
Log.Information($"GattCharacteristic '{characteristic.Uuid}' " +
"doesn't support 'Write/WritableAuxiliaries/" +
"WriteWithoutResponse'");
return(false);
}
var status = await characteristic.WriteValueAsync(buffer);
return(status == GattCommunicationStatus.Success);
}
public async Task <IGattWriteResultWrapper> TryWriteWithoutResponseAsync(
[NotNull] IGattCharacteristicWrapper characteristic,
[NotNull] IBuffer buffer)
{
Guard.ArgumentNotNull(characteristic,
nameof(characteristic));
Guard.ArgumentNotNull(buffer,
nameof(buffer));
if (SupportsWriteWithoutResponse(characteristic))
{
var message = $"GattCharacteristic '{characteristic.Uuid}' " +
"doesn't support 'Write/WritableAuxiliaries/" +
"WriteWithoutResponse'";
Log.Information(message);
return(GattWriteResultWrapper.NotSupported);
}
var status = await characteristic.WriteValueWithResultAsync(buffer);
return(status);
}
public async Task <(bool, byte [])> TryReadValueAsync(
IGattCharacteristicWrapper characteristic)
{
Guard.ArgumentNotNull(characteristic,
nameof(characteristic));
if (SupportsNotify(characteristic))
{
_logger.Warning($"GattCharacteristic '{characteristic.Uuid}' " +
"doesn't support 'Read' but supports 'Notify'");
return(false, ArrayEmpty); // need to subscribe to value change
}
if (SupportsRead(characteristic))
{
return(await ReadValue(characteristic));
}
_logger.Information($"GattCharacteristic '{characteristic.Uuid}' " +
"doesn't support 'Read'");
return(false, ArrayEmpty);
}
private static bool SupportsWritableAuxiliaries(IGattCharacteristicWrapper characteristic)
{
return((characteristic.CharacteristicProperties & GattCharacteristicProperties.WritableAuxiliaries) !=
GattCharacteristicProperties.WritableAuxiliaries);
}
private static bool SupportsWrite(IGattCharacteristicWrapper characteristic)
{
return((characteristic.CharacteristicProperties & GattCharacteristicProperties.Write) !=
GattCharacteristicProperties.Write);
}
private static bool SupportsNotify(IGattCharacteristicWrapper characteristic)
{
return((characteristic.CharacteristicProperties & GattCharacteristicProperties.Notify) ==
GattCharacteristicProperties.Notify);
}
private static bool SupportsRead(IGattCharacteristicWrapper characteristic)
{
return((characteristic.CharacteristicProperties & GattCharacteristicProperties.Read) ==
GattCharacteristicProperties.Read);
}
