ajy/code/ajyApp/stores/ble.js

/**
 * 艾灸椅 BLE Pinia Store
 * 真正的应用级单例，跨页面共享蓝牙状态
 *
 * 用法:
 *   import { useBleStore } from '@/stores/ble'
 *   const bleStore = useBleStore()
 *
 *   // 扫描
 *   await bleStore.startScan({ timeout: 15000, returnAll: true })
 *
 *   // 连接
 *   await bleStore.connectDevice(deviceId)
 *
 *   // 发送指令
 *   await bleStore.sendBasic({ power: 1, moxiState: 1 })
 *
 *   // 读取状态（自动响应式）
 *   bleStore.linked / bleStore.searching / bleStore.deviceStatus
 */

import { defineStore } from 'pinia'
import logger from '@/utils/ble/logger.js'
import {
	DEFAULT_CONFIG, BLE_STATE, BLE_ERROR,
	POWER, MOXI_STATE, MUTE, MODE, SUB_MODE, TEMPERATURE, CHAIR_ANGLE
} from '@/utils/ble/constants.js'
import {
	encodeBasic, encodeModeParam1, encodeModeParam2, encodeAcupoints,
	bufferToArrayBuffer, arrayBufferToU8, bytesToHex, FrameParser
} from '@/utils/ble/protocol.js'
import { ensureBlePrerequisite, openLocationSettings } from '@/utils/ble/permission.js'

// ========== 跨 nvue 页面共享内部变量（通过 globalData 确保单例） ==========
function _getShared() {
	const app = getApp()
	if (!app.globalData) app.globalData = {}
	if (!app.globalData._bleInternal) {
		app.globalData._bleInternal = {
			instanceId: Date.now() + '_' + Math.random().toString(36).slice(2, 6),
			serviceId: null,
			writeCharId: null,
			notifyCharId: null,
			reconnectTimer: null,
			reconnectCount: 0,
			reconnectGeneration: 0,  // 重连代数，用于丢弃僵尸回调
			writeLock: Promise.resolve(),
			bound: false,
			cancelScan: null,
			scanAborted: false,      // 标记扫描已被外部中止，防止僵尸扫描
			onDeviceFound: null,     // 当前扫描的设备发现回调
			scanStartHistory: [],    // 近期 startDiscovery 调用时间戳，用于检测 Android 限流
			intentionalDisconnect: false, // 标记主动断开，防止系统回调误触发重连
			_connectedBeforeScan: false, // 标记扫描前是否处于已连接状态
			parser: null,
			config: { ...DEFAULT_CONFIG }
		}
		console.log(`[BLE Store] 首次创建共享实例，instanceId = ${app.globalData._bleInternal.instanceId}`)
	}
	return app.globalData._bleInternal
}

// 兼容模块加载阶段（getApp()可能未就绪），延迟到首次调用时获取
let _shared = null
function _S() {
	if (!_shared) _shared = _getShared()
	return _shared
}

// 便捷访问
function _instanceId() { return _S().instanceId }

// ========== 工具函数 ==========
function _invoke(apiFn, params) {
	return new Promise((resolve, reject) => {
		apiFn({ ...params, success: resolve, fail: reject, complete: () => {} })
	})
}

function _err(code, origin) {
	const err = new Error(code)
	err.code = code
	if (origin) err.origin = origin
	return err
}

function _uuidEq(a, b) {
	return String(a || '').toLowerCase() === String(b || '').toLowerCase()
}

export const useBleStore = defineStore('ble', {
	state: () => ({
		// ===== 连接状态 =====
		bleState: BLE_STATE.IDLE,
		device: null, // { deviceId, name, RSSI }
		linked: false,

		// ===== 蓝牙开关状态 =====
		bleAdapterOff: false, // 蓝牙适配器未开启，页面可监听此状态展示提示

		// ===== 扫描 =====
		searching: false,
		scannedDevices: [],
		scanThrottled: false, // 检测到 Android 扫描限流时为 true，页面可监听此状态提示用户

		// ===== 设备运行状态（来自上报） =====
		deviceStatus: 0, // 0停止 1预热 2点火 3艾灸 4灭火 5暂停
		hotPercentage: '0%',
		ispreHot: false,
		subTime: '00:00:00',
		modeType: 0, // 0无艾灸 1专业 2自定义 3专家
		chairAngle: 90,

		// ===== 重连 =====
		reconnectDrawer: false,
		reconnectCount: 0,

		// ===== 异常 =====
		excepDrawer: false,
		exceTxt: 0,

		// ===== 耗材状态 =====
		otherSetting: {
			aijiuNum: '0',
			lvxinNum: '0',
			huishouNum: '0'
		}
	}),

	actions: {
		// ============== 配置 ==============
		configure(opt = {}) {
			const s = _S()
			s.config = { ...s.config, ...opt }
			logger.setEnabled(s.config.debug)
		},

		// ============== 内部状态管理 ==============
		_setState(s) {
			if (this.bleState === s) return
			const prevState = this.bleState
			this.bleState = s
			// 进入扫描状态时，如果当前有活跃连接，不应丢失 linked 状态
			if (s === BLE_STATE.SCANNING && prevState === BLE_STATE.READY_COMM) {
				_S()._connectedBeforeScan = true
				// linked 保持 true，仅更新 searching
			} else if (s === BLE_STATE.READY && _S()._connectedBeforeScan && this.device) {
				// 扫描结束恢复连接状态：物理连接仍存活
				_S()._connectedBeforeScan = false
				this.bleState = BLE_STATE.READY_COMM
				this.linked = true
			} else {
				_S()._connectedBeforeScan = false
				this.linked = (s === BLE_STATE.READY_COMM)
			}
			this.searching = (s === BLE_STATE.SCANNING)
			logger.info(`[instanceId=${_instanceId()}] state ->`, s, this.linked ? '(linked)' : '')
		},

		// ============== 初始化 / 释放 ==============
		async init() {
			console.log(`[BLE Store] init() called, instanceId = ${_instanceId()}`)
			if (this.bleState !== BLE_STATE.IDLE && this.bleState !== BLE_STATE.DISCONNECTED) {
				logger.info('蓝牙已初始化，跳过重复初始化')
				return
			}
			try {
				await _invoke(uni.openBluetoothAdapter, {})
				this.bleAdapterOff = false
			} catch (e) {
				logger.error('openBluetoothAdapter fail', e)
				const code = e && (e.errCode || e.code)
				const isOff = code === 10001
				if (isOff) {
					this.bleAdapterOff = true
					this._showBleOffPrompt('请先开启手机蓝牙，才能连接艾灸椅设备')
				}
				throw _err(isOff ? BLE_ERROR.ADAPTER_OFF : BLE_ERROR.NOT_SUPPORT, e)
			}
			this._bindSystemListeners()
			this._setState(BLE_STATE.READY)
			logger.info('蓝牙适配器已初始化')
		},

		async destroy() {
			this._clearReconnect()
			const s = _S()
			if (s.cancelScan) { s.cancelScan(); s.cancelScan = null }
			s.onDeviceFound = null
			try { await this.disconnect() } catch (_) {}
			try { await _invoke(uni.closeBluetoothAdapter, {}) } catch (_) {}
			this._unbindSystemListeners()
			this._setState(BLE_STATE.IDLE)
			if (s.parser) s.parser.reset()
		},

		/**
		 * 轻量级重置：只关闭适配器并重置状态，不解绑全局监听器
		 * 适用于页面切换时清除残留扫描/连接状态
		 */
		async resetAdapter() {
			const s = _S()
			s.intentionalDisconnect = true
			this._clearReconnect()
			if (s.cancelScan) { s.cancelScan(); s.cancelScan = null }
			s.onDeviceFound = null
			try { await _invoke(uni.closeBluetoothAdapter, {}) } catch (_) {}
			this._setState(BLE_STATE.IDLE)
			if (s.parser) s.parser.reset()
			s.intentionalDisconnect = false
		},

		/**
		 * 绑定BLE系统监听器 - 必须在 App.vue onLaunch 中调用
		 * 确保回调绑定到 App.vue 的 taskCenter（永不销毁）
		 */
		bindGlobalListeners() {
			if (_S().bound) return
			this._bindSystemListeners()
		},

		_bindSystemListeners() {
			const s = _S()
			if (s.bound) return

			// 初始化帧解析器
			if (!s.parser) {
				s.parser = new FrameParser(
					(decoded, frame) => this._onFrame(decoded, frame),
					(err, frame) => logger.warn('frame parse error', err.message, bytesToHex(frame))
				)
			}

			uni.onBluetoothAdapterStateChange(this._onAdapterStateChange = (res) => {
				logger.info('adapterStateChange', res)
				const s = _S()
				if (!res.available) {
					// 主动关闭适配器时不显示提示且不触发重连
					if (s.intentionalDisconnect) return
					this.bleAdapterOff = true
					this._showBleOffPrompt('蓝牙已关闭，设备连接已断开。请重新开启蓝牙以继续使用')
					this._handleDisconnected(BLE_ERROR.ADAPTER_OFF)
				} else {
					this.bleAdapterOff = false
					// 蓝牙重新开启：如果之前有连接过的设备且当前处于断连状态，自动发起重连
					this._onAdapterRestored()
				}
			})
			uni.onBLEConnectionStateChange(this._onConnStateChange = (res) => {
				logger.info('connectionStateChange', res)
				if (!res.connected && this.device && res.deviceId === this.device.deviceId) {
					this._handleDisconnected(BLE_ERROR.DISCONNECTED)
				}
			})
			uni.onBLECharacteristicValueChange(this._onCharChange = (res) => {
				const u8 = arrayBufferToU8(res.value)
				logger.log('<=', bytesToHex(u8))
				if (s.parser) s.parser.feed(u8)
			})
			// 永久注册设备发现监听器（不可反复 on/off，否则多次后系统丢失监听）
			uni.onBluetoothDeviceFound((res) => {
				if (s.onDeviceFound) s.onDeviceFound(res)
			})
			s.bound = true
			logger.info(`[instanceId=${s.instanceId}] BLE系统监听器已全局绑定（含onBluetoothDeviceFound）`)
		},

		_unbindSystemListeners() {
			// 全局监听器不再主动解绑，防止 taskCenter 丢失
			// 仅在极端情况下（如蓝牙完全不再使用）才解绑
		},

		// ============== 确保就绪 ==============
		async _ensureReady() {
			if (this.bleState === BLE_STATE.IDLE) await this.init()
			try {
				const res = await _invoke(uni.getBluetoothAdapterState, {})
				if (!res.available) {
					this.bleAdapterOff = true
					this._showBleOffPrompt('请先开启手机蓝牙，才能连接艾灸椅设备')
					throw _err(BLE_ERROR.ADAPTER_OFF)
				}
				this.bleAdapterOff = false
			} catch (e) {
				if (e && e.code && String(e.code).startsWith('BLE_')) throw e
				throw _err(BLE_ERROR.ADAPTER_OFF, e)
			}
		},

		// ============== 扫描 ==============
		async startScan(opt = {}) {
			const s = _S()
			console.log(`[BLE Store] startScan() called, instanceId = ${s.instanceId}`)
			// 重置中止标记
			s.scanAborted = false
			this.scanThrottled = false
			// 取消上一次残留扫描
			if (s.cancelScan) { s.cancelScan(); s.cancelScan = null }
			// 停止上一次发现
			await _invoke(uni.stopBluetoothDevicesDiscovery, {}).catch(() => {})

			await this._ensureReady()

			// 如果在 await 期间页面已卸载并调用了 stopScan，直接中止
			if (s.scanAborted) {
				logger.info('startScan aborted (page already unloaded)')
				return opt.returnAll ? [] : null
			}

			const {
				namePrefix = s.config.deviceNamePrefix,
				deviceName,
				services,
				timeout = s.config.scanTimeout,
				returnAll = false
			} = opt

			// 清空上次扫描结果
			this.scannedDevices = []

			// Android 限流检测（30秒内最多5次，iOS 无此限制）
			const platform = uni.getSystemInfoSync().platform
			if (platform === 'android') {
				const now = Date.now()
				s.scanStartHistory = s.scanStartHistory.filter(t => now - t < 30000)
				if (s.scanStartHistory.length >= 4) {
					this.scanThrottled = true
					logger.warn(`BLE scan throttle: ${s.scanStartHistory.length + 1} starts in 30s, system may ignore`)
				}
				s.scanStartHistory.push(now)
			}

			const devices = new Map()
			const matched = []

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

				const onFound = (res) => {
					if (finished) return
					for (const d of res.devices) {
						if (devices.has(d.deviceId)) continue
						devices.set(d.deviceId, d)
						const name = d.name || d.localName || ''
						const hit =
							(deviceName && name === deviceName) ||
							(namePrefix && name.startsWith(namePrefix)) ||
							(!deviceName && !namePrefix)
						if (hit) {
							matched.push(d)
							const exists = this.scannedDevices.find(item => item.deviceId === d.deviceId)
							if (!exists) {
								this.scannedDevices.push({
									deviceId: d.deviceId,
									name: name,
									RSSI: d.RSSI || ''
								})
							}
							if (!returnAll) { finish(null, d); return }
						}
					}
				}

				const timer = setTimeout(() => {
					if (returnAll) finish(null, matched)
					else if (matched.length) finish(null, matched[0])
					else finish(_err(BLE_ERROR.SCAN_FAIL, { msg: '扫描超时，未发现目标设备' }))
				}, timeout)

				const finish = (err, data) => {
					if (finished) return
					finished = true
					s.cancelScan = null
					s.onDeviceFound = null
					clearTimeout(timer)
					_invoke(uni.stopBluetoothDevicesDiscovery, {}).catch(() => {})
					this._setState(BLE_STATE.READY)
					err ? reject(err) : resolve(data)
				}

				s.cancelScan = () => finish(null, returnAll ? matched : (matched[0] || null))

				// 通过共享回调分发事件（监听器已在 _bindSystemListeners 中永久注册）
				s.onDeviceFound = onFound
				this._setState(BLE_STATE.SCANNING)

				try {
					await _invoke(uni.startBluetoothDevicesDiscovery, {
						allowDuplicatesKey: false,
						interval: 0,
						services
					})
				} catch (e) {
					finish(_err(BLE_ERROR.SCAN_FAIL, e))
				}
			})
		},

		/** 停止扫描 */
		stopScan() {
			const s = _S()
			s.scanAborted = true
			s.onDeviceFound = null
			if (s.cancelScan) {
				s.cancelScan()
				s.cancelScan = null
			} else {
				try {
					uni.stopBluetoothDevicesDiscovery({ success() {}, fail() {} })
				} catch (e) {}
			}
			this.searching = false
			this.scanThrottled = false
			if (this.bleState === BLE_STATE.SCANNING) {
				// _setState(READY) 内部会检测 _connectedBeforeScan，
				// 若扫描前有连接则自动恢复为 READY_COMM
				this._setState(BLE_STATE.READY)
			}
		},

		// ============== 连接 ==============
		async connectDevice(deviceId) {
			const s = _S()
			console.log(`[BLE Store] connectDevice() called, instanceId = ${s.instanceId}`)
			if (!deviceId) throw _err(BLE_ERROR.CONNECT_FAIL, { msg: 'deviceId 不能为空' })
			await this._ensureReady()
			if (this.bleState === BLE_STATE.CONNECTING) throw _err(BLE_ERROR.BUSY)
			this._setState(BLE_STATE.CONNECTING)
			this.device = { deviceId, name: '' }

			try {
				await _invoke(uni.createBLEConnection, {
					deviceId,
					timeout: s.config.connectTimeout
				})
				this._setState(BLE_STATE.CONNECTED)

				// Android 提升 MTU
				// #ifdef APP-PLUS
				if (uni.getSystemInfoSync().platform === 'android' && uni.setBLEMTU) {
					try { await _invoke(uni.setBLEMTU, { deviceId, mtu: 185 }) } catch (_) {}
				}
				// #endif

				await this._discoverAndSubscribe(deviceId)
				this._setState(BLE_STATE.READY_COMM)
				s.reconnectCount = 0
			} catch (e) {
				this._setState(BLE_STATE.DISCONNECTED)
				this.device = null // 连接失败，清空 device 防止延迟回调误触发重连
				try { await _invoke(uni.closeBLEConnection, { deviceId }) } catch (_) {}
				const code = e && (e.errCode || e.code)
				if (code === 10003 || code === -1) {
					throw _err(BLE_ERROR.CONNECT_TIMEOUT, e)
				}
				throw _err(BLE_ERROR.CONNECT_FAIL, e)
			}
		},

		/** 扫描 + 连接一步到位（支持 deviceId 直连优先，跳过扫描） */
		async scanAndConnect(opt = {}) {
			const { deviceId: directId, deviceName, ...restOpt } = opt

			// 策略：如果已有 deviceId，先尝试直连（不扫描），失败后回退扫描
			if (directId) {
				try {
					logger.info(`directConnect attempt, deviceId=${directId}`)
					await this.connectDevice(directId)
					this.device.name = deviceName || this.device.name || ''
					logger.info('directConnect success, scan skipped')
					return this.device
				} catch (e) {
					logger.warn('directConnect failed, fallback to scan', e.message || e.code)
					// connectDevice 失败时已清空 this.device 并关闭连接，无需额外处理
				}
			}

			// 回退：扫描 + 连接
			const scanOpt = { ...restOpt }
			if (deviceName) scanOpt.deviceName = deviceName
			const device = await this.startScan(scanOpt)
			await this.connectDevice(device.deviceId)
			this.device.name = device.name || device.localName || ''
			return this.device
		},

		/** 主动断开 */
		async disconnect() {
			const s = _S()
			s.intentionalDisconnect = true
			this._clearReconnect()
			if (!this.device) {
				s.intentionalDisconnect = false
				return
			}
			const { deviceId } = this.device
			// 先置空 device，防止 onBLEConnectionStateChange 回调误匹配
			this.device = null
			this._setState(BLE_STATE.DISCONNECTED)
			try { await _invoke(uni.closeBLEConnection, { deviceId }) } catch (_) {}
			s.intentionalDisconnect = false
		},

		/** 发现服务并订阅通知 */
		async _discoverAndSubscribe(deviceId) {
			const s = _S()
			const svcRes = await _invoke(uni.getBLEDeviceServices, { deviceId })
			const services = svcRes.services || []
			const targetSvc = services.find(sv => _uuidEq(sv.uuid, s.config.serviceId))
				|| services.find(sv => sv.isPrimary)
				|| services[0]
			if (!targetSvc) throw _err(BLE_ERROR.SERVICE_NOT_FOUND)
			s.serviceId = targetSvc.uuid

			const charRes = await _invoke(uni.getBLEDeviceCharacteristics, {
				deviceId, serviceId: s.serviceId
			})
			const chars = charRes.characteristics || []

			const writeChar = chars.find(c => _uuidEq(c.uuid, s.config.writeCharId))
				|| chars.find(c => c.properties && (c.properties.write || c.properties.writeNoResponse || c.properties.writeDefault))
			const notifyChar = chars.find(c => _uuidEq(c.uuid, s.config.notifyCharId))
				|| chars.find(c => c.properties && (c.properties.notify || c.properties.indicate))

			if (!writeChar) throw _err(BLE_ERROR.CHAR_NOT_FOUND, { msg: '未找到写特征' })
			if (!notifyChar) throw _err(BLE_ERROR.CHAR_NOT_FOUND, { msg: '未找到通知特征' })

			s.writeCharId = writeChar.uuid
			s.notifyCharId = notifyChar.uuid

			await _invoke(uni.notifyBLECharacteristicValueChange, {
				deviceId,
				serviceId: s.serviceId,
				characteristicId: s.notifyCharId,
				state: true
			})
		},

		// ============== 断连处理 & 自动重连 ==============
		_handleDisconnected(reason) {
			const s = _S()
			// 主动断开/重置时不触发重连
			if (s.intentionalDisconnect) return
			if (this.bleState === BLE_STATE.DISCONNECTED || this.bleState === BLE_STATE.IDLE) return
			const device = this.device
			this._setState(BLE_STATE.DISCONNECTED)
			if (s.parser) s.parser.reset()
			this._attemptReconnect(device, reason)
		},

		_attemptReconnect(device, reason) {
			const s = _S()
			if (!s.config.autoReconnect || !device || s.reconnectCount >= s.config.maxReconnect) {
				if (s.reconnectCount >= s.config.maxReconnect) {
					logger.warn('reconnect max reached, waiting for adapter restore')
					s.reconnectCount = 0
					this.reconnectDrawer = false
					this.reconnectCount = 0
				}
				return
			}
			s.reconnectCount++
			this.reconnectCount = s.reconnectCount
			this.reconnectDrawer = true
			const delay = Math.min(1000 * s.reconnectCount, 5000)
			logger.warn(`reconnect in ${delay}ms (${s.reconnectCount}/${s.config.maxReconnect})`)

			const gen = s.reconnectGeneration
			s.reconnectTimer = setTimeout(async () => {
				if (s.reconnectGeneration !== gen) {
					logger.info('reconnect callback aborted (generation mismatch)')
					return
				}
				try {
					// 先关闭适配器清除脏状态（加标志防止回调干扰）
					s.intentionalDisconnect = true
					try { await _invoke(uni.closeBluetoothAdapter, {}) } catch (_) {}
					s.intentionalDisconnect = false
					this._setState(BLE_STATE.IDLE)
					if (s.reconnectGeneration !== gen) return
					// 优先使用 deviceId 直连，避免不必要的扫描触发 Android 限流
					const scanOpt = { timeout: 8000 }
					if (device.deviceId) scanOpt.deviceId = device.deviceId
					if (device.name) scanOpt.deviceName = device.name
					await this.scanAndConnect(scanOpt)
					if (s.reconnectGeneration !== gen) return
					this.reconnectDrawer = false
					this.reconnectCount = 0
					logger.info('reconnect success')
				} catch (e) {
					if (s.reconnectGeneration !== gen) return
					logger.error('reconnect fail', e)
					this._attemptReconnect(device, reason)
				}
			}, delay)
		},

		_clearReconnect() {
			const s = _S()
			if (s.reconnectTimer) { clearTimeout(s.reconnectTimer); s.reconnectTimer = null }
			s.reconnectCount = 0
			s.reconnectGeneration++ // 递增代数，使正在执行的僵尸回调自动失效
			this.reconnectCount = 0
			this.reconnectDrawer = false
		},

		/**
		 * 蓝牙适配器从关闭恢复为开启时调用
		 * 如果之前有连接过的设备且当前处于断连状态，自动扫描并重新连接
		 */
		_onAdapterRestored() {
			const device = this.device
			if (!device || !device.deviceId) return
			if (this.bleState !== BLE_STATE.DISCONNECTED && this.bleState !== BLE_STATE.IDLE) return
			logger.info('adapter restored, auto reconnecting to', device.name || device.deviceId)
			// 重置重连计数，发起新一轮重连
			this._clearReconnect()
			this._setState(BLE_STATE.IDLE)
			// 延迟 1.5s 等待适配器完全就绪（Android 蓝牙状态延迟）
			const s = _S()
			const gen = s.reconnectGeneration
			this.reconnectDrawer = true
			this.reconnectCount = 1
			s.reconnectTimer = setTimeout(async () => {
				if (s.reconnectGeneration !== gen) return
				try {
					// 关闭旧适配器，确保重新打开时状态干净
					s.intentionalDisconnect = true
					try { await _invoke(uni.closeBluetoothAdapter, {}) } catch (_) {}
					s.intentionalDisconnect = false
					if (s.reconnectGeneration !== gen) return
					// 优先直连，避免扫描触发限流
					const scanOpt = { timeout: 8000 }
					if (device.deviceId) scanOpt.deviceId = device.deviceId
					if (device.name) scanOpt.deviceName = device.name
					await this.scanAndConnect(scanOpt)
					if (s.reconnectGeneration !== gen) return
					this.reconnectDrawer = false
					this.reconnectCount = 0
					logger.info('adapter restore reconnect success')
				} catch (e) {
					if (s.reconnectGeneration !== gen) return
					logger.error('adapter restore reconnect fail', e)
					// 失败后进入常规重连流程（还有2次机会）
					s.reconnectCount = 1
					this._attemptReconnect(device, BLE_ERROR.ADAPTER_OFF)
				}
			}, 1500)
		},

		// ============== 收包处理 ==============
		_onFrame(decoded, frame) {
			logger.info('frame received', decoded.funcCode)
			if (decoded.parsed) {
				if (decoded.parsed.type === 'GROUP_1') {
					this._handleGroup1(decoded.parsed)
				} else if (decoded.parsed.type === 'GROUP_2') {
					this._handleGroup2(decoded.parsed)
				}
			}
		},

		/** 解析参数组1 */
		_handleGroup1(data) {
			// 设备运行状态
			switch (data.runtimeState) {
				case 0x00: this.deviceStatus = 0; break
				case 0x01:
				case 0x02: this.deviceStatus = 1; break
				case 0x03: this.deviceStatus = 3; break
				case 0x04: this.deviceStatus = 4; break
				case 0x05: this.deviceStatus = 5; break
			}
			// 模式
			switch (data.mode) {
				case MODE.LEISURE: this.modeType = 0; break
				case MODE.PROFESSIONAL: this.modeType = 1; break
				case MODE.PERSONAL: this.modeType = 2; break
				case MODE.EXPERT: this.modeType = 3; break
			}
			// 剩余时间
			const m = data.remainMinute || 0
			const s = data.remainSecond || 0
			const h = Math.floor(m / 60)
			const m1 = m % 60
			this.subTime = `${h.toString().padStart(2, '0')}:${m1.toString().padStart(2, '0')}:${s.toString().padStart(2, '0')}`
			// 异常检测
			if (data.foreignDetect === 0x02) {
				this.excepDrawer = true
				this.exceTxt = 1
			}
			// 耗材状态
			this.otherSetting.aijiuNum = String(data.consumable || 0)
			this.otherSetting.lvxinNum = String(data.filterPercent || 0)
			this.otherSetting.huishouNum = String(data.recycleBinPct || 0)
		},

		/** 解析参数组2 */
		_handleGroup2(data) {
			if (data.preheatPercent < 100) {
				this.ispreHot = false
				this.hotPercentage = data.preheatPercent + '%'
			} else {
				this.ispreHot = true
				this.hotPercentage = data.ignitePercent + '%'
			}
			// 椅子角度
			if (data.chairAngle) {
				const angleMap = {
					1: 90, 2: 105, 3: 120, 4: 135, 5: 150
				}
				if (angleMap[data.chairAngle]) {
					this.chairAngle = angleMap[data.chairAngle]
				}
			}
		},

		// ============== 发送指令 ==============
		async writeRaw(u8) {
			if (!this.linked) throw _err(BLE_ERROR.DISCONNECTED)
			const s = _S()
			const payload = bufferToArrayBuffer(u8)
			s.writeLock = s.writeLock.then(async () => {
				logger.log('=>', bytesToHex(u8))
				logger.log('write params:', {
					deviceId: this.device.deviceId,
					serviceId: s.serviceId,
					characteristicId: s.writeCharId,
					valueByteLength: payload.byteLength
				})
				try {
					await _invoke(uni.writeBLECharacteristicValue, {
						deviceId: this.device.deviceId,
						serviceId: s.serviceId,
						characteristicId: s.writeCharId,
						value: payload
					})
				} catch (e) {
					logger.error('writeBLE origin error:', JSON.stringify(e))
					throw _err(BLE_ERROR.WRITE_FAIL, e)
				}
			})
			return s.writeLock
		},

		/** 下发基本功能指令 (0x01) */
		sendBasic(opt) { return this.writeRaw(encodeBasic(opt)) },

		/** 下发模式参数 1 (步骤 1-7) */
		sendModeParam1(opt) { return this.writeRaw(encodeModeParam1(opt)) },

		/** 下发模式参数 2 (步骤 8-14) */
		sendModeParam2(opt) { return this.writeRaw(encodeModeParam2(opt)) },

		/** 下发穴位坐标 */
		async sendAcupoints(points = []) {
			for (let i = 0; i < points.length; i += 2) {
				const pair = points.slice(i, i + 2)
				await this.writeRaw(encodeAcupoints(pair))
			}
		},

		// ---- 常用快捷方法 ----
		powerOn() { return this.sendBasic({ power: POWER.ON }) },
		powerOff() { return this.sendBasic({ power: POWER.OFF }) },
		startMoxi(opt = {}) { return this.sendBasic({ power: POWER.ON, moxiState: MOXI_STATE.START, ...opt }) },
		pauseMoxi() { return this.sendBasic({ moxiState: MOXI_STATE.PAUSE }) },
		stopMoxi() { return this.sendBasic({ moxiState: MOXI_STATE.DONE }) },
		setMute(on) { return this.sendBasic({ mute: on ? MUTE.ON : MUTE.OFF }) },
		setTemperature(v) { return this.sendBasic({ temperature: v }) },
		setChairAngle(v) { return this.sendBasic({ angle: v }) },

		// ============== 蓝牙关闭提示 ==============
		/**
		 * 弹窗提示用户蓝牙未开启，引导用户前往设置开启
		 * 内部做防抖，避免短时间内重复弹窗
		 */
		_showBleOffPrompt(message) {
			const s = _S()
			// 弹窗正在显示中，不重复弹出
			if (s._bleOffPromptShowing) return
			s._bleOffPromptShowing = true

			uni.showModal({
				title: '蓝牙未开启',
				content: message || '请开启手机蓝牙后重试',
				confirmText: '去设置',
				cancelText: '取消',
				success: (res) => {
					s._bleOffPromptShowing = false
					if (res.confirm) {
						// #ifdef APP-PLUS
						const platform = uni.getSystemInfoSync().platform
						if (platform === 'android') {
							try {
								const main = plus.android.runtimeMainActivity()
								const Intent = plus.android.importClass('android.content.Intent')
								const Settings = plus.android.importClass('android.provider.Settings')
								const intent = new Intent(Settings.ACTION_BLUETOOTH_SETTINGS)
								main.startActivity(intent)
							} catch (e) {
								logger.error('跳转蓝牙设置失败', e)
							}
						} else if (platform === 'ios') {
							// iOS 可以打开 App 设置页
							plus.runtime.openURL('App-Prefs:root=Bluetooth')
						}
						// #endif
					}
				}
			})
		}
	}
})