FISLib_Old/Vinno.FIS.TRTCClient.Common/Pipe/PipeMessageData.cs

using System;
using System.IO;
using System.Text;

namespace Vinno.FIS.TRTCClient.Common.Pipe
{
    public class PipeTransferData
    {
        protected void WriteInt(int value, Stream stream)
        {
            stream.Write(BitConverter.GetBytes(value), 0, sizeof(int));
        }

        protected void WriteString(string value, Stream stream)
        {
            var valueData = Encoding.Unicode.GetBytes(value);
            stream.Write(BitConverter.GetBytes(valueData.Length), 0, sizeof(int));
            stream.Write(valueData, 0, valueData.Length);
        }

        protected void WriteBytes(byte[] value, Stream stream)
        {
            var dataLength = value.Length;
            stream.Write(BitConverter.GetBytes(dataLength), 0, sizeof(int));
            stream.Write(value, 0, dataLength);
        }

        protected void WriteBool(bool value, Stream stream)
        {
            stream.Write(BitConverter.GetBytes(value), 0, sizeof(bool));
        }

        protected static int ReadInt(Stream stream)
        {
            var data = new byte[sizeof(int)];
            stream.Read(data, 0, sizeof(int));
            return BitConverter.ToInt32(data, 0);
        }

        protected static string ReadString(Stream stream)
        {
            var dataLength = ReadInt(stream);
            var data = new byte[dataLength];
            stream.Read(data, 0, dataLength);
            return Encoding.Unicode.GetString(data, 0, dataLength);
        }

        protected static byte[] ReadBytes(Stream stream)
        {
            var dataLength = ReadInt(stream);
            var data = new byte[dataLength];
            stream.Read(data, 0, dataLength);
            return data;
        }

        protected static bool ReadBool(Stream stream)
        {
            var data = new byte[sizeof(bool)];
            stream.Read(data, 0, sizeof(bool));
            return BitConverter.ToBoolean(data, 0);
        }
    }

    public class PipeMessageData : PipeTransferData
    {
        public PipeMessage PipeMessage { get; }

        public byte[] MessageData { get; }

        public PipeMessageData(PipeMessage pipeMessage, byte[] data)
        {
            PipeMessage = pipeMessage;
            MessageData = data;
        }

        public byte[] ToBytes()
        {
            byte[] result = new byte[0];
            using (var stream = new MemoryStream())
            {
                WriteInt((int)PipeMessage, stream);
                WriteBytes(MessageData, stream);
                result = stream.ToArray();
            }
            return result;
        }

        public static PipeMessageData FromBytes(byte[] bytes)
        {
            using (var stream = new MemoryStream(bytes))
            {
                stream.Position = 0;
                var pipeMessage = (PipeMessage)ReadInt(stream);
                var messageData = ReadBytes(stream);
                return new PipeMessageData(pipeMessage, messageData);
            }
        }
    }

    public class PipeConnectOtherRoomMessage : PipeTransferData
    {
        public string UserId { get; }

        public int RoomId { get; }

        public PipeConnectOtherRoomMessage(string userId, int roomId)
        {
            UserId = userId;
            RoomId = roomId;
        }

        public byte[] ToBytes()
        {
            byte[] result = new byte[0];
            using (var stream = new MemoryStream())
            {
                WriteString(UserId, stream);
                WriteInt(RoomId, stream);
                result = stream.ToArray();
            }
            return result;
        }

        public static PipeConnectOtherRoomMessage FromBytes(byte[] bytes)
        {
            using (var stream = new MemoryStream(bytes))
            {
                stream.Position = 0;
                var userId = ReadString(stream);
                var roomId = ReadInt(stream);
                return new PipeConnectOtherRoomMessage(userId, roomId);
            }
        }
    }

    public class PipeBoolMessage : PipeTransferData
    {
        public bool Value { get; }

        public PipeBoolMessage(bool value)
        {
            Value = value;
        }

        public byte[] ToBytes()
        {
            byte[] result = new byte[0];
            using (var stream = new MemoryStream())
            {
                WriteBool(Value, stream);
                result = stream.ToArray();
            }
            return result;
        }

        public static PipeBoolMessage FromBytes(byte[] bytes)
        {
            using (var stream = new MemoryStream(bytes))
            {
                stream.Position = 0;
                var isMute = ReadBool(stream);
                return new PipeBoolMessage(isMute);
            }
        }
    }

    public class PipeRemoteUserLeaveRoomMessage : PipeTransferData
    {
        public string UserId { get; }

        public int Reason { get; }

        public PipeRemoteUserLeaveRoomMessage(string userId, int reason)
        {
            UserId = userId;
            Reason = reason;
        }

        public byte[] ToBytes()
        {
            byte[] result = new byte[0];
            using (var stream = new MemoryStream())
            {
                WriteString(UserId, stream);
                WriteInt(Reason, stream);
                result = stream.ToArray();
            }
            return result;
        }

        public static PipeRemoteUserLeaveRoomMessage FromBytes(byte[] bytes)
        {
            using (var stream = new MemoryStream(bytes))
            {
                stream.Position = 0;
                var userId = ReadString(stream);
                var reason = ReadInt(stream);
                return new PipeRemoteUserLeaveRoomMessage(userId, reason);
            }
        }
    }

    public class PipeUserIdMessage : PipeTransferData
    {
        public string UserId { get; }

        public PipeUserIdMessage(string userId)
        {
            UserId = userId;
        }

        public byte[] ToBytes()
        {
            byte[] result = new byte[0];
            using (var stream = new MemoryStream())
            {
                WriteString(UserId, stream);
                result = stream.ToArray();
            }
            return result;
        }

        public static PipeUserIdMessage FromBytes(byte[] bytes)
        {
            using (var stream = new MemoryStream(bytes))
            {
                stream.Position = 0;
                var userId = ReadString(stream);
                return new PipeUserIdMessage(userId);
            }
        }
    }

    public class PipeImageSizeData : PipeTransferData
    {
        public int Width { get; }

        public int Height { get; }

        public PipeImageSizeData(int width, int height)
        {
            Width = width;
            Height = height;
        }

        public byte[] ToBytes()
        {
            byte[] result = new byte[0];
            using (var stream = new MemoryStream())
            {
                WriteInt(Width, stream);
                WriteInt(Height, stream);
                result = stream.ToArray();
            }
            return result;
        }

        public static PipeImageSizeData FromBytes(byte[] bytes)
        {
            using (var stream = new MemoryStream(bytes))
            {
                stream.Position = 0;
                var width = ReadInt(stream);
                var height = ReadInt(stream);
                return new PipeImageSizeData(width, height);
            }
        }
    }

    public class PipeRemoteImageSizeData : PipeTransferData
    {
        public string UserId { get; }

        public int Width { get; set; }

        public int Height { get; set; }

        public PipeRemoteImageSizeData(string userId, int width, int height)
        {
            UserId = userId;
            Width = width;
            Height = height;
        }

        public byte[] ToBytes()
        {
            byte[] result = new byte[0];
            using (var stream = new MemoryStream())
            {
                WriteString(UserId, stream);
                WriteInt(Width, stream);
                WriteInt(Height, stream);
                result = stream.ToArray();
            }
            return result;
        }

        public static PipeRemoteImageSizeData FromBytes(byte[] bytes)
        {
            using (var stream = new MemoryStream(bytes))
            {
                stream.Position = 0;
                var userId = ReadString(stream);
                var width = ReadInt(stream);
                var height = ReadInt(stream);
                return new PipeRemoteImageSizeData(userId, width, height);
            }
        }
    }
}