aswi2021virtual-surreality-gitlab/deltarobot-vr/Assets/DeltaRobotVr/Client.cs @ a5c3168d

using System;
using System.Net.Sockets;
using System.Threading;
using System.IO;
using System.Linq;
using System.Text;
using UnityEngine;

namespace DeltaRobotVr
{
    
    /// <summary>
    /// Singleton class responsible for communication with the Deltarobot server.
    /// </summary>
    public sealed class Client
    {
        // singleton instance
        public static readonly Client Instance = new Client();

        // default server
        private const string DefaultHost = "127.0.0.1";
        private const int DefaultPort = 4242;

        // protocol constants
        private const UInt16 ProtocolMagicId = 0x3001;
        private const UInt16 ProtocolVersionId = 0x2002;
        private const UInt16 PingId = 0x3004;
        private const UInt16 PongId = 0x3005;
        private const UInt16 EotId = 0xF006;
        private const UInt16 CurrentActuatorPositionId = 0x4003;
        private const UInt16 CurrentDirectionVectorId = 0x4007;
        private const UInt16 DesiredDirectionVectorId = 0x4008;
        private const UInt16 CurveId = 0xF009;

        private const UInt16 Size8 = 0x0000;
        private const UInt16 Size16 = 0x1000;
        private const UInt16 Size32 = 0x2000;
        private const UInt16 Size64 = 0x3000;
        private const UInt16 Size128 = 0x4000;
        private const UInt16 SizeVariable = 0xF000;
        
        private static readonly byte[] ProtocolMagicValue = Encoding.ASCII.GetBytes("DeltaRVr");
        private const UInt32 ProtocolVersionValue = 1;

        private const UInt32 PointLength = 12;

        private const int ReconnectPollMillis = 200;
        private const int ReconnectTimeMillis = 3000;
        private const int ConnectTimeoutMillis = 3000;
        
        private Thread _thread;
        
        private readonly object _isRunningLock = new object();
        private bool _isRunning;

        private readonly object _actuatorPositionLock = new object();
        private Single3 _actuatorPosition;

        private readonly object _currentDirectionVectorLock = new object();
        private Single3 _currentDirectionVector;

        private readonly object _desiredDirectionVectorLock = new object();
        private Single3 _desiredDirectionVector;

        private readonly object _curveLock = new object();
        private Single3[] _curve;
        private long _curveCounter = 0;

        private volatile bool _isConnected;
        private volatile string _eotReason = string.Empty;

        private readonly object _reconnectTimeLock = new object();
        private DateTime _reconnectTime = DateTime.Now;

        static Client()
        {
        }

        private Client()
        {
        }

        /// <summary>
        /// Starts the client thread and connects to the server.
        /// </summary>
        public void Start()
        {
            IsRunning = true;
            _thread = new Thread(ThreadProcedure);
            _thread.Start();
        }

        /// <summary>
        /// Gracefully stops the client thread. Blocks until the thread actually stops.
        /// </summary>
        public void Stop()
        {
            IsRunning = false;
            if (_thread != null)
            {
                _thread.Join();
                _thread = null;
            }
        }

        /// <summary>
        /// Contains a reason received in an end-of-transmission message.
        /// </summary>
        public string EotReason
        {
            get => _eotReason;
            private set => _eotReason = value;
        }

        /// <summary>
        /// Whether the client is currently maintaining an active connection to the server.
        /// </summary>
        public bool IsConnected
        {
            get => _isConnected;
            private set => _isConnected = value;
        }

        /// <summary>
        /// Current position of the actuator (in server's world space).
        /// </summary>
        public Single3 ActuatorPosition
        {
            get
            {
                lock (_actuatorPositionLock)
                {
                    return _actuatorPosition;
                }
            }
            private set
            {
                lock (_actuatorPositionLock)
                {
                    _actuatorPosition = value;
                }
            } 
        }

        /// <summary>
        /// The actual direction the actuator is currently moving in.
        /// </summary>
        public Single3 ActualDirectionVector
        {
            get
            {
                lock (_currentDirectionVectorLock)
                {
                    return _currentDirectionVector;
                }
            }
            private set
            {
                lock (_currentDirectionVectorLock)
                {
                    _currentDirectionVector = value;
                }
            }
        }

        /// <summary>
        /// The target direction the actuator should be moving in so that it draws the curve.
        /// </summary>
        public Single3 TargetDirectionVector
        {
            get
            {
                lock (_desiredDirectionVectorLock)
                {
                    return _desiredDirectionVector;
                }
            }
            private set
            {
                lock (_desiredDirectionVectorLock)
                {
                    _desiredDirectionVector = value;
                }
            }
        }

        /// <summary>
        /// The current exercise curve.
        /// </summary>
        public Single3[] Curve
        {
            get
            {
                lock (_curveLock)
                {
                    return _curve;
                }
            }
            private set
            {
                lock (_curveLock)
                {
                    _curve = value;
                }
            }
        }

        /// <summary>
        /// A counter used to determine whether the curve has changed. The curve remains the same while the counter is
        /// the same.
        /// </summary>
        public long CurveCounter
        {
            get
            {
                lock (_curveLock)
                {
                    return _curveCounter;
                }
            }
            private set
            {
                lock (_curveLock)
                {
                    _curveCounter = value;
                }
            }
        }

        /// <summary>
        /// Whether the client thread should keep on reading data from the server.
        /// </summary>
        public bool IsRunning
        {
            get {
                lock (_isRunningLock)
                {
                    return _isRunning;
                }
            }
            private set
            {
                lock (_isRunningLock)
                {
                    _isRunning = value;
                }
            }
        }

        /// <summary>
        /// The time at which the client will attempt to reconnect to the server again.
        /// </summary>
        public DateTime ReconnectTime
        {
            get
            {
                lock (_reconnectTimeLock)
                {
                    return _reconnectTime;
                }
            }
            private set
            {
                lock (_reconnectTimeLock)
                {
                    _reconnectTime = value;
                }
            }
        }

        /// <summary>
        /// The client thread function.
        /// </summary>
        private void ThreadProcedure()
        {
            while (IsRunning)
            {
                try
                {
                    var host = ConfigurationProvider.Instance.Host;
                    var port = ConfigurationProvider.Instance.Port;

                    if (port < 0 || host.Length == 0)
                    {
                        // Obviously invalid values
                        host = DefaultHost;
                        port = DefaultPort;
                    }

                    using var client = new TcpClient();
                    var asyncConnect = client.BeginConnect(host, port, null, null);

                    var connected = asyncConnect.AsyncWaitHandle.WaitOne(TimeSpan.FromMilliseconds(ConnectTimeoutMillis));
                    if (!connected)
                    {
                        Debug.LogWarning("Connection not established - timed out");
                        continue;
                    }
                    
                    using var stream = client.GetStream();
                    BinaryReader reader = new BinaryReader(stream);
                    BinaryWriter writer = new BinaryWriter(stream);
                    IsConnected = true;

                    SendProtocolPreamble(writer);

                    // main message reception loop
                    while (IsRunning && IsConnected)
                    {
                        ReadMessages(reader, writer);
                    }

                    if (client.Connected)
                    {
                        SendEot(writer, "Client stopped by user");
                    }
                }
                catch (Exception e)
                {
                    if (e is SocketException || e is IOException)
                    {
                        Debug.LogWarning($"Connection error:\n{e}");
                    }
                    else
                    {
                        Debug.LogError($"Exception in communication thread:\n{e}");
                    }
                }
                finally
                {
                    IsConnected = false;
                }
                
                // wait before reconnection - short polls to prevent blocking if application is closed
                ReconnectTime = DateTime.Now.AddMilliseconds(ReconnectTimeMillis);
                while (IsRunning && DateTime.Now < ReconnectTime)
                {
                    Thread.Sleep(ReconnectPollMillis);
                }
            }
        }


        private void ReadMessages(BinaryReader reader, BinaryWriter writer)
        {
            var messageIdentifier = reader.ReadUInt16();
            switch (messageIdentifier)
            {
                case ProtocolMagicId:
                    ProcessProtocolMagic(reader);
                    break;
                case ProtocolVersionId:
                    ProcessProtocolVersion(reader);
                    break;
                case PingId:
                    ProcessPing(reader, writer);
                    break;
                case EotId:
                    ProcessEot(reader);
                    break;
                case CurrentActuatorPositionId:
                    ProcessActuatorPosition(reader);
                    break;
                case CurrentDirectionVectorId:
                    ProcessActualDirectionVector(reader);
                    break;
                case DesiredDirectionVectorId:
                    ProcessTargetDirectionVector(reader);
                    break;
                case CurveId:
                    ProcessCurve(reader);
                    break;
                default: // unknown message
                    var sizeIdentifier = (UInt16) (messageIdentifier & 0xF000);
                    switch (sizeIdentifier)
                    {
                        case Size8:
                            Skip8(reader);
                            break;
                        case Size16:
                            Skip16(reader);
                            break;
                        case Size32:
                            Skip32(reader);
                            break;
                        case Size64:
                            Skip64(reader);
                            break;
                        case Size128:
                            Skip128(reader);
                            break;
                        case SizeVariable:
                            SkipVariableLength(reader);
                            break;
                    }

                    break;
            }
        }

        private void SendProtocolPreamble(BinaryWriter writer)
        {
            writer.Write(ProtocolMagicId);
            writer.Write(ProtocolMagicValue);
            writer.Write(ProtocolVersionId);
            writer.Write(ProtocolVersionValue);
        }

        private void Skip8(BinaryReader reader)
        {
            reader.ReadByte();
        }

        private void Skip16(BinaryReader reader)
        {
            reader.ReadUInt16();
        }

        private void Skip32(BinaryReader reader)
        {
            reader.ReadUInt32();
        }

        private void Skip64(BinaryReader reader)
        {
            reader.ReadUInt64();
        }

        private void Skip128(BinaryReader reader)
        {
            reader.ReadUInt64();
            reader.ReadUInt64();
        }

        private void SkipVariableLength(BinaryReader reader)
        {
            UInt32 numberOfBytes = reader.ReadUInt32();
            reader.ReadBytes((int) numberOfBytes);
        }

        private void ProcessActuatorPosition(BinaryReader reader)
        {
            var x = reader.ReadSingle();
            var y = reader.ReadSingle();
            var z = reader.ReadSingle();
            reader.ReadSingle(); // skip unused

            ActuatorPosition = new Single3(x, y, z);
        }

        private void ProcessActualDirectionVector(BinaryReader reader)
        {
            var x = reader.ReadSingle();
            var y = reader.ReadSingle();
            var z = reader.ReadSingle();
            reader.ReadSingle(); // skip unused

            ActualDirectionVector = new Single3(x, y, z);
        }

        private void ProcessTargetDirectionVector(BinaryReader reader)
        {
            var x = reader.ReadSingle();
            var y = reader.ReadSingle();
            var z = reader.ReadSingle();
            reader.ReadSingle(); // skip unused

            TargetDirectionVector = new Single3(x, y, z);
        }

        private void ProcessCurve(BinaryReader reader)
        {
            UInt32 numberOfBytes = reader.ReadUInt32();
            UInt32 numberOfPoints = numberOfBytes / PointLength;
            Single3[] curve = new Single3[numberOfPoints];

            for(int i = 0; i < numberOfPoints; i++)
            {
                var x = reader.ReadSingle();
                var y = reader.ReadSingle();
                var z = reader.ReadSingle();
                curve[i] = new Single3(x, y, z);
            }

            lock(_curveLock)
            {
                CurveCounter++;
                Curve = curve;
            }
        }

        private void ProcessEot(BinaryReader reader)
        {
            UInt32 numberOfBytes = reader.ReadUInt32();
            Byte[] buffer = reader.ReadBytes((int) numberOfBytes);
            EotReason = Encoding.ASCII.GetString(buffer);
            IsConnected = false;
        }

        private void ProcessProtocolMagic(BinaryReader reader)
        {
            byte[] value = reader.ReadBytes(8);
            if (!value.SequenceEqual(ProtocolMagicValue))
            {
                IsConnected = false;
            }
        }

        private void ProcessProtocolVersion(BinaryReader reader)
        {
            UInt32 value = reader.ReadUInt32();
            if (value != ProtocolVersionValue)
            {
                IsConnected = false;
            }
        }

        private void ProcessPing(BinaryReader reader, BinaryWriter writer)
        {
            UInt64 pingValue = reader.ReadUInt64();

            writer.Write(PongId);
            writer.Write(pingValue);
        }

        private void SendEot(BinaryWriter writer, string reason)
        {
            writer.Write(EotId);
            writer.Write((UInt32) reason.Length);
            writer.Write(Encoding.ASCII.GetBytes(reason));
        }
    }
}