public int Read(NetworkStream stream, int offset, int size)
{
ValidateAndThrow(stream);
if (offset < 0)
{
throw new ArgumentOutOfRangeException(nameof(offset), offset, $"{nameof(offset)} must be greater than or equal to zero.");
}
if (size < 0)
{
throw new ArgumentOutOfRangeException(nameof(size), size, $"{nameof(size)} must be greater than or equal to zero.");
}
if (offset + size > m_Buffer.Length)
{
throw new InvalidOperationException($"Reading {size} bytes starting at offset {offset} would read past the end of the buffer (buffer length = {m_Buffer.Length}).");
}
int bytesRemaining = size;
while (bytesRemaining > 0)
{
int bytesRead = stream.Read(m_Buffer, offset, bytesRemaining);
CollaborationNetworkingIndicator.NotifyIncomingDataReceived();
offset += bytesRead;
bytesRemaining -= bytesRead;
}
return(size);
}
void CheckForLocalCollaborationData(ARKitSessionSubsystem subsystem)
{
// Check for new data and queue it
if (subsystem.collaborationDataCount > 0)
{
CollaborationNetworkingIndicator.NotifyHasCollaborationData();
lock (m_CollaborationDataSendQueue)
{
while (subsystem.collaborationDataCount > 0)
{
m_CollaborationDataSendQueue.Enqueue(subsystem.DequeueCollaborationData());
}
}
}
}
void Update()
{
var subsystem = GetSubsystem();
if (subsystem == null)
{
return;
}
// Check for new collaboration data
while (subsystem.collaborationDataCount > 0)
{
using (var collaborationData = subsystem.DequeueCollaborationData())
{
CollaborationNetworkingIndicator.NotifyHasCollaborationData();
if (m_MCSession.ConnectedPeerCount == 0)
{
continue;
}
using (var serializedData = collaborationData.ToSerialized())
using (var data = NSData.CreateWithBytesNoCopy(serializedData.bytes))
{
m_MCSession.SendToAllPeers(data, collaborationData.priority == ARCollaborationDataPriority.Critical
? MCSessionSendDataMode.Reliable
: MCSessionSendDataMode.Unreliable);
CollaborationNetworkingIndicator.NotifyOutgoingDataSent();
}
}
}
// Check for incoming data
while (m_MCSession.ReceivedDataQueueSize > 0)
{
CollaborationNetworkingIndicator.NotifyIncomingDataReceived();
using (var data = m_MCSession.DequeueReceivedData())
using (var collaborationData = new ARCollaborationData(data.Bytes))
{
if (collaborationData.valid)
{
subsystem.UpdateWithCollaborationData(collaborationData);
}
}
}
}
public void Send(NetworkStream stream, int offset, int size)
{
ValidateAndThrow(stream);
if (offset + size > m_Buffer.Length)
{
throw new InvalidOperationException($"Writing {size} bytes starting at offset {offset} would write past the end of the buffer (buffer length = {m_Buffer.Length}).");
}
try
{
stream.Write(m_Buffer, offset, size);
CollaborationNetworkingIndicator.NotifyOutgoingDataSent();
}
catch (SocketException socketException)
{
Logger.Log($"Socket exception: {socketException}");
}
}
/// <summary>
/// Send message to other device using socket connection.
/// </summary>
static void SendData(NetworkStream stream, NativeArray <byte> bytes)
{
try
{
var byteArray = bytes.ToArray();
int length = IPAddress.HostToNetworkOrder(byteArray.Length);
var lengthBytes = BitConverter.GetBytes(length);
stream.Write(lengthBytes, 0, lengthBytes.Length);
stream.Write(byteArray, 0, byteArray.Length);
CollaborationNetworkingIndicator.NotifyOutgoingDataSent();
if (byteArray.Length > 1024)
{
Logger.Log($"Sent {byteArray.Length} bytes to remote.");
}
}
catch (SocketException socketException)
{
Logger.Log("Socket exception: " + socketException);
}
}
unsafe void ProcessRemoteCollaborationData(ARKitSessionSubsystem subsystem)
{
// Check for remote data and apply it
lock (m_CollaborationDataReadQueue)
{
while (m_CollaborationDataReadQueue.Count > 0)
{
using (var collaborationData = m_CollaborationDataReadQueue.Dequeue())
{
// Only notify user concerning large data sizes
if (collaborationData.bytes.Length > 1024)
{
Logger.Log($"Received {collaborationData.bytes.Length} bytes from remote host. Updating session.");
}
CollaborationNetworkingIndicator.NotifyIncomingDataReceived();
// Assume we only put in valid collaboration data into the queue.
subsystem.UpdateWithCollaborationData(collaborationData);
}
}
}
}
void CheckForLocalCollaborationData(ARKitSessionSubsystem subsystem)
{
// Exit if no new data is available
if (subsystem.collaborationDataCount == 0)
{
return;
}
lock (m_CollaborationDataSendQueue)
{
// Enqueue all new collaboration data with critical priority
while (subsystem.collaborationDataCount > 0)
{
var collaborationData = subsystem.DequeueCollaborationData();
// As all data in this sample is sent over TCP, only send critical data
if (collaborationData.priority == ARCollaborationDataPriority.Critical)
{
m_CollaborationDataSendQueue.Enqueue(collaborationData);
CollaborationNetworkingIndicator.NotifyHasCollaborationData();
}
}
}
}
void Update()
{
var subsystem = GetSubsystem();
if (subsystem == null)
{
return;
}
// Check for new collaboration data
while (subsystem.collaborationDataCount > 0)
{
using (var collaborationData = subsystem.DequeueCollaborationData())
{
CollaborationNetworkingIndicator.NotifyHasCollaborationData();
if (m_MCSession.ConnectedPeerCount == 0)
{
continue;
}
using (var serializedData = collaborationData.ToSerialized())
using (var data = NSData.CreateWithBytesNoCopy(serializedData.bytes))
{
m_MCSession.SendToAllPeers(data, collaborationData.priority == ARCollaborationDataPriority.Critical
? MCSessionSendDataMode.Reliable
: MCSessionSendDataMode.Unreliable);
CollaborationNetworkingIndicator.NotifyOutgoingDataSent();
// Only log 'critical' data as 'optional' data tends to come every frame
if (collaborationData.priority == ARCollaborationDataPriority.Critical)
{
Logger.Log($"Sent {data.Length} bytes of collaboration data.");
}
}
}
}
// Check for incoming data
while (m_MCSession.ReceivedDataQueueSize > 0)
{
CollaborationNetworkingIndicator.NotifyIncomingDataReceived();
using (var data = m_MCSession.DequeueReceivedData())
using (var collaborationData = new ARCollaborationData(data.Bytes))
{
if (collaborationData.valid)
{
subsystem.UpdateWithCollaborationData(collaborationData);
if (collaborationData.priority == ARCollaborationDataPriority.Critical)
{
Logger.Log($"Received {data.Bytes.Length} bytes of collaboration data.");
}
}
else
{
Logger.Log($"Received {data.Bytes.Length} bytes from remote, but the collaboration data was not valid.");
}
}
}
}
