APP/utils/BleHelper.js

import receivTool from "@/utils/BleReceive.js"
var recei = null;
const serviceDic = [ //合作供应商的蓝牙主服务
	{
		"serviceId": "0000FFE0-0000-1000-8000-00805F9B34FB",
		"writeId": "0000FFE1-0000-1000-8000-00805F9B34FB",
		"notifyId": "0000FFE2-0000-1000-8000-00805F9B34FB"
	},
	{
		"serviceId": "0000FFF0-0000-1000-8000-00805F9B34FB",
		"writeId": "0000FFF2-0000-1000-8000-00805F9B34FB",
		"notifyId": "0000FFF1-0000-1000-8000-00805F9B34FB"
	},
	{
		"serviceId": "0000AE30-0000-1000-8000-00805F9B34FB",
		"writeId": "0000AE03-0000-1000-8000-00805F9B34FB",
		"notifyId": "0000AE02-0000-1000-8000-00805F9B34FB"
	}

];

class BleHelper {
	constructor() {
		this.StorageKey = "linkedDevices";

		recei = receivTool.getBleReceive();

		this.init();
	}
	init() {

		var store = uni.getStorageInfoSync();
		var f = store.keys.includes(this.StorageKey);
		var linkedDevices = [];
		if (f) {
			linkedDevices = uni.getStorageSync(this.StorageKey);
		}
		if (linkedDevices && linkedDevices.length && linkedDevices.length > 0) {
			// console.log("111111", linkedDevices);
			linkedDevices = linkedDevices.filter((v) => {
				if (v) {
					v.Linked = false;
					v.notifyState = false;
				}
				return v ? true : false;
			});
		}


		const systemInfo = uni.getSystemInfoSync();



		setTimeout(() => {
			this.OpenBlue().then(() => {
				this.linkAllDevices();
			});

		}, 10);
		this.data = {
			isOpenBlue: false, //蓝牙模块是否开启
			available: false, //蓝牙状态是否可用
			discovering: false, //蓝牙是否正在搜索
			searchList: [], //已搜索到的设备列表,
			isSubscribe: false, //是否开启了订阅
			LinkedList: linkedDevices, //已连接的设备列表 
			platform: systemInfo.uniPlatform
		}
		this.cfg = {
			onDeviceFound: [], //发现新设备的事件
			receivDataCallback: [], //接收到数据的事件
			bleDisposeCallback: [], //蓝牙断开连接的事件
			recoveryCallback: [], //蓝牙连接恢复的事件
			stateRecoveryCallback: [], //蓝牙适配器恢复可用事件
			stateBreakCallback: [] //蓝牙适配器不可用事件
		}
		// this.addReceiveCallback((a, b, c) => {
		// 	recei.ReceiveData(a, b, c);
		// }, "BleReceiveData");
		this.dic = {
			errRemarks: [{
					key: '10000',
					remark: '未初始化蓝牙适配器'
				},
				{
					key: '10001',
					remark: '当前蓝牙适配器不可用'
				},
				{
					key: '10002',
					remark: '没有找到指定设备'
				},
				{
					key: '10003',
					remark: '蓝牙设备连接失败'
				},
				{
					key: '10004',
					remark: '蓝牙设备没有找到指定服务'
				},
				{
					key: '10005',
					remark: '蓝牙设备没有找到指定特征值'
				},
				{
					key: '10006',
					remark: '蓝牙连接已断开'
				},
				{
					key: '10007',
					remark: '蓝牙设备当前特征值不支持此操作'
				},
				{
					key: '10008',
					remark: '其余所有系统上报的异常'
				},
				{
					key: '10009',
					remark: '蓝牙设备不支持BLE低功耗蓝牙'
				},
				{
					key: '10010',
					remark: '已连接'
				},
				{
					key: '10011',
					remark: '蓝牙设备配对设备需要配对码'
				},
				{
					key: '10012',
					remark: '蓝牙设备连接超时'
				},
				{
					key: '10013',
					remark: '连接 deviceId 为空或者是格式不正确'
				}
			]
		}
	}
	//从缓存中删除某个设备，bleId蓝牙id，deviceId数据库中的设备id
	DropDevice(bleId, deviceId) {

		let flag = false;
		for (var i = 0; i < this.data.LinkedList.length; i++) {
			let item = this.data.LinkedList[i];
			if (deviceId && item.device) {
				if (item.device.id == deviceId) {
					console.log("找到要删除的设备", item);
					this.data.LinkedList.splice(i, 1);
					this.disconnectDevice(item.deviceId);
					flag = true;
					break;
				}

			} else {
				if (bleId && item.deviceId == bleId) {
					console.log("找到要删除的设备1,", item)
					this.data.LinkedList.splice(i, 1);
					this.disconnectDevice(item.deviceId);
					flag = true;
					break;
				}
			}
		}
		if (flag) {
			this.updateCache();
		}

	}

	//更新缓存
	updateCache() {

		uni.setStorageSync(this.StorageKey, this.data.LinkedList);

	}
	//连接所有已连接过的设备
	linkAllDevices() {
		// console.log("模块启动时，自动连接已连接过的设备", this.data.LinkedList);
		if (this.data.platform == 'web') {
			return;
		}
		if (this.data.LinkedList && this.data.LinkedList.length > 0) {
			let flag = false;
			for (var i = 0; i < this.data.LinkedList.length; i++) {
				let device = this.data.LinkedList[i];
				// console.log("自动连接绑定过的设备:" + device.deviceId);
				if (device.macAddress && device.device && device.device.id) {
					this.LinkBlue(device.deviceId, device.writeServiceId, device.wirteCharactId, device
						.notifyCharactId);
					flag = true;
				}

			}
			if (!flag) {
				this.updateCache();
			}
		} else {
			// console.log("蓝牙未连接过任何设备");
			this.updateCache();
		}
	}
	//获取当前页面栈
	getCurrentPagePath() {

		const pages = getCurrentPages();

		if (pages.length === 0) {
			return "";
		}

		const currentPage = pages[pages.length - 1];
		// console.log("currentPage=", currentPage.route);
		return currentPage.route;
	}
	//添加事件回调
	addCallback(callback, currKey, type) {
		if (!type) {
			return;
		}
		let key = currKey ? currKey : this.getCurrentPagePath();
		if (!key) {
			key = new Date().getTime();
		}
		if (key) {
			// console.log("key=" + key);
			let f = this.cfg[type].findIndex((v) => {
				return v.key == key;
			});
			if (f > -1) {
				this.cfg[type][f].callback = callback;
				return;
			}
			this.cfg[type].push({
				key: key,
				callback: callback
			});
		}
	}
	//移除事件回调
	removeCallback(currKey, type) {
		if (!type) {
			return;
		}
		let key = currKey ? currKey : this.getCurrentPagePath();

		if (key) {
			// console.log("key=" + key);
			let f = this.cfg[type].findIndex((v) => {
				return v.key == key;
			});
			if (f > -1) {
				this.cfg[type].splice(f, 1);
			}
		} else {
			if (this.cfg[type].length > 0) {
				this.cfg[type].splice(this.cfg[type].length - 1, 1);
			}

		}
	}





	//设置蓝牙恢复连接的回调
	addRecoveryCallback(callback, currKey) {
		this.addCallback(callback, currKey, 'recoveryCallback');
	}

	//移除蓝牙恢复连接的回调
	removeRecoveryCallback(currKey) {
		this.removeCallback(currKey, 'recoveryCallback');
	}

	//设置蓝牙断开连接的回调
	addDisposeCallback(callback, currKey) {
		this.addCallback(callback, currKey, 'bleDisposeCallback');
	}

	//移除蓝牙断开连接的回调
	removeDisposeCallback(currKey) {
		this.removeCallback(currKey, 'bleDisposeCallback');
	}


	//设置发现新设备的回调
	addDeviceFound(callback, currKey) {
		this.addCallback(callback, currKey, 'onDeviceFound');
	}

	//移除发现新设备的回调
	removeDeviceFound(currKey) {
		this.removeCallback(currKey, 'onDeviceFound');
	}

	//添加接收到数据的回调
	addReceiveCallback(callback, currKey) {
		this.addCallback(callback, currKey, 'receivDataCallback');
	}

	//移除接收到数据的回调
	removeReceiveCallback(currKey) {
		this.removeCallback(currKey, 'receivDataCallback');
	}

	//添加蓝牙不可用的回调
	addStateBreakCallback(callback, currKey) {
		this.addCallback(callback, currKey, 'stateBreakCallback');
	}

	//移除蓝牙不可用的回调
	removeStateBreakCallback(currKey) {
		this.removeCallback(currKey, 'stateBreakCallback');
	}


	//设置蓝牙适配器恢复可用的回调
	addStateRecoveryCallback(callback, currKey) {
		this.addCallback(callback, currKey, 'stateRecoveryCallback');
	}

	//移除蓝牙适配器恢复的回调
	removeStateRecoveryCallback(currKey) {
		this.removeCallback(currKey, 'stateRecoveryCallback');
	}

	//清除所有事件回调
	removeAllCallback(currKey) {
		this.removeDeviceFound(currKey)
		this.removeDisposeCallback(currKey);
		this.removeReceiveCallback(currKey);
		this.removeRecoveryCallback(currKey);
		this.removeStateRecoveryCallback(currKey);
		this.removeStateBreakCallback(currKey);
	}


	getError(ex) {
		let code = ex.code;
		ex.msg = "未知的异常"
		let f = this.dic.errRemarks.find((v) => {
			return v.key == code;
		});
		if (f) {
			ex.msg = f.remark;
		}
		return ex;
	}
	//引导到设置中打开蓝牙
	showBlueSetting(showTip) {
		let platform = process.env.UNI_PLATFORM;


		var openBlueSetting = function() {
			// 判断平台类型
			if (platform === 'mp-weixin') {
				uni.openSetting();
			} else if (platform === 'app-plus' || platform === 'app') {
				//----------------------------------------------------------------
				const osName = plus.os.name;

				if (osName === 'iOS') {
					// iOS 平台打开蓝牙设置
					plus.runtime.openURL('App-Prefs:root=Bluetooth', function() {
						////console.log('成功打开蓝牙设置');
					}, function(err) {
						console.error('打开蓝牙设置失败：' + err.message);
						uni.showModal({
							title: '提示',
							content: '无法自动打开蓝牙设置，请手动前往设置 > 蓝牙 进行操作。',
							showCancel: false
						});
					});
				} else if (osName === 'Android') {
					// Android 平台打开蓝牙设置
					try {
						const Intent = plus.android.importClass('android.content.Intent');
						const Settings = plus.android.importClass('android.provider.Settings');
						const main = plus.android.runtimeMainActivity();
						const intent = new Intent(Settings.ACTION_BLUETOOTH_SETTINGS);
						main.startActivity(intent);
					} catch (e) {
						console.error('打开蓝牙设置失败：' + e.message);
						// 尝试使用通用设置页面作为备选方案
						plus.runtime.openURL('settings://', function() {
							////console.log('打开系统设置成功，请手动找到蓝牙选项');
						}, function() {
							uni.showModal({
								title: '提示',
								content: '无法自动打开蓝牙设置，请手动前往设置页面开启蓝牙。',
								showCancel: false
							});
						});
					}
				} else {
					uni.showModal({
						title: '提示',
						content: '当前系统不支持自动打开蓝牙设置，请手动操作。',
						showCancel: false
					});
				}


				//--------------------------------------------------------------------
			} else if (platform === 'mp-alipay') {
				uni.openSetting();
			}

		}

		if (showTip !== undefined) {
			openBlueSetting();
			return;
		}
		if (platform === 'mp-weixin' || platform === 'app-plus' ||
			platform === 'mp-alipay' || platform === 'app') {
			uni.showModal({
				title: '蓝牙未开启',
				content: '请在系统设置中打开蓝牙以使用此功能',
				success: (res) => {
					if (res.confirm) {
						openBlueSetting();
					}
				}
			});
		} else {
			////console.log("当前平台不支持打开系统设置" + platform);
		}


	}

	//获取蓝牙适配器状态
	CheckBlue() {
		if (this.data.platform == 'web') {
			return Promise.resolve({
				available: true,
				discovering: false
			});
		}
		return new Promise((resolve, reject) => {
			if (this.data.available) {
				// console.log("蓝牙模块是可用状态");
				resolve({
					available: this.data.available,
					discovering: this.data.discovering
				});
				return;
			}
			if (!this.data.isOpenBlue) {
				console.error("蓝牙模块未打开");
				resolve({
					available: false,
					discovering: false
				});
				return;
			}
			uni.getBluetoothAdapterState({
				success: (info) => {
					// console.log("蓝牙状态获取成功,", info)
					this.data.available = info.available;
					this.data.discovering = info.discovering;
					resolve(info);
				},
				fail: (ex1) => {
					console.error("蓝牙状态获取失败", ex1);
					let res1 = {
						available: false,
						discovering: false
					}
					resolve(res1);
				}
			});
		});
	}
	//打开蓝牙适配器
	OpenBlue() {

		if (this.data.platform == 'web') {
			this.data.isOpenBlue = true;
			this.data.available = true;
			this.data.isSubscribe = true;
			return Promise.resolve(true);
		}
		var init = () => {
			return new Promise((resolve, reject) => {
				if (this.data.isOpenBlue) {
					// console.log("蓝牙状态已可用，提前返回");
					resolve(false);
					return;
				}

				uni.openBluetoothAdapter({
					success: (args) => {
						// console.log("蓝牙初始化成功:" + JSON.stringify(args));
						this.data.isOpenBlue = true;
						this.data.available = true;
						resolve(true);

						if (this.data.isSubscribe) { //整个App生命周期，只订阅一次
							return;
						}
						console.log("开始订阅各类变化消息");
						this.data.isSubscribe = true;

						// 保存每个设备的连接状态
						let bleDeviceStates = {};


						var bytesToHexString = (bytes) => {
							return bytes.map(byte => byte.toString(16).padStart(2,
								'0'));
						}

						uni.onBluetoothAdapterStateChange((state) => {
							 console.log('蓝牙状态发生变化:' + JSON.stringify(state));
							this.data.discovering = state.discovering;
							
							if (this.data.available !== state.available) {
								this.data.available = state.available;
								
								if (this.data.available && this.data
									.isOpenBlue) { //蓝牙状态再次可用，重连所有设备

									if (this.cfg.stateRecoveryCallback.length > 0) {
										this.cfg.stateRecoveryCallback.forEach(
											c => {
												try {
													c.callback();
												} catch (error) {
													console.error(
														"蓝牙适配器已恢复,但回调函数发生错误",
														error);
												}
											})
									}

								}
							}


							if (!state.available) { //蓝牙状态不可用了，将所有设备标记为断开连接

								this.data.LinkedList.filter((v) => {
									v.Linked = false;
									v.notifyState = false;
									return true;
								});
								let keys = Object.keys(bleDeviceStates)
								keys.filter(v => {
									bleDeviceStates[v] = false;
								});

								this.cfg.stateBreakCallback.forEach(f => {
									try {
										f.callback();
									} catch (error) {
										console.error("蓝牙状态不可用了,执行回调异常",
											error)
									}

								})

								this.updateCache();
							}
						});



						uni.onBLEConnectionStateChange((res) => {
							console.log("蓝牙连接状态变化了", res);
							// 检查状态是否真的发生了变化
							if (bleDeviceStates[res.deviceId] === res.connected) {
								console.error('专业给Uniapp填坑,连接状态重复回调');
								return;
							}

							// 更新状态记录
							bleDeviceStates[res.deviceId] = res.connected;

							setTimeout(() => {
								if (!res.connected) {
									console.error("蓝牙已断开", res);
									let f = this.data.LinkedList.find((
										v) => {
										if (v.deviceId == res
											.deviceId) {
											v.Linked = false;
											v.notifyState = false;
											return true;
										}
										return false;
									});
									this.updateCache();
									if (f && f.device && f.device.id) {
										console.log("尝试5次恢复连接,", f
											.deviceId);
										this.LinkBlue(res.deviceId, f
											.writeServiceId, f
											.wirteCharactId, f
											.notifyCharactId, 5);
									}

									if (this.cfg.bleDisposeCallback.length >
										0) {
										this.cfg.bleDisposeCallback.forEach(
											(c) => {
												try {
													c.callback(res);
												} catch (error) {
													console.error(
														"执行蓝牙断开连接的回调出现异常,",
														error)
												}
											});
									}

								} else {
									console.log("蓝牙连接已恢复，", res);
									if (this.cfg.recoveryCallback.length >
										0) {
										this.cfg.recoveryCallback.forEach((
											c) => {
											try {
												c.callback(res);
											} catch (error) {
												console.error(
													"执行蓝牙恢复连接的回调出现异常,",
													error)
											}
										});
									}
								}

							}, 0);
						});

						console.log("111111111")
						uni.onBluetoothDeviceFound((res) => {
							 // console.log("发现新设备:" + JSON.stringify(res,'name'));
							let arr = [];
							for (var i = 0; i < res.devices.length; i++) {
								let item = res.devices[i];
								// if(item.name){
								// console.log("发现新设备",item.name+" "+item.RSSI);	
								// }
								
								let f = serviceDic.find(v => {
									return item.advertisServiceUUIDs
										.includes(v.serviceId);
								});
								if (f) {

									// console.log("发现目标设备:", item);
									arr.push(item);
								}

							}
							if (arr.length === 0) {
								// console.error("发现了设备,但不是想要的设备", res);
								return;
							}
							res.devices = arr;
							this.data.searchList = this.data.searchList.concat(
								res);
							if (this.cfg.onDeviceFound) {
								if (this.cfg.onDeviceFound.length > 0) {
									this.cfg.onDeviceFound.forEach((found) => {
										try {
											found.callback(res);
										} catch (error) {
											console.error("处理发现设备的回调出现异常,",
												error);
										}

									});
								}

							}
						});

						uni.onBLECharacteristicValueChange((receive) => {
							//订阅消息
							console.log("收到订阅消息", receive);
							let f = this.data.LinkedList.find((v) => {
								return v.deviceId == receive.deviceId;
							})
							let dataView = new DataView(receive.value);

							// 转换为字节数组
							let bytes = [];
							for (let i = 0; i < dataView.byteLength; i++) {
								bytes.push(dataView.getUint8(i));
							}

							let hexs = bytesToHexString(bytes);
							let str = '';
							try {
								let uint8Array = new Uint8Array(receive.value);

								for (let i = 0; i < uint8Array.length; i++) {
									// 将每个字节转换为对应的字符
									str += String.fromCharCode(uint8Array[i]);
								}

								let header = "mac address:";
								let isUpdate = false;
								if (str.indexOf(header) == 0) { //650以文本传输mac
									console.log("str=", str);
									this.data.LinkedList.find((v) => {
										if (v.deviceId == receive
											.deviceId) {
											let macStr = str.replace(
												header, "");
											if (macStr.includes(':')) {
												v.macAddress = macStr;
											} else {
												v.macAddress = macStr
													.replace(
														/(.{2})/g, '$1:')
													.slice(0, -1)
											}
											str = header + v.macAddress;
											console.log("收到mac地址:", v
												.macAddress)
										}
									});
									isUpdate = true;

								}

								if (str.indexOf('imei:') == 0) { //670以此方式传输imei
									let imei = str.split(':')[1];


									this.data.LinkedList.find((v) => {
										if (v.deviceId == receive
											.deviceId) {
											v.imei = imei;
											isUpdate = true;
										}
									});


								}

								if (bytes[0] == 0xFC) { //6155以0xFC开头代表mac地址
									console.log("收到mac地址:", bytes)
									if (bytes.length >= 7) {
										console.log("hexs=", hexs);
										let mac = hexs.slice(1, 7).join(":")
											.toUpperCase();
										this.data.LinkedList.find((v) => {
											if (v.deviceId == receive
												.deviceId) {
												v.macAddress = mac;
												isUpdate = true;
											}
										});

									}
								}

								try {
									let trimmedStr = str.trim();
									if (trimmedStr && (trimmedStr.startsWith('{') || trimmedStr.startsWith('['))) {
										let receivJson = JSON.parse(str);
										let key = "sta_address"; //HBY100以此方式上传mac地址
										if (key in receivJson) {
											this.data.LinkedList.find((v) => {
												if (v.deviceId == receive
													.deviceId) {
													let macStr = receivJson[
														key];
													if (macStr.includes(':')) {
														v.macAddress = macStr;
													} else {
														v.macAddress = macStr
															.replace(/(.{2})/g,
																'$1:').slice(0,
																-1)
													}

													isUpdate = true;
												}
											});

										}
									}
								} catch (convertException) {
									if (str && (str.trim().startsWith('{') || str.trim().startsWith('['))) {
										console.error("JSON解析失败（可能是格式错误的数据）", convertException);
									}
								}

								if (isUpdate) {
									this.updateCache();
								}
								 // console.log("str1=", str);
							} catch (ex) {
								console.error("将数据转文本失败", ex);
							}

							try {
								// console.log("11111");
								let recData = {
									deviceId: receive.deviceId,
									serviceId: receive.serviceId,
									characteristicId: receive.characteristicId,
									bytes: bytes,
									str: str,
									hexs: hexs
								};
								// console.log("监听到特征值:" + JSON.stringify(recData));
								if (this.cfg.receivDataCallback) {

									if (this.cfg.receivDataCallback.length > 0) {

										let path = this.getCurrentPagePath();
										// console.log("有人订阅消息")
										this.cfg.receivDataCallback.forEach((
											rec) => {
											// console.log("有人订阅消息111", )
											if (rec.callback) {
												try {
													rec.callback(recData, f,
														path, this.cfg
														.receivDataCallback
													);
												} catch (err) {
													console.error(
														"订阅消息出现异常",
														err);
												}

											}
										})
									} else {
										console.log("无人订阅消息");
									}
								} else {
									console.log("无人订阅receivDataCallback,不处理数据");
								}
							} catch (ex) {
								console.error("处理订阅消息失败,ex=", ex);
							}

						});


					},
					fail: (ex2) => {
						console.error("蓝牙模块启动失败", ex2);
						reject(this.getError(ex2));
					}
				});
			});
		}

		return new Promise((resolve, reject) => {
			if (this.data.isOpenBlue) {
				resolve();
				return;
			}

			this.CheckBlue().then((res) => {
				// console.log("res=", res)
				return init();
			}).then(resolve).catch((ex) => {
				console.error("异常：", ex);
				reject(ex);
			});


		});
	}
	//关闭蓝牙适配器
	CloseBlue() {
		if (this.data.platform == 'web') {
			this.data.available = false;
			this.data.discovering = false;
			this.data.isOpenBlue = false;
			this.data.searchList = [];

			return Promise.resolve();
		}
		return new Promise((resolve, reject) => {


			this.StopSearch();

			this.disconnectDevice();

			uni.closeBluetoothAdapter({
				success: () => {
					// console.log("蓝牙模块已关闭");
					this.data.available = false;
					this.data.discovering = false;
					this.data.isOpenBlue = false;
					this.data.searchList = [];
					resolve();
				},
				fail: (ex) => {
					console.error('无法关闭蓝牙模块:', ex);
					ex = this.getError(ex);
					reject(ex);
				},
				complete: () => {

				}
			});

		});

	}

	//开始搜索新设备
	StartSearch() {
		if (this.data.platform == 'web') {
			return Promise.resolve({});
		}
		this.data.searchList = [];
		var these = this;
		//开始搜索
		var Search = () => {
			//只搜索合作供应商的服务id
			let serviceIds = serviceDic.map(v => {
				return v.serviceId
			});

			//搜索一个服务id的设备，循环调用
			let RunSearch = (serviceId) => {
				return new Promise((resolve, reject) => {
					uni.startBluetoothDevicesDiscovery({
						services: serviceId ? [serviceId] : [],
						allowDuplicatesKey: true,
						success: (res) => {
							console.log('开始搜索蓝牙设备成功');
							resolve(res);

						},
						fail: (err) => {
							console.error(`搜索蓝牙设备失败:`, err);

							reject(this.getError(err));
						}
					});
				});

			}


			return new Promise((resolve, reject) => {
				let promises = [];
				// for (let i = 0; i < serviceIds.length; i++) {

				// 	promises.push(RunSearch(serviceIds[i]));

				// }
				promises.push(RunSearch());
				Promise.all(promises).then(resolve).catch(reject);

			});


		}



		return this.OpenBlue().then((res) => {
			// console.log("蓝牙适配器状态", res)

			return Search();
		});


	}


	//停止搜索
	StopSearch() {
		if (this.data.platform == 'web' || !this.data.discovering) {
			console.error("web平台或当前没有搜索,直接返回");
			return Promise.resolve();
		}
		let p1 = new Promise((resolve, reject) => {
			uni.stopBluetoothDevicesDiscovery({
				success: (res) => {
					// console.log("停止搜索蓝牙设备成功");
					resolve();
				},
				fail: (ex) => {
					console.error("无法停止蓝牙搜索");

					reject(this.getError(ex));
				}
			});
		});

		let p2 = new Promise((succ, err) => {
			setTimeout(() => {
				err({
					code: -1
				});
			}, 100);
		});


		return new Promise((resolve, reject) => {
			Promise.race([p1, p2]).then(resolve).catch(ex => {
				if (ex.code == -1) {
					console.error('专业给Uniapp填坑,停止搜索永无回调处理');
					resolve();
					return;
				}
				reject(ex);
			});
		});



	}
	//获取已连接的设备
	getLinkBlue(callback) {
		return new Promise((resolve, reject) => {
			uni.getConnectedBluetoothDevices({
				success: (res) => {

					resolve(res);


				},
				fail: (ex) => {
					////console.log("获取已连接设备异常", ex);

					reject({
						devices: []
					});

				}
			});
		});


	}

	//订阅消息
	subScribe(deviceId, state) {
		console.log("开始订阅消息", deviceId, state);
		return new Promise((resolve, reject) => {
			setTimeout(() => {

				let c = this.data.LinkedList.find((v) => {
					return v.deviceId == deviceId;
				});
				if (!deviceId) {
					console.error('deviceId无效')
					reject({
						code: 404,
						msg: 'deviceId无效'
					});
					return;
				}
				if (!c) {
					console.error("已找不到该设备");
					reject({
						code: 404,
						msg: '已找不到该设备'
					});
					return;
				}
				if (state) {
					if (c.notifyState) {
						resolve();
						return;
					}
				}

				let startSubScribe = (id, serviceId, characteristicId) => {
					// console.log("serviceId=", serviceId);
					// console.log("characteristicId=", characteristicId);
					let p1 = new Promise((succ, err) => {

						uni.notifyBLECharacteristicValueChange({
							deviceId: id,
							serviceId: serviceId,
							characteristicId: characteristicId,
							state: state,
							success: (res) => {
								if (state) {
									// console.log("订阅消息成功", res);
								} else {
									// console.log("取消订阅成功", res);
								}

								this.data.LinkedList.find((v) => {
									if (v.deviceId == deviceId) {
										v.notifyState = state;
									}
								});
								// console.log("success SubScribe");
								succ(
									res
								); //见了鬼了，有时候执行了succ但promise永远pending了
							},
							fail: (ex) => {

								err(this.getError(ex));
							}
						});
					});

					let p2 = new Promise((succ, err) => {
						setTimeout(() => {
							err({
								code: -1
							});
						}, 50);
					});
					return new Promise((succ, err) => {
						Promise.race([p1, p2]).then(succ).catch(ex => {
							// console.error("异常了：",ex);
							if (ex.code == -1) {
								console.error('专业给Uniapp填坑,订阅消息永无回调了');
								succ();
								return;
							}
							err(ex);
						})
					});

				}

				let serv = serviceDic.find(v => {
					return v.serviceId == c.writeServiceId;
				});
				let promies = new Array();
				if (c.notifyServiceid && c.notifyCharactId) {
					promies.push(startSubScribe(c.deviceId, c.notifyServiceid, c.notifyCharactId));
				} else if (serv) {
					promies.push(startSubScribe(c.deviceId, serv.serviceId, serv.notifyId));
				} else if (c.Characteristics && c.Characteristics.length) {
					for (var i = 0; i < c.Characteristics.length; i++) {
						let item = c.Characteristics[i];
						let serviceId = item.serviceId;
						let characteristicId = item.uuid;

						if (item.properties.notify) {
							promies.push(startSubScribe(deviceId, serviceId, characteristicId));

						}
					}
				} else {
					// console.log("c=", c);
					// console.log("serv=", serv);
					reject({
						code: 403,
						msg: "出现错误,找不到任何通知特征"
					});
					return;
				}

				if (promies.length > 0) {


					Promise.allSettled(promies).then((results) => {

						results.forEach((result, index) => {
							if (result.status === "fulfilled") {
								console.log(`订阅消息操作${index + 1}成功:`, result.value);
							} else {
								console.error(`订阅消息操作${index + 1}失败:`, result.reason);
							}
						});
						console.log("订阅消息完成，deviceId:", deviceId);
						resolve();
					}).catch((ex) => {
						console.error("异常,ex=", ex);
						reject(ex);
					}).finally(() => {
						// console.log("finally")
					});
				} else {
					console.error("没有特征需要订阅");
					resolve();
				}



			}, 800);

		});
	}

	//获取服务
	getService(id, targetServiceId, writeCharId, notifyCharId) {

		if (!targetServiceId) {
			targetServiceId = "xx"; // "FFE0";
		}
		return new Promise((resolve, reject) => {
			var repeatCnt = 0;
			var startgetService = () => {

				uni.getBLEDeviceServices({
					deviceId: id,
					success: (res) => {
						if (res.services && res.services.length > 0) {
							 console.log("获取到服务：" + JSON.stringify(res));

							this.data.LinkedList.find((v) => {
								if (v.deviceId == id) {
									v.services = res.services;
								}
							});
							//this.updateCache();

							var promises = [];
							let s = null;
							let se = res.services.find((v) => {

								s = serviceDic.find(k => {

									return k.serviceId == v.uuid;
								})
								if (s) {
									return true;
								}
								return false;
								// return v.uuid.indexOf(targetServiceId) > -1;
							});

							if (se) {
								 console.log("合作供应商的", s)
								this.data.LinkedList.find((v) => {
									if (v.deviceId == id) {
										v.writeServiceId = s.serviceId;
										v.wirteCharactId = s.writeId;
										v.notifyServiceid = s.serviceId;
										v.notifyCharactId = s.notifyId;
									}
								});
								this.updateCache();

								//合作供应商的设备，直接订阅消息，不走发现特征了
								promises.push(this.subScribe(id, true));

								// promises.push(this.getFeatrus(id, se.uuid, writeCharId,
								// 	notifyCharId));


							} else 
							
							{
								console.error("预设的蓝牙服务和特征中找不到");
								for (var i = 0; i < res.services.length; i++) {
									let service = res.services[i];
									promises.push(this.getFeatrus(id, service.uuid,
										writeCharId, notifyCharId));
								}
							}


							if (promises.length == 0) {
								console.error("未找到主服务");
								reject({
									msg: "未找到主服务",
									code: -1
								});
							} else {

								Promise.all(promises)
									.then(results => {
										console.log("results= ",results);
										if (!s) {
											//非指定供应商的设备，走订阅消息
											return this.subScribe(id, true);
										} else {
											//指定供应商的设备已经订阅过了
											return Promise.resolve();
										}

									})
									.then((res) => {
										// console.log('设备连接成功，初始化完成', this.data
										// 	.LinkedList);

										resolve();
									})
									.catch(error => {
										console.error("errrr=", error);
										reject(error);
									});
							}



						} else {
							repeatCnt++;
							if (repeatCnt > 5) {

								reject({
									msg: "获取设备服务失败",
									code: -1
								});

								return;
							}
							setTimeout(function() {
								startgetService(id);

							}, 100 + repeatCnt * 300);
						}
					},
					fail: (ex) => {
						reject(this.getError(ex));
					}
				})
			}

			setTimeout(function() {
				startgetService(id);
			}, 100);
		});
	}

	//获取特征
	getFeatrus(id, serviceId, writeCharId, notifyCharId) {
		var promise = new Promise((resolve, reject) => {
			uni.getBLEDeviceCharacteristics({
				deviceId: id,
				serviceId: serviceId,
				success: (res) => {

					console.log("获取到特征:" + JSON.stringify(res));
					res.characteristics.forEach((v) => {
						v.serviceId = serviceId;
					});

					//写特征
					let writeChar = res.characteristics.find(char => {
						let fe = serviceDic.find(v => {
							return v.serviceId == serviceId && v.writeId == char
								.uuid;
						})
						// return char.uuid.indexOf(writeCharId) > -1
						if (fe) {
							return true;
						}
						return false;
					});
					// if (!writeChar) {
					// 	writeChar = res.characteristics.find(char => {
					// 		return char.properties.write;
					// 	});
					// }
					//通知特征
					let notiChar = res.characteristics.find(char => {
						let fe = serviceDic.find(v => {
							return v.serviceId == serviceId && v.notifyId ==
								char.uuid;
						})
						// return char.uuid.indexOf(writeCharId) > -1
						if (fe) {
							return true;
						}
						return false;
						// return char.uuid.indexOf(notifyCharId) > -1;
					});
					// if (!notiChar) {
					// 	notiChar = res.characteristics.find(char => {
					// 		return char.properties.notify;
					// 	});
					// }
					this.data.LinkedList.find(function(v) {
						if (v.deviceId == id) {
							if (!v.Characteristics) {
								v.Characteristics = [];
							}

							for (var i = 0; i < res.characteristics.length; i++) {
								let item = res.characteristics[i];
								let flag = false;
								for (var j = 0; j < v.Characteristics.length; j++) {
									let charact = v.Characteristics[j];
									if (charact.uuid == item.uuid) {
										flag = true;
										break;
									}
								}
								if (!flag) {
									v.Characteristics.push(item);
								}
							}


							if (writeChar) {
								v.writeServiceId = serviceId;
								v.wirteCharactId = writeChar.uuid;
							}

							if (notiChar) {
								v.notifyServiceid = serviceId;
								v.notifyCharactId = notiChar.uuid;
							}
							return true;
						}
						return false;
					});



					this.updateCache();
					resolve(res);
				},
				fail: (ex) => {
					////console.log("获取特征出现异常:" + JSON.stringify(ex));
					reject(ex);
				}
			});
		});
		return promise;
	}

	//连接某个设备
	LinkBlue(deviceId, targetServiceId, writeCharId, notifyCharId, maxRetries) {
		if (this.data.platform == 'web') {
			return Promise.resolve(true);
		}
		if (maxRetries === undefined) {
			maxRetries = 0; // 最大重试次数
		}
		if (!writeCharId) {
			writeCharId = "xxxx"; // "FFE1";
		}
		if (!notifyCharId) {
			notifyCharId = "xxxxx"; // "FFE2";
		}



		let fIndex = -1;
		let f = this.data.LinkedList.find((v, index) => {
			if (v.deviceId == deviceId) {
				fIndex = index;
				return true;
			}
			return false;
		});
		////console.log("findex=" + fIndex);

		var these = this;


		//连接设备
		var linkDevice = () => {
			// 添加重试次数限制
			let retryCount = 0;


			const connect = () => {
				return new Promise((resolve, reject) => {
					if (fIndex > -1 && f?.Linked) {
						// console.log("当前已连接，跳过其他步骤");
						resolve(false);
						return;
					}

					if (!this.data.available) {
						reject(this.getError({
							code: 10001
						}));
						return;
					}

					// console.log("正在连接" + deviceId);
					uni.createBLEConnection({
						deviceId: deviceId,
						timeout: 30000,
						success: (info) => {
							 console.log("新连接成功", this.data.LinkedList);
							this.getLinkBlue().then((arr) => {
								let cr = arr.devices.find(c => {
									if (c.deviceId == deviceId) {
										c.Linked = true;
										return true;
									}
									return false;
								});

								if (fIndex > -1) {
									this.data.LinkedList[fIndex].Linked = true;
								} else {
									this.data.LinkedList.push(cr);
								}

								this.updateCache();
								// console.log("LinkedList=", this.data
								// 	.LinkedList);

								// 处理 MTU 设置
								if (plus.os.name === 'Android') {
									this.setMtu(deviceId).catch(ex=>{
										console.error("mtu设置失败=",ex);
									});
								}
								resolve(true);

							}).catch((ex) => {
								reject(this.getError(ex));
							});
						},
						fail: (ex) => {
							ex = this.getError(ex);
							console.error("蓝牙" + deviceId + "连接失败" + JSON.stringify(
								ex));

							// 连接超时后自动重试
							if (ex.code === 10012 && retryCount < maxRetries) {
								retryCount++;
								console.log(`重试连接 (${retryCount}/${maxRetries})`);
								// 使用 setTimeout 避免递归调用栈溢出
								setTimeout(() => {
									connect().then(resolve).catch(reject);
								}, 1000); // 延迟1秒后重试
							} else {
								reject(ex);
							}
						}
					});
				});
			};

			return connect();
		};




		return new Promise((resolve, reject) => {
			this.OpenBlue().then((res) => {
				////console.log("2222222");
				return linkDevice(deviceId);
			}).then((res) => {

				if (res) { //新连接
					// console.log("11111111");
					if (fIndex == -1) {
						// console.log("开始获取服务", targetServiceId)
						return this.getService(deviceId, targetServiceId, writeCharId,
							notifyCharId); //获取服务	
					} else {
						if (f.wirteCharactId && f.notifyCharactId) {
							if (!f.notifyState) {
								// console.log("开始订阅特征");
								this.subScribe(deviceId, true);
							} else {
								console.log("不订阅消息");
							}
							return Promise.resolve(true);
						} else {
							console.log("开始获取服务", targetServiceId)
							return this.getService(deviceId, targetServiceId, writeCharId,
								notifyCharId);
						}


					}
				} else { //已连接过，直接订阅消息		
					// console.log("11111111");
					if (fIndex > -1 && f) {
						if (!f.notifyState) {
							console.log("设备已连接但未订阅，开始订阅消息");
							return this.subScribe(deviceId, true).then(() => {
								console.log("订阅消息完成");
								return Promise.resolve(true);
							}).catch(err => {
								console.error("订阅消息失败:", err);
								return Promise.resolve(true);
							});
						} else {
							console.log("设备已连接且已订阅消息");
						}
					}
					return Promise.resolve(true); //已连接过的设备无需获取服务
				}

			}).then(() => {
				// console.log("then.....");

				setTimeout(() => {
					resolve();
				}, 500);
			}).catch((ex) => {
				console.error("出现异常", ex);
				reject(ex);
			});
		});


	}

	setMtu(deviceId) {
		let prom = new Promise((_succ, _err) => {
			uni.setBLEMTU({
				deviceId: deviceId,
				mtu: 512,
				success: (mtuRes) => {
					console.log("mtu约定成功");
					_succ(mtuRes);
				},
				fail: (ex) => {
			
					ex = this.getError(ex);
					_err(
						ex
					); 
				},
				complete() {
					console.log("设置mtu完毕");
				}
			});
		});
		return prom;
	}
	//断开连接
	disconnectDevice(deviceId) {
		if (this.data.platform == 'web') {
			return Promise.resolve();
		}
		var disconnect = (id) => {
			return new Promise((resolve, reject) => {
				uni.closeBLEConnection({
					deviceId: id,
					success: (res) => {
						console.log("用户主动断开了蓝牙:" + id);
						this.subScribe(id, false);
						resolve();
					},
					fail: (ex) => {
						console.error("无法断开蓝牙连接", ex);
						reject(this.getError(ex));
					}
				});
			});

		}
		if (deviceId) {
			return disconnect(deviceId);
		}

		if (this.data.LinkedList.length > 0) {
			let arr = [];
			for (var i = 0; i < this.data.LinkedList.length; i++) {
				let item = this.data.LinkedList[i];
				if (item.Linked) {
					arr.push(disconnect(item.deviceId));
				}

			}
			if (arr.length) {
				return new Promise((_succ, _err) => {
					Promise.allSettled(arr).then((results) => {
						results.forEach((result, index) => {
							if (result.status === 'fulfilled') {
								////console.log(`第${index + 1}个Promise成功:`, result.value);
							} else {
								////console.log(`第${index + 1}个Promise失败:`, result.reason.message);
							}
						});
						_succ()
					}).catch((ex) => {
						_err();
					});
				});
			}
		}

		return Promise.resolve();

	}
	//向蓝牙设备发送一个字符串的ASCII码
	sendString(deviceid, str, writeServiceId, wirteCharactId, ms) {
		if (str && typeof(str) == 'object') {
			str = JSON.stringify(str);
		}
		if (str) {

			let buffer = new ArrayBuffer(str.length);
			let dataView = new DataView(buffer);

			// 2. 将字符串转换为 ASCII 码并写入 DataView
			for (let i = 0; i < str.length; i++) {
				dataView.setUint8(i, str.charCodeAt(i));
			}

			return this.sendData(deviceid, buffer, writeServiceId, wirteCharactId, ms);
		} else {
			return Promise.resolve({
				code: 200,
				msg: "没有数据要发送"
			})
		}
	}

	//向蓝牙设备发送一个16进制的数组数据
	sendHexs(deviceid, array, writeServiceId, wirteCharactId, ms) {
		if (array && array.length) {
			let bufferSize = array.length;
			let buffer = new ArrayBuffer(bufferSize);
			let dataView = new DataView(buffer);
			for (let i = 0; i < array.length; i++) {
				dataView.setUint8(i, array);
			}

			return this.sendData(deviceid, buffer, writeServiceId, wirteCharactId, ms);

		} else {
			return Promise.resolve({
				code: 200,
				msg: "没有数据要发送"
			})
		}

	}
	//向蓝牙设备发送数据，如果没连接将自动连接后再发
	sendData(deviceid, buffer, writeServiceId, wirteCharactId, ms) {
		if (this.data.platform == 'web') {
			return Promise.resolve("h5平台默认成功");
		}
		
		// 打印发送的蓝牙指令
		let bufferHex = '';
		if (buffer) {
			let bytes = [];
			// 处理不同类型的buffer（ArrayBuffer、Uint8Array等）
			if (buffer instanceof ArrayBuffer) {
				let dataView = new DataView(buffer);
				for (let i = 0; i < buffer.byteLength; i++) {
					bytes.push(dataView.getUint8(i));
				}
			} else if (buffer.byteLength !== undefined) {
				// 如果是 Uint8Array 或其他类型
				for (let i = 0; i < buffer.byteLength; i++) {
					bytes.push(buffer[i] || 0);
				}
			} else if (Array.isArray(buffer)) {
				bytes = buffer;
			}
			if (bytes.length > 0) {
				bufferHex = bytes.map(b => '0x' + b.toString(16).padStart(2, '0').toUpperCase()).join(' ');
			}
		}
		// console.log("准备发送蓝牙指令 - deviceId:", deviceid, "writeServiceId:", writeServiceId, "writeCharactId:", wirteCharactId);
		// console.log("发送数据(Hex):", bufferHex || "(空数据)");
		// console.log("发送数据(原始buffer长度):", buffer ? (buffer.byteLength || buffer.length || 0) : 0);
		if (ms === undefined) {
			ms = 50;
		}
		let c = this.data.LinkedList.find((v) => {
			return v.deviceId == deviceid;
		});
		let device = {
			deviceId: deviceid,
			writeServiceId: null,
			wirteCharactId: null
		};
		if (writeServiceId) {
			device.writeServiceId = writeServiceId;
		}
		if (wirteCharactId) {
			device.wirteCharactId = wirteCharactId;
		}
		if (!device.writeServiceId || !device.wirteCharactId) {
			//console.log("从已连接中找设备")
			if (c) {
				device = c;
			}
		}



		let sendBuffer = () => {

			return new Promise(async (resolve, reject) => {

				var promise = new Promise((succ, err) => {
					if (!c) {
						err(this.getError({
							code: 10002
						})); //没有找到指定设备
						return;
					}
					// console.log("device=", device);
					uni.writeBLECharacteristicValue({
						deviceId: device.deviceId,
						serviceId: device.writeServiceId,
						characteristicId: device.wirteCharactId,
						value: buffer,
						writeType: 'write',
						success: () => {
							console.log("✓ 蓝牙指令发送成功 - deviceId:", device.deviceId);
							succ();
						},
						fail: (ex) => {
							ex = this.getError(ex);
							console.error("✗ 蓝牙指令发送失败 - deviceId:", device.deviceId, "错误:", ex);

							err(ex);
						}
					});
				});
				if (plus.os.name == 'iOS') {

					function timeOut(ms) {
						return new Promise((_, err) => {
							setTimeout(() => {
								err({
									code: -1,
									errMsg: '超时了'
								})
							}, ms);
						});
					}

					Promise.race([timeOut(ms), promise]).then(resolve).catch((ex) => {
						// console.error("ex=", ex);
						if (ex.code == -1) {
							console.error('专业给Uniapp填坑,发送消息永无回调');
							resolve(ex);
						} else {
							reject(ex);
						}

					}).finally(() => {
						//console.log("完成了")
					});
				} else {
					promise.then(resolve).catch(reject);
				}
			});

		}
		if (c.Linked) {
			// console.log("蓝牙已连接，直接发送数据");
			return sendBuffer();
		} else {
			// console.log("蓝牙未连接，先连接蓝牙再发送数据");
			return new Promise((resolve, reject) => {
				let f = this.data.LinkedList.find((v) => {
					return v.deviceId == deviceid;
				});
				if (!f) {
					reject({
						code: '-9',
						msg: '蓝牙未连接过此设备,请重新使用蓝牙添加该设备'
					});
					retrn;
				}
				this.LinkBlue(f.deviceId, f.writeServiceId, f.wirteCharactId, f.notifyCharactId).then((
					res) => {
					console.log("连接成功");
					return sendBuffer();
				}).then(() => {
					//console.log("发送成功")
					resolve();
				}).catch((ex) => {
					console.error("出现异常", ex);
					reject(this.getError(ex));
				});
			});
		}


	}

	//将点阵数据转换成RGB565
	convertToRGB565(pixels, type) {
		if (!type) {
			type = 'rgb';
		}
		const result = new Uint16Array(pixels.length / 4);
		let index = 0;
		for (let i = 0; i < pixels.length; i += 4) {
			let r = pixels[i];
			let g = pixels[i + 1];
			let b = pixels[i + 2];
			let a = pixels[i + 3];

			if (type == 'bgr') {
				result[index++] = ((b & 0xF8) << 8) | ((g & 0xFC) << 3) | (r >> 3);
			} else {
				result[index++] = ((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3);
			}

		}

		return result;
	}



}

let instance = null;
export default {
	getBleTool: function(found, receive) {
		if (!instance) {
			instance = new BleHelper();

		} else {
			////console.log("调用现有实例");
		}

		return instance;
	}
}