Merge branch 'dev_lishuo' into dev_mobile

Assets/Scripts/Apis/MapApi.cs

@@ -59,7 +59,12 @@ namespace Assets.Scripts.Apis
         /// <returns></returns>
         public Task<JsonResult<List<MapRoute>>> GetList(int pageIndex, int pageSize, string name, string distance="", string hands="", bool is3D=false, string sort="", string sortDire = "", bool isFav = false)
         {
-            var url = $"Map/GetRoute?pageIndex={ pageIndex }&pageSize={ pageSize }&name={ name }&distance={ distance }&hands={ hands }&is3D={ is3D }&sort={ sort }&sortDire={ sortDire }&isFav={isFav}";
+            string lngLat = "";
+            if (sort.Equals("Near"))
+            {
+                lngLat = $"{App.longitude},{App.latitude}";
+            }
+            var url = $"Map/GetRoute?pageIndex={ pageIndex }&pageSize={ pageSize }&name={ name }&distance={ distance }&hands={ hands }&is3D={ is3D }&sort={ sort }&sortDire={ sortDire }&isFav={isFav}&lngLat={lngLat}";
 
             return GetAsync<JsonResult<List<MapRoute>>>(url);
         }

Assets/Scripts/Devices/Ble/BleDevice.cs

@@ -17,7 +17,7 @@ namespace Assets.Scripts.Devices.Ble
 
     public abstract class BleDevice : AbstractDevice
     {
-        protected BleWinHwInterface hwInterface;
+        protected IBleWinHwInterface hwInterface;
         protected BlePeripheralInfo peripheralInfo;
         private readonly HashSet<BleService> services = new HashSet<BleService>();
 
@@ -32,7 +32,7 @@ namespace Assets.Scripts.Devices.Ble
         }
         public List<ICharacteristic> Characteristics { get; protected set; } = new List<ICharacteristic>();
 
-        public BleDevice(BlePeripheralInfo peripheralInfo, BleWinHwInterface bleWinHwInterface, SensorType sensor) : base(peripheralInfo.Address, NetworkType.BLE)
+        public BleDevice(BlePeripheralInfo peripheralInfo, IBleWinHwInterface bleWinHwInterface, SensorType sensor) : base(peripheralInfo.Address, NetworkType.BLE)
         {
             this.hwInterface = bleWinHwInterface;
             this.hwInterface.BluetoothStateChangedEvent += BluetoothStateChangedEvent;
@@ -50,7 +50,7 @@ namespace Assets.Scripts.Devices.Ble
             Characteristics.Add(new ModelNumberCharacteristic());
         }
 
-        private void HwInterface_PeripheralDisconnectedEvent(BleWinHwInterface hwInterface, BlePeripheralInfo peripheral, BleResponse response, bool manualDisconnect)
+        private void HwInterface_PeripheralDisconnectedEvent(IBleWinHwInterface hwInterface, BlePeripheralInfo peripheral, BleResponse response, bool manualDisconnect)
         {
             if (!peripheral.MatchAddress(this.peripheralInfo.Address))
             {
@@ -93,7 +93,7 @@ namespace Assets.Scripts.Devices.Ble
             }
         }
 
-        private void PeripheralConnectedAction(BleWinHwInterface hwInterface, BlePeripheralInfo sender, BleResponse response)
+        private void PeripheralConnectedAction(IBleWinHwInterface hwInterface, BlePeripheralInfo sender, BleResponse response)
         {
             Debug.Log($"连接{ this.Name }"+response.IsSuccess);
             if (response.IsSuccess)
@@ -136,7 +136,7 @@ namespace Assets.Scripts.Devices.Ble
 
         
 
-        private void ServicesDiscoveredAction(BleWinHwInterface hwInterface, BlePeripheralInfo sender, BleResponse<List<BleServiceInfo>> response)
+        private void ServicesDiscoveredAction(IBleWinHwInterface hwInterface, BlePeripheralInfo sender, BleResponse<List<BleServiceInfo>> response)
         {
             //Debug.Log("搜索service");
             if(!response.IsSuccess || !response.Data.Any())
@@ -211,7 +211,7 @@ namespace Assets.Scripts.Devices.Ble
         {
         }        
 
-        private void BluetoothStateChangedEvent(BleWinHwInterface hwInterface, BleState state)
+        private void BluetoothStateChangedEvent(IBleWinHwInterface hwInterface, BleState state)
         {
             switch (state)
             {

Assets/Scripts/Devices/Ble/BleDeviceAdapter.cs

@@ -1,6 +1,7 @@
 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;
@@ -17,15 +18,16 @@ namespace Assets.Scripts.Devices.Ble
 
         private IDictionary<string, BleDevice> discoveredDevices = new Dictionary<string, BleDevice>();
 
-        private BleWinHwInterface hwInterface;
-        public BleDeviceAdapter()
+        private IBleWinHwInterface hwInterface { get; set; }
+        public BleDeviceAdapter(IBleWinHwInterface bleWinHwInterface)
         {
-            hwInterface = BleWinHwInterface.GetInterface();
+            
+            hwInterface = bleWinHwInterface;// BleWinHwInterface.GetInterface();
 
             hwInterface.BluetoothStateChangedEvent += HwInterface_BluetoothStateChangedEvent;
         }
 
-        private void HwInterface_BluetoothStateChangedEvent(BleWinHwInterface hwInterface, BleState bleState)
+        private void HwInterface_BluetoothStateChangedEvent(IBleWinHwInterface hwInterface, BleState bleState)
         {
             //Debug.Log("22222222222222" + bleState);
             if(bleState == BleState.Off)

Assets/Scripts/Devices/Ble/BluetoothStateChangedCallback.cs

@@ -1,4 +1,5 @@
-using System;
+using Assets.Scripts.Devices.Ble.Interfaces;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -6,6 +7,6 @@ using System.Threading.Tasks;
 
 namespace Assets.Scripts.Ble
 {
-    public delegate void BluetoothStateChangedCallback(BleWinHwInterface hwInterface, BleState bleState);
+    public delegate void BluetoothStateChangedCallback(IBleWinHwInterface hwInterface, BleState bleState);
 
 }

Assets/Scripts/Devices/Ble/CharacteristicReadCallback.cs

@@ -1,4 +1,5 @@
 using Assets.Scripts.Devices.Ble;
+using Assets.Scripts.Devices.Ble.Interfaces;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -7,5 +8,5 @@ using System.Threading.Tasks;
 
 namespace Assets.Scripts.Ble
 {
-    public delegate void CharacteristicReadCallback(BleWinHwInterface hwInterface, BleCharacteristicInfo characteristic, BleResponse<byte[]> response);
+    public delegate void CharacteristicReadCallback(IBleWinHwInterface hwInterface, BleCharacteristicInfo characteristic, BleResponse<byte[]> response);
 }

Assets/Scripts/Devices/Ble/CharacteristicsDiscoveredCallback.cs

@@ -1,4 +1,5 @@
 using Assets.Scripts.Devices.Ble;
+using Assets.Scripts.Devices.Ble.Interfaces;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -7,5 +8,5 @@ using System.Threading.Tasks;
 
 namespace Assets.Scripts.Ble
 {
-    public delegate void CharacteristicsDiscoveredCallback(BleWinHwInterface hwInterface, BleServiceInfo service, BleResponse<List<BleCharacteristicInfo>> response);
+    public delegate void CharacteristicsDiscoveredCallback(IBleWinHwInterface hwInterface, BleServiceInfo service, BleResponse<List<BleCharacteristicInfo>> response);
 }

Assets/Scripts/Devices/Ble/Devices/CyclingPower.cs

@@ -1,6 +1,7 @@
 using Assets.Scripts.Ble;
 using Assets.Scripts.Devices.Ant.Interfaces;
 using Assets.Scripts.Devices.Ble.Characteristic;
+using Assets.Scripts.Devices.Ble.Interfaces;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -14,7 +15,7 @@ namespace Assets.Scripts.Devices.Ble.Devices
     {
         private List<BleServiceInfo> Services;
         private CyclingPowerMeasurement cyclingPowerMeasurement;
-        public CyclingPower(BlePeripheralInfo peripheralInfo, BleWinHwInterface bleWinHwInterface) : base(peripheralInfo, bleWinHwInterface, Ant.SensorType.Power)
+        public CyclingPower(BlePeripheralInfo peripheralInfo, IBleWinHwInterface bleWinHwInterface) : base(peripheralInfo, bleWinHwInterface, Ant.SensorType.Power)
         {
             Priority = 2;
             cyclingPowerMeasurement = new CyclingPowerMeasurement(1920);
@@ -49,7 +50,7 @@ namespace Assets.Scripts.Devices.Ble.Devices
         }
 
 
-        private void CharacteristicReadMainCallback(BleWinHwInterface hwInterface, BleCharacteristicInfo characteristic, BleResponse<byte[]> response)
+        private void CharacteristicReadMainCallback(IBleWinHwInterface hwInterface, BleCharacteristicInfo characteristic, BleResponse<byte[]> response)
         {
             //Debug.Log("power main call" + string.Join(",", response.Data));
 

Assets/Scripts/Devices/Ble/Devices/Ftms.cs

@@ -1,6 +1,7 @@
 using Assets.Scripts.Ble;
 using Assets.Scripts.Devices.Ant.Interfaces;
 using Assets.Scripts.Devices.Ble.Characteristic;
+using Assets.Scripts.Devices.Ble.Interfaces;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -21,7 +22,7 @@ namespace Assets.Scripts.Devices.Ble.Devices
         private List<BleServiceInfo> Services;
         private BleCharacteristicInfo controlPointCharacteristic;
 
-        public Ftms(BlePeripheralInfo peripheralInfo, BleWinHwInterface bleWinHwInterface) :base(peripheralInfo, bleWinHwInterface, Ant.SensorType.Trainer)
+        public Ftms(BlePeripheralInfo peripheralInfo, IBleWinHwInterface bleWinHwInterface) :base(peripheralInfo, bleWinHwInterface, Ant.SensorType.Trainer)
         {
             this._ftmsIndoorBikeData = new FtmsIndoorBikeData();
             base.Characteristics.Add(this._ftmsIndoorBikeData);
@@ -60,7 +61,7 @@ namespace Assets.Scripts.Devices.Ble.Devices
             }
         }
 
-        private void CharacteristicReadMainCallback(BleWinHwInterface hwInterface, BleCharacteristicInfo characteristic, BleResponse<byte[]> response)
+        private void CharacteristicReadMainCallback(IBleWinHwInterface hwInterface, BleCharacteristicInfo characteristic, BleResponse<byte[]> response)
         {
             foreach (var item in base.Characteristics)
             {

Assets/Scripts/Devices/Ble/Devices/HeartRate.cs

@@ -1,6 +1,7 @@
 using Assets.Scripts.Ble;
 using Assets.Scripts.Devices.Ant.Interfaces;
 using Assets.Scripts.Devices.Ble.Characteristic;
+using Assets.Scripts.Devices.Ble.Interfaces;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -16,7 +17,7 @@ namespace Assets.Scripts.Devices.Ble.Devices
 
         private List<BleServiceInfo> Services;
         private HeartRateMeasurement heartRateMeasurement;
-        public HeartRate(BlePeripheralInfo peripheralInfo, BleWinHwInterface bleWinHwInterface) : base(peripheralInfo, bleWinHwInterface, Ant.SensorType.HeartRate)
+        public HeartRate(BlePeripheralInfo peripheralInfo, IBleWinHwInterface bleWinHwInterface) : base(peripheralInfo, bleWinHwInterface, Ant.SensorType.HeartRate)
         {
             Priority = 2;
             heartRateMeasurement = new HeartRateMeasurement();
@@ -73,7 +74,7 @@ namespace Assets.Scripts.Devices.Ble.Devices
             });
         }
 
-        private void CharacteristicReadMainCallback(BleWinHwInterface hwInterface, BleCharacteristicInfo characteristic, BleResponse<byte[]> response)
+        private void CharacteristicReadMainCallback(IBleWinHwInterface hwInterface, BleCharacteristicInfo characteristic, BleResponse<byte[]> response)
         {
             //Debug.Log("heart rate main call" + string.Join(",", response.Data));
 

Assets/Scripts/Devices/Ble/Devices/SpeedCadence.cs

@@ -1,6 +1,7 @@
 using Assets.Scripts.Ble;
 using Assets.Scripts.Devices.Ant.Interfaces;
 using Assets.Scripts.Devices.Ble.Characteristic;
+using Assets.Scripts.Devices.Ble.Interfaces;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -18,7 +19,7 @@ namespace Assets.Scripts.Devices.Ble.Devices
 
         private double _wheelCircumference;
         private List<BleServiceInfo> Services;
-        public SpeedCadence(BlePeripheralInfo peripheralInfo, BleWinHwInterface bleWinHwInterface) : base(peripheralInfo, bleWinHwInterface, Ant.SensorType.SpeedCadence)
+        public SpeedCadence(BlePeripheralInfo peripheralInfo, IBleWinHwInterface bleWinHwInterface) : base(peripheralInfo, bleWinHwInterface, Ant.SensorType.SpeedCadence)
         {
             Debug.Log("创建速度踏频设备");
             Priority = 1;
@@ -81,7 +82,7 @@ namespace Assets.Scripts.Devices.Ble.Devices
         }
 
 
-        private void CharacteristicReadMainCallback(BleWinHwInterface hwInterface, BleCharacteristicInfo characteristic, BleResponse<byte[]> response)
+        private void CharacteristicReadMainCallback(IBleWinHwInterface hwInterface, BleCharacteristicInfo characteristic, BleResponse<byte[]> response)
         {
             //Debug.Log("power main call" + string.Join(",", response.Data));
 

Assets/Scripts/Devices/Ble/Devices/Tacx.cs

@@ -2,6 +2,7 @@
 using Assets.Scripts.Devices.Ant;
 using Assets.Scripts.Devices.Ant.Interfaces;
 using Assets.Scripts.Devices.Ble.Characteristic;
+using Assets.Scripts.Devices.Ble.Interfaces;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -30,7 +31,7 @@ namespace Assets.Scripts.Devices.Ble.Devices
         /// </summary>
         private double _grade = 0;
 
-        public Tacx(BlePeripheralInfo peripheralInfo, BleWinHwInterface bleWinHwInterface) : base(peripheralInfo, bleWinHwInterface, Ant.SensorType.Trainer)
+        public Tacx(BlePeripheralInfo peripheralInfo, IBleWinHwInterface bleWinHwInterface) : base(peripheralInfo, bleWinHwInterface, Ant.SensorType.Trainer)
         {
             tacxFecNotify = new TacxFecNotify();
             base.Characteristics.Add(tacxFecNotify);
@@ -75,7 +76,7 @@ namespace Assets.Scripts.Devices.Ble.Devices
             }
         }
 
-        private void CharacteristicReadMainCallback(BleWinHwInterface hwInterface, BleCharacteristicInfo characteristic, BleResponse<byte[]> response)
+        private void CharacteristicReadMainCallback(IBleWinHwInterface hwInterface, BleCharacteristicInfo characteristic, BleResponse<byte[]> response)
         {
             foreach (var item in base.Characteristics)
             {

Assets/Scripts/Devices/Ble/HeartRate/HeartRateService.cs

@@ -2,6 +2,7 @@
 using Assets.Scripts.Ble.Service;
 using Assets.Scripts.Commands;
 using Assets.Scripts.Devices.Ble;
+using Assets.Scripts.Devices.Ble.Interfaces;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -36,12 +37,12 @@ namespace Assets.Scripts.Ble.HeartRate
             }
         }
 
-        private void HrmCharacteristicSubscribed(BleWinHwInterface winHwInterface, BleCharacteristicInfo characteristic, BleResponse response)
+        private void HrmCharacteristicSubscribed(IBleWinHwInterface winHwInterface, BleCharacteristicInfo characteristic, BleResponse response)
         {
 
         }
 
-        private void HrmCharacteristicRead(BleWinHwInterface winHwInterface, BleCharacteristicInfo characteristic, BleResponse<byte[]> response)
+        private void HrmCharacteristicRead(IBleWinHwInterface winHwInterface, BleCharacteristicInfo characteristic, BleResponse<byte[]> response)
         {
             HeartRateMeasurementValue heartRateMeasurementValue;
             if(base.CheckCharacteristicResponse<HeartRateMeasurementValue>(characteristic, response, (BleCharacteristicInfo info, BleResponse<byte[]> bleResponse) => new HeartRateMeasurementValue(bleResponse.Data), out heartRateMeasurementValue) != CommandResponseCode.Success)

Assets/Scripts/Devices/Ble/Interfaces/IBleWinHwInterface.cs

@@ -0,0 +1,28 @@
+using Assets.Scripts.Ble;
+using Assets.Scripts.Ble.Scan;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Assets.Scripts.Devices.Ble.Interfaces
+{
+    public interface IBleWinHwInterface
+    {
+        void StartScan(Action<BleAdvertisementInfo> discoveredCallBack);
+        void ConnectPeripheral(BlePeripheralInfo info, Action<IBleWinHwInterface, BlePeripheralInfo, BleResponse> callback);
+        void DisconnectPeripheral(BlePeripheralInfo peripheral, Action callback);
+        void DiscoverServices(BlePeripheralInfo peripheral, Action<IBleWinHwInterface, BlePeripheralInfo, BleResponse<List<BleServiceInfo>>> callback);
+        void DiscoverCharacteristic(BleServiceInfo service, CharacteristicsDiscoveredCallback callback);
+        void SubscribeCharacteristic(BleCharacteristicInfo characteristic, Action<IBleWinHwInterface, BleCharacteristicInfo, BleResponse> callback);
+        void WriteCharacteristic(BleCharacteristicInfo characteristic, byte[] data);
+        void ReadCharacteristic(BleCharacteristicInfo characteristic, CharacteristicReadCallback callback);
+        void Dispose();
+        BleState BleState { get; set; }
+        Dictionary<string, BleAdvertisementInfo> pCache { get; set; }
+        event BluetoothStateChangedCallback BluetoothStateChangedEvent;
+        event CharacteristicReadCallback CharacteristicReadEvent;
+        event PeripheralDisconnectedCallback PeripheralDisconnectedEvent;
+    }
+}

Assets/Scripts/Devices/Ble/Interfaces/IBleWinHwInterface.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 86216427171ac784296ca577b921b2e7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/Devices/Ble/PeripheralDisconnectedCallback.cs

@@ -1,4 +1,5 @@
 using Assets.Scripts.Ble;
+using Assets.Scripts.Devices.Ble.Interfaces;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -7,5 +8,5 @@ using System.Threading.Tasks;
 
 namespace Assets.Scripts.Devices.Ble
 {
-    public delegate void PeripheralDisconnectedCallback(BleWinHwInterface hwInterface, BlePeripheralInfo peripheral, BleResponse response, bool manualDisconnect);
+    public delegate void PeripheralDisconnectedCallback(IBleWinHwInterface hwInterface, BlePeripheralInfo peripheral, BleResponse response, bool manualDisconnect);
 }

Assets/Scripts/Devices/Ble/Service/BleService.cs

@@ -8,6 +8,7 @@ using Assets.Scripts.Ble.Commands;
 using Assets.Scripts.Commands;
 using Assets.Scripts.Devices.Ble;
 using Assets.Scripts.Devices.Ble.Extension;
+using Assets.Scripts.Devices.Ble.Interfaces;
 using UnityEngine;
 
 namespace Assets.Scripts.Ble.Service
@@ -18,7 +19,7 @@ namespace Assets.Scripts.Ble.Service
 		private BleServiceInfo serviceInfo;
 
 		private List<BleCharacteristicInfo> characteristics;
-		private readonly Dictionary<Guid, Action<BleWinHwInterface, BleCharacteristicInfo, BleResponse<byte[]>>> registeredCharacteristicReadEvents = new Dictionary<Guid, Action<BleWinHwInterface, BleCharacteristicInfo, BleResponse<byte[]>>>();
+		private readonly Dictionary<Guid, Action<IBleWinHwInterface, BleCharacteristicInfo, BleResponse<byte[]>>> registeredCharacteristicReadEvents = new Dictionary<Guid, Action<IBleWinHwInterface, BleCharacteristicInfo, BleResponse<byte[]>>>();
 
 		public IReadOnlyList<BleCharacteristicInfo> Characteristics
 		{
@@ -58,7 +59,7 @@ namespace Assets.Scripts.Ble.Service
 			this.hwInterface.CharacteristicReadEvent += CharacteristicReadMainCallback;
 		}
 
-		private void CharacteristicReadMainCallback(BleWinHwInterface hwInterface, BleCharacteristicInfo characteristic, BleResponse<byte[]> response)
+		private void CharacteristicReadMainCallback(IBleWinHwInterface hwInterface, BleCharacteristicInfo characteristic, BleResponse<byte[]> response)
 		{
 			//Debug.Log("read main callback");
 			if (this.registeredCharacteristicReadEvents.ContainsKey(characteristic.Id) && characteristic.Service.Equals(this.serviceInfo))
@@ -79,7 +80,7 @@ namespace Assets.Scripts.Ble.Service
 			this.CheckCharacteristicDiscoveredResponse(this.hwInterface, this.serviceInfo, scanCharacteristicsResponse);
 		}
 
-		private void CheckCharacteristicDiscoveredResponse(BleWinHwInterface hwInterface, BleServiceInfo service, BleResponse<List<BleCharacteristicInfo>> response)
+		private void CheckCharacteristicDiscoveredResponse(IBleWinHwInterface hwInterface, BleServiceInfo service, BleResponse<List<BleCharacteristicInfo>> response)
 		{
 			if (!service.Equals(this.serviceInfo))
 			{
@@ -98,8 +99,8 @@ namespace Assets.Scripts.Ble.Service
 
 		protected abstract void CharacteristicsDiscovered(BleResponse<List<BleCharacteristicInfo>> response);
 
-		protected void SubscribeCharacteristic(BleCharacteristicInfo characteristic, Action<BleWinHwInterface, BleCharacteristicInfo, BleResponse> notificationCallback,
-			Action<BleWinHwInterface, BleCharacteristicInfo, BleResponse<byte[]>> readCallback)
+		protected void SubscribeCharacteristic(BleCharacteristicInfo characteristic, Action<IBleWinHwInterface, BleCharacteristicInfo, BleResponse> notificationCallback,
+			Action<IBleWinHwInterface, BleCharacteristicInfo, BleResponse<byte[]>> readCallback)
 		{
 			this.hwInterface.SubscribeCharacteristic(characteristic, (hw, info, response) =>
 			{

Assets/Scripts/Devices/Ble/Win/BleWinHwInterface.cs

@@ -2,6 +2,7 @@
 using Assets.Scripts.Ble.Win;
 using Assets.Scripts.Devices.Ant;
 using Assets.Scripts.Devices.Ble;
+using Assets.Scripts.Devices.Ble.Interfaces;
 using Assets.Scripts.Devices.Ble.Win;
 using System;
 using System.Collections.Generic;
@@ -12,13 +13,24 @@ using UnityEngine;
 
 namespace Assets.Scripts.Ble
 {
-    public sealed class BleWinHwInterface
+    public sealed class BleWinHwInterface: IBleWinHwInterface
     {
         private static BleWinHwInterface hwInterface;
         private WclBleMainThread wclBleMainThread;
 
-        public readonly Dictionary<string, BleAdvertisementInfo> pCache = new Dictionary<string, BleAdvertisementInfo>();
-
+        private Dictionary<string, BleAdvertisementInfo> _pCache;
+        public Dictionary<string, BleAdvertisementInfo> pCache
+        {
+            get
+            {
+                if (_pCache == null)
+                {
+                    _pCache = new Dictionary<string, BleAdvertisementInfo>();
+                }
+                return _pCache;
+            }
+            set { _pCache = value; }
+        }
         private Action<BleAdvertisementInfo> _discoveredCallback;
 
         private Dictionary<BlePeripheralInfo, Action<BleWinHwInterface, BlePeripheralInfo, BleResponse>> callbacks = new Dictionary<BlePeripheralInfo, Action<BleWinHwInterface, BlePeripheralInfo, BleResponse>>();
@@ -43,6 +55,7 @@ namespace Assets.Scripts.Ble
             }
         }
 
+
         private BluetoothStateChangedCallback bluetoothStateChanged;
         public event BluetoothStateChangedCallback BluetoothStateChangedEvent
         {
@@ -55,7 +68,7 @@ namespace Assets.Scripts.Ble
                 this.bluetoothStateChanged -= value;
             }
         }
-
+       
         private BleState nativeState;
         public BleState BleState
         {
@@ -63,7 +76,7 @@ namespace Assets.Scripts.Ble
             {
                 return this.nativeState;
             }
-            private set
+            set
             {
                 if(this.nativeState != value)
                 {
@@ -201,7 +214,7 @@ namespace Assets.Scripts.Ble
             return wclBleGattThread;
         }
 
-        internal void ConnectPeripheral(BlePeripheralInfo info, Action<BleWinHwInterface, BlePeripheralInfo, BleResponse> callback)
+        public void ConnectPeripheral(BlePeripheralInfo info, Action<IBleWinHwInterface, BlePeripheralInfo, BleResponse> callback)
         {
             this.callbacks.Add(info, callback);
             WclBleGattThread wclBleGattThread = this.wclBleMainThread.GetGattThread(info);
@@ -229,8 +242,8 @@ namespace Assets.Scripts.Ble
                 
             //});
         }
-        
-        internal void DisconnectPeripheral(BlePeripheralInfo peripheral, Action callback)
+
+        public void DisconnectPeripheral(BlePeripheralInfo peripheral, Action callback)
         {
             var gattThread = this.wclBleMainThread.GetGattThread(peripheral);
             if(gattThread != null && gattThread.CanLoadWork)
@@ -372,7 +385,7 @@ namespace Assets.Scripts.Ble
             }
         }
 
-        public void DiscoverServices(BlePeripheralInfo peripheral, Action<BleWinHwInterface, BlePeripheralInfo, BleResponse<List<BleServiceInfo>>> callback)
+        public void DiscoverServices(BlePeripheralInfo peripheral, Action<IBleWinHwInterface, BlePeripheralInfo, BleResponse<List<BleServiceInfo>>> callback)
         {
             WclBleGattThread gattThread = this.wclBleMainThread.GetGattThread(peripheral);
             if(gattThread == null)
@@ -420,7 +433,7 @@ namespace Assets.Scripts.Ble
             this.GattCharacteristicsDiscovered(gattThread, service, response);
         }
 
-        public void SubscribeCharacteristic(BleCharacteristicInfo characteristic, Action<BleWinHwInterface, BleCharacteristicInfo, BleResponse> callback)
+        public void SubscribeCharacteristic(BleCharacteristicInfo characteristic, Action<IBleWinHwInterface, BleCharacteristicInfo, BleResponse> callback)
         {
             WclBleGattThread gattThread = this.wclBleMainThread.GetGattThread(characteristic.Peripheral);
 

Assets/Scripts/Devices/Ble/mobile.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9fa2f8906f5360c47b807eaef8d42263
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/Devices/Ble/mobile/BleMobileInterface.cs

@@ -0,0 +1,525 @@
+using Assets.Scripts.Ble.Scan;
+using Assets.Scripts.Ble.Win;
+using Assets.Scripts.Devices.Ant;
+using Assets.Scripts.Devices.Ble;
+using Assets.Scripts.Devices.Ble.Interfaces;
+using Assets.Scripts.Devices.Ble.Win;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using UnityEngine;
+
+namespace Assets.Scripts.Ble
+{
+    public sealed class BleMobileInterface: IBleWinHwInterface
+    {
+        private static BleMobileInterface hwInterface;
+        private WclBleMainThread wclBleMainThread;
+
+        private Dictionary<string, BleAdvertisementInfo> _pCache;
+        public Dictionary<string, BleAdvertisementInfo> pCache
+        {
+            get
+            {
+                if (_pCache == null)
+                {
+                    _pCache = new Dictionary<string, BleAdvertisementInfo>();
+                }
+                return _pCache;
+            }
+            set { _pCache = value; }
+        }
+        private Action<BleAdvertisementInfo> _discoveredCallback;
+
+        private Dictionary<BlePeripheralInfo, Action<IBleWinHwInterface, BlePeripheralInfo, BleResponse>> callbacks = new Dictionary<BlePeripheralInfo, Action<IBleWinHwInterface, BlePeripheralInfo, BleResponse>>();
+        private Dictionary<BlePeripheralInfo, Action<IBleWinHwInterface, BlePeripheralInfo, BleResponse<List<BleServiceInfo>>>> servicesCallbacks = new Dictionary<BlePeripheralInfo, Action<IBleWinHwInterface, BlePeripheralInfo, BleResponse<List<BleServiceInfo>>>>();
+        //private Dictionary<BlePeripheralInfo, Action<BleWinHwInterface, BleServiceInfo, BleResponse<List<BleCharacteristicInfo>>>> characteristicsCallbacks = new Dictionary<BlePeripheralInfo, Action<BleWinHwInterface, BleServiceInfo, BleResponse<List<BleCharacteristicInfo>>>>();
+        private Dictionary<BlePeripheralInfo, Action<IBleWinHwInterface, BleCharacteristicInfo, BleResponse>> characteristicNotificationCallbacks = new Dictionary<BlePeripheralInfo, Action<IBleWinHwInterface, BleCharacteristicInfo, BleResponse>>();
+        private Dictionary<BleCharacteristicInfo, CharacteristicReadCallback> characteristicReadCallbacks = new Dictionary<BleCharacteristicInfo, CharacteristicReadCallback>();
+        private Dictionary<BleServiceInfo, CharacteristicsDiscoveredCallback> characteristicsDiscoveredCallbacks = new Dictionary<BleServiceInfo, CharacteristicsDiscoveredCallback>();
+
+        private Dictionary<BlePeripheralInfo, Action> disconnectedCallback = new Dictionary<BlePeripheralInfo, Action>();
+
+        private CharacteristicReadCallback characteristicReadEvent;
+        public event CharacteristicReadCallback CharacteristicReadEvent
+        {
+            add
+            {
+                this.characteristicReadEvent += value;
+            }
+            remove
+            {
+                this.characteristicReadEvent -= value;
+            }
+        }
+
+
+        private BluetoothStateChangedCallback bluetoothStateChanged;
+        public event BluetoothStateChangedCallback BluetoothStateChangedEvent
+        {
+            add
+            {
+                this.bluetoothStateChanged += value;
+            }
+            remove
+            {
+                this.bluetoothStateChanged -= value;
+            }
+        }
+       
+        private BleState nativeState;
+        public BleState BleState
+        {
+            get
+            {
+                return this.nativeState;
+            }
+            set
+            {
+                if(this.nativeState != value)
+                {
+                    this.nativeState = value;
+                    this.bluetoothStateChanged?.Invoke(this, this.nativeState);
+                }
+            }
+        }
+
+        private PeripheralDisconnectedCallback peripheralDisconnectedEvent;
+        public event PeripheralDisconnectedCallback PeripheralDisconnectedEvent
+        {
+            add
+            {
+                this.peripheralDisconnectedEvent += value;
+            }
+            remove
+            {
+                this.peripheralDisconnectedEvent -= value;
+            }
+        }
+
+        private BleMobileInterface()
+        {
+            wclBleMainThread = new WclBleMainThread();            
+            wclBleMainThread.ManagerStatusChanged += ManagerStatusChanged;
+            wclBleMainThread.ScanInfoReceived += WatcherScanInfoReceived;
+            //wclBleMainThread.gatt
+            wclBleMainThread.Start();
+
+        }
+
+        private void WatcherScanInfoReceived(WclBleMainThread sender, long address, string name, int rssi, CPPBridge.WclBleAdvertisementType packetType, Guid? service)
+        {
+            //if(address != 224160707349234)
+            //{
+            //return;
+            //}
+            //Debug.Log($"address:{ address }, name:{ name }, service:{ (service == null ? "" : service.Value.ToString()) }");
+          
+            SensorType sensor = SensorType.None;
+            List<Guid> services = new List<Guid>();
+            if (service != null)
+            {                    
+                services = new List<Guid> { service.Value };
+                foreach(var item in ServiceUuids.Services)
+                {
+                    if(item.IdGuid != service.Value)
+                    {
+                        continue;
+                    }
+                    if(item.IdByteArray == ServiceUuids.Ftms)
+                    {
+                        sensor = SensorType.Trainer;
+                    }
+                    else if(item.IdByteArray == ServiceUuids.HeartRate)
+                    {
+                        sensor = SensorType.HeartRate;
+                    }
+                    else if(item.IdByteArray == ServiceUuids.CyclingPower)
+                    {
+                        sensor = SensorType.Power;
+                        //sensor = SensorType.Trainer;
+                    }
+                    else if(item.IdByteArray == ServiceUuids.CyclingSpeedCadence)
+                    {
+                        sensor = SensorType.SpeedCadence;
+                    }
+                    else if(item.IdByteArray == ServiceUuids.TacxBle)
+                    {
+                        sensor = SensorType.Trainer;
+                    }
+                }
+            };
+            var addressStr = address.ToString("X12");
+            if (!pCache.ContainsKey(addressStr))
+            {
+                var device = new BleAdvertisementInfo(new WinBlePeripheralInfo(addressStr, name), rssi, true, services, null, sensor);
+                pCache.Add(addressStr, device);
+
+                //WclBleGattThread gattClient = this.SetUpGattClient(device.Peripheral);
+                //this.ConnectInternal(gattClient);
+            }
+            if (!string.IsNullOrWhiteSpace(name))
+            {
+                (pCache[addressStr].Peripheral as WinBlePeripheralInfo).SetName(name);
+            }
+            if(sensor == SensorType.None)
+            {
+                return;
+            }
+            pCache[addressStr].SensorType = sensor;
+            pCache[addressStr].Rssi = rssi;
+            //Debug.Log(sensor);
+            //pCache[address.ToString()].SensorType = sensor;
+  
+                foreach (var item in services)
+                {
+                    pCache[addressStr].TryAddService(item);
+                }
+            
+            pCache[addressStr].Index++;
+            if(pCache[addressStr].SensorType == SensorType.Power && pCache[addressStr].Services.Any(s=> s.Equals(ServiceUuids.Get(ServiceUuids.TacxBle).IdGuid)))
+            {
+                pCache[addressStr].SensorType = SensorType.Trainer;
+                //Debug.Log("纠正为trainer, "+ pCache[address.ToString()].Index);
+            }
+            
+
+            if (pCache[addressStr].SensorType == SensorType.Power)
+            {
+                if (pCache[addressStr].Index > 4)
+                {
+                    _discoveredCallback?.Invoke(pCache[addressStr]);
+                }
+            }
+            else if(pCache[addressStr].SensorType != SensorType.None)
+            {
+                _discoveredCallback?.Invoke(pCache[addressStr]);
+            }
+        }
+
+        private WclBleGattThread SetUpGattClient(BlePeripheralInfo peripheral)
+        {
+            WclBleGattThread wclBleGattThread = this.wclBleMainThread.CreateGattThread(peripheral);
+            wclBleGattThread.GattConnected += this.GattConnected;
+            wclBleGattThread.GattDisconnected += this.GattDisconnected;
+            wclBleGattThread.GattServicesDiscovered += this.GattServicesDiscovered;
+            wclBleGattThread.GattCharacteristicsDiscovered += this.GattCharacteristicsDiscovered;
+            wclBleGattThread.GattCharacteristicSubscribed += this.GattCharacteristicSubscribed;
+            wclBleGattThread.GattCharacteristicRead += this.GattCharacteristicRead;
+            wclBleGattThread.GattCharacteristicWrote += this.GattCharacteristicWrote;
+            wclBleGattThread.GattCharacteristicChanged += this.GattCharacteristicChanged;
+            wclBleGattThread.Start();
+            return wclBleGattThread;
+        }
+
+        public void ConnectPeripheral(BlePeripheralInfo info, Action<IBleWinHwInterface, BlePeripheralInfo, BleResponse> callback)
+        {
+            this.callbacks.Add(info, callback);
+            WclBleGattThread wclBleGattThread = this.wclBleMainThread.GetGattThread(info);
+            
+            if(wclBleGattThread == null)
+            {
+                
+                wclBleGattThread = this.SetUpGattClient(info);
+                this.ConnectInternal(wclBleGattThread);
+                return;
+            }
+            else
+            {
+                this.ConnectInternal(wclBleGattThread);
+            }
+        }
+
+        private void ConnectInternal(WclBleGattThread gattClient)
+        {
+            //Task.Run(() =>
+            //{
+                int num = gattClient.Connect();
+                Debug.Log("连接设备返回" + num);
+
+                
+            //});
+        }
+
+        public void DisconnectPeripheral(BlePeripheralInfo peripheral, Action callback)
+        {
+            var gattThread = this.wclBleMainThread.GetGattThread(peripheral);
+            if(gattThread != null && gattThread.CanLoadWork)
+            {
+                this.callbacks.Remove(peripheral);
+                this.servicesCallbacks.Remove(peripheral);
+                this.characteristicNotificationCallbacks.Remove(peripheral);
+
+                this.disconnectedCallback.Add(peripheral, callback);
+                gattThread.Discounect();
+            }
+        }
+
+
+        public static BleMobileInterface GetInterface()
+        {
+            if(hwInterface == null)
+            {
+                hwInterface = new BleMobileInterface();
+            }
+
+            return hwInterface;
+        }
+
+        public void StartScan(Action<BleAdvertisementInfo> discoveredCallBack)
+        {
+            pCache.Clear();
+            _discoveredCallback = discoveredCallBack;
+            this.wclBleMainThread.StartWatcher();
+        }
+
+        private void ManagerStatusChanged(WclBleMainThread sender, WclBleManagerStatus status)
+        {
+            this.BleState = BleMobileInterface.StateFromNativeState(status);
+            //Debug.Log("win hw:" + status);
+
+        }
+
+        private void GattConnected(WclBleGattThread gattClient, BleResponse response)
+        {
+            Debug.Log($"gatt connected { response.ToString() }");
+            if (!response.IsSuccess)
+            {
+                gattClient.Stop();
+
+                this.callbacks[gattClient.Peripheral].Invoke(this, gattClient.Peripheral, response);
+                this.callbacks.Remove(gattClient.Peripheral);
+                return;
+            }
+            this.callbacks[gattClient.Peripheral].Invoke(this, gattClient.Peripheral, response);
+            this.callbacks.Remove(gattClient.Peripheral);
+        }
+
+        private void CleanUpPeripheral(BlePeripheralInfo peripheralInfo)
+        {
+            //this.callbacks.Clear()
+        }
+
+        private void GattDisconnected(WclBleGattThread gattClient, BleResponse response)
+        {
+            Debug.Log($"gatt disconnected { gattClient.Peripheral.Name }");
+            
+            this.callbacks.Remove(gattClient.Peripheral);
+            this.servicesCallbacks.Remove(gattClient.Peripheral);
+            this.characteristicNotificationCallbacks.Remove(gattClient.Peripheral);
+            //App.MainDeviceAdapter.PrintStatus();
+
+            var manualDisconnect = disconnectedCallback.ContainsKey(gattClient.Peripheral);
+            this.peripheralDisconnectedEvent(this, gattClient.Peripheral, response, manualDisconnect);
+
+            //App.MainDeviceAdapter.PrintStatus();
+            if (disconnectedCallback.ContainsKey(gattClient.Peripheral))
+            {
+                disconnectedCallback[gattClient.Peripheral].Invoke();
+                disconnectedCallback.Remove(gattClient.Peripheral);
+            }
+            //this.pCache.Remove(gattClient.Peripheral.Address);
+
+
+
+        }
+        private void GattServicesDiscovered(WclBleGattThread gattClient, BleResponse<List<BleServiceInfo>> response)
+        {
+            //Debug.Log("services discovered");
+            //this.callbacks[gattClient.Peripheral].Invoke(this, gattClient.Peripheral, response);
+
+            //foreach (var item in response.Data)
+            //{
+            //    Debug.Log(item.ToString());
+            //}
+
+            if (this.servicesCallbacks.ContainsKey(gattClient.Peripheral))
+            {
+                this.servicesCallbacks[gattClient.Peripheral].Invoke(this, gattClient.Peripheral, response);
+            }
+        }
+
+        private void GattCharacteristicsDiscovered(WclBleGattThread gattClient, BleServiceInfo service, BleResponse<List<BleCharacteristicInfo>> response)
+        {
+            //Debug.Log("characteristics discovered");
+
+            if (this.characteristicsDiscoveredCallbacks.ContainsKey(service))
+            {
+                this.characteristicsDiscoveredCallbacks[service].Invoke(this, service, response);
+            }
+        }
+
+        private void GattCharacteristicSubscribed(WclBleGattThread gattClient, BleCharacteristicInfo characteristic, BleResponse response)
+        {
+            //Debug.Log("characteristics subscribed");
+            if (this.characteristicNotificationCallbacks.ContainsKey(gattClient.Peripheral))
+            {
+                this.characteristicNotificationCallbacks[gattClient.Peripheral].Invoke(this, characteristic, response);
+            }
+        }
+        private void GattCharacteristicRead(WclBleGattThread gattClient, BleCharacteristicInfo characteristic, BleResponse<byte[]> response)
+        {
+            Debug.Log("characteristic read");
+
+            if (this.characteristicReadCallbacks.ContainsKey(characteristic))
+            {
+                this.characteristicReadCallbacks[characteristic].Invoke(this, characteristic, response);
+                this.characteristicReadCallbacks.Remove(characteristic);
+            }
+
+            this.characteristicReadEvent.Invoke(this, characteristic, response);
+        }
+
+        private void GattCharacteristicWrote(WclBleGattThread gattClient, BleCharacteristicInfo characteristic, BleResponse<BleCharacteristicWriteType> response)
+        {
+            Debug.Log("characteristic wrote");
+        }
+        private void GattCharacteristicChanged(WclBleGattThread gattClient, BleCharacteristicInfo characteristic, BleResponse<byte[]> response)
+        {
+            //Debug.Log("characteristic changed");
+            if(this.wclBleMainThread.GetGattThread(characteristic.Peripheral) != null)
+            {
+                this.characteristicReadEvent.Invoke(this, characteristic, response);
+            }
+        }
+
+        public void DiscoverServices(BlePeripheralInfo peripheral, Action<IBleWinHwInterface, BlePeripheralInfo, BleResponse<List<BleServiceInfo>>> callback)
+        {
+            WclBleGattThread gattThread = this.wclBleMainThread.GetGattThread(peripheral);
+            if(gattThread == null)
+            {
+                return;
+            }
+
+            this.servicesCallbacks.Add(peripheral, callback);
+            int num = gattThread.DiscoverServices();
+            if (WclBleErrors.IsSuccessCode(num))
+            {
+                return;
+            }
+
+            
+            BleResponse<List<BleServiceInfo>> response = new BleResponse<List<BleServiceInfo>>
+            {
+                IsSuccess = false,
+                Error = new BleHwInterfaceError(new int?(num), "WclBleGattClientErrorDomain", string.Format("Error discovering services - {0}", num))
+            };
+            this.GattServicesDiscovered(gattThread, response);
+        }
+
+        public void DiscoverCharacteristic(BleServiceInfo service, CharacteristicsDiscoveredCallback callback)
+        {
+            WclBleGattThread gattThread = this.wclBleMainThread.GetGattThread(service.Peripheral);
+            if(gattThread == null)
+            {
+                return;
+            }
+            if (!this.characteristicsDiscoveredCallbacks.ContainsKey(service))
+            {
+                this.characteristicsDiscoveredCallbacks.Add(service, callback);
+            }
+            int num = gattThread.DiscoverCharacteristics(service);
+            if (WclBleErrors.IsSuccessCode(num))
+            {
+                return;
+            }
+            BleResponse<List<BleCharacteristicInfo>> response = new BleResponse<List<BleCharacteristicInfo>>
+            {
+                IsSuccess = false,
+                Error = new BleHwInterfaceError(new int?(num), "WclBleGattClientErrorDomain", string.Format("Error discovering characteristics - {0}", num))
+            };
+            this.GattCharacteristicsDiscovered(gattThread, service, response);
+        }
+
+        public void SubscribeCharacteristic(BleCharacteristicInfo characteristic, Action<IBleWinHwInterface, BleCharacteristicInfo, BleResponse> callback)
+        {
+            WclBleGattThread gattThread = this.wclBleMainThread.GetGattThread(characteristic.Peripheral);
+
+            this.characteristicNotificationCallbacks.Add(gattThread.Peripheral, callback);
+            int num = gattThread.SubscribeCharacteristic(characteristic);
+            if (WclBleErrors.IsSuccessCode(num))
+            {
+                return;
+            }
+            BleResponse<List<BleServiceInfo>> response = new BleResponse<List<BleServiceInfo>>
+            {
+                IsSuccess = false,
+                Error = new BleHwInterfaceError(new int?(num), "WclBleGattClientErrorDomain", string.Format("Error subscribing characteristic - {0}", num))
+            };
+            this.GattCharacteristicSubscribed(gattThread, characteristic, response);
+        }
+
+        public void WriteCharacteristic(BleCharacteristicInfo characteristic, byte[] data)
+        {
+            var gattThread = this.wclBleMainThread.GetGattThread(characteristic.Peripheral);
+            if(gattThread == null)
+            {
+                return;
+            }
+
+            int num = gattThread.WriteCharacteristic(characteristic, data);
+            if (WclBleErrors.IsSuccessCode(num))
+            {
+                Debug.Log("设置命令成功");
+                return;
+            }
+        }
+
+
+        public void Dispose()
+        {
+            this.wclBleMainThread.ManagerStatusChanged -= ManagerStatusChanged;
+            this.wclBleMainThread.ScanInfoReceived -= WatcherScanInfoReceived;
+            this.wclBleMainThread.Stop();
+            this.wclBleMainThread = null;
+            hwInterface = null;
+            pCache.Clear();
+        }
+
+        public void ReadCharacteristic(BleCharacteristicInfo characteristic, CharacteristicReadCallback callback)
+        {
+            WclBleGattThread gattThread = this.wclBleMainThread.GetGattThread(characteristic.Peripheral);
+            if(gattThread == null)
+            {
+                return;
+            }
+            this.characteristicReadCallbacks.Add(characteristic, callback);
+            int num = gattThread.ReadCharacteristicValue(characteristic);
+            if (WclBleErrors.IsSuccessCode(num))
+            {
+                return;
+            }
+        }
+
+        private static BleState StateFromNativeState(WclBleManagerStatus status)
+        {
+            switch (status)
+            {
+                case WclBleManagerStatus.RadioOff:
+                    return BleState.Off;
+                case WclBleManagerStatus.RadioOn:
+                    return BleState.On;
+                case WclBleManagerStatus.Unknown:
+                    return BleState.Unknown;
+                default:
+                    return BleState.Unavailable;
+            }
+        }
+
+        private class WinBlePeripheralInfo : BlePeripheralInfo
+        {
+            // Token: 0x06003F35 RID: 16181 RVA: 0x000E9FBF File Offset: 0x000E81BF
+            public WinBlePeripheralInfo(string address, string name) : base(address, name)
+            {
+            }
+
+            // Token: 0x06003F36 RID: 16182 RVA: 0x000E9FC9 File Offset: 0x000E81C9
+            public void SetName(string name)
+            {
+                base.Name = name;
+            }
+        }
+    }
+}

Assets/Scripts/Devices/Ble/mobile/BleMobileInterface.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2e5257ea169e69a498a3e4d935a51306
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/Devices/MainDeviceAdapter.cs

@@ -1,4 +1,5 @@
-using Assets.Scripts.Devices.Ant;
+using Assets.Scripts.Ble;
+using Assets.Scripts.Devices.Ant;
 using Assets.Scripts.Devices.Ble;
 using System;
 using System.Collections.Generic;
@@ -27,7 +28,11 @@ namespace Assets.Scripts.Devices
 
         private void CreateBleAdapter()
         {
-            adapters.Add(new BleDeviceAdapter());
+#if UNITY_IOS || UNITY_TVOS || UNITY_ANDROID
+            adapters.Add(new BleDeviceAdapter(BleWinHwInterface.GetInterface()));
+#else
+            adapters.Add(new BleDeviceAdapter(BleWinHwInterface.GetInterface()));
+#endif
         }
 
         public void StartScan()

Assets/Scripts/Scenes/Ride/Competiton/CompetitionLoadingController.cs

@@ -115,6 +115,7 @@ namespace Assets.Scenes.Ride.Scripts
         GameObject MoreHead { get; set; }
         Text CompetitionTitle { get; set; }
         Text EndTime { get; set; }
+        Text MapId { get; set; }
         //构建赛事界面
         protected override void InitGameObject()
         {
@@ -135,6 +136,7 @@ namespace Assets.Scenes.Ride.Scripts
             ReadMore = panel.transform.Find("ReadMore").gameObject;
             GetReady = panel.transform.Find("GetReady").GetComponent<Text>();
             GetReadyTitle = panel.transform.Find("GetReadyTitle").GetComponent<Text>();
+            MapId = panel.transform.Find("MapId").GetComponent<Text>();
             Watcher = Resources.Load<GameObject>("UI/Prefab/Match/Watcher");
             MoreHead = Resources.Load<GameObject>("UI/Prefab/Match/MoreHead");
             Watch.GetComponent<Button>().enabled = false;
@@ -183,6 +185,8 @@ namespace Assets.Scenes.Ride.Scripts
             ShowPlayers(competition.UserList);
             //路书描述
             mapDescText.text = competition.Dec;
+            //线路编号
+            MapId.text = route.Id.ToString();
 
             ReadMore.SetActive(!string.IsNullOrEmpty(competition.CompetitionPreviewUrl));
             //主办方logo

Assets/Scripts/Scenes/Ride/Scripts/LoadingController.cs

@@ -20,6 +20,7 @@ namespace Assets.Scenes.Ride.Scripts
 		protected RawImage mapCountry;
 		protected RawImage altitudeGraph;
 		protected Transform mapRanking;
+		protected Text mapId;
 		#endregion
 
 		public override void InjectController(CyclingController controller)
@@ -54,6 +55,7 @@ namespace Assets.Scenes.Ride.Scripts
 			head = panel.transform.Find("UploadByHead").GetComponent<RawImage>();
 			altitudeGraph = panel.transform.Find("AltitudeGraph").GetComponent<RawImage>();
 			mapRanking = panel.transform.Find("MapRanking");
+			mapId = panel.transform.Find("MapId").GetComponent<Text>();
 		}
 		protected override void InitGameObjectData()
 		{
@@ -67,6 +69,7 @@ namespace Assets.Scenes.Ride.Scripts
 			rideNum.text = route.TheHeat.ToString();
 			distance.text = route.Distance.ToString("f1") + "KM";
 			mapDescText.text = route.Dec;
+			mapId.text = route.Id.ToString();
 			var userList = ConfigHelper.mapApi.GetOnlineUserInfo(new int[] { route.UserId }).data;
 			if (userList.Count > 0)
 			{

Assets/Scripts/Scenes/Ride/Scripts/NearByFactory.cs

@@ -29,8 +29,21 @@ namespace Assets.Scenes.Ride.Scripts
         protected override void CreateList()
         {
             OnlineUserNum.text =  MapUDPService.GetNearRiderCount().ToString();
+            LayoutRebuilder.ForceRebuildLayoutImmediate(OnlineUserNum.rectTransform);
             var nearList = MapUDPService.GetNearRiderData(pageIndex, pageSize, new double[] { playerController.Currentlatlong.x, playerController.Currentlatlong.y });
             totalPages = MapUDPService.GetNearRiderCount();
+            //删除
+            var currentNearList = FindObjectsOfType<NearByItemScript>();
+            foreach (var item in currentNearList)
+            {
+                var e = nearList.Where(c => c.Id == item.UserId).FirstOrDefault();
+                if (e == null)
+                {
+                    item.transform.gameObject.SetActive(false);
+                    bufferSize--;
+                }
+            }
+
             for (int i = 0; i < nearList.Count(); i++)
             {
                 Create(nearList[i]);

Assets/Scripts/UI/Prefab/MapList/MapFilterOptions.cs

@@ -40,7 +40,7 @@ namespace Assets.Scripts.UI.Prefab.MapList
             {"HC","750-99999" },
         };
         public static List<Dropdown.OptionData> sorts = new string[] {
-            "Trend","Name","Distance","Difficulty"//,"Times"
+           "Near", "Trend","Name","Distance","Difficulty","Time"
         }.Select(x => new Dropdown.OptionData(x)).ToList();
         public static Dictionary<string, string> diffDisplayDict = new Dictionary<string, string>()
         {

Assets/Scripts/UI/Prefab/Panel/MapListController.cs

@@ -43,6 +43,8 @@ public class MapListController : PFUIPanel
     private bool isEnd = false;
     protected override void Start()
     {
+        sort = "Near";
+        sortDire = "asc";
         //if (hardSelector != null) 
         //{
         //    hardSelector.onValueChanged.AddListener(ChangeHard);
@@ -179,8 +181,17 @@ public class MapListController : PFUIPanel
                     sort = "Hot";
                 }
                 var image = sortDir.Find("Image").GetComponent<Image>();
-                image.sprite = Resources.Load<Sprite>("Images/DOWN");
-                sortDire = "desc";
+                if (sort == "Near")
+                {
+                    image.sprite = Resources.Load<Sprite>("Images/UP");
+                    sortDire = "asc";
+                }
+                else 
+                {
+                    image.sprite = Resources.Load<Sprite>("Images/DOWN");
+                    sortDire = "desc";
+                }
+                
                 Refresh();
             });
         }
@@ -265,7 +276,7 @@ public class MapListController : PFUIPanel
     string distance = "";
     List<string> hands = new List<string>();
     bool is3d = false,isFav = false;
-    string sort = "Hot",sortDire = "desc";
+    string sort = "",sortDire = "";
     //string name = "";
     //string name = "";
     async void GetList() 

Assets/Scripts/Utils/Utils.cs

@@ -111,7 +111,7 @@ namespace Assets.Scripts
                         {"Power","Power Meter|Images/Devices/Power_3" },
                         {"Cadence","Cadence Sensor|Images/Devices/Cadence_3" },
                         {"HeartRate","Heart Rate Monitor|Images/Devices/Heart Rate_3" },
-                        {"SpeedCadence","Speed Meter|Images/Devices/Speed_3" },
+                        {"SpeedCadence","Cadence Sensor|Images/Devices/Cadence_3" },
                         {"Speed","Speed Meter|Images/Devices/Speed_3" }
                     };
                 }