powerfun-unity/Assets/Scripts/Devices/Ble/BleDeviceAdapter.cs

using Assets.Scripts.Ble;
using Assets.Scripts.Ble.Service;
using Assets.Scripts.Devices.Ble.Devices;
using Assets.Scripts.Devices.Ble.Interfaces;
using Assets.Scripts.UI.Prefab.Device;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using UnityEngine;

namespace Assets.Scripts.Devices.Ble
{
    public class BleDeviceAdapter : DeviceAdapter
    {
        public override ConnectionInterface Interface => ConnectionInterface.BLE;

        private IDictionary<string, BleDevice> discoveredDevices = new Dictionary<string, BleDevice>();

        private IBleWinHwInterface hwInterface { get; set; }
        public BleDeviceAdapter(IBleWinHwInterface bleWinHwInterface)
        {
            
            hwInterface = bleWinHwInterface;// BleWinHwInterface.GetInterface();

            hwInterface.BluetoothStateChangedEvent += HwInterface_BluetoothStateChangedEvent;
        }

        private void HwInterface_BluetoothStateChangedEvent(IBleWinHwInterface hwInterface, BleState bleState)
        {
            //Debug.Log("22222222222222" + bleState);
            if(bleState == BleState.Off)
            {
                discoveredDevices.Clear();
            }
            else
            {
                this.StartScan();
            }
        }

        public override IEnumerable<AbstractDevice> GetDevices()
        {
            //throw new NotImplementedException();
            return discoveredDevices.Select(d => d.Value);
        }

        public override DeviceAdapterState GetState()
        {
            if(hwInterface.BleState == BleState.On)
            {
                return DeviceAdapterState.On;
            }
            return DeviceAdapterState.Unavailable;
        }

        public override void StartScan()
        {
            hwInterface.StartScan((device) =>
            { 
                if (!discoveredDevices.ContainsKey(device.Peripheral.Address))
                {
                    Debug.Log($"发现设备{ device.Peripheral.Address }, \t\tName:{ device.Peripheral.Name }, type:{ device.SensorType } 服务：{string.Join(",", device.Services)}");

                    if (string.IsNullOrWhiteSpace(device.Peripheral.Name))
                    {
                        return;
                    }
                    if (device.SensorType == Ant.SensorType.FtmsTrainer) 
                    {
                        var device1 = new Ftms(device.Peripheral, hwInterface);
                        if (discoveredDevices.ContainsKey(device.Peripheral.Address))
                        {
                            discoveredDevices[device.Peripheral.Address] = device1;
                        }
                        else
                        {
                            discoveredDevices.Add(device.Peripheral.Address, device1);
                        }
                    }
                    else if (device.SensorType == Ant.SensorType.Trainer)
                    {
                        //var device1 = new Ftms(device.Peripheral, hwInterface);
                        //discoveredDevices.Add(device.Peripheral.Address, device0);

                        var device1 = new Tacx(device.Peripheral, hwInterface);
                        if (discoveredDevices.ContainsKey(device.Peripheral.Address))
                        {
                            discoveredDevices[device.Peripheral.Address] = device1;
                        }
                        else 
                        {
                            discoveredDevices.Add(device.Peripheral.Address, device1);
                        }
                    }
                    else if (device.SensorType == Ant.SensorType.HeartRate)
                    {
                        var device1 = new HeartRate(device.Peripheral, hwInterface);
                        discoveredDevices.Add(device.Peripheral.Address, device1);
                    }
                    else if (device.SensorType == Ant.SensorType.Power)
                    {
                        var device1 = new CyclingPower(device.Peripheral, hwInterface);
                        discoveredDevices.Add(device.Peripheral.Address, device1);
                    }
                    else if (device.SensorType == Ant.SensorType.SpeedCadence)
                    {
                        var device1 = new SpeedCadence(device.Peripheral, hwInterface);
                        discoveredDevices.Add(device.Peripheral.Address, device1);
                    }
                    else if (device.SensorType == Ant.SensorType.Rower) 
                    {
                        var device1 = new FtmsRower(device.Peripheral, hwInterface);
                        if (discoveredDevices.ContainsKey(device.Peripheral.Address))
                        {
                            discoveredDevices[device.Peripheral.Address] = device1;
                        }
                        else
                        {
                            discoveredDevices.Add(device.Peripheral.Address, device1);
                        }
                    }
                    else
                    {
                        return;
                    }

                    var device111 = discoveredDevices.Last().Value;
                    if (device111 != null && device111.State == Ant.DeviceState.Disconnected)
                    {
                        if (DeviceCache.Exist(device111))
                        {
                            //TODO:取消注释，自动连接设备
                            //Debug.Log("自动连接" + device111.Id);

                            if (App.IsRowerMode == true)
                            {
                                if (device111.Sensor == Ant.SensorType.Rower || device111.Sensor == Ant.SensorType.HeartRate)
                                {
                                    device111.Connect();
                                }
                            }
                            else if(App.IsRowerMode == false)
                            {
                                if (device111.Sensor != Ant.SensorType.Rower) 
                                {
                                    device111.Connect();
                                }
                            }
                        }
                    }

                    //discoveredDevices.Add(device.Peripheral.Address, new BleDevice(device.Peripheral, hwInterface, device.SensorType));

                }
                if (discoveredDevices.ContainsKey(device.Peripheral.Address))
                {
                    discoveredDevices[device.Peripheral.Address].SignalStrength = device.Rssi;
                    //Debug.Log($"设备{ device.Peripheral.Name }信号量：{ device.Rssi }");
                }
            });
        }

        public override void StopScan()
        {
            hwInterface.StopScan();
        }

        public override void Dispose()
        {
            this.ReleaseDevices();
            hwInterface.Dispose();
            base.Dispose();
        }

        public void ReleaseDevices()
        {
            foreach (var item in discoveredDevices)
            {
                item.Value.Dispose();
            }
        }

        public override void Refresh()
        {
            var list = discoveredDevices.ToList();
            foreach (var item in list)
            {
                if (item.Value.State == Ant.DeviceState.Disconnected)
                {
                    item.Value.Dispose();
                    discoveredDevices.Remove(item.Key);
                }
            }
        }

        /// <summary>
        /// 清除未连接的设备
        /// </summary>
        public void ClearDevice(string address)
        {
            var list = discoveredDevices.ToList();
            foreach (var item in list)
            {
                if(item.Value.State == Ant.DeviceState.Disconnected)
                {
                    if (!string.IsNullOrWhiteSpace(address) && item.Key != address)
                    {
                        continue;
                    }
                    hwInterface.pCache.Remove(item.Key);
                    item.Value.Dispose();
                    discoveredDevices.Remove(item.Key);                    
                }
            }
        }
    }
}