1214 lines
42 KiB
JavaScript
1214 lines
42 KiB
JavaScript
/**
|
||
* 蓝牙 BLE 采集服务
|
||
*/
|
||
const hex = require('../utils/hex.js');
|
||
|
||
// BLE 状态常量
|
||
const BLE_STATE = {
|
||
DISCONNECTED: 'disconnected',
|
||
CONNECTING: 'connecting',
|
||
CONNECTED: 'connected',
|
||
DISCOVERING: 'discovering',
|
||
READY: 'ready',
|
||
};
|
||
|
||
// 默认配置
|
||
const DEFAULT_CONFIG = {
|
||
// 扫描超时时间（毫秒）
|
||
scanTimeout: 10000,
|
||
// 连接超时时间（毫秒）
|
||
connectTimeout: 10000,
|
||
// 主动拆链后等待系统断链回调的时间（毫秒，超时兜底）
|
||
// native 断链是异步的，固定短延时会造成"以为断了其实没断"→ 随即建链又拿 already connect
|
||
closeWaitTimeout: 1500,
|
||
// 单个 GATT 操作（发现服务/特征/启用通知/设 MTU）的回调超时（毫秒）
|
||
// native 回调不返回时不能让状态机永久卡住（会连带卡死后续所有重连）
|
||
opTimeout: 5000,
|
||
// 适配器级操作（open/closeBluetoothAdapter）的回调超时（毫秒）
|
||
// 与 GATT 操作分开：这两个回调丢失的后果最重 —— 复位流程永不结算会把
|
||
// 网关的串行队列一起锁死，之后所有启停/重连都排队不执行（"怎么点都连不上"）
|
||
adapterOpTimeout: 5000,
|
||
// 连续建链失败多少次后复位蓝牙适配器（清掉 native 残留的半开连接）
|
||
adapterResetAfter: 3,
|
||
// 默认服务 UUID（需根据实际设备配置）
|
||
serviceUUIDs: [],
|
||
// 调试日志开关（高频数据禁止逐包打印，否则阻塞 BLE 接收）
|
||
debug: false,
|
||
// 掉线自动重连（工业场景建议开启）
|
||
autoReconnect: true,
|
||
};
|
||
|
||
class BleService {
|
||
constructor() {
|
||
this.state = BLE_STATE.DISCONNECTED;
|
||
this.deviceId = null;
|
||
this.serviceId = null;
|
||
this.notifyCharacteristicId = null;
|
||
this.writeCharacteristicId = null;
|
||
this.onDataCallback = null;
|
||
this.onStateChangeCallback = null;
|
||
this.config = { ...DEFAULT_CONFIG };
|
||
// 监听器注册标志（防止叠加）
|
||
this._listenersRegistered = false;
|
||
// 适配器是否已开启
|
||
this._openedAdapter = false;
|
||
// 收包计数/最近收包时间（诊断、静默探测用）
|
||
this._recvCount = 0;
|
||
this._lastRecvAt = 0;
|
||
// 当前会话已启用 notify 的特征列表
|
||
this._notifyCharacteristicIds = [];
|
||
// 自动重连相关
|
||
this._lastDeviceId = null;
|
||
this._lastServiceId = null;
|
||
this._reconnectTimer = null;
|
||
this._reconnectAttempts = 0;
|
||
this._manuallyDisconnected = false;
|
||
|
||
// 并发控制：连接流程在同一时刻只允许一个，同设备在途连接复用同一 Promise
|
||
// （并发发起 createBLEConnection 会拿到 fail:already connect，是历史报错根源）
|
||
this._connectPromise = null;
|
||
this._connectingDeviceId = null;
|
||
// 流程序号：自增即作废此前所有在途流程（切设备/主动断开时用），防止旧流程写脏会话状态
|
||
this._connectSeq = 0;
|
||
// 主动拆链时等待系统断链回调的唤醒器：deviceId -> resolve
|
||
this._disconnectWaiters = new Map();
|
||
// 连续建链失败计数（达到阈值复位适配器，用于清掉 native 半开连接）
|
||
this._consecutiveCreateFails = 0;
|
||
// 系统蓝牙可用性（onBluetoothAdapterStateChange 去抖用：部分平台注册时会回放当前状态）
|
||
this._adapterAvailable = true;
|
||
}
|
||
|
||
/**
|
||
* 设置配置
|
||
* @param {Object} config
|
||
*/
|
||
setConfig(config) {
|
||
this.config = { ...DEFAULT_CONFIG, ...config };
|
||
}
|
||
|
||
/**
|
||
* 设置数据回调
|
||
* @param {Function} callback - (data: {hex, buffer}) => void
|
||
*/
|
||
onData(callback) {
|
||
this.onDataCallback = callback;
|
||
}
|
||
|
||
/**
|
||
* 设置状态变化回调
|
||
* @param {Function} callback - (state) => void
|
||
*/
|
||
onStateChange(callback) {
|
||
this.onStateChangeCallback = callback;
|
||
}
|
||
|
||
/**
|
||
* 更新状态并通知
|
||
* @param {string} state
|
||
*/
|
||
_setState(state) {
|
||
this.state = state;
|
||
if (this.onStateChangeCallback) {
|
||
this.onStateChangeCallback(state);
|
||
}
|
||
console.log('[BLE] 状态变更:', state);
|
||
}
|
||
|
||
/**
|
||
* 初始化蓝牙适配器（幂等）
|
||
* wx 级全局监听只注册一次，不再每次 off/on 抖动，避免多页/重连切换时的丢包窗口。
|
||
* @returns {Promise}
|
||
*/
|
||
initBluetooth() {
|
||
return new Promise((resolve, reject) => {
|
||
// 已开启且监听已挂：直接复用
|
||
if (this._openedAdapter && this._listenersRegistered) {
|
||
resolve();
|
||
return;
|
||
}
|
||
|
||
// 已开适配器但监听未挂（异常恢复路径），补挂监听即可
|
||
const registerListeners = () => {
|
||
if (this._listenersRegistered) return;
|
||
|
||
wx.onBLEConnectionStateChange((res) => {
|
||
console.log('[BLE] 连接状态变化:', res);
|
||
if (res.connected) return;
|
||
|
||
// 唤醒"拆链后重建"的等待方：等系统确认断开，替代不可靠的固定延时
|
||
this._settleDisconnectWait(res.deviceId);
|
||
|
||
const wasConnected = this.state === BLE_STATE.READY || this.state === BLE_STATE.CONNECTED;
|
||
this._setState(BLE_STATE.DISCONNECTED);
|
||
// 保留 deviceId 供重连使用（不再置空），掉线自动重连。
|
||
// 已有连接流程在途时不重排（该流程失败会自行排重连），避免并发 createBLEConnection
|
||
if (wasConnected && this.config.autoReconnect && !this._manuallyDisconnected
|
||
&& !this._connectPromise && this._lastDeviceId) {
|
||
this._scheduleReconnect();
|
||
}
|
||
});
|
||
|
||
wx.onBLECharacteristicValueChange((res) => {
|
||
// 只处理当前会话设备的值变化，防止切换设备后旧连接/残留连接串包
|
||
if (this.deviceId && res.deviceId && res.deviceId !== this.deviceId) {
|
||
return;
|
||
}
|
||
const hexData = hex.arrayBufferToHex(res.value);
|
||
this._recvCount++;
|
||
this._lastRecvAt = Date.now();
|
||
// 首包 + 每 20 包打印摘要，debug 时逐包打印，避免高频逐包日志阻塞接收
|
||
if (this.config.debug || this._recvCount === 1 || this._recvCount % 20 === 0) {
|
||
console.log(`[BLE] 收到数据 #${this._recvCount} (${hexData.length / 2}字节):`, hexData);
|
||
}
|
||
if (this.onDataCallback) {
|
||
this.onDataCallback({
|
||
hex: hexData,
|
||
buffer: res.value,
|
||
deviceId: res.deviceId,
|
||
serviceId: res.serviceId,
|
||
characteristicId: res.characteristicId,
|
||
});
|
||
}
|
||
});
|
||
|
||
// 系统层蓝牙开关变化：必须跟踪，否则 native 已断开全部链路而本进程
|
||
// 仍停在 ready 的假象上（状态显示"已连接"却永远收不到数据，也无法自愈）
|
||
wx.onBluetoothAdapterStateChange((res) => {
|
||
console.log('[BLE] 适配器状态变化:', res);
|
||
const available = res.available !== false;
|
||
if (available === this._adapterAvailable) return; // 去抖：注册时可能回放当前状态
|
||
this._adapterAvailable = available;
|
||
|
||
if (!available) {
|
||
this._invalidateSession('系统蓝牙已关闭');
|
||
return;
|
||
}
|
||
// 重新打开蓝牙：native 侧适配器已被系统作废，不能假设自己还开着 ——
|
||
// 置 false 让下一次 initBluetooth 真正 open 一次，并立刻补一次连接
|
||
this._openedAdapter = false;
|
||
if (this.config.autoReconnect && !this._manuallyDisconnected && this._lastDeviceId) {
|
||
this._clearReconnectTimer();
|
||
this._reconnectAttempts = 0;
|
||
this._scheduleReconnect();
|
||
}
|
||
});
|
||
|
||
this._listenersRegistered = true;
|
||
console.log('[BLE] 已注册全局监听');
|
||
};
|
||
|
||
if (this._openedAdapter) {
|
||
registerListeners();
|
||
resolve();
|
||
return;
|
||
}
|
||
|
||
// native 不回调时必须超时作废：否则 _openedAdapter 停在 false、
|
||
// 上层的连接闸门也永不释放，之后所有重连都会被排队卡死
|
||
let settled = false;
|
||
const timer = setTimeout(() => {
|
||
if (settled) return;
|
||
settled = true;
|
||
console.error('[BLE] 初始化适配器回调超时');
|
||
reject(new Error('蓝牙初始化超时'));
|
||
}, this.config.adapterOpTimeout);
|
||
const finish = (fn, arg) => {
|
||
if (settled) return;
|
||
settled = true;
|
||
clearTimeout(timer);
|
||
fn(arg);
|
||
};
|
||
|
||
wx.openBluetoothAdapter({
|
||
success: () => {
|
||
console.log('[BLE] 初始化成功');
|
||
this._openedAdapter = true;
|
||
registerListeners();
|
||
finish(resolve);
|
||
},
|
||
fail: (err) => {
|
||
const msg = (err && err.errMsg) || '';
|
||
// 部分平台适配器已开启时 open 会报 already 类错误，视为成功
|
||
if (/already/i.test(msg)) {
|
||
console.log('[BLE] 适配器已开启（忽略 already）');
|
||
this._openedAdapter = true;
|
||
registerListeners();
|
||
finish(resolve);
|
||
} else {
|
||
console.error('[BLE] 初始化失败:', err);
|
||
finish(reject, new Error('蓝牙初始化失败: ' + (msg || '未知错误')));
|
||
}
|
||
},
|
||
});
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 获取平台合适的 MTU 值
|
||
* @returns {number}
|
||
*/
|
||
_getMtu() {
|
||
try {
|
||
const platform = wx.getSystemInfoSync().platform;
|
||
// iOS 最大 185，超出会协商失败；Android 建议 247
|
||
return platform === 'ios' ? 185 : 247;
|
||
} catch (e) {
|
||
return 247;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 扫描蓝牙设备
|
||
* @param {Array<string>} serviceUUIDs - 服务 UUID 列表（可选）
|
||
* @param {number} timeout - 超时时间（毫秒）
|
||
* @returns {Promise<Array>} 设备列表
|
||
*/
|
||
scanDevices(serviceUUIDs = null, timeout = null) {
|
||
return new Promise((resolve, reject) => {
|
||
const uuids = serviceUUIDs || this.config.serviceUUIDs;
|
||
const scanTimeout = timeout || this.config.scanTimeout;
|
||
|
||
const devices = [];
|
||
const deviceMap = new Map();
|
||
|
||
// 移除旧的扫描监听器，防止叠加
|
||
try {
|
||
wx.offBluetoothDeviceFound();
|
||
} catch (e) {
|
||
// 忽略移除失败
|
||
}
|
||
|
||
// 开始扫描
|
||
wx.startBluetoothDevicesDiscovery({
|
||
services: uuids.length > 0 ? uuids : undefined,
|
||
allowDuplicatesKey: false,
|
||
success: () => {
|
||
console.log('[BLE] 开始扫描, 超时:', scanTimeout);
|
||
// 监听扫描结果
|
||
wx.onBluetoothDeviceFound((res) => {
|
||
res.devices.forEach((device) => {
|
||
// 去重
|
||
if (!deviceMap.has(device.deviceId)) {
|
||
deviceMap.set(device.deviceId, true);
|
||
devices.push({
|
||
deviceId: device.deviceId,
|
||
name: device.name || '未知设备',
|
||
localName: device.localName,
|
||
advertisData: device.advertisData,
|
||
RSSI: device.RSSI,
|
||
});
|
||
}
|
||
});
|
||
});
|
||
|
||
// 设置超时
|
||
setTimeout(() => {
|
||
wx.stopBluetoothDevicesDiscovery({
|
||
success: () => {
|
||
console.log('[BLE] 扫描完成, 发现设备:', devices.length);
|
||
// 移除扫描监听器
|
||
try {
|
||
wx.offBluetoothDeviceFound();
|
||
} catch (e) {
|
||
// 忽略
|
||
}
|
||
resolve(devices);
|
||
},
|
||
fail: () => {
|
||
try {
|
||
wx.offBluetoothDeviceFound();
|
||
} catch (e) {
|
||
// 忽略
|
||
}
|
||
resolve(devices);
|
||
},
|
||
});
|
||
}, scanTimeout);
|
||
},
|
||
fail: (err) => {
|
||
console.error('[BLE] 扫描失败:', err);
|
||
reject(new Error('扫描失败: ' + (err.errMsg || '未知错误')));
|
||
},
|
||
});
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 停止扫描
|
||
*/
|
||
stopScan() {
|
||
return new Promise((resolve) => {
|
||
wx.stopBluetoothDevicesDiscovery({
|
||
success: () => {
|
||
console.log('[BLE] 已停止扫描');
|
||
resolve();
|
||
},
|
||
fail: () => {
|
||
resolve();
|
||
},
|
||
});
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 连接设备（幂等 + 并发安全）
|
||
*
|
||
* 依据微信 BLE 的三条硬约束设计：
|
||
* 1) 同一设备重复发起会返回 fail:already connect —— 这是"链路已存在"而非失败，
|
||
* 必须视为连接成功直接复用；拆链重建只会引入竞态（native 断链是异步的）。
|
||
* 2) 并发的第二个 createBLEConnection 必然拿到 already connect ——
|
||
* 因此同一设备在途连接复用同一 Promise，绝不并发发起。
|
||
* 3) 切换设备时旧流程必须作废 —— 用自增 seq 作废在途流程，防止旧流程写脏 serviceId/状态。
|
||
*
|
||
* @param {string} deviceId - 设备 ID
|
||
* @param {string} serviceId - 服务 UUID（可选，不传则自动发现）
|
||
* @returns {Promise}
|
||
*/
|
||
connectDevice(deviceId, serviceId = null) {
|
||
if (!deviceId) {
|
||
return Promise.reject(new Error('设备ID为空'));
|
||
}
|
||
|
||
// 同设备已有在途连接：复用，不再发起第二次（并发发起是 already connect 的根源）
|
||
if (this._connectPromise && this._connectingDeviceId === deviceId) {
|
||
console.log('[BLE] 连接已在进行中，复用本次连接:', deviceId);
|
||
return this._connectPromise;
|
||
}
|
||
|
||
// 记录连接目标，供自动重连使用
|
||
this.deviceId = deviceId;
|
||
this._lastDeviceId = deviceId;
|
||
this._lastServiceId = serviceId;
|
||
this._manuallyDisconnected = false;
|
||
this._clearReconnectTimer();
|
||
this._setState(BLE_STATE.CONNECTING);
|
||
|
||
const seq = ++this._connectSeq; // 作废此前所有在途流程
|
||
this._connectingDeviceId = deviceId;
|
||
|
||
const promise = this._connectFlow(deviceId, serviceId, seq).catch((err) => {
|
||
// 主动断开/切设备导致的作废：不算失败，不上屏
|
||
if (err && err.cancelled) throw err;
|
||
// 失败详情在各自重试循环里记录（_scheduleReconnect / forceReconnect），
|
||
// connectDevice 只负责"一次尝试"的语义，重试策略交给调用方
|
||
if (this.deviceId === deviceId) this._setState(BLE_STATE.DISCONNECTED);
|
||
throw err;
|
||
});
|
||
|
||
this._connectPromise = promise;
|
||
const clear = () => {
|
||
if (this._connectPromise === promise) {
|
||
this._connectPromise = null;
|
||
this._connectingDeviceId = null;
|
||
}
|
||
};
|
||
promise.then(clear, clear);
|
||
return promise;
|
||
}
|
||
|
||
/**
|
||
* 连接主流程：建链 → 设 MTU → 发现服务/启用 notify
|
||
* @param {string} deviceId
|
||
* @param {string} serviceId
|
||
* @param {number} seq - 流程序号（作废判定）
|
||
*/
|
||
async _connectFlow(deviceId, serviceId, seq) {
|
||
this._assertCurrent(seq);
|
||
|
||
// 建链的前置条件：适配器必须是打开的。冷启动由 gateway 先开，但自动重连 /
|
||
// 硬重连是绕过 gateway 启动流程直接进来的，期间适配器可能已被系统作废
|
||
// （关蓝牙、复位失败等），不在这里兜住就会一直以 not init(10001) 失败。
|
||
// initBluetooth 幂等：已打开且监听已挂时立即返回，不产生额外 native 调用。
|
||
await this.initBluetooth();
|
||
this._assertCurrent(seq);
|
||
|
||
let reused = false;
|
||
try {
|
||
await this._createConnection(deviceId, seq);
|
||
} catch (err) {
|
||
const errMsg = (err && err.errMsg) || '';
|
||
if (!/already connect/i.test(errMsg)) {
|
||
// 已被作废的流程（用户停用设备 / 切设备 / 主动断开）不得升级成"复位适配器"：
|
||
// 复位是全局破坏性操作（拆掉所有链路 + 关开适配器），替一个已经没人要的连接
|
||
// 去复位，正是"设备关了还在反复复位蓝牙"的来源。作废即抛 cancelled，
|
||
// 上层按"不算失败"处理（不上屏、不排重试）
|
||
this._assertCurrent(seq);
|
||
await this._escalateCreateFailure();
|
||
throw new Error('连接失败: ' + (errMsg || err.message || '未知错误'));
|
||
}
|
||
// 系统层链路已存在（本机其它调用、上次会话残留）：视为连接成功，直接复用该链路
|
||
reused = true;
|
||
this._consecutiveCreateFails = 0;
|
||
console.warn('[BLE] 系统层已存在连接，复用现有链路:', deviceId);
|
||
}
|
||
|
||
this._assertCurrent(seq);
|
||
await this._setMtu(deviceId);
|
||
|
||
this._assertLinkFresh(seq, deviceId);
|
||
try {
|
||
return await this._discoverServices(deviceId, serviceId, seq);
|
||
} catch (err) {
|
||
// 仅当复用到的是"僵尸链路"（服务表取不到）才做一次干净重建；
|
||
// 新建链路仍失败说明是真实错误，流程已作废也不必再折腾
|
||
if (!reused || (err && err.cancelled)) throw err;
|
||
console.warn('[BLE] 复用链路不可用，重建:', err && err.message);
|
||
}
|
||
|
||
await this._rebuildConnection(deviceId, seq);
|
||
this._assertLinkFresh(seq, deviceId);
|
||
await this._setMtu(deviceId);
|
||
return this._discoverServices(deviceId, serviceId, seq);
|
||
}
|
||
|
||
/**
|
||
* 建链失败升级：连续失败（尤其"连接超时"）会让 native 栈停在半开连接，
|
||
* 其后 createBLEConnection 会反复 already connect / 超时，连"关开关重开"都救不回来。
|
||
* 达到阈值即复位适配器清掉残留连接，把状态机从死循环里拉出来。
|
||
*/
|
||
async _escalateCreateFailure() {
|
||
this._consecutiveCreateFails++;
|
||
if (this._consecutiveCreateFails < this.config.adapterResetAfter) return;
|
||
this._consecutiveCreateFails = 0;
|
||
console.warn(`[BLE] 连续 ${this.config.adapterResetAfter} 次建链失败，复位适配器`);
|
||
try {
|
||
await this.resetAdapter();
|
||
} catch (err) {
|
||
console.error('[BLE] 适配器复位失败:', err && err.message);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 包装 wx 异步 API：加回调超时兜底
|
||
* native 回调不返回时，Promise 会永久 pending，把在途连接闸门（_connectPromise）卡死，
|
||
* 表现就是"之后怎么点都连不上"
|
||
* @param {Function} executor - (resolve, reject) => void，内部调用 wx API
|
||
* @param {string} what - 操作名（日志与错误文案）
|
||
* @param {number} [timeout] - 覆盖默认 opTimeout（适配器级操作用自己的超时）
|
||
* @returns {Promise}
|
||
*/
|
||
_callWithTimeout(executor, what, timeout = this.config.opTimeout) {
|
||
return new Promise((resolve, reject) => {
|
||
let settled = false;
|
||
const timer = setTimeout(() => {
|
||
if (settled) return;
|
||
settled = true;
|
||
console.warn(`[BLE] ${what}回调超时:`, what);
|
||
reject(new Error(`${what}超时`));
|
||
}, timeout);
|
||
|
||
const wrap = (fn) => (arg) => {
|
||
if (settled) return;
|
||
settled = true;
|
||
clearTimeout(timer);
|
||
fn(arg);
|
||
};
|
||
|
||
executor(wrap(resolve), wrap(reject));
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 发起 createBLEConnection（带超时；超时后清理可能已建立的链路）
|
||
* fail 原样 reject，交由上层判读 already connect
|
||
* @returns {Promise}
|
||
*/
|
||
_createConnection(deviceId, seq) {
|
||
return new Promise((resolve, reject) => {
|
||
let settled = false;
|
||
const timer = setTimeout(() => {
|
||
if (settled) return;
|
||
settled = true;
|
||
console.warn('[BLE] 连接超时:', deviceId);
|
||
// 超时不代表没连上：native 可能仍在连接中，先拆链清掉可能已建立的链路
|
||
wx.closeBLEConnection({ deviceId, complete: () => {} });
|
||
const err = new Error('连接超时');
|
||
err.timeout = true;
|
||
reject(err);
|
||
}, this.config.connectTimeout);
|
||
|
||
wx.createBLEConnection({
|
||
deviceId,
|
||
success: () => {
|
||
if (settled) return;
|
||
settled = true;
|
||
clearTimeout(timer);
|
||
console.log('[BLE] 连接成功:', deviceId);
|
||
if (seq === this._connectSeq) {
|
||
this._reconnectAttempts = 0;
|
||
this._consecutiveCreateFails = 0;
|
||
}
|
||
resolve();
|
||
},
|
||
fail: (err) => {
|
||
if (settled) return;
|
||
settled = true;
|
||
clearTimeout(timer);
|
||
reject(err);
|
||
},
|
||
});
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 设置 MTU（提高传输效率，iOS 最大 185，Android 建议 247）
|
||
* 失败不影响连接，故用 complete 结算；回调超时同样忽略
|
||
* @returns {Promise}
|
||
*/
|
||
_setMtu(deviceId) {
|
||
return this._callWithTimeout(
|
||
(resolve, reject) => wx.setBLEMTU({
|
||
deviceId,
|
||
mtu: this._getMtu(),
|
||
complete: resolve,
|
||
fail: reject,
|
||
}),
|
||
'设置MTU'
|
||
).catch(() => { /* MTU 非关键路径，失败照常继续 */ });
|
||
}
|
||
|
||
/**
|
||
* 干净重建链路：先拆链并等系统确认断开，再建链
|
||
* 只用于"复用到的链路不可用"这一条路径，且每次连接流程最多一次
|
||
*/
|
||
async _rebuildConnection(deviceId, seq) {
|
||
await this._closeConnection(deviceId);
|
||
this._assertCurrent(seq);
|
||
try {
|
||
await this._createConnection(deviceId, seq);
|
||
} catch (err) {
|
||
const errMsg = (err && err.errMsg) || '';
|
||
// 断链尚未走完时会再次 already connect：链路已在，继续用即可
|
||
if (/already connect/i.test(errMsg)) {
|
||
this._consecutiveCreateFails = 0;
|
||
return;
|
||
}
|
||
// 同 _connectFlow：作废的流程不得复位适配器（那是全局破坏性操作）
|
||
this._assertCurrent(seq);
|
||
await this._escalateCreateFailure();
|
||
throw new Error('重连失败: ' + (errMsg || err.message || '未知错误'));
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 主动断开并等待系统断链回调（最多 closeWaitTimeout 兜底）
|
||
* @returns {Promise}
|
||
*/
|
||
async _closeConnection(deviceId) {
|
||
const wait = new Promise((resolve) => {
|
||
this._disconnectWaiters.set(deviceId, resolve);
|
||
setTimeout(() => {
|
||
// 超时兜底：不再无限等下去
|
||
if (this._disconnectWaiters.get(deviceId) === resolve) {
|
||
this._disconnectWaiters.delete(deviceId);
|
||
console.warn('[BLE] 等待断链回调超时，按已断开处理:', deviceId);
|
||
resolve();
|
||
}
|
||
}, this.config.closeWaitTimeout);
|
||
});
|
||
|
||
wx.closeBLEConnection({
|
||
deviceId,
|
||
fail: () => {
|
||
// 本就未连接：没有断链事件可等，立即结算
|
||
this._settleDisconnectWait(deviceId);
|
||
},
|
||
});
|
||
|
||
await wait;
|
||
}
|
||
|
||
/** 唤醒等待断链的结算器 */
|
||
_settleDisconnectWait(deviceId) {
|
||
const resolve = this._disconnectWaiters.get(deviceId);
|
||
if (resolve) {
|
||
this._disconnectWaiters.delete(deviceId);
|
||
resolve();
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 唤醒所有等待断链的结算器
|
||
* native 层整片失效/复位时必须主动唤醒，否则调用方只能干等自己的超时兜底
|
||
*/
|
||
_settleAllDisconnectWaits() {
|
||
const waiters = Array.from(this._disconnectWaiters.values());
|
||
this._disconnectWaiters.clear();
|
||
waiters.forEach((resolve) => resolve());
|
||
}
|
||
|
||
/**
|
||
* 作废当前会话（native 层已不可用时的统一出口）
|
||
*
|
||
* 用于"系统蓝牙被关掉"这类场景：native 已断开全部链路，本进程若继续停在
|
||
* ready 就是假象（状态显示"已连接"却永远收不到数据，且没有任何回调能纠正它）。
|
||
* 只归零会话，**不触碰 `_manuallyDisconnected`** —— 那是"用户主动断开链路"的语义，
|
||
* 保留它才能让自动重连在适配器恢复后自然接上。
|
||
* @param {string} reason - 日志原因
|
||
*/
|
||
_invalidateSession(reason) {
|
||
console.warn('[BLE] 作废会话:', reason);
|
||
this._openedAdapter = false; // 适配器已失效，下次 initBluetooth 会重开
|
||
this._connectSeq++; // 作废所有在途流程
|
||
this._connectPromise = null;
|
||
this._connectingDeviceId = null;
|
||
this._clearReconnectTimer();
|
||
this._settleAllDisconnectWaits();
|
||
this.serviceId = null;
|
||
this.notifyCharacteristicId = null;
|
||
this.writeCharacteristicId = null;
|
||
this._notifyCharacteristicIds = [];
|
||
this._lastRecvAt = 0;
|
||
if (this.state !== BLE_STATE.DISCONNECTED) {
|
||
this._setState(BLE_STATE.DISCONNECTED);
|
||
}
|
||
// 适配器可能只是被临时关掉：按退避重排重连，用户重新打开蓝牙后自然接上
|
||
if (this.config.autoReconnect && !this._manuallyDisconnected && this._lastDeviceId) {
|
||
this._scheduleReconnect();
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 流程是否仍然有效（未被新连接流程取代、未被主动断开）
|
||
* @param {number} seq
|
||
* @returns {boolean}
|
||
*/
|
||
_isCurrent(seq) {
|
||
return seq === this._connectSeq && !this._manuallyDisconnected;
|
||
}
|
||
|
||
/** 作废判定：失效则抛出带 cancelled 标记的错误（上层不报错、不重排） */
|
||
_assertCurrent(seq) {
|
||
if (this._isCurrent(seq)) return;
|
||
throw this._cancelError('连接流程已作废');
|
||
}
|
||
|
||
/**
|
||
* 作废判定 + 链路清理：建链成功后流程若被作废，该链路已无人管理，需要主动关掉，
|
||
* 否则会残留成下一次连接时"already connect"的僵尸链路
|
||
*/
|
||
_assertLinkFresh(seq, deviceId) {
|
||
if (this._isCurrent(seq)) return;
|
||
this._discardLink(deviceId);
|
||
throw this._cancelError('连接流程已作废');
|
||
}
|
||
|
||
/**
|
||
* 丢弃非当前目标的链路（fire-and-forget）
|
||
* 若该设备仍是当前目标且非用户主动断开，则保留给新流程复用，不做无谓拆链
|
||
*/
|
||
_discardLink(deviceId) {
|
||
if (deviceId === this._lastDeviceId && !this._manuallyDisconnected) return;
|
||
console.log('[BLE] 丢弃作废流程的链路:', deviceId);
|
||
wx.closeBLEConnection({ deviceId, complete: () => {} });
|
||
}
|
||
|
||
_cancelError(message) {
|
||
const err = new Error(message);
|
||
err.cancelled = true;
|
||
return err;
|
||
}
|
||
|
||
/**
|
||
* 发现服务和特征值
|
||
* @param {string} deviceId
|
||
* @param {string} serviceId
|
||
* @param {number} seq
|
||
* @returns {Promise}
|
||
*/
|
||
_discoverServices(deviceId, serviceId, seq) {
|
||
this._setState(BLE_STATE.DISCOVERING);
|
||
|
||
const fetchServices = this._callWithTimeout(
|
||
(resolve, reject) => wx.getBLEDeviceServices({ deviceId, success: resolve, fail: reject }),
|
||
'获取服务'
|
||
);
|
||
|
||
return fetchServices
|
||
.then((res) => {
|
||
if (!this._isCurrent(seq)) throw this._cancelError('连接流程已作废');
|
||
console.log('[BLE] 发现服务:', res.services);
|
||
const services = res.services;
|
||
|
||
// 选择目标服务
|
||
let targetService = null;
|
||
if (serviceId) {
|
||
// 指定了服务 UUID
|
||
targetService = services.find(s => s.uuid.toLowerCase().includes(serviceId.toLowerCase()));
|
||
} else {
|
||
// 自动选择：排除通用服务（GAP 0x1800, GATT 0x1801 等）
|
||
const GENERIC_SERVICE_PREFIXES = ['00001800', '00001801', '0000180a', '0000180f'];
|
||
targetService = services.find(s =>
|
||
!GENERIC_SERVICE_PREFIXES.some(p => s.uuid.toLowerCase().startsWith(p))
|
||
);
|
||
// 如果没有非通用服务，选择第一个主服务
|
||
if (!targetService) {
|
||
targetService = services.find(s => s.isPrimary) || services[0];
|
||
}
|
||
}
|
||
|
||
if (!targetService) {
|
||
throw new Error('未找到目标服务');
|
||
}
|
||
return targetService.uuid;
|
||
})
|
||
.catch((err) => {
|
||
if (err && err.cancelled) throw err;
|
||
console.error('[BLE] 获取服务失败:', err && err.message);
|
||
throw new Error('获取服务失败: ' + ((err && err.message) || '未知错误'));
|
||
})
|
||
.then((uuid) => {
|
||
this.serviceId = uuid;
|
||
console.log('[BLE] 目标服务:', this.serviceId);
|
||
return this._discoverCharacteristics(deviceId, uuid, seq);
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 发现特征值
|
||
* 目标服务下所有 notify/indicate 特征都尝试启用（数据特征未必是第一个 notify 特征），
|
||
* 单个特征启用失败仅告警跳过，至少一个成功即视为就绪。
|
||
* @param {string} deviceId
|
||
* @param {string} serviceId
|
||
* @param {number} seq
|
||
* @returns {Promise}
|
||
*/
|
||
_discoverCharacteristics(deviceId, serviceId, seq) {
|
||
return this._callWithTimeout(
|
||
(resolve, reject) => wx.getBLEDeviceCharacteristics({
|
||
deviceId,
|
||
serviceId,
|
||
success: resolve,
|
||
fail: reject,
|
||
}),
|
||
'获取特征值'
|
||
)
|
||
.then((res) => {
|
||
if (!this._isCurrent(seq)) throw this._cancelError('连接流程已作废');
|
||
console.log('[BLE] 发现特征值:', res.characteristics.map(c => ({
|
||
uuid: c.uuid,
|
||
properties: c.properties,
|
||
})));
|
||
const characteristics = res.characteristics;
|
||
|
||
const notifyChars = characteristics.filter(c => c.properties.notify || c.properties.indicate);
|
||
const writeChar = characteristics.find(c => c.properties.write || c.properties.writeNoResponse);
|
||
if (writeChar) {
|
||
this.writeCharacteristicId = writeChar.uuid;
|
||
console.log('[BLE] 写入特征值:', this.writeCharacteristicId);
|
||
}
|
||
|
||
if (notifyChars.length === 0) {
|
||
// 没有通知特征值，但可能有写入特征值
|
||
console.warn('[BLE] ⚠️ 未找到 notify/indicate 特征值！设备将无法主动上报数据，只能被动写入。请核对设备的 GATT 服务/特征值。');
|
||
this._notifyCharacteristicIds = [];
|
||
this.notifyCharacteristicId = null;
|
||
this._lastRecvAt = Date.now();
|
||
this._setState(BLE_STATE.READY);
|
||
return {
|
||
serviceId: this.serviceId,
|
||
notifyCharacteristicIds: [],
|
||
notifyCharacteristicId: null,
|
||
writeCharacteristicId: this.writeCharacteristicId,
|
||
};
|
||
}
|
||
|
||
// 串行逐个启用 notify
|
||
return this._enableAllNotify(deviceId, serviceId, notifyChars).then((enabled) => {
|
||
if (!this._isCurrent(seq)) throw this._cancelError('连接流程已作废');
|
||
this._notifyCharacteristicIds = enabled;
|
||
this.notifyCharacteristicId = enabled[0] || null;
|
||
if (enabled.length === 0) {
|
||
console.error('[BLE] 所有 notify 特征启用均失败');
|
||
const err = new Error('启用通知失败');
|
||
err.notifyFailed = true;
|
||
throw err;
|
||
}
|
||
console.log('[BLE] 已启用 notify 特征:', enabled);
|
||
// 作为后续“静默/掉线”探测的基线
|
||
this._lastRecvAt = Date.now();
|
||
this._setState(BLE_STATE.READY);
|
||
return {
|
||
serviceId: this.serviceId,
|
||
notifyCharacteristicIds: enabled,
|
||
notifyCharacteristicId: this.notifyCharacteristicId,
|
||
writeCharacteristicId: this.writeCharacteristicId,
|
||
};
|
||
});
|
||
})
|
||
.catch((err) => {
|
||
if (err && (err.cancelled || err.notifyFailed)) throw err;
|
||
console.error('[BLE] 获取特征值失败:', err && err.message);
|
||
throw new Error('获取特征值失败: ' + ((err && err.message) || '未知错误'));
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 串行启用多个 notify/indicate 特征
|
||
* @param {string} deviceId
|
||
* @param {string} serviceId
|
||
* @param {Array} chars - 特征数组（含 uuid）
|
||
* @returns {Promise<Array<string>>} 成功启用的特征 UUID 列表
|
||
*/
|
||
_enableAllNotify(deviceId, serviceId, chars) {
|
||
return chars.reduce((chain, c) => {
|
||
return chain.then((enabled) => {
|
||
return this._enableNotify(deviceId, serviceId, c.uuid).then((ok) => {
|
||
if (ok) enabled.push(c.uuid);
|
||
return enabled;
|
||
});
|
||
});
|
||
}, Promise.resolve([]));
|
||
}
|
||
|
||
/**
|
||
* 启用单个特征的 notify/indicate
|
||
* @returns {Promise<string|null>} 成功返回特征 UUID，失败返回 null（不抛错）
|
||
*/
|
||
_enableNotify(deviceId, serviceId, characteristicId) {
|
||
return this._callWithTimeout(
|
||
(resolve, reject) => wx.notifyBLECharacteristicValueChange({
|
||
deviceId,
|
||
serviceId,
|
||
characteristicId,
|
||
state: true,
|
||
success: resolve,
|
||
fail: reject,
|
||
}),
|
||
'启用通知'
|
||
)
|
||
.then(() => {
|
||
console.log('[BLE] 启用通知:', characteristicId);
|
||
return characteristicId;
|
||
})
|
||
.catch((err) => {
|
||
console.warn('[BLE] 启用通知失败(跳过):', characteristicId, err && err.message);
|
||
return null;
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 写入数据
|
||
* @param {string} hexData - 十六进制字符串
|
||
* @returns {Promise}
|
||
*/
|
||
writeCommand(hexData) {
|
||
return new Promise((resolve, reject) => {
|
||
if (!this.deviceId || !this.serviceId || !this.writeCharacteristicId) {
|
||
reject(new Error('设备未连接或无写入特征值'));
|
||
return;
|
||
}
|
||
|
||
const buffer = hex.hexToArrayBuffer(hexData);
|
||
|
||
wx.writeBLECharacteristicValue({
|
||
deviceId: this.deviceId,
|
||
serviceId: this.serviceId,
|
||
characteristicId: this.writeCharacteristicId,
|
||
value: buffer,
|
||
success: () => {
|
||
console.log('[BLE] 写入成功:', hexData);
|
||
resolve();
|
||
},
|
||
fail: (err) => {
|
||
console.error('[BLE] 写入失败:', err);
|
||
reject(new Error('写入失败: ' + (err.errMsg || '未知错误')));
|
||
},
|
||
});
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 清除自动重连定时器
|
||
*/
|
||
_clearReconnectTimer() {
|
||
if (this._reconnectTimer) {
|
||
clearTimeout(this._reconnectTimer);
|
||
this._reconnectTimer = null;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 调度自动重连（指数退避：1s → 2s → 4s ... 最大 15s）
|
||
* 重试循环的唯一归属地：失败继续退避，直到成功或用户主动断开
|
||
*/
|
||
_scheduleReconnect() {
|
||
if (this._reconnectTimer) return;
|
||
// 用户主动断开（含设备被停用后的收尾断开）后不得再排重连
|
||
if (this._manuallyDisconnected) return;
|
||
const delay = Math.min(1000 * Math.pow(2, this._reconnectAttempts), 15000);
|
||
this._reconnectAttempts++;
|
||
console.log(`[BLE] ${delay}ms 后自动重连（第 ${this._reconnectAttempts} 次）`);
|
||
this._reconnectTimer = setTimeout(() => {
|
||
this._reconnectTimer = null;
|
||
if (!this._lastDeviceId) return;
|
||
// 排队到触发之间用户可能已经主动断开/停用设备：触发时必须重新确认意图，
|
||
// 否则定时器会把刚断开的链路又拉起来
|
||
if (this._manuallyDisconnected) return;
|
||
this.connectDevice(this._lastDeviceId, this._lastServiceId).catch((err) => {
|
||
if (err && err.cancelled) return;
|
||
console.error('[BLE] 自动重连失败:', err && err.message);
|
||
this._scheduleReconnect();
|
||
});
|
||
}, delay);
|
||
}
|
||
|
||
/**
|
||
* 断开连接
|
||
*/
|
||
disconnect() {
|
||
return new Promise((resolve) => {
|
||
// 用户主动断开：停止自动重连，并作废在途连接流程（否则流程收尾会写脏会话状态）
|
||
this._manuallyDisconnected = true;
|
||
this._connectSeq++;
|
||
this._connectPromise = null;
|
||
this._connectingDeviceId = null;
|
||
this._reconnectAttempts = 0;
|
||
this._clearReconnectTimer();
|
||
|
||
if (!this.deviceId) {
|
||
if (this.state !== BLE_STATE.DISCONNECTED) {
|
||
this._setState(BLE_STATE.DISCONNECTED);
|
||
}
|
||
resolve();
|
||
return;
|
||
}
|
||
|
||
wx.closeBLEConnection({
|
||
deviceId: this.deviceId,
|
||
success: () => {
|
||
console.log('[BLE] 已断开连接');
|
||
},
|
||
complete: () => {
|
||
this._setState(BLE_STATE.DISCONNECTED);
|
||
this.deviceId = null;
|
||
this.serviceId = null;
|
||
this.notifyCharacteristicId = null;
|
||
this.writeCharacteristicId = null;
|
||
this._notifyCharacteristicIds = [];
|
||
this._lastRecvAt = 0;
|
||
resolve();
|
||
},
|
||
});
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 关闭蓝牙适配器
|
||
*/
|
||
closeBluetooth() {
|
||
return new Promise((resolve) => {
|
||
this.disconnect().then(() => {
|
||
wx.closeBluetoothAdapter({
|
||
success: () => {
|
||
console.log('[BLE] 已关闭蓝牙适配器');
|
||
},
|
||
complete: () => {
|
||
resolve();
|
||
},
|
||
});
|
||
});
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 获取当前状态
|
||
* @returns {string}
|
||
*/
|
||
getState() {
|
||
return this.state;
|
||
}
|
||
|
||
/**
|
||
* 是否已连接
|
||
* @returns {boolean}
|
||
*/
|
||
isConnected() {
|
||
return this.state === BLE_STATE.READY || this.state === BLE_STATE.CONNECTED;
|
||
}
|
||
|
||
/**
|
||
* 是否处于可接收数据的就绪态
|
||
* @returns {boolean}
|
||
*/
|
||
isReady() {
|
||
return this.state === BLE_STATE.READY || this.state === BLE_STATE.CONNECTED;
|
||
}
|
||
|
||
/**
|
||
* 是否正处于连接流程中
|
||
* @returns {boolean}
|
||
*/
|
||
isConnecting() {
|
||
return !!this._connectPromise;
|
||
}
|
||
|
||
/**
|
||
* 复位蓝牙适配器（close → open）
|
||
*
|
||
* 用于 native 栈停在"半开连接"的场景：此时 closeBLEConnection + createBLEConnection
|
||
* 会反复 already connect / 连接超时，连"关开关重开"都救不回来，
|
||
* 只有关掉适配器（同时清掉进程内所有 GATT 状态）再重开才能真正复位。
|
||
* 关闭期间禁止自动重连与在途流程，避免复位过程被自己打断。
|
||
*
|
||
* 两条硬约束（都带超时兜底，任一环节 native 不回调也必须走完）：
|
||
* - 必须在 finally 里**复原** `_manuallyDisconnected`（而不是无条件置 false）。
|
||
* 入口置 true 是"复位期间禁自动重连"的需要；无条件置 false 会把复位之前
|
||
* 就已存在的"用户主动断开/设备已停用"意图一起抹掉，复位结束后自动重连被
|
||
* 重新拉起 —— 表现为"设备关了还在连蓝牙"。若无条件残留 true 则相反：
|
||
* 同时禁用自动重连 + 让 `_isCurrent()` 恒 false（所有在途流程被判作废）= 死态。
|
||
* - 必须保证本 Promise 一定会结算，否则网关的串行队列（_chain）会被锁死，
|
||
* 之后所有 start/stop/ensureStarted/retryBle 全部排队不执行。
|
||
* @returns {Promise}
|
||
*/
|
||
async resetAdapter() {
|
||
console.log('[BLE] 复位蓝牙适配器');
|
||
const wasManuallyDisconnected = this._manuallyDisconnected;
|
||
this._manuallyDisconnected = true;
|
||
this._connectSeq++; // 作废所有在途流程
|
||
this._connectPromise = null;
|
||
this._connectingDeviceId = null;
|
||
this._clearReconnectTimer();
|
||
this._settleAllDisconnectWaits();
|
||
|
||
try {
|
||
await this._closeAdapter();
|
||
this._openedAdapter = false;
|
||
this.serviceId = null;
|
||
this.notifyCharacteristicId = null;
|
||
this.writeCharacteristicId = null;
|
||
this._notifyCharacteristicIds = [];
|
||
this._lastRecvAt = 0;
|
||
this._setState(BLE_STATE.DISCONNECTED);
|
||
await this.initBluetooth();
|
||
} finally {
|
||
this._manuallyDisconnected = wasManuallyDisconnected;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 关闭蓝牙适配器（带超时兜底；失败也按已关闭继续）
|
||
* 关不掉必须继续走 open：停在"半关"状态比重新开一次更糟，
|
||
* 而卡在等待回调则会把整条重连链一起拖死
|
||
* @returns {Promise}
|
||
*/
|
||
_closeAdapter() {
|
||
return this._callWithTimeout(
|
||
(resolve) => wx.closeBluetoothAdapter({ success: resolve, fail: resolve, complete: resolve }),
|
||
'关闭蓝牙适配器',
|
||
this.config.adapterOpTimeout
|
||
).catch((err) => {
|
||
console.warn('[BLE] 关闭适配器未正常回调，按已关闭继续:', err && err.message);
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 手动硬重连：复位适配器 + 重建链路
|
||
* 详情页 BLE 状态点击触发，是"自动重连卡死"时的确定性出口
|
||
* @param {string} deviceId - 目标设备（缺省用上次目标）
|
||
* @param {string} serviceId - 服务 UUID（可选）
|
||
* @returns {Promise}
|
||
*/
|
||
hardReconnect(deviceId = null, serviceId = null) {
|
||
const target = deviceId || this._lastDeviceId;
|
||
if (!target) {
|
||
return Promise.reject(new Error('无重连目标'));
|
||
}
|
||
console.log('[BLE] 手动硬重连:', target);
|
||
return this.resetAdapter()
|
||
.then(() => this.connectDevice(target, serviceId || this._lastServiceId));
|
||
}
|
||
|
||
/**
|
||
* 强制重连当前目标设备（用于静默/掉线恢复）
|
||
* 先拆旧链再建链，确保拿到的是全新链路（静默可能只是"没有测量"，由调用方先探活）
|
||
* @returns {Promise}
|
||
*/
|
||
forceReconnect() {
|
||
const deviceId = this._lastDeviceId;
|
||
if (!deviceId) {
|
||
return Promise.reject(new Error('无重连目标'));
|
||
}
|
||
this._clearReconnectTimer();
|
||
this._reconnectAttempts = 0;
|
||
this._manuallyDisconnected = false;
|
||
|
||
// 已有在途连接：直接复用，绝不并发发起第二次 createBLEConnection
|
||
if (this._connectPromise && this._connectingDeviceId === deviceId) {
|
||
console.log('[BLE] 连接已在进行中，强制重连复用该流程:', deviceId);
|
||
return this._connectPromise;
|
||
}
|
||
|
||
console.log('[BLE] 强制重连（先拆旧链）:', deviceId);
|
||
return this._closeConnection(deviceId)
|
||
.then(() => this.connectDevice(deviceId, this._lastServiceId))
|
||
.catch((err) => {
|
||
if (err && err.cancelled) throw err;
|
||
console.error('[BLE] 强制重连失败:', err && err.message);
|
||
// 强制重连由页面/网关按需触发，无人再排重试 → 此处必须自愈，
|
||
// 否则链路会停在未连接状态直到下次回前台
|
||
if (this.config.autoReconnect && !this._manuallyDisconnected && this._lastDeviceId) {
|
||
this._scheduleReconnect();
|
||
}
|
||
throw err;
|
||
});
|
||
}
|
||
|
||
/**
|
||
* GATT 层探活：读一次服务表，确认链路是否真的还可用
|
||
* 用于区分"设备没在测量（静默正常）"与"链路已死"，避免无谓拆链重建
|
||
* @returns {Promise<boolean>}
|
||
*/
|
||
checkLinkAlive() {
|
||
const deviceId = this.deviceId;
|
||
if (!deviceId || !this.isReady()) return Promise.resolve(false);
|
||
return this._callWithTimeout(
|
||
(resolve, reject) => wx.getBLEDeviceServices({ deviceId, success: resolve, fail: reject }),
|
||
'链路探活'
|
||
)
|
||
.then(() => true)
|
||
.catch((err) => {
|
||
console.warn('[BLE] 链路探活失败:', err && (err.errMsg || err.message));
|
||
return false;
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 诊断信息（真机排查“收不到/收一条即停”用）
|
||
* @returns {Object}
|
||
*/
|
||
getDiagnostics() {
|
||
return {
|
||
state: this.state,
|
||
adapterOpen: !!this._openedAdapter,
|
||
deviceId: this.deviceId,
|
||
serviceId: this.serviceId,
|
||
notifyCharacteristicId: this.notifyCharacteristicId,
|
||
notifyCharacteristicIds: this._notifyCharacteristicIds || [],
|
||
writeCharacteristicId: this.writeCharacteristicId,
|
||
recvCount: this._recvCount,
|
||
lastRecvAt: this._lastRecvAt,
|
||
autoReconnect: this.config.autoReconnect,
|
||
connecting: !!this._connectPromise,
|
||
consecutiveCreateFails: this._consecutiveCreateFails,
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 清除数据回调（页面卸载时调用）
|
||
*/
|
||
clearCallbacks() {
|
||
this.onDataCallback = null;
|
||
this.onStateChangeCallback = null;
|
||
console.log('[BLE] 已清除回调');
|
||
}
|
||
}
|
||
|
||
// 导出单例
|
||
const bleService = new BleService();
|
||
|
||
module.exports = {
|
||
BLE_STATE,
|
||
BleService,
|
||
bleService,
|
||
}; |