public void TestSerializeString()
{
var buffer = ArrayPool <byte> .Shared.Rent(16);
var count = _networkSerializer.Serialize(typeof(string), ref buffer, 4, "Hello World",
ArrayPool <byte> .Shared);
Assert.Equal(new ArraySegment <byte>(new byte[4]), new ArraySegment <byte>(buffer, 0, 4));
Assert.Equal(14, count);
var result = _networkSerializer.Deserialize(typeof(string), buffer, 4);
Assert.Equal("Hello World", (string)result);
}
public MainPage(ScannerConnection connection, bool offlineMode)
{
this.connection = connection;
this.serializer = new ProtobufNetworkSerializer();
NavigationPage.SetHasNavigationBar(this, false);
var grid = new Grid();
grid.ColumnDefinitions.Add(new ColumnDefinition {
Width = new GridLength(1, GridUnitType.Star)
});
grid.ColumnDefinitions.Add(new ColumnDefinition {
Width = new GridLength(4, GridUnitType.Star)
});
bulbsStack = new StackLayout();
grid.Children.Add(bulbsStack);
urhoSurface = new UrhoSurface
{
BackgroundColor = Color.Black,
VerticalOptions = LayoutOptions.FillAndExpand
};
var stack = new StackLayout
{
VerticalOptions = LayoutOptions.FillAndExpand,
Children = { urhoSurface }
};
grid.Children.Add(stack);
Grid.SetColumn(stack, 1);
Content = grid;
if (!offlineMode)
{
space = new SpaceDto();
connection.RegisterFor <SurfaceDto>(OnSurfaceReceived);
connection.RegisterFor <BulbAddedDto>(OnBulbAdded);
connection.RegisterFor <CurrentPositionDto>(OnCurrentPositionUpdated);
Start();
}
else
{
space = serializer.Deserialize <SpaceDto>(
(byte[])Application.Current.Properties[nameof(SpaceDto)]);
}
}
public MainPage(ScannerConnection connection, bool offlineMode)
{
this.connection = connection;
this.serializer = new ProtobufNetworkSerializer();
NavigationPage.SetHasNavigationBar(this, false);
var grid = new Grid();
grid.ColumnDefinitions.Add(new ColumnDefinition {Width = new GridLength(1, GridUnitType.Star)});
grid.ColumnDefinitions.Add(new ColumnDefinition {Width = new GridLength(4, GridUnitType.Star)});
bulbsStack = new StackLayout();
grid.Children.Add(bulbsStack);
urhoSurface = new UrhoSurface
{
BackgroundColor = Color.Black,
VerticalOptions = LayoutOptions.FillAndExpand
};
var stack = new StackLayout
{
VerticalOptions = LayoutOptions.FillAndExpand,
Children = {urhoSurface}
};
grid.Children.Add(stack);
Grid.SetColumn(stack, 1);
Content = grid;
if (!offlineMode)
{
space = new SpaceDto();
connection.RegisterFor<SurfaceDto>(OnSurfaceReceived);
connection.RegisterFor<BulbAddedDto>(OnBulbAdded);
connection.RegisterFor<CurrentPositionDto>(OnCurrentPositionUpdated);
Start();
}
else
{
space = serializer.Deserialize<SpaceDto>(
(byte[])Application.Current.Properties[nameof(SpaceDto)]);
}
}
public async Task WaitForCompanion()
{
Serializer = new ProtobufNetworkSerializer();
var tcs = new TaskCompletionSource <bool>();
listener = new UdpSocketReceiver();
listener.MessageReceived += (s, e) =>
{
remoteAddress = e.RemoteAddress;
remotePort = e.RemotePort;
var dto = Serializer.Deserialize <BaseDto>(e.ByteData);
var handshakeDto = dto as PingDto;
if (handshakeDto != null)
{
var msg = handshakeDto.Message;
}
tcs.TrySetResult(true);
};
await listener.StartListeningAsync(Port);
await tcs.Task;
}
private async Task <BufferSegment> ExecuteMethod(byte[] data, int offset)
{
//PROTOCOL
//CALL:
//HEAD - integer - callback identifier
//HEAD - uinteger - The method identifier
//HEAD - integer * parameters - the length of each parameter
//--------------------------------------------------------------------------
//DATA - length of the parameters - serialized parameters
//
//RETURN:
//HEAD - 1 byte - the response type (0 = executed, 1 = result returned, 2 = exception, 3 = not implemented)
//HEAD - integer - callback identifier
//(BODY - return object length - the serialized return object)
var methodId = BitConverter.ToUInt32(data, offset + 4);
var callbackId = BitConverter.ToInt32(data, offset);
const int responseHeaderLength = 4;
void WriteResponseHeader(byte[] buffer)
{
//Buffer.BlockCopy(data, offset, buffer, CustomOffset + 1, 4);
BinaryUtils.WriteInt32(buffer, CustomOffset + 1, callbackId);
}
if (!Cache.MethodInvokers.TryGetValue(methodId, out var methodInvoker))
{
var responseLength = responseHeaderLength + 1 /* response type */;
var response = Cache.Pool.Rent(responseLength + CustomOffset);
WriteResponseHeader(response);
response[CustomOffset + responseLength] = (byte)NetworkCallResponse.MethodNotImplemented;
return(new BufferSegment(response, CustomOffset, responseLength, Cache.Pool));
}
var parameters = new object[methodInvoker.ParameterCount];
var parameterOffset = offset + 8 + parameters.Length * 4;
for (var i = 0; i < methodInvoker.ParameterCount; i++)
{
var type = methodInvoker.ParameterTypes[i];
var parameterLength = BitConverter.ToInt32(data, offset + 8 + i * 4);
parameters[i] = _serializer.Deserialize(type, data, parameterOffset);
parameterOffset += parameterLength;
}
Task task;
try
{
task = methodInvoker.Invoke(_implementation, parameters);
await task.ConfigureAwait(false);
}
catch (Exception e)
{
var responseLength = responseHeaderLength + 1 /* response type */ + EstimatedResultBufferSize /* exception */;
var takenBuffer = Cache.Pool.Rent(responseLength + CustomOffset);
var response = takenBuffer;
var length = _serializer.SerializeException(ref response, CustomOffset + responseHeaderLength + 1, e, Cache.Pool);
WriteResponseHeader(response);
response[CustomOffset] = (byte)NetworkCallResponse.Exception;
if (takenBuffer == response)
{
return(new BufferSegment(response, CustomOffset, length + responseHeaderLength + 1, Cache.Pool));
}
Cache.Pool.Return(takenBuffer);
return(new BufferSegment(response, CustomOffset, length + responseHeaderLength + 1, Cache.Pool));
}
if (methodInvoker.ReturnsResult)
{
var result = methodInvoker.TaskReturnPropertyInfo.GetValue(task);
var takenBuffer = Cache.Pool.Rent(CustomOffset + EstimatedResultBufferSize);
var response = takenBuffer;
WriteResponseHeader(response);
response[CustomOffset] = (byte)NetworkCallResponse.ResultReturned;
var responseLength = _serializer.Serialize(methodInvoker.ReturnType, ref response,
responseHeaderLength + 1 + CustomOffset, result, Cache.Pool);
if (takenBuffer == response)
{
return(new BufferSegment(response, CustomOffset, responseLength + responseHeaderLength + 1,
Cache.Pool));
}
Cache.Pool.Return(takenBuffer);
return(new BufferSegment(response, CustomOffset, responseLength + responseHeaderLength + 1, Cache.Pool));
}
else
{
var responseLength = responseHeaderLength + 1 /* response type */;
var response = Cache.Pool.Rent(responseLength + CustomOffset);
WriteResponseHeader(response);
response[CustomOffset] = (byte)NetworkCallResponse.MethodExecuted;
return(new BufferSegment(response, CustomOffset, responseLength, Cache.Pool));
}
}
/// <summary>
/// Receive data from a <see cref="EventRegister" />
/// </summary>
/// <param name="data">An array of bytes</param>
/// <param name="offset">The starting position within the buffer</param>
public override void ReceiveData(byte[] data, int offset)
{
var responseType = (EventResponseType)data[offset];
switch (responseType)
{
case EventResponseType.TriggerEvent:
case EventResponseType.TriggerEventWithParameter:
case EventResponseType.TriggerEventWithTransmissionInfo:
case EventResponseType.TriggerEventWithTransmissionInfoAndParameter:
var eventId = BitConverter.ToUInt64(data, offset + 1);
List <IEventTrigger> triggers;
if (!_subscribedEvents.TryGetValue(eventId, out var subscribedEvent))
{
return;
}
lock (subscribedEvent.TriggersLock)
{
triggers = subscribedEvent.Triggers.ToList(); //copy list
}
object parameter;
object transmissionInfo;
if (responseType == EventResponseType.TriggerEvent)
{
transmissionInfo = null;
parameter = null;
}
else
{
var transmissionInfoLength = BitConverter.ToUInt16(data, offset + 9);
if (transmissionInfoLength > 0)
{
transmissionInfo = _serializer.Deserialize(subscribedEvent.EventHandlerTransmissionInfoType,
data, offset + 11);
}
else
{
transmissionInfo = null;
}
if (responseType == EventResponseType.TriggerEventWithParameter || responseType ==
EventResponseType.TriggerEventWithTransmissionInfoAndParameter)
{
parameter = _serializer.Deserialize(subscribedEvent.EventHandlerParameterType, data,
offset + 11 + transmissionInfoLength);
}
else
{
parameter = null;
}
}
foreach (var eventTrigger in triggers)
{
eventTrigger.TriggerEvent(subscribedEvent.EventInfo, transmissionInfo, parameter);
}
break;
default:
throw new ArgumentOutOfRangeException();
}
}
