webRtc/Assets/Script/WebRtc/MessageChannel.cs

// Assets/Script/MessageChannel.cs

using System;
using System.Collections.Generic;
using System.Text;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using UnityEngine;

namespace Unity.RenderStreaming
{
    public class MessageChannel : DataChannelBase
    {
        public event Action<string, UserInfo> OnMessageReceived;
        public event Action<string, MediaStateChange> OnMediaStateChangeReceived;

        [Header("消息记录")] [SerializeField, TextArea(1, 3)]
        private string lastReceivedMessage;

        [SerializeField] private int receivedMessageCount;

        [SerializeField] private List<MessageRecord> messageHistory = new List<MessageRecord>();

        private const int MAX_HISTORY = 100;

        public IReadOnlyList<MessageRecord> MessageHistory => messageHistory;
        public int ReceivedMessageCount => receivedMessageCount;

        private void Start()
        {
            label = "on-message";
        }

        public override void OnMessage(string message)
        {
            try
            {
                Debug.Log($"[MessageChannel] Received: {message}");
                var record = JsonConvert.DeserializeObject<MessageRecord>(message);
                if (record == null)
                {
                    record = new MessageRecord { type = "raw", data = message };
                }

                JObject json = null;
                switch (record.type)
                {
                    case MessageTypes.Chat:
                        var chat = record.data as ChatData;
                        break;
                    case MessageTypes.UserInfo:
                        json = record.data as JObject;
                        var info = json.ToObject<UserInfo>();
                        OnMessageReceived?.Invoke(ConnectionId, info);
                        break;
                    case MessageTypes.MediaStateChange:
                        json = record.data as JObject;
                        var mediaState = json.ToObject<MediaStateChange>();
                        OnMediaStateChangeReceived?.Invoke(ConnectionId, mediaState);
                        break;
                }

                messageHistory.Add(record);
                if (messageHistory.Count > MAX_HISTORY)
                    messageHistory.RemoveAt(0);

                lastReceivedMessage = message;
                receivedMessageCount++;
            }
            catch (Exception e)
            {
                Debug.LogError($"[MessageChannel] Parse error: {e.Message}");
            }
        }

        public void SendMessage<T>(string type, T data)
        {
            var record = new MessageRecord
            {
                type = type,
                data = JsonConvert.SerializeObject(data)
            };
            string json = JsonConvert.SerializeObject(record);
            Send(json);

            record.isSent = true;
            messageHistory.Add(record);
            if (messageHistory.Count > MAX_HISTORY)
                messageHistory.RemoveAt(0);
        }

        public void SendMessage(string message)
        {
            Send(message);
            var record = new MessageRecord { type = "raw", data = message, isSent = true };
            messageHistory.Add(record);
            if (messageHistory.Count > MAX_HISTORY)
                messageHistory.RemoveAt(0);
        }

        public void ClearHistory()
        {
            messageHistory.Clear();
            receivedMessageCount = 0;
            lastReceivedMessage = "";
        }

        [Serializable]
        public class MessageRecord
        {
            public string type;
            public object data;
            public bool isSent;
            public string timestamp = DateTime.Now.ToString();
        }
    }
}