powerfun-unity/Assets/Scripts/UI/Prefab/Device/DeviceView.cs

using Assets.Scripts.Devices.Ant;
using System.Collections;
using System.Collections.Generic;
using System;
using System.Linq;
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using Assets.Scripts.Devices.Ant.Interfaces;
using Assets.Scripts.UI.UIEffect;
using Assets.Scripts;
using DG.Tweening;
using Assets.Scripts.UI.Prefab.Device;
using Assets.Scripts.Devices;

public class DeviceView : MonoBehaviour
{
    [SerializeField]
    private SensorType mType;

    private SensorType SensorType
    {
        get
        {
            //Debug.Log(mType);
            //Enum.TryParse(mType, out SensorType sensorType);
            return mType;
        }
    }

    private GameObject mSearchButton;
    private GameObject mPairButton;
    private GameObject mDisconnectButton;
    private GameObject unconnectionPanel;
    private GameObject connectionPanel;
    private Text searchState;
    private ConnectDeviceModal deviceModal;
    private Text title;
    private Text noDevice;
    private Text powerValue;
    private Text powerUnit;
    //private Text cadenceValue;
    //private Text speedValue;
    //private Text heartRateValue;
    private Image logo;
    /// <summary>
    /// 没有设备的logo
    /// </summary>
    private Sprite sprite0;
    /// <summary>
    /// 连接中的logo
    /// </summary>
    private Sprite sprite1;
    /// <summary>
    /// 已连接的logo
    /// </summary>
    private Sprite sprite3;

    private float timer = 1.0f;
    private void Awake()
    {
        title = this.transform.Find("Title").GetComponent<Text>();
        noDevice = this.transform.Find("NoDevice").GetComponent<Text>();
        unconnectionPanel = this.transform.Find("UnconnectionPanel").gameObject;
        mSearchButton = unconnectionPanel.transform.Find("SearchButton").gameObject;
        mPairButton = unconnectionPanel.transform.Find("PairButton").gameObject;
        searchState = unconnectionPanel.transform.Find("SearchState").GetComponent<Text>();
        mPairButton.SetActive(false);
        connectionPanel = this.transform.Find("ConnectionPanel").gameObject;

        var material = Instantiate(Resources.Load<Material>("UI/Material/RoundedCornersTextureMaterial"));        
        var rect = ((RectTransform)transform).rect;
        material.SetVector(Shader.PropertyToID("_WidthHeightRadius"), new Vector4(rect.width, rect.height, rect.height * 0.2f, 0));
        this.GetComponent<Image>().material = material;

        var img1 = unconnectionPanel.GetComponent<Image>();
        if(img1 != null)
        {
            img1.material = material;

            //var gradient = unconnectionPanel.GetComponent<UIGradient>();
            //if (gradient != null)
            //{
            //    gradient.color1 = Utils.HexToColor("353543");
            //    gradient.color2 = Utils.HexToColor("23232D");
            //}
        }        

        var img2 = connectionPanel.GetComponent<Image>();
        if(img2 != null)
        {
            img2.material = material;

            //var gradient1 = connectionPanel.GetComponent<UIGradient>();
            //if (gradient1 != null)
            //{
            //    gradient1.color1 = Utils.HexToColor("FF7485");
            //    gradient1.color2 = Utils.HexToColor("F93086");
            //}
        }

        logo = this.transform.Find("Logo").GetComponent<Image>();
        
        
        mDisconnectButton = connectionPanel.transform.Find("DisconnectBtn").gameObject;
        var powerValueObj = connectionPanel.transform.Find("PowerValue");
        if(powerValueObj != null)
        {
            powerValue = powerValueObj.gameObject.GetComponent<Text>();
        }

        var powerUnitObj = connectionPanel.transform.Find("PowerUnit");
        if(powerUnitObj != null)
        {
            powerUnit = powerUnitObj.gameObject.GetComponent<Text>();
        }

        InitLogo();
        title.text = GetTitle();

        connectionPanel.SetActive(false);

        UIManager.AddEvent(mPairButton, EventTriggerType.PointerClick, new UnityAction<UnityEngine.EventSystems.BaseEventData>(e =>
        {
            if (deviceModal == null)
            {
                
#if UNITY_IOS || UNITY_ANDROID
                var obj = Resources.Load("UI/Prefab/Device/Mobile/ConnectDeviceModal");
#else
                var obj = Resources.Load("UI/Prefab/Device/ConnectDeviceModal");
#endif
                GameObject gameObject = (GameObject)Instantiate(obj);
                deviceModal = gameObject.GetComponent<ConnectDeviceModal>();
            }
            deviceModal.SensorType = this.SensorType;
            UIManager.Show(deviceModal, null, true);
        }));

        UIManager.AddEvent(mDisconnectButton, EventTriggerType.PointerClick, new UnityEngine.Events.UnityAction<BaseEventData>(e => {
            //var device = GetDevice();
            //if(device != null && device.State == DeviceState.Connected)
            //{
            //    device.Disconnect();
            //}

#if UNITY_IOS || UNITY_ANDROID
            var obj = Resources.Load("UI/Prefab/Device/Mobile/ConnectDeviceModal");
#else
            var obj = Resources.Load("UI/Prefab/Device/ConnectDeviceModal");
#endif
            GameObject gameObject = (GameObject)Instantiate(obj);
            deviceModal = gameObject.GetComponent<ConnectDeviceModal>();
            deviceModal.SensorType = this.SensorType;
            UIManager.Show(deviceModal, null, true);
        }));

    }

    void InitLogo()
    {
        if (SensorType == SensorType.Power)
        {
            sprite0 = Resources.Load<Sprite>("Images/Devices/Power_0");
            sprite1 = Resources.Load<Sprite>("Images/Devices/Power_1");
            sprite3 = Resources.Load<Sprite>("Images/Devices/Power_4");

            powerUnit.text = "W";
        }
        else if (SensorType == SensorType.Speed)
        {
            sprite0 = Resources.Load<Sprite>("Images/Devices/Speed_0");
            sprite1 = Resources.Load<Sprite>("Images/Devices/Speed_1");
            sprite3 = Resources.Load<Sprite>("Images/Devices/Speed_4");

            powerUnit.text = "KPH";
        }
        else if (SensorType == SensorType.Cadence || SensorType == SensorType.SpeedCadence)
        {
            sprite0 = Resources.Load<Sprite>("Images/Devices/Cadence_0");
            sprite1 = Resources.Load<Sprite>("Images/Devices/Cadence_1");
            sprite3 = Resources.Load<Sprite>("Images/Devices/Cadence_4");

            powerUnit.text = "RPM";
        }
        else if (SensorType == SensorType.HeartRate)
        {
            sprite0 = Resources.Load<Sprite>("Images/Devices/Heart Rate_0");
            sprite1 = Resources.Load<Sprite>("Images/Devices/Heart Rate_1");
            sprite3 = Resources.Load<Sprite>("Images/Devices/Heart Rate_4");

            powerUnit.text = "BPM";
        }
        else if(SensorType == SensorType.Trainer)
        {
            sprite0 = Resources.Load<Sprite>("Images/Devices/Trainer_0");
            sprite1 = Resources.Load<Sprite>("Images/Devices/Trainer_1");
            sprite3 = Resources.Load<Sprite>("Images/Devices/Trainer_4");
        }
    }

    // Start is called before the first frame update
    void Start()
    {
        Main();
    }

    // Update is called once per frame
    void Update()
    {
        //if(SensorType != SensorType.Trainer)
        //{
        //    return;
        //}
        timer -= Time.deltaTime;
        if (timer <= 0)
        {            
            Main();

            timer = 1.0f;
        }
    }

    void Main()
    {
        var connectedDevice = GetCurrentDevice();
        if(connectedDevice == null)
        {
            connectedDevice = GetDevice();
        }
        if(connectedDevice == null)
        {
            unconnectionPanel.SetActive(true);
            connectionPanel.SetActive(false);

            logo.sprite = sprite0;
            noDevice.text = "NO DEVICE";
            searchState.text = "Searching...";            
                
            var hasDevice = App.MainDeviceAdapter.GetDevices().Any(d => d.Sensor == SensorType);
            if (hasDevice)
            {
                mSearchButton.SetActive(false);
                mPairButton.SetActive(true);
#if UNITY_IOS || UNITY_ANDROID
                //searchState.gameObject.SetActive(false);
#endif
                logo.sprite = sprite1;

                //App.MainDeviceAdapter.GetDevices().First(d => d.Sensor == SensorType).Connect();
            }
            else
            {
#if !(UNITY_IOS || UNITY_ANDROID)
                mSearchButton.SetActive(true);
#endif
                mPairButton.SetActive(false);
            }
        }
        else if(connectedDevice.State == DeviceState.Connecting)
        {
            unconnectionPanel.SetActive(true);
            connectionPanel.SetActive(false);
            logo.sprite = sprite1;

            //title.text = connectedDevice.Name;
            if (connectedDevice.Network == NetworkType.BLE)
            {
                //noDevice.enabled = false;
                noDevice.text = connectedDevice.Name;
            }
            else
            {
                //noDevice.enabled = true;
                noDevice.text = connectedDevice.Name +" "+ connectedDevice.DeviceNumber.ToString();
            }
#if (UNITY_IOS || UNITY_ANDROID)
            mPairButton.SetActive(true);
            searchState.gameObject.SetActive(true);
#endif
            searchState.text = "Connecting...";


        }
        else if (connectedDevice.State == DeviceState.Connected)
        {
            unconnectionPanel.SetActive(false);

            if (connectionPanel.activeInHierarchy == false)
            {
                var connectionCanvasGroup = connectionPanel.GetComponent<CanvasGroup>();
                connectionCanvasGroup.alpha = 0;
                connectionPanel.SetActive(true);
                connectionCanvasGroup.DOFade(1f, .3f).OnComplete(()=> {
                    //if (logoSprite != null) {
                    //    logo.sprite = logoSprite;
                    //}
                });
                DeviceCache.Add(connectedDevice);

                Debug.Log("connected");

                
            }

            logo.sprite = sprite3;

            //title.text = connectedDevice.Name;
            if (connectedDevice.Network == NetworkType.BLE)
            {
                //noDevice.enabled = false;
                noDevice.text = connectedDevice.Name;
            }
            else
            {
                //noDevice.enabled = true;
                noDevice.text = connectedDevice.Name +" "+ connectedDevice.DeviceNumber.ToString();
            }
            noDevice.color = Color.white;

            if (powerValue != null)
            {
                powerValue.text = GetValue(connectedDevice);
            }           
        }

        //Debug.Log(Newtonsoft.Json.JsonConvert.SerializeObject(App.MainDeviceAdapter.GetDevices().Where(d => d.Sensor == SensorType)));
    }

    string GetTitle()
    {
        switch (SensorType)
        {
            case SensorType.None:
                break;
            case SensorType.SpeedCadence:
            case SensorType.Cadence:
                return "Cadence Sensor";
            case SensorType.HeartRate:
                return "Heart Rate Monitor";
            case SensorType.Power:
                return "Power Meter";
            case SensorType.Speed:            
                return "Speed Meter";
            case SensorType.Trainer:
                return "Smart Trainer";
            case SensorType.VirtualPower:
                break;
            default:
                break;
        }
        return "";
    }


    string GetValue(AbstractDevice connectedDevice)
    {
        switch (SensorType)
        {
            case SensorType.None:
                break;
            case SensorType.SpeedCadence:
            case SensorType.Cadence:
                //cadenceValue.text = (connectedDevice as ICadenceDevice).Cadence.ToString();
                return (connectedDevice as ICadenceDevice).Cadence.ToString();
            case SensorType.HeartRate:
                return (connectedDevice as IHeartRateDevice).HeartRate.ToString();
            case SensorType.Power:
                return (connectedDevice as IPowerDevice).Power.ToString();
            case SensorType.Speed:
                return (connectedDevice as ISpeedDevice).Speed.ToString();               
            case SensorType.Trainer:
                //powerValue.text = (connectedDevice as IPowerDevice).Power.ToString();
                //cadenceValue.GetComponent<Text>().text = (connectedDevice as ICadenceDevice).Cadence.ToString();
                //speedValue.GetComponent<Text>().text = (connectedDevice as ISpeedDevice).Speed.ToString();
                break;
            case SensorType.VirtualPower:
                break;
            default:
                break;
        }
        return "";
    }
    AbstractDevice GetCurrentDevice()
    {
        //return AntConnector.Instance().discoveredDevices.FirstOrDefault(d => (d.State == DeviceState.Connected || d.State == DeviceState.Connecting) && d.Sensor == SensorType);
        return App.MainDeviceAdapter.GetDevices().FirstOrDefault(d => (d.State == DeviceState.Connected || d.State == DeviceState.Connecting) && d.Sensor == SensorType);
    }

    /// <summary>
    /// 获取已经连接的设备
    /// </summary>
    /// <returns></returns>
    AbstractDevice GetDevice()
    {
        //return AntConnector.Instance().discoveredDevices.FirstOrDefault(d => (d.State == DeviceState.Connected || d.State == DeviceState.Connecting) && d.Sensor == SensorType);
        var devices = App.MainDeviceAdapter.GetDevices().Where(d => (d.State == DeviceState.Connected));
        switch (SensorType)
        {
            case SensorType.None:
                break;
            case SensorType.SpeedCadence:
            case SensorType.Cadence:
                return devices.FirstOrDefault(d => d is ICadenceDevice);                
            case SensorType.HeartRate:
                return devices.FirstOrDefault(d => d is IHeartRateDevice);
            case SensorType.Power:
                var item = devices.FirstOrDefault(d => d is IPowerDevice);
                //if (powerValue != null)
                //{
                //    powerValue.GetComponent<Text>().text = (item as IPowerDevice).Power.ToString();
                //}
                return item;
            case SensorType.Speed:
                return devices.FirstOrDefault(d => d is ISpeedDevice);
            case SensorType.Trainer:
                var item3 = devices.FirstOrDefault(d => d.Sensor == SensorType.Trainer);
                return item3;                
            case SensorType.VirtualPower:
                break;
            default:
                return null;
        }
        return null;
    }
}