public void PortInputFormatSingleEncoder_Decode(string dataAsString, byte expectedPortId, byte expectedMode, uint expectedDeltaInterval, bool expectedNotificationEnabled)
{
// arrange
var data = BytesStringUtil.StringToData(dataAsString);
// act
var message = MessageEncoder.Decode(data, null) as PortInputFormatSingleMessage;
// assert
Assert.Equal(expectedPortId, message.PortId);
Assert.Equal(expectedMode, message.ModeIndex);
Assert.Equal(expectedDeltaInterval, message.DeltaInterval);
Assert.Equal(expectedNotificationEnabled, message.NotificationEnabled);
// reverse
var reverseMessage = new PortInputFormatSingleMessage(expectedPortId, expectedMode, expectedDeltaInterval, expectedNotificationEnabled)
{
HubId = 0,
};
var reverseData = MessageEncoder.Encode(reverseMessage, null);
var reverseDataAsString = BytesStringUtil.DataToString(reverseData);
Assert.Equal(dataAsString, reverseDataAsString);
}
public void HubAttachedIOEncoder_Decode_Attached <T>(string messageAsString, DeviceType expectedType, byte expectedPortId, string expectedHwVersion, string expectedSwVersion)
{
// arrange
var data = BytesStringUtil.StringToData(messageAsString).AsSpan().Slice(3);
// act
var message = new HubAttachedIOEncoder().Decode(0x00, data) as HubAttachedIOForAttachedDeviceMessage;
// assert
Assert.Equal(expectedPortId, message.PortId);
Assert.Equal(expectedType, message.IOTypeId);
Assert.Equal(new Version(expectedHwVersion), message.HardwareRevision);
Assert.Equal(new Version(expectedSwVersion), message.SoftwareRevision);
// reverse test
var reverseMessage = new HubAttachedIOForAttachedDeviceMessage()
{
Event = HubAttachedIOEvent.AttachedIO,
IOTypeId = expectedType,
PortId = expectedPortId,
HardwareRevision = Version.Parse(expectedHwVersion),
SoftwareRevision = Version.Parse(expectedSwVersion),
};
// act
var reverseData = MessageEncoder.Encode(reverseMessage, null);
var reverseDataAsString = BytesStringUtil.DataToString(reverseData);
Assert.Equal(messageAsString, reverseDataAsString);
}
public async Task ExecuteAsync(byte portId)
{
Console.WriteLine($"Discover Port {portId}. Receiving Messages ...");
await protocol.ConnectAsync(); // registering to bluetooth notification
await Task.Delay(2000); // await ports to be announced initially by device.
using var disposable = protocol.UpstreamMessages.Subscribe(x => Console.Write("."));
await discoverPorts.ExecuteAsync(portId);
await protocol.SendMessageReceiveResultAsync <HubActionMessage>(new HubActionMessage()
{
HubId = 0, Action = HubAction.SwitchOffHub
}, result => result.Action == HubAction.HubWillSwitchOff);
Console.WriteLine(string.Empty);
Console.WriteLine($"Discover Ports Function: {discoverPorts.ReceivedMessages} / {discoverPorts.SentMessages}");
Console.WriteLine("##################################################");
foreach (var data in discoverPorts.ReceivedMessagesData.OrderBy(x => x[2]).ThenBy(x => x[4]).ThenBy(x => (x.Length <= 5) ? -1 : x[5]))
{
Console.WriteLine(BytesStringUtil.DataToString(data));
}
Console.WriteLine("##################################################");
}
private void PortOutputCommandEncoder_Encode(string expectedDataAsString, PoweredUpMessage message)
{
// act
var data = MessageEncoder.Encode(message, null);
// assert
Assert.Equal(expectedDataAsString, BytesStringUtil.DataToString(data));
}
public void HubPropertiesEncoder_Encode_Downstream(HubProperty property, HubPropertyOperation operation, string expectedData)
{
// act
var data = MessageEncoder.Encode(new HubPropertyMessage(property, operation), null);
// assert
Assert.Equal(expectedData, BytesStringUtil.DataToString(data));
}
public void PortInformationRequestEncoder_Encode(byte portId, PortInformationType informationType, string expectedData)
{
// arrange
var message = new PortInformationRequestMessage(portId, informationType);
// act
var data = MessageEncoder.Encode(message, null);
// assert
Assert.Equal(expectedData, BytesStringUtil.DataToString(data));
}
public void HubAlertEncoder_Encode(HubAlert alert, HubAlertOperation operation, byte payload, string expectedData)
{
// arrange
var message = new HubAlertMessage(alert, operation, payload);
// act
var data = MessageEncoder.Encode(message, null);
// assert
Assert.Equal(expectedData, BytesStringUtil.DataToString(data));
}
public async Task SendBytesAsync(byte[] data)
{
if (_characteristic == null)
{
throw new InvalidOperationException($"Cannot invoke {nameof(SendBytesAsync)} when device is not connected ({nameof(_characteristic)} is null)");
}
_logger?.LogDebug($"> {BytesStringUtil.DataToString(data)}");
await _characteristic.WriteValueAsync(data);
}
public void PortInputFormatSetupCombinedModeEncoder_Encode_SimpleCommands(string expectedDataAsString, byte portId, PortInputFormatSetupCombinedSubCommand subCommand)
{
// arrange
var message = new PortInputFormatSetupCombinedModeMessage(portId, subCommand);
// act
var data = MessageEncoder.Encode(message, null);
// assert
Assert.Equal(expectedDataAsString, BytesStringUtil.DataToString(data));
}
public void HubActionsEncoder_Encode(HubAction action, string expectedData)
{
// arrange
var message = new HubActionMessage(action);
// act
var data = MessageEncoder.Encode(message, null);
// assert
Assert.Equal(expectedData, BytesStringUtil.DataToString(data));
}
public void PortModeInformationRequestEncoder_Encode_Disconnected(byte port, string expectedData)
{
// arrange
var message = new VirtualPortSetupForDisconnectedMessage(port);
// act
var data = MessageEncoder.Encode(message, null);
// assert
Assert.Equal(expectedData, BytesStringUtil.DataToString(data));
}
public void PortInputFormatSetupSingleEncoder_Encode(string expectedDataAsString, byte portId, byte mode, uint deltaInterval, bool notificationEnabled)
{
// arrange
var message = new PortInputFormatSetupSingleMessage(portId, mode, deltaInterval, notificationEnabled);
// act
var data = MessageEncoder.Encode(message, null);
// assert
Assert.Equal(expectedDataAsString, BytesStringUtil.DataToString(data));
}
public async Task ReceiveBytesAsync(Func <byte[], Task> handler)
{
if (_characteristic == null)
{
throw new InvalidOperationException($"Cannot invoke {nameof(SendBytesAsync)} when device is not connected ({nameof(_characteristic)} is null)");
}
await _characteristic.NotifyValueChangeAsync(async data =>
{
_logger?.LogDebug($"< {BytesStringUtil.DataToString(data)}");
await handler(data);
});
_logger?.LogDebug("Registered Receive Handler");
}
public void PortInputFormatSetupCombinedModeEncoder_Encode_ModeDataSetCommands(string expectedDataAsString, byte portId, byte[] modeDataSets)
{
// arrange
var message = new PortInputFormatSetupCombinedModeForSetModeDataSetMessage(portId, 0,
modeDataSets.Select(b => new PortInputFormatSetupCombinedModeModeDataSet(
Mode: (byte)((b & 0xF0) >> 4),
DataSet: (byte)(b & 0x0F)
)).ToArray()
);
// act
var data = MessageEncoder.Encode(message, null);
// assert
Assert.Equal(expectedDataAsString, BytesStringUtil.DataToString(data));
}
public async Task ExecuteAsync(SystemType knownSystemType, byte portId, bool headerEnabled)
{
Console.WriteLine($"Discover Port {portId}. Receiving Messages ...");
await protocol.ConnectAsync(knownSystemType); // registering to bluetooth notification
await Task.Delay(2000); // await ports to be announced initially by device.
using var disposable = protocol.UpstreamMessages.Subscribe(x => Console.Write("."));
await discoverPorts.ExecuteAsync(portId);
await protocol.SendMessageReceiveResultAsync <HubActionMessage>(new HubActionMessage(HubAction.SwitchOffHub) { HubId = 0 }, result => result.Action == HubAction.HubWillSwitchOff);
Console.WriteLine(string.Empty);
Console.WriteLine($"Discover Ports Function: {discoverPorts.ReceivedMessages} / {discoverPorts.SentMessages}");
Console.WriteLine(knownSystemType);
Console.WriteLine("##################################################");
//Exception was thrown if no device was attached to the port
if (discoverPorts.ReceivedMessages > 0)
{
var systemTypeMessage = CreateSystemTypeHeader(knownSystemType);
var attachedIOMessage = CreateAttachedIOHeader(portId);
if (headerEnabled)
{
Console.WriteLine(BytesStringUtil.DataToString(systemTypeMessage));
Console.WriteLine(BytesStringUtil.DataToString(attachedIOMessage));
}
foreach (var data in discoverPorts.ReceivedMessagesData.OrderBy(x => x[2]).ThenBy(x => x[4]).ThenBy(x => (x.Length <= 5) ? -1 : x[5]))
{
Console.WriteLine(BytesStringUtil.DataToString(data));
}
}
else
{
Console.WriteLine($":-( It seems there is no device attached to port {portId} on this hub...");
}
Console.WriteLine("##################################################");
}
public override string ToString()
=> $"Unknown Message Type: {(MessageType)this.MessageType} Length: {this.Length} Content: {BytesStringUtil.DataToString(this.Data)}";