killapp/Assets/Scripts/Network/NetworkStateManager.cs

using System;
using System.Collections;
using System.Threading.Tasks;
using UnityEngine;

namespace Kill.Network
{
    /// <summary>
    /// 网络状态管理器 - 监控网络连接状态变化
    /// </summary>
    public class NetworkStateManager : MonoBehaviour
    {
        public static NetworkStateManager Instance { get; private set; }

        /// <summary>
        /// 当前网络连接状态
        /// </summary>
        public NetworkConnectivityState CurrentState { get; private set; }

        /// <summary>
        /// 是否已连接网络
        /// </summary>
        public bool IsConnected => CurrentState != NetworkConnectivityState.Disconnected;

        /// <summary>
        /// 网络状态变化事件
        /// </summary>
        public event EventHandler<NetworkStateChangedEventArgs> OnNetworkStateChanged;

        /// <summary>
        /// 网络恢复连接事件
        /// </summary>
        public event EventHandler OnNetworkConnected;

        /// <summary>
        /// 网络断开事件
        /// </summary>
        public event EventHandler OnNetworkDisconnected;

        /// <summary>
        /// 检测间隔(秒)
        /// </summary>
        [SerializeField] private float checkInterval = 3f;

        /// <summary>
        /// 上次网络状态
        /// </summary>
        private NetworkConnectivityState _lastState;

        /// <summary>
        /// 是否正在监控
        /// </summary>
        private bool _isMonitoring = false;

        private void Awake()
        {
            if (Instance == null)
            {
                Instance = this;
                DontDestroyOnLoad(gameObject);
            }
            else
            {
                Destroy(gameObject);
                return;
            }
        }

        public async Task Init()
        {
            // 初始化当前状态
            _lastState = GetCurrentNetworkState();
            CurrentState = _lastState;
            
            // 开始监控
            StartMonitoring();
        }

        private void OnDestroy()
        {
            StopMonitoring();
        }

        /// <summary>
        /// 开始监控网络状态
        /// </summary>
        public void StartMonitoring()
        {
            if (_isMonitoring) return;
            
            _isMonitoring = true;
            StartCoroutine(MonitorNetworkState());
            Debug.Log("[NetworkStateManager] 开始监控网络状态");
        }

        /// <summary>
        /// 停止监控网络状态
        /// </summary>
        public void StopMonitoring()
        {
            _isMonitoring = false;
            StopAllCoroutines();
            Debug.Log("[NetworkStateManager] 停止监控网络状态");
        }

        /// <summary>
        /// 监控网络状态的协程
        /// </summary>
        private IEnumerator MonitorNetworkState()
        {
            while (_isMonitoring)
            {
                CheckNetworkState();
                yield return new WaitForSeconds(checkInterval);
            }
        }

        /// <summary>
        /// 检查网络状态
        /// </summary>
        public void CheckNetworkState()
        {
            NetworkConnectivityState currentState = GetCurrentNetworkState();
            
            if (currentState != _lastState)
            {
                // 状态发生变化
                var eventArgs = new NetworkStateChangedEventArgs
                {
                    PreviousState = _lastState,
                    CurrentState = currentState,
                    IsConnected = currentState != NetworkConnectivityState.Disconnected,
                    ChangeTime = DateTime.Now
                };

                CurrentState = currentState;
                _lastState = currentState;

                // 触发事件
                OnNetworkStateChanged?.Invoke(this, eventArgs);

                if (currentState == NetworkConnectivityState.Disconnected)
                {
                    OnNetworkDisconnected?.Invoke(this, EventArgs.Empty);
                    Debug.Log("[NetworkStateManager] 网络已断开");
                }
                else
                {
                    OnNetworkConnected?.Invoke(this, EventArgs.Empty);
                    Debug.Log($"[NetworkStateManager] 网络已连接: {currentState}");
                }
            }
        }

        /// <summary>
        /// 获取当前网络状态
        /// </summary>
        private NetworkConnectivityState GetCurrentNetworkState()
        {
            if (Application.internetReachability == NetworkReachability.NotReachable)
            {
                return NetworkConnectivityState.Disconnected;
            }
            else if (Application.internetReachability == NetworkReachability.ReachableViaLocalAreaNetwork)
            {
                return NetworkConnectivityState.Wifi;
            }
            else if (Application.internetReachability == NetworkReachability.ReachableViaCarrierDataNetwork)
            {
                return NetworkConnectivityState.Cellular;
            }
            
            return NetworkConnectivityState.Unknown;
        }

        /// <summary>
        /// 检查是否可以使用网络（WiFi或移动数据）
        /// </summary>
        public bool CanUseNetwork(bool allowCellular = true)
        {
            if (!IsConnected) return false;
            
            if (!allowCellular && CurrentState == NetworkConnectivityState.Cellular)
            {
                return false;
            }
            
            return true;
        }

        /// <summary>
        /// 检查是否可以使用WiFi
        /// </summary>
        public bool IsWifiConnected()
        {
            return CurrentState == NetworkConnectivityState.Wifi;
        }

        /// <summary>
        /// 检查是否使用移动数据
        /// </summary>
        public bool IsCellularConnected()
        {
            return CurrentState == NetworkConnectivityState.Cellular;
        }
    }
}