killapp/Assets/Scripts/Bluetooth/BLEDeviceState.cs

using System;
using System.Collections.Generic;
using Kill.Bluetooth.Protocol;

namespace Kill.Bluetooth
{
    /// <summary>
    /// 设备配置变化字段。
    /// </summary>
    public enum BLEDeviceStateField : byte
    {
        None = 0,
        Connection,
        WorkMode,
        LockState,
        ScheduleTasks,
        Angle,
        Distance,
        FillLight,
        FillLightConnection,
        VisualDetection,
        MillimeterWave,
        Language,
        HardwareStatus,
        CapacitorState
    }

    /// <summary>
    /// 蓝牙设备运行状态。
    /// 以设备 MAC 为边界保存状态，避免切换设备时旧设备数据覆盖当前设备。
    /// </summary>
    [Serializable]
    public sealed class BLEDeviceState
    {
        public string DeviceMac { get; private set; }

        public bool IsConnected { get; private set; }

        public WorkMode? WorkMode { get; private set; }

        public DeviceLockControl? LockState { get; private set; }

        public ScheduleTask[] ScheduleTasks { get; private set; } = new ScheduleTask[0];

        public AngleControl? Angle { get; private set; }

        public DistanceControl? Distance { get; private set; }

        public FillLightControl? FillLight { get; private set; }

        public FillLightConnectionStatus? FillLightConnection { get; private set; }

        public VisualDetectionSetting? VisualDetection { get; private set; }

        public MillimeterWaveSetting? MillimeterWave { get; private set; }

        public LanguageSetting? Language { get; private set; }

        public HardwareStatus? HardwareStatus { get; private set; }

        public CapacitorStateNotification? CapacitorState { get; private set; }

        public DateTime LastUpdatedAt { get; private set; }

        public BLEDeviceState(string deviceMac)
        {
            DeviceMac = deviceMac ?? string.Empty;
            LastUpdatedAt = DateTime.Now;
        }

        internal bool SetConnection(bool connected)
        {
            if (IsConnected == connected)
            {
                return false;
            }

            IsConnected = connected;
            MarkUpdated();
            return true;
        }

        internal bool SetWorkMode(WorkMode mode)
        {
            if (WorkMode.HasValue && WorkMode.Value == mode)
            {
                return false;
            }

            WorkMode = mode;
            MarkUpdated();
            return true;
        }

        internal bool SetLockState(DeviceLockControl lockState)
        {
            if (LockState.HasValue && LockState.Value.IsLocked == lockState.IsLocked)
            {
                return false;
            }

            LockState = lockState;
            MarkUpdated();
            return true;
        }

        internal bool SetScheduleTasks(ScheduleTask[] tasks)
        {
            ScheduleTask[] newTasks = tasks == null ? new ScheduleTask[0] : (ScheduleTask[])tasks.Clone();
            if (ScheduleTasksEqual(ScheduleTasks, newTasks))
            {
                return false;
            }

            ScheduleTasks = newTasks;
            MarkUpdated();
            return true;
        }

        internal bool SetAngle(AngleControl angle)
        {
            if (Angle.HasValue && Angle.Value.AngleRange == angle.AngleRange)
            {
                return false;
            }

            Angle = angle;
            MarkUpdated();
            return true;
        }

        internal bool SetDistance(DistanceControl distance)
        {
            if (Distance.HasValue &&
                Distance.Value.DetectionDistance == distance.DetectionDistance &&
                Distance.Value.AimDistance == distance.AimDistance)
            {
                return false;
            }

            Distance = distance;
            MarkUpdated();
            return true;
        }

        internal bool SetFillLight(FillLightControl fillLight)
        {
            if (FillLight.HasValue &&
                FillLight.Value.Enable == fillLight.Enable &&
                FillLight.Value.LightType == fillLight.LightType &&
                FillLight.Value.Intensity == fillLight.Intensity)
            {
                return false;
            }

            FillLight = fillLight;
            MarkUpdated();
            return true;
        }

        internal bool SetFillLightConnection(FillLightConnectionStatus status)
        {
            if (FillLightConnection.HasValue &&
                FillLightConnection.Value.IsConnected == status.IsConnected)
            {
                return false;
            }

            FillLightConnection = status;
            MarkUpdated();
            return true;
        }

        internal bool SetVisualDetection(VisualDetectionSetting setting)
        {
            if (VisualDetection.HasValue &&
                VisualDetection.Value.Enable == setting.Enable &&
                VisualDetection.Value.Sensitivity == setting.Sensitivity)
            {
                return false;
            }

            VisualDetection = setting;
            MarkUpdated();
            return true;
        }

        internal bool SetMillimeterWave(MillimeterWaveSetting setting)
        {
            if (MillimeterWave.HasValue &&
                MillimeterWave.Value.Enable == setting.Enable &&
                MillimeterWave.Value.Sensitivity == setting.Sensitivity &&
                MillimeterWave.Value.ActualSafeDistance == setting.ActualSafeDistance)
            {
                return false;
            }

            MillimeterWave = setting;
            MarkUpdated();
            return true;
        }

        internal bool SetLanguage(LanguageSetting language)
        {
            if (Language.HasValue && Language.Value.Language == language.Language)
            {
                return false;
            }

            Language = language;
            MarkUpdated();
            return true;
        }

        internal bool SetHardwareStatus(HardwareStatus hardwareStatus)
        {
            if (HardwareStatus.HasValue && HardwareStatus.Value.Equals(hardwareStatus))
            {
                return false;
            }

            HardwareStatus = hardwareStatus;
            MarkUpdated();
            return true;
        }

        internal bool SetCapacitorState(CapacitorStateNotification capacitorState)
        {
            if (CapacitorState.HasValue && CapacitorState.Value.State == capacitorState.State)
            {
                return false;
            }

            CapacitorState = capacitorState;
            MarkUpdated();
            return true;
        }

        private void MarkUpdated()
        {
            LastUpdatedAt = DateTime.Now;
        }

        private static bool ScheduleTasksEqual(ScheduleTask[] left, ScheduleTask[] right)
        {
            if (left == null || right == null || left.Length != right.Length)
            {
                return false;
            }

            for (int i = 0; i < left.Length; i++)
            {
                if (!left[i].Equals(right[i]))
                {
                    return false;
                }
            }

            return true;
        }
    }
}