private void CompleteRead(IAsyncResult ar)
{
var size = m_socket.EndReceive(ar);
if (size > 0 &&
ar.AsyncState is byte[] data)
{
Scheduler.Schedule(() =>
{
var start = 0;
OscPacket packet = null;
try
{
packet = OscPacket.FromByteArray(data, ref start, size);
}
catch (Exception e)
{
if (!SuppressParsingExceptions)
{
throw new Exception("Error deserialising packet", e);
}
packet = null;
}
if (packet != null)
{
ForwardPacket(packet);
}
});
}
}
// Update is called once per frame
void Update()
{
if (dataReceived)
{
dataReceived = false;
FrameParser(OscPacket.FromByteArray(receivedEndPoint, bytePacket));
}
}
void Update()
{
if (dataReceived)
{
dataReceived = false;
FrameParser(OscPacket.FromByteArray(receivingEndPoint, bytePacket));
}
// when you're done appending messages, call SendBundle to send all the messages together in a bundle
SendBundle();
}
// Update is called once per frame
public void Report(ref List <RigidBodyGeneric> rbs, ref List <Vector3> unidentifiedMarkerPositions)
{
if (!connected && frameCounter + 60 < Time.frameCount)
{
SendCommand("Connect " + localPort);
frameCounter = Time.frameCount;
}
if (dataReceived)
{
dataReceived = false;
ParsePacket(OscPacket.FromByteArray(receivedEndPoint, bytePacket), ref rbs, ref unidentifiedMarkerPositions);
}
}
public void TestArrayDeserialisation()
{
var msg = OscPacket.FromByteArray(CreateExpectedDataArray());
const string typeTag = ",[ifs]";
msg.Should().BeOfType <OscMessage>()
.Which
.TypeTag.Should().Be(typeTag);
var actual = msg.Data[0] as object[]; // the heterogeneous array.
AssertCorrectArray(actual);
}
private void DeSerializerAndDeliver(byte[] data, IObserver <OscPacket> responseStream)
{
OscPacket response;
try
{
response = OscPacket.FromByteArray(data);
}
catch (Exception)
{
response = null;
}
if (response != null)
{
responseStream.OnNext(response);
}
}
private void DeSerializerAndDeliver(byte[] data)
{
OscPacket response;
try
{
response = OscPacket.FromByteArray(data);
}
catch (Exception e)
{
response = null;
}
if (response != null)
{
ForwardPacket(response);
}
}
private static void DeserialiseAndDeliver(byte[] data, OscInboundTcpStream stream)
{
OscPacket packet;
try
{
packet = OscPacket.FromByteArray(data);
}
catch (Exception e)
{
packet = null;
}
if (packet != null)
{
stream.ForwardPacket(packet);
}
}
public void TestArrayDeserialisation4()
{
var msg = OscPacket.FromByteArray(CreateExpectedDataArray4());
const string typeTag = ",[ifs]b";
msg.Should().BeOfType <OscMessage>()
.Which
.TypeTag.Should().Be(typeTag);
var actual = msg.Data[0] as object[]; // the heterogeneous array.
AssertCorrectArray(actual);
var expectedBlob = CreateTestBlob();
var actualBlob = (byte[])msg.Data[1];
actualBlob.Should().BeEquivalentTo(expectedBlob);
}
private void parseData(IPEndPoint sourceEndPoint, byte[] data)
{
try
{
OscPacket packet = OscPacket.FromByteArray(data);
onPacketReceived(packet);
if (packet.IsBundle)
{
onBundleReceived(packet as OscBundle);
}
else
{
onMessageReceived(packet as OscMessage);
}
} catch (Exception ex)
{
if (!ConsumeParsingExceptions)
{
onError(ex);
}
}
}
