-
+
-
+
-
-
-
-
-
- {{ scope.row.assigneeUser?.deptName || scope.row.ownerUser?.deptName }}
-
-
-
-
-
-
-
-
- {{ formatPast2(scope.row.durationInMillis) }}
-
-
-
-
-
+
+
+
+
+ {{ scope.row.assigneeUser?.deptName || scope.row.ownerUser?.deptName }}
+
+
+
+
+
+
+
+
+ {{ formatPast2(scope.row.durationInMillis) }}
+
+
+
+
+
diff --git a/web/src/components/bpmnProcessDesigner/package/theme/index.scss b/web/src/components/bpmnProcessDesigner/package/theme/index.scss
index 2404760..c320d08 100644
--- a/web/src/components/bpmnProcessDesigner/package/theme/index.scss
+++ b/web/src/components/bpmnProcessDesigner/package/theme/index.scss
@@ -2,14 +2,15 @@
@use './process-panel.scss';
$success-color: #4eb819;
-$primary-color: #409EFF;
-$danger-color: #F56C6C;
+$primary-color: #409eff;
+$danger-color: #f56c6c;
$cancel-color: #909399;
.process-viewer {
position: relative;
- border: 1px solid #EFEFEF;
- background: url('data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNDAiIGhlaWdodD0iNDAiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+PGRlZnM+PHBhdHRlcm4gaWQ9ImEiIHdpZHRoPSI0MCIgaGVpZ2h0PSI0MCIgcGF0dGVyblVuaXRzPSJ1c2VyU3BhY2VPblVzZSI+PHBhdGggZD0iTTAgMTBoNDBNMTAgMHY0ME0wIDIwaDQwTTIwIDB2NDBNMCAzMGg0ME0zMCAwdjQwIiBmaWxsPSJub25lIiBzdHJva2U9IiNlMGUwZTAiIG9wYWNpdHk9Ii4yIi8+PHBhdGggZD0iTTQwIDBIMHY0MCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZTBlMGUwIi8+PC9wYXR0ZXJuPjwvZGVmcz48cmVjdCB3aWR0aD0iMTAwJSIgaGVpZ2h0PSIxMDAlIiBmaWxsPSJ1cmwoI2EpIi8+PC9zdmc+') repeat!important;
+ border: 1px solid #efefef;
+ background: url('data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iNDAiIGhlaWdodD0iNDAiIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2ZyI+PGRlZnM+PHBhdHRlcm4gaWQ9ImEiIHdpZHRoPSI0MCIgaGVpZ2h0PSI0MCIgcGF0dGVyblVuaXRzPSJ1c2VyU3BhY2VPblVzZSI+PHBhdGggZD0iTTAgMTBoNDBNMTAgMHY0ME0wIDIwaDQwTTIwIDB2NDBNMCAzMGg0ME0zMCAwdjQwIiBmaWxsPSJub25lIiBzdHJva2U9IiNlMGUwZTAiIG9wYWNpdHk9Ii4yIi8+PHBhdGggZD0iTTQwIDBIMHY0MCIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjZTBlMGUwIi8+PC9wYXR0ZXJuPjwvZGVmcz48cmVjdCB3aWR0aD0iMTAwJSIgaGVpZ2h0PSIxMDAlIiBmaWxsPSJ1cmwoI2EpIi8+PC9zdmc+')
+ repeat !important;
.success-arrow {
fill: $success-color;
@@ -23,7 +24,7 @@ $cancel-color: #909399;
.success.djs-connection {
.djs-visual path {
- stroke: $success-color!important;
+ stroke: $success-color !important;
//marker-end: url(#sequenceflow-end-white-success)!important;
}
}
@@ -36,82 +37,84 @@ $cancel-color: #909399;
.success.djs-shape {
.djs-visual rect {
- stroke: $success-color!important;
- fill: $success-color!important;
- fill-opacity: 0.15!important;
+ stroke: $success-color !important;
+ fill: $success-color !important;
+ fill-opacity: 0.15 !important;
}
.djs-visual polygon {
- stroke: $success-color!important;
+ stroke: $success-color !important;
}
.djs-visual path:nth-child(2) {
- stroke: $success-color!important;
- fill: $success-color!important;
+ stroke: $success-color !important;
+ fill: $success-color !important;
}
.djs-visual circle {
- stroke: $success-color!important;
- fill: $success-color!important;
- fill-opacity: 0.15!important;
+ stroke: $success-color !important;
+ fill: $success-color !important;
+ fill-opacity: 0.15 !important;
}
}
.primary.djs-shape {
.djs-visual rect {
- stroke: $primary-color!important;
- fill: $primary-color!important;
- fill-opacity: 0.15!important;
+ stroke: $primary-color !important;
+ fill: $primary-color !important;
+ fill-opacity: 0.15 !important;
}
.djs-visual polygon {
- stroke: $primary-color!important;
+ stroke: $primary-color !important;
}
.djs-visual circle {
- stroke: $primary-color!important;
- fill: $primary-color!important;
- fill-opacity: 0.15!important;
+ stroke: $primary-color !important;
+ fill: $primary-color !important;
+ fill-opacity: 0.15 !important;
}
}
.danger.djs-shape {
.djs-visual rect {
- stroke: $danger-color!important;
- fill: $danger-color!important;
- fill-opacity: 0.15!important;
+ stroke: $danger-color !important;
+ fill: $danger-color !important;
+ fill-opacity: 0.15 !important;
}
.djs-visual polygon {
- stroke: $danger-color!important;
+ stroke: $danger-color !important;
}
.djs-visual circle {
- stroke: $danger-color!important;
- fill: $danger-color!important;
- fill-opacity: 0.15!important;
+ stroke: $danger-color !important;
+ fill: $danger-color !important;
+ fill-opacity: 0.15 !important;
}
}
.cancel.djs-shape {
.djs-visual rect {
- stroke: $cancel-color!important;
- fill: $cancel-color!important;
- fill-opacity: 0.15!important;
+ stroke: $cancel-color !important;
+ fill: $cancel-color !important;
+ fill-opacity: 0.15 !important;
}
.djs-visual polygon {
- stroke: $cancel-color!important;
+ stroke: $cancel-color !important;
}
.djs-visual circle {
- stroke: $cancel-color!important;
- fill: $cancel-color!important;
- fill-opacity: 0.15!important;
+ stroke: $cancel-color !important;
+ fill: $cancel-color !important;
+ fill-opacity: 0.15 !important;
}
}
}
-.process-viewer .djs-tooltip-container, .process-viewer .djs-overlay-container, .process-viewer .djs-palette {
+.process-viewer .djs-tooltip-container,
+.process-viewer .djs-overlay-container,
+.process-viewer .djs-palette {
display: none;
}
diff --git a/web/src/hooks/web/useWatermark.ts b/web/src/hooks/web/useWatermark.ts
index 028926b..aa604e0 100644
--- a/web/src/hooks/web/useWatermark.ts
+++ b/web/src/hooks/web/useWatermark.ts
@@ -8,7 +8,7 @@ export function useWatermark(appendEl: HTMLElement | null = document.body) {
const id = domSymbol.toString()
const appStore = useAppStore()
let watermarkStr = ''
-
+
const clear = () => {
const domId = document.getElementById(id)
if (domId) {
diff --git a/web/src/layout/components/Footer/src/Footer.vue b/web/src/layout/components/Footer/src/Footer.vue
index 5ea6b5e..2f3dea8 100644
--- a/web/src/layout/components/Footer/src/Footer.vue
+++ b/web/src/layout/components/Footer/src/Footer.vue
@@ -22,6 +22,8 @@ const currentYear = computed(() => new Date().getFullYear())
:class="prefixCls"
class="h-[var(--app-footer-height)] bg-[var(--app-content-bg-color)] text-center leading-[var(--app-footer-height)] text-[var(--el-text-color-placeholder)] dark:bg-[var(--el-bg-color)] overflow-hidden"
>
- Copyright ©{{ currentYear }} {{ title }} 京公网安备 11010702002311号
+ Copyright ©{{ currentYear }} {{ title }} 京公网安备 11010702002311号
diff --git a/web/src/layout/components/Setting/src/Setting.vue b/web/src/layout/components/Setting/src/Setting.vue
index 2973674..005e9fb 100644
--- a/web/src/layout/components/Setting/src/Setting.vue
+++ b/web/src/layout/components/Setting/src/Setting.vue
@@ -297,6 +297,6 @@ $prefix-cls: #{$namespace}-setting;
.#{$prefix-cls} {
border-radius: 6px 0 0 6px;
- z-index: 1200;/*修正没有z-index会被表格层覆盖,值不要超过4000*/
+ z-index: 1200; /*修正没有z-index会被表格层覆盖,值不要超过4000*/
}
diff --git a/web/src/layout/components/TenantVisit/index.vue b/web/src/layout/components/TenantVisit/index.vue
index 2d7dced..07adfa6 100644
--- a/web/src/layout/components/TenantVisit/index.vue
+++ b/web/src/layout/components/TenantVisit/index.vue
@@ -1,8 +1,14 @@
+
结束
+ try {
+ await ElMessageBox.confirm(
+ `
`,
- '选择锁具',
- {
- confirmButtonText: '确定',
- cancelButtonText: '取消',
- dangerouslyUseHTMLString: true,
- beforeClose: (action, _instance, done) => {
- if (action === 'confirm') {
- const selector = document.getElementById('lockSelector') as HTMLSelectElement
- const selectedValue = selector?.value
-
- if (!selectedValue) {
- ElMessage.warning('请选择一个锁具')
- return false
- }
-
- selectedLockId = selectedValue
- }
- done()
- }
- }
- )
+ '选择锁具',
+ {
+ confirmButtonText: '确定',
+ cancelButtonText: '取消',
+ dangerouslyUseHTMLString: true,
+ beforeClose: (action, _instance, done) => {
+ if (action === 'confirm') {
+ const selector = document.getElementById('lockSelector') as HTMLSelectElement
+ const selectedValue = selector?.value
- // 用户点击确定后执行绑定
- if (selectedLockId) {
- await performBind(detail, Number(selectedLockId), useUserStore().getUser.id)
+ if (!selectedValue) {
+ ElMessage.warning('请选择一个锁具')
+ return false
}
- } catch (error) {
- // 用户取消选择，不做任何操作
- console.log('用户取消选择锁具')
+
+ selectedLockId = selectedValue
+ }
+ done()
}
+ }
+ )
+
+ // 用户点击确定后执行绑定
+ if (selectedLockId) {
+ await performBind(detail, Number(selectedLockId), useUserStore().getUser.id)
}
- } catch (error) {
- ElMessage.error('绑定失败，请重试')
+ } catch (error) {
+ // 用户取消选择，不做任何操作
+ console.log('用户取消选择锁具')
throw error
+ }
}
+ } catch (error) {
+ // ElMessage.error('绑定失败，请重试')
+ throw error
+ }
}
// 将 localId 转换为 File（先尝试 getLocalImgData，失败则用 Canvas 回退）
async function convertLocalIdToFile(localId: string): Promise {
- // 优先：getLocalImgData（iOS 常见）
- if ((ww as any).getLocalImgData) {
- try {
- const localDataRes = await (ww as any).getLocalImgData({ localId })
- const base64 = String((localDataRes && localDataRes.localData) || '')
- const dataUrl = base64.startsWith('data:') ? base64 : `data:image/jpeg;base64,${base64}`
- return download.base64ToFile(dataUrl, 'photo')
- } catch (_) { /* fallback to canvas */ }
+ // 优先：getLocalImgData（iOS 常见）
+ if ((ww as any).getLocalImgData) {
+ try {
+ const localDataRes = await (ww as any).getLocalImgData({ localId })
+ const base64 = String((localDataRes && localDataRes.localData) || '')
+ const dataUrl = base64.startsWith('data:') ? base64 : `data:image/jpeg;base64,${base64}`
+ return download.base64ToFile(dataUrl, 'photo')
+ } catch (_) {
+ /* fallback to canvas */
}
+ }
- // 回退：使用 Canvas 生成 base64 再转 File（Android 常见）
- return await new Promise((resolve, reject) => {
- const img = new Image()
- img.crossOrigin = 'anonymous'
- img.onload = () => {
- try {
- const canvas = document.createElement('canvas')
- canvas.width = img.width
- canvas.height = img.height
- const ctx = canvas.getContext('2d')
- if (!ctx) throw new Error('canvas context 获取失败')
- ctx.drawImage(img, 0, 0, img.width, img.height)
- const dataUrl = canvas.toDataURL('image/jpeg')
- resolve(download.base64ToFile(dataUrl, 'photo'))
- } catch (err) {
- reject(err)
- }
- }
- img.onerror = (err) => reject(err)
- img.src = localId
- })
+ // 回退：使用 Canvas 生成 base64 再转 File（Android 常见）
+ return await new Promise((resolve, reject) => {
+ const img = new Image()
+ img.crossOrigin = 'anonymous'
+ img.onload = () => {
+ try {
+ const canvas = document.createElement('canvas')
+ canvas.width = img.width
+ canvas.height = img.height
+ const ctx = canvas.getContext('2d')
+ if (!ctx) throw new Error('canvas context 获取失败')
+ ctx.drawImage(img, 0, 0, img.width, img.height)
+ const dataUrl = canvas.toDataURL('image/jpeg')
+ resolve(download.base64ToFile(dataUrl, 'photo'))
+ } catch (err) {
+ reject(err)
+ }
+ }
+ img.onerror = (err) => reject(err)
+ img.src = localId
+ })
}
// 创建文件选择器（非企业微信环境使用）
async function selectFile(): Promise {
- return new Promise((resolve, reject) => {
- const input = document.createElement('input')
- input.type = 'file'
- input.accept = 'image/*'
- input.style.display = 'none'
+ return new Promise((resolve, reject) => {
+ const input = document.createElement('input')
+ input.type = 'file'
+ input.accept = 'image/*'
+ input.style.display = 'none'
- input.onchange = (event) => {
- const target = event.target as HTMLInputElement
- const file = target.files?.[0]
- document.body.removeChild(input)
+ input.onchange = (event) => {
+ const target = event.target as HTMLInputElement
+ const file = target.files?.[0]
+ document.body.removeChild(input)
- if (file) {
- resolve(file)
- } else {
- reject(new Error('未选择文件'))
- }
- }
+ if (file) {
+ resolve(file)
+ } else {
+ reject(new Error('未选择文件'))
+ }
+ }
- input.oncancel = () => {
- document.body.removeChild(input)
- reject(new Error('用户取消选择'))
- }
+ input.oncancel = () => {
+ document.body.removeChild(input)
+ reject(new Error('用户取消选择'))
+ }
- document.body.appendChild(input)
- input.click()
- })
+ document.body.appendChild(input)
+ input.click()
+ })
}
export const getPhoto = async () => {
- try {
- if (appStore.isWorkWechat) {
- // 放宽企业微信JSSDK类型限制，兼容不同终端返回与参数
- const chooseRes = await (ww as any).chooseImage({
- count: 1,
- sizeType: ['original'],
- sourceType: ['camera'],
- defaultCameraMode: 'normal',
- isSaveToAlbum: false
- } as any) as {
- localIds?: string[]
- localId?: string
- tempFiles?: Array<{ file?: File }>
- }
+ try {
+ if (appStore.isWorkWechat) {
+ // 放宽企业微信JSSDK类型限制，兼容不同终端返回与参数
+ const chooseRes = (await (ww as any).chooseImage({
+ count: 1,
+ sizeType: ['original'],
+ sourceType: ['camera'],
+ defaultCameraMode: 'normal',
+ isSaveToAlbum: false
+ } as any)) as {
+ localIds?: string[]
+ localId?: string
+ tempFiles?: Array<{ file?: File }>
+ }
- // 企业微信返回可能是 tempFiles 或 localIds/localId
- const directFile: File | undefined = (chooseRes as any)?.tempFiles?.[0]?.file
- const localId: string | undefined = chooseRes?.localIds?.[0] || (chooseRes as any)?.localId
+ // 企业微信返回可能是 tempFiles 或 localIds/localId
+ const directFile: File | undefined = (chooseRes as any)?.tempFiles?.[0]?.file
+ const localId: string | undefined = chooseRes?.localIds?.[0] || (chooseRes as any)?.localId
- const file: File | null = directFile
- ? directFile
- : (localId ? await convertLocalIdToFile(localId) : null)
+ const file: File | null = directFile
+ ? directFile
+ : localId
+ ? await convertLocalIdToFile(localId)
+ : null
- if (!file) throw new Error('无法获取拍照文件')
+ if (!file) throw new Error('无法获取拍照文件')
- const uploadRes = await updateFile({ file })
- return uploadRes && uploadRes.data
- } else {
- // 非企业微信环境：选择文件并上传
- const file = await selectFile()
- const uploadRes = await updateFile({ file })
- return uploadRes && uploadRes.data
- }
- } catch (err) {
- ElMessage.error('文件上传失败')
- throw err
- }
+ const uploadRes = await updateFile({ file })
+ return uploadRes && uploadRes.data
+ } else {
+ // 非企业微信环境：选择文件并上传
+ const file = await selectFile()
+ const uploadRes = await updateFile({ file })
+ return uploadRes && uploadRes.data
+ }
+ } catch (err) {
+ ElMessage.error('文件上传失败')
+ throw err
+ }
}
diff --git a/web/src/utils/permission.ts b/web/src/utils/permission.ts
index 4138173..74144d3 100644
--- a/web/src/utils/permission.ts
+++ b/web/src/utils/permission.ts
@@ -1,6 +1,5 @@
import { CACHE_KEY, useCache } from '@/hooks/web/useCache'
-import {hasPermission} from "@/directives/permission/hasPermi";
-
+import { hasPermission } from '@/directives/permission/hasPermi'
const { t } = useI18n() // 国际化
diff --git a/web/src/utils/routerHelper.ts b/web/src/utils/routerHelper.ts
index 7a87bd7..5becfac 100644
--- a/web/src/utils/routerHelper.ts
+++ b/web/src/utils/routerHelper.ts
@@ -101,7 +101,7 @@ export const generateRoute = (routes: AppCustomRouteRecordRaw[]): AppRouteRecord
if (!route.children && route.parentId == 0 && route.component) {
data.component = Layout
data.meta = {
- hidden: meta.hidden,
+ hidden: meta.hidden
}
data.name = toCamelCase(route.path, true) + 'Parent'
data.redirect = ''
diff --git a/web/src/utils/ww.ts b/web/src/utils/ww.ts
index df9e88d..6a2080a 100644
--- a/web/src/utils/ww.ts
+++ b/web/src/utils/ww.ts
@@ -3,1853 +3,1996 @@ import { useAppStore } from '@/store/modules/app'
const appStore = useAppStore()
import { getAgentConfigSignature, getConfigSignature } from '@/api/lock'
ww.register({
- corpId: 'ww6e1eee0a8ae45397',
- agentId: 1000002,
- jsApiList: [
- // 蓝牙基础API
- 'openBluetoothAdapter',
- 'getBluetoothAdapterState',
- 'closeBluetoothAdapter',
-
- // 设备发现API
- 'startBluetoothDevicesDiscovery',
- 'stopBluetoothDevicesDiscovery',
- 'getBluetoothDevices',
- 'getConnectedBluetoothDevices',
-
- // BLE连接管理API
- 'createBLEConnection',
- 'closeBLEConnection',
- 'onBLEConnectionStateChange',
-
- // BLE服务和特征值API
- 'getBLEDeviceServices',
- 'getBLEDeviceCharacteristics',
- 'readBLECharacteristicValue',
- 'writeBLECharacteristicValue',
- 'notifyBLECharacteristicValueChange',
- 'onBLECharacteristicValueChange',
-
- // 其他功能API
- 'getLocation', // 地理位置
- 'scanQRCode', // 扫码
- 'chooseImage',//拍照
- 'getLocalImgData',//获取本地图片
- 'getContext'
- ],
- getConfigSignature: getConfigSignature,
- getAgentConfigSignature: getAgentConfigSignature,
+ corpId: 'ww6e1eee0a8ae45397',
+ agentId: 1000002,
+ jsApiList: [
+ // 蓝牙基础API
+ 'openBluetoothAdapter',
+ 'getBluetoothAdapterState',
+ 'closeBluetoothAdapter',
+
+ // 设备发现API
+ 'startBluetoothDevicesDiscovery',
+ 'stopBluetoothDevicesDiscovery',
+ 'getBluetoothDevices',
+ 'getConnectedBluetoothDevices',
+
+ // BLE连接管理API
+ 'createBLEConnection',
+ 'closeBLEConnection',
+ 'onBLEConnectionStateChange',
+
+ // BLE服务和特征值API
+ 'getBLEDeviceServices',
+ 'getBLEDeviceCharacteristics',
+ 'readBLECharacteristicValue',
+ 'writeBLECharacteristicValue',
+ 'notifyBLECharacteristicValueChange',
+ 'onBLECharacteristicValueChange',
+
+ // 其他功能API
+ 'getLocation', // 地理位置
+ 'scanQRCode', // 扫码
+ 'chooseImage', //拍照
+ 'getLocalImgData', //获取本地图片
+ 'getContext'
+ ],
+ getConfigSignature: getConfigSignature,
+ getAgentConfigSignature: getAgentConfigSignature
})
ww.getContext().then(() => {
- appStore.isWorkWechat = true
+ appStore.isWorkWechat = true
})
type BluetoothDevice = {
- deviceId: string
- name: string
- RSSI: number
- advertisData: ArrayBuffer
- advertisServiceUUIDs: string[]
- localName: string
- serviceData: any
+ deviceId: string
+ name: string
+ RSSI: number
+ advertisData: ArrayBuffer
+ advertisServiceUUIDs: string[]
+ localName: string
+ serviceData: any
}
type BluetoothService = {
- uuid: string
- isPrimary: boolean
+ uuid: string
+ isPrimary: boolean
}
type BluetoothCharacteristic = {
- uuid: string
- properties: {
- read: boolean
- write: boolean
- notify: boolean
- indicate: boolean
- writeNoResponse?: boolean
- }
+ uuid: string
+ properties: {
+ read: boolean
+ write: boolean
+ notify: boolean
+ indicate: boolean
+ writeNoResponse?: boolean
+ }
}
type Bluetooth = {
- isSupport: boolean
- isOpen: boolean
- isDiscovering: boolean
- isConnected: boolean
- currentDevice: BluetoothDevice | null
- connectedDevices: BluetoothDevice[]
- discoveredDevices: BluetoothDevice[]
-
- // 基础功能
- checkSupport: () => Promise
- getState: () => Promise
- discover: (services?: string[], timeout?: number) => Promise
- stopDiscovery: () => Promise
-
- // 设备管理
- getDiscoveredDevices: () => Promise
- getConnectedDevices: () => Promise
- connect: (deviceId: string) => Promise
- disconnect: (deviceId: string) => Promise
-
- // 服务和特征值
- getServices: (deviceId: string) => Promise
- getCharacteristics: (deviceId: string, serviceId: string) => Promise
-
- // 数据读写
- readCharacteristic: (deviceId: string, serviceId: string, characteristicId: string) => Promise
- writeCharacteristic: (deviceId: string, serviceId: string, characteristicId: string, value: ArrayBuffer) => Promise
- notifyCharacteristic: (deviceId: string, serviceId: string, characteristicId: string, state: boolean) => Promise
-
- // 事件监听
- onCharacteristicValueChange: (callback: (res: any) => void) => void
- onConnectionStateChange: (callback: (res: any) => void) => void
-
- // 实用方法
- init: () => Promise
- reset: () => Promise
- clearDevices: () => void
-
- // 权限管理
- requestPermissions: () => Promise
- checkPermissions: () => Promise
- openAppSetting: () => Promise
+ isSupport: boolean
+ isOpen: boolean
+ isDiscovering: boolean
+ isConnected: boolean
+ currentDevice: BluetoothDevice | null
+ connectedDevices: BluetoothDevice[]
+ discoveredDevices: BluetoothDevice[]
+
+ // 基础功能
+ checkSupport: () => Promise
+ getState: () => Promise
+ discover: (services?: string[], timeout?: number) => Promise
+ stopDiscovery: () => Promise
+
+ // 设备管理
+ getDiscoveredDevices: () => Promise
+ getConnectedDevices: () => Promise
+ connect: (deviceId: string) => Promise
+ disconnect: (deviceId: string) => Promise
+
+ // 服务和特征值
+ getServices: (deviceId: string) => Promise
+ getCharacteristics: (deviceId: string, serviceId: string) => Promise
+
+ // 数据读写
+ readCharacteristic: (
+ deviceId: string,
+ serviceId: string,
+ characteristicId: string
+ ) => Promise
+ writeCharacteristic: (
+ deviceId: string,
+ serviceId: string,
+ characteristicId: string,
+ value: ArrayBuffer
+ ) => Promise
+ notifyCharacteristic: (
+ deviceId: string,
+ serviceId: string,
+ characteristicId: string,
+ state: boolean
+ ) => Promise
+
+ // 事件监听
+ onCharacteristicValueChange: (callback: (res: any) => void) => void
+ onConnectionStateChange: (callback: (res: any) => void) => void
+
+ // 实用方法
+ init: () => Promise
+ reset: () => Promise
+ clearDevices: () => void
+
+ // 权限管理
+ requestPermissions: () => Promise
+ checkPermissions: () => Promise
+ openAppSetting: () => Promise
}
// 权限结果类型
type PermissionResult = {
- camera: PermissionStatus
- location: PermissionStatus
- bluetooth: PermissionStatus
- microphone?: PermissionStatus
- storage?: PermissionStatus
- contacts?: PermissionStatus
+ camera: PermissionStatus
+ location: PermissionStatus
+ bluetooth: PermissionStatus
+ microphone?: PermissionStatus
+ storage?: PermissionStatus
+ contacts?: PermissionStatus
}
type PermissionStatus = 'granted' | 'denied' | 'restricted' | 'notDetermined' | 'unavailable'
class wwBluetooth implements Bluetooth {
- isSupport: boolean
- isOpen: boolean
- isDiscovering: boolean
- isConnected: boolean
- currentDevice: BluetoothDevice | null
- connectedDevices: BluetoothDevice[]
- discoveredDevices: BluetoothDevice[]
-
- private discoveryTimeout?: NodeJS.Timeout
- private characteristicCallbacks: Map void>
- private connectionCallbacks: ((res: any) => void)[]
- private heartbeatInterval: NodeJS.Timeout | null = null
- public currentHeartbeatDeviceId: string | null = null
-
- constructor() {
- this.isSupport = false
- this.isConnected = false
- this.isOpen = false
- this.isDiscovering = false
- this.currentDevice = null
- this.connectedDevices = []
- this.discoveredDevices = []
- this.characteristicCallbacks = new Map()
- this.connectionCallbacks = []
- }
- async checkSupport() {
- return new Promise((resolve, reject) => {
- ww.openBluetoothAdapter(
- {
- success: (res) => {
- this.isSupport = true
- resolve(res)
- },
- fail: (err) => {
- this.isSupport = false
- reject(err)
- }
- }
- )
- })
- }
- async getState() {
- return new Promise((resolve, reject) => {
- ww.getBluetoothAdapterState(
- {
- success: (res) => {
- resolve(res)
- },
- fail: (err) => {
- reject(err)
- }
- }
- )
- })
- }
- async discover(services?: string[], timeout: number = 10000) {
- return new Promise((resolve, reject) => {
- this.isDiscovering = true
- this.discoveredDevices = []
-
- const options: any = {
- success: (res: any) => {
- if (timeout > 0) {
- this.discoveryTimeout = setTimeout(() => {
- this.stopDiscovery()
- }, timeout)
- }
- resolve(res)
- },
- fail: (err: any) => {
- this.isDiscovering = false
- reject(err)
- }
- }
-
- if (services && services.length > 0) {
- options.services = services
- }
-
- ww.startBluetoothDevicesDiscovery(options)
- })
- }
- async stopDiscovery() {
- return new Promise((resolve, reject) => {
- this.isDiscovering = false
- if (this.discoveryTimeout) {
- clearTimeout(this.discoveryTimeout)
- this.discoveryTimeout = undefined
+ isSupport: boolean
+ isOpen: boolean
+ isDiscovering: boolean
+ isConnected: boolean
+ currentDevice: BluetoothDevice | null
+ connectedDevices: BluetoothDevice[]
+ discoveredDevices: BluetoothDevice[]
+
+ private discoveryTimeout?: NodeJS.Timeout
+ private characteristicCallbacks: Map void>
+ private connectionCallbacks: ((res: any) => void)[]
+ private heartbeatInterval: NodeJS.Timeout | null = null
+ public currentHeartbeatDeviceId: string | null = null
+
+ constructor() {
+ this.isSupport = false
+ this.isConnected = false
+ this.isOpen = false
+ this.isDiscovering = false
+ this.currentDevice = null
+ this.connectedDevices = []
+ this.discoveredDevices = []
+ this.characteristicCallbacks = new Map()
+ this.connectionCallbacks = []
+ }
+ async checkSupport() {
+ return new Promise((resolve, reject) => {
+ ww.openBluetoothAdapter({
+ success: (res) => {
+ this.isSupport = true
+ resolve(res)
+ },
+ fail: (err) => {
+ this.isSupport = false
+ reject(err)
+ }
+ })
+ })
+ }
+ async getState() {
+ return new Promise((resolve, reject) => {
+ ww.getBluetoothAdapterState({
+ success: (res) => {
+ resolve(res)
+ },
+ fail: (err) => {
+ reject(err)
+ }
+ })
+ })
+ }
+ async discover(services?: string[], timeout: number = 10000) {
+ return new Promise((resolve, reject) => {
+ this.isDiscovering = true
+ this.discoveredDevices = []
+
+ const options: any = {
+ success: (res: any) => {
+ if (timeout > 0) {
+ this.discoveryTimeout = setTimeout(() => {
+ this.stopDiscovery()
+ }, timeout)
+ }
+ resolve(res)
+ },
+ fail: (err: any) => {
+ this.isDiscovering = false
+ reject(err)
+ }
+ }
+
+ if (services && services.length > 0) {
+ options.services = services
+ }
+
+ ww.startBluetoothDevicesDiscovery(options)
+ })
+ }
+ async stopDiscovery() {
+ return new Promise((resolve, reject) => {
+ this.isDiscovering = false
+ if (this.discoveryTimeout) {
+ clearTimeout(this.discoveryTimeout)
+ this.discoveryTimeout = undefined
+ }
+
+ ww.stopBluetoothDevicesDiscovery({
+ success: (res) => {
+ resolve(res)
+ },
+ fail: (err) => {
+ reject(err)
+ }
+ })
+ })
+ }
+ async getDiscoveredDevices(): Promise {
+ return new Promise((resolve, reject) => {
+ ww.getBluetoothDevices({
+ success: (res: any) => {
+ this.discoveredDevices = res.devices || []
+ resolve(this.discoveredDevices)
+ },
+ fail: (err) => {
+ reject(err)
+ }
+ })
+ })
+ }
+ async getConnectedDevices(): Promise {
+ return new Promise((resolve, reject) => {
+ ww.getConnectedBluetoothDevices({
+ success: (res: any) => {
+ this.connectedDevices = res.devices || []
+ resolve(this.connectedDevices)
+ },
+ fail: (err) => {
+ reject(err)
+ },
+ services: []
+ })
+ })
+ }
+ async connect(deviceId: string) {
+ return new Promise((resolve, reject) => {
+ ww.createBLEConnection({
+ deviceId: deviceId,
+ success: (res) => {
+ this.isConnected = true
+ const device = this.discoveredDevices.find((d) => d.deviceId === deviceId)
+ if (device && !this.connectedDevices.find((d) => d.deviceId === deviceId)) {
+ this.connectedDevices.push(device)
+ this.currentDevice = device
+ }
+ this.connectionCallbacks.forEach((callback) => callback({ deviceId, connected: true }))
+ resolve(res)
+ },
+ fail: (err) => {
+ reject(err)
+ }
+ })
+ })
+ }
+
+ async disconnect(deviceId: string) {
+ return new Promise((resolve, reject) => {
+ ww.closeBLEConnection({
+ deviceId: deviceId,
+ success: (res) => {
+ this.connectedDevices = this.connectedDevices.filter((d) => d.deviceId !== deviceId)
+ if (this.currentDevice?.deviceId === deviceId) {
+ this.currentDevice = null
+ // 清理当前设备的监听器和心跳
+ this.clearEventListeners()
+ this.stopHeartbeat()
+ }
+ this.isConnected = this.connectedDevices.length > 0
+ this.connectionCallbacks.forEach((callback) => callback({ deviceId, connected: false }))
+ console.log(`[蓝牙调试] 设备 ${deviceId} 已断开连接`)
+ resolve(res)
+ },
+ fail: (err) => {
+ reject(err)
+ }
+ })
+ })
+ }
+
+ // 服务和特征值操作
+ async getServices(deviceId: string): Promise {
+ return new Promise((resolve, reject) => {
+ ww.getBLEDeviceServices({
+ deviceId: deviceId,
+ success: (res: any) => {
+ resolve(res.services || [])
+ },
+ fail: (err) => {
+ reject(err)
+ }
+ })
+ })
+ }
+
+ async getCharacteristics(
+ deviceId: string,
+ serviceId: string
+ ): Promise {
+ return new Promise((resolve, reject) => {
+ ww.getBLEDeviceCharacteristics({
+ deviceId: deviceId,
+ serviceId: serviceId,
+ success: (res: any) => {
+ resolve(res.characteristics || [])
+ },
+ fail: (err) => {
+ reject(err)
+ }
+ })
+ })
+ }
+
+ // 数据读写操作
+ async readCharacteristic(deviceId: string, serviceId: string, characteristicId: string) {
+ return new Promise((resolve, reject) => {
+ ww.readBLECharacteristicValue({
+ deviceId: deviceId,
+ serviceId: serviceId,
+ characteristicId: characteristicId,
+ success: (res: any) => {
+ resolve(res)
+ },
+ fail: (err) => {
+ reject(err)
+ }
+ })
+ })
+ }
+
+ async writeCharacteristic(
+ deviceId: string,
+ serviceId: string,
+ characteristicId: string,
+ value: ArrayBuffer
+ ) {
+ return new Promise((resolve, reject) => {
+ // 检查API是否存在
+ if (!ww.writeBLECharacteristicValue) {
+ reject(new Error('writeBLECharacteristicValue API不可用'))
+ return
+ }
+
+ // 企业微信可能对数据长度有限制，通常是20字节
+ if (value.byteLength > 20) {
+ console.warn(`[蓝牙调试] 数据长度 ${value.byteLength} 超过建议的20字节限制`)
+ }
+
+ console.log(`[蓝牙调试] 调用writeBLECharacteristicValue:`, {
+ deviceId,
+ serviceId,
+ characteristicId,
+ valueByteLength: value.byteLength,
+ valueHex: Array.from(new Uint8Array(value))
+ .map((b) => b.toString(16).padStart(2, '0'))
+ .join(' ')
+ })
+
+ // 企业微信蓝牙API的参数配置
+ const params: any = {
+ deviceId: deviceId,
+ serviceId: serviceId,
+ characteristicId: characteristicId,
+ value: value,
+ success: (res: any) => {
+ console.log(`[蓝牙调试] writeBLECharacteristicValue success:`, res)
+ resolve(res)
+ },
+ fail: (err: any) => {
+ console.error(`[蓝牙调试] writeBLECharacteristicValue fail:`, err)
+
+ // 企业微信特有的错误处理
+ if (err.errMsg) {
+ if (err.errMsg.includes('fail_system err')) {
+ // 系统错误，可能是特征值不支持或权限问题
+ const newError = new Error(
+ '蓝牙写入失败：设备特征值不支持写入或权限不足。请检查设备是否支持该特征值的写入操作。'
+ )
+ ;(newError as any).originalError = err
+ reject(newError)
+ } else if (err.errMsg.includes('fail_device not connected')) {
+ reject(new Error('设备已断开连接，请重新连接设备'))
+ } else if (err.errMsg.includes('fail_invalid characteristic')) {
+ reject(new Error('无效的特征值ID，请检查特征值是否存在'))
+ } else if (err.errMsg.includes('fail_write not permit')) {
+ reject(new Error('特征值不允许写入操作'))
+ } else {
+ reject(err)
}
+ } else {
+ reject(err)
+ }
+ }
+ }
+
+ // 企业微信可能需要指定写入类型
+ // 如果支持writeNoResponse，优先使用（更可靠）
+ try {
+ // 先尝试标准写入
+ ww.writeBLECharacteristicValue(params)
+ } catch (error) {
+ console.error(`[蓝牙调试] 标准写入失败，尝试其他方式:`, error)
+ reject(error)
+ }
+ })
+ }
+
+ async notifyCharacteristic(
+ deviceId: string,
+ serviceId: string,
+ characteristicId: string,
+ state: boolean
+ ) {
+ return new Promise((resolve, reject) => {
+ ww.notifyBLECharacteristicValueChange({
+ deviceId: deviceId,
+ serviceId: serviceId,
+ characteristicId: characteristicId,
+ state: state,
+ success: (res: any) => {
+ resolve(res)
+ },
+ fail: (err) => {
+ reject(err)
+ }
+ })
+ })
+ }
+
+ // 事件监听
+ onCharacteristicValueChange(callback: (res: any) => void) {
+ // 清理现有的监听器，避免重复绑定
+ this.characteristicCallbacks.clear()
+
+ const key = 'characteristic_change'
+ this.characteristicCallbacks.set(key, callback)
+
+ // 企业微信环境中，避免重复绑定
+ // 注意：这里可能需要在设备断开时清理
+ ww.onBLECharacteristicValueChange(callback)
+ console.log(`[蓝牙调试] 特征值变化监听器已设置`)
+ }
+
+ onConnectionStateChange(callback: (res: any) => void) {
+ // 避免重复添加相同的回调
+ if (!this.connectionCallbacks.includes(callback)) {
+ this.connectionCallbacks.push(callback)
+
+ // 包装回调函数，添加心跳管理逻辑
+ const wrappedCallback = (res: any) => {
+ console.log(`[蓝牙调试] 连接状态变化: 设备${res.deviceId}, 连接状态: ${res.connected}`)
+
+ // 特别关注断开连接的情况
+ if (!res.connected) {
+ console.warn(`[蓝牙调试] 设备断开连接: ${res.deviceId}`)
+
+ // 如果是当前心跳设备，停止心跳
+ if (this.currentHeartbeatDeviceId === res.deviceId) {
+ console.log(`[蓝牙调试] 停止心跳，设备: ${res.deviceId}`)
+ this.stopHeartbeat()
+ }
+
+ // 从连接设备列表中移除
+ this.connectedDevices = this.connectedDevices.filter((d) => d.deviceId !== res.deviceId)
+ if (this.currentDevice?.deviceId === res.deviceId) {
+ this.currentDevice = null
+ }
+ this.isConnected = this.connectedDevices.length > 0
+ } else {
+ console.log(`[蓝牙调试] 设备连接成功: ${res.deviceId}`)
+ }
- ww.stopBluetoothDevicesDiscovery({
- success: (res) => {
- resolve(res)
- },
- fail: (err) => {
- reject(err)
- }
- })
- })
- }
- async getDiscoveredDevices(): Promise {
- return new Promise((resolve, reject) => {
- ww.getBluetoothDevices({
- success: (res: any) => {
- this.discoveredDevices = res.devices || []
- resolve(this.discoveredDevices)
- },
- fail: (err) => {
- reject(err)
- }
- })
- })
- }
- async getConnectedDevices(): Promise {
- return new Promise((resolve, reject) => {
- ww.getConnectedBluetoothDevices({
- success: (res: any) => {
- this.connectedDevices = res.devices || []
- resolve(this.connectedDevices)
- },
- fail: (err) => {
- reject(err)
- },
- services: []
- })
- })
- }
- async connect(deviceId: string) {
- return new Promise((resolve, reject) => {
- ww.createBLEConnection({
- deviceId: deviceId,
- success: (res) => {
- this.isConnected = true
- const device = this.discoveredDevices.find(d => d.deviceId === deviceId)
- if (device && !this.connectedDevices.find(d => d.deviceId === deviceId)) {
- this.connectedDevices.push(device)
- this.currentDevice = device
- }
- this.connectionCallbacks.forEach(callback => callback({ deviceId, connected: true }))
- resolve(res)
- },
- fail: (err) => {
- reject(err)
- }
- })
- })
- }
+ // 调用原始回调
+ callback(res)
+ }
- async disconnect(deviceId: string) {
- return new Promise((resolve, reject) => {
- ww.closeBLEConnection({
- deviceId: deviceId,
- success: (res) => {
- this.connectedDevices = this.connectedDevices.filter(d => d.deviceId !== deviceId)
- if (this.currentDevice?.deviceId === deviceId) {
- this.currentDevice = null
- // 清理当前设备的监听器和心跳
- this.clearEventListeners()
- this.stopHeartbeat()
- }
- this.isConnected = this.connectedDevices.length > 0
- this.connectionCallbacks.forEach(callback => callback({ deviceId, connected: false }))
- console.log(`[蓝牙调试] 设备 ${deviceId} 已断开连接`)
- resolve(res)
- },
- fail: (err) => {
- reject(err)
- }
- })
- })
+ ww.onBLEConnectionStateChange && ww.onBLEConnectionStateChange(wrappedCallback)
+ console.log(`[蓝牙调试] 连接状态变化监听器已设置`)
}
-
- // 服务和特征值操作
- async getServices(deviceId: string): Promise {
- return new Promise((resolve, reject) => {
- ww.getBLEDeviceServices({
- deviceId: deviceId,
- success: (res: any) => {
- resolve(res.services || [])
- },
- fail: (err) => {
- reject(err)
- }
- })
- })
+ }
+
+ // 清理监听器的方法
+ clearEventListeners() {
+ this.characteristicCallbacks.clear()
+ this.connectionCallbacks.length = 0
+ console.log(`[蓝牙调试] 事件监听器已清理`)
+ }
+
+ /**
+ * 请求系统权限
+ * @returns Promise
+ */
+ async requestPermissions(): Promise {
+ const result: PermissionResult = {
+ camera: 'notDetermined',
+ location: 'notDetermined',
+ bluetooth: 'notDetermined'
}
- async getCharacteristics(deviceId: string, serviceId: string): Promise {
- return new Promise((resolve, reject) => {
- ww.getBLEDeviceCharacteristics({
- deviceId: deviceId,
- serviceId: serviceId,
- success: (res: any) => {
- resolve(res.characteristics || [])
- },
- fail: (err) => {
- reject(err)
- }
+ try {
+ // 请求相机权限 - 企业微信可能不支持authorize，使用其他方式
+ try {
+ // 尝试通过其他方式请求相机权限
+ result.camera = 'notDetermined'
+ console.log('[权限管理] 相机权限在企业微信中可能需要手动开启')
+ } catch (error) {
+ console.warn('相机权限检查失败:', error)
+ result.camera = 'denied'
+ }
+
+ // 请求地理位置权限
+ try {
+ if (ww.getLocation) {
+ await new Promise((resolve, reject) => {
+ ww.getLocation({
+ type: 'gcj02' as any, // 类型断言
+ success: () => {
+ result.location = 'granted'
+ resolve(true)
+ },
+ fail: (err: any) => {
+ console.warn('地理位置权限请求失败:', err)
+ result.location = 'denied'
+ resolve(false)
+ }
})
- })
- }
-
- // 数据读写操作
- async readCharacteristic(deviceId: string, serviceId: string, characteristicId: string) {
- return new Promise((resolve, reject) => {
- ww.readBLECharacteristicValue({
- deviceId: deviceId,
- serviceId: serviceId,
- characteristicId: characteristicId,
- success: (res: any) => {
- resolve(res)
- },
- fail: (err) => {
- reject(err)
- }
+ })
+ } else {
+ result.location = 'unavailable'
+ }
+ } catch (error) {
+ console.warn('地理位置权限检查失败:', error)
+ result.location = 'denied'
+ }
+
+ // 请求蓝牙权限
+ try {
+ if (ww.openBluetoothAdapter) {
+ await new Promise((resolve, reject) => {
+ ww.openBluetoothAdapter({
+ success: () => {
+ result.bluetooth = 'granted'
+ resolve(true)
+ },
+ fail: (err: any) => {
+ console.warn('蓝牙权限请求失败:', err)
+ result.bluetooth = 'denied'
+ resolve(false)
+ }
})
- })
+ })
+ } else {
+ result.bluetooth = 'unavailable'
+ }
+ } catch (error) {
+ console.warn('蓝牙权限检查失败:', error)
+ result.bluetooth = 'denied'
+ }
+
+ // 请求麦克风权限（如果支持）
+ try {
+ // 企业微信可能不支持authorize，使用其他方式
+ result.microphone = 'notDetermined'
+ console.log('[权限管理] 麦克风权限在企业微信中可能需要手动开启')
+ } catch (error) {
+ console.warn('麦克风权限检查失败:', error)
+ result.microphone = 'denied'
+ }
+
+ console.log('[权限管理] 权限请求结果:', result)
+ return result
+ } catch (error) {
+ console.error('[权限管理] 权限请求过程中出错:', error)
+ return result
}
-
- async writeCharacteristic(deviceId: string, serviceId: string, characteristicId: string, value: ArrayBuffer) {
- return new Promise((resolve, reject) => {
- // 检查API是否存在
- if (!ww.writeBLECharacteristicValue) {
- reject(new Error('writeBLECharacteristicValue API不可用'));
- return;
- }
-
- // 企业微信可能对数据长度有限制，通常是20字节
- if (value.byteLength > 20) {
- console.warn(`[蓝牙调试] 数据长度 ${value.byteLength} 超过建议的20字节限制`);
- }
-
- console.log(`[蓝牙调试] 调用writeBLECharacteristicValue:`, {
- deviceId,
- serviceId,
- characteristicId,
- valueByteLength: value.byteLength,
- valueHex: Array.from(new Uint8Array(value)).map(b => b.toString(16).padStart(2, '0')).join(' ')
- });
-
- // 企业微信蓝牙API的参数配置
- const params: any = {
- deviceId: deviceId,
- serviceId: serviceId,
- characteristicId: characteristicId,
- value: value,
- success: (res: any) => {
- console.log(`[蓝牙调试] writeBLECharacteristicValue success:`, res);
- resolve(res)
- },
- fail: (err: any) => {
- console.error(`[蓝牙调试] writeBLECharacteristicValue fail:`, err);
-
- // 企业微信特有的错误处理
- if (err.errMsg) {
- if (err.errMsg.includes('fail_system err')) {
- // 系统错误，可能是特征值不支持或权限问题
- const newError = new Error('蓝牙写入失败：设备特征值不支持写入或权限不足。请检查设备是否支持该特征值的写入操作。');
- (newError as any).originalError = err;
- reject(newError);
- } else if (err.errMsg.includes('fail_device not connected')) {
- reject(new Error('设备已断开连接，请重新连接设备'));
- } else if (err.errMsg.includes('fail_invalid characteristic')) {
- reject(new Error('无效的特征值ID，请检查特征值是否存在'));
- } else if (err.errMsg.includes('fail_write not permit')) {
- reject(new Error('特征值不允许写入操作'));
- } else {
- reject(err);
- }
- } else {
- reject(err);
- }
- }
- };
-
- // 企业微信可能需要指定写入类型
- // 如果支持writeNoResponse，优先使用（更可靠）
- try {
- // 先尝试标准写入
- ww.writeBLECharacteristicValue(params);
- } catch (error) {
- console.error(`[蓝牙调试] 标准写入失败，尝试其他方式:`, error);
- reject(error);
- }
- })
+ }
+
+ /**
+ * 检查当前权限状态
+ * @returns Promise
+ */
+ async checkPermissions(): Promise {
+ const result: PermissionResult = {
+ camera: 'notDetermined',
+ location: 'notDetermined',
+ bluetooth: 'notDetermined'
}
- async notifyCharacteristic(deviceId: string, serviceId: string, characteristicId: string, state: boolean) {
- return new Promise((resolve, reject) => {
- ww.notifyBLECharacteristicValueChange({
- deviceId: deviceId,
- serviceId: serviceId,
- characteristicId: characteristicId,
- state: state,
- success: (res: any) => {
- resolve(res)
- },
- fail: (err) => {
- reject(err)
- }
+ try {
+ // 检查相机权限 - 企业微信可能不支持getSetting
+ try {
+ // 企业微信中相机权限检查方式不同
+ result.camera = 'notDetermined'
+ console.log('[权限管理] 相机权限状态在企业微信中无法直接检查')
+ } catch (error) {
+ console.warn('相机权限检查失败:', error)
+ result.camera = 'notDetermined'
+ }
+
+ // 检查地理位置权限 - 企业微信可能不支持getSetting
+ try {
+ // 企业微信中地理位置权限检查方式不同
+ result.location = 'notDetermined'
+ console.log('[权限管理] 地理位置权限状态在企业微信中无法直接检查')
+ } catch (error) {
+ console.warn('地理位置权限检查失败:', error)
+ result.location = 'notDetermined'
+ }
+
+ // 检查蓝牙权限
+ try {
+ if (ww.getBluetoothAdapterState) {
+ const state = (await new Promise((resolve, reject) => {
+ ww.getBluetoothAdapterState({
+ success: (res: any) => resolve(res),
+ fail: (err: any) => reject(err)
})
- })
- }
-
- // 事件监听
- onCharacteristicValueChange(callback: (res: any) => void) {
- // 清理现有的监听器，避免重复绑定
- this.characteristicCallbacks.clear()
-
- const key = 'characteristic_change'
- this.characteristicCallbacks.set(key, callback)
-
- // 企业微信环境中，避免重复绑定
- // 注意：这里可能需要在设备断开时清理
- ww.onBLECharacteristicValueChange(callback)
- console.log(`[蓝牙调试] 特征值变化监听器已设置`)
- }
-
- onConnectionStateChange(callback: (res: any) => void) {
- // 避免重复添加相同的回调
- if (!this.connectionCallbacks.includes(callback)) {
- this.connectionCallbacks.push(callback)
-
- // 包装回调函数，添加心跳管理逻辑
- const wrappedCallback = (res: any) => {
- console.log(`[蓝牙调试] 连接状态变化: 设备${res.deviceId}, 连接状态: ${res.connected}`)
-
- // 特别关注断开连接的情况
- if (!res.connected) {
- console.warn(`[蓝牙调试] 设备断开连接: ${res.deviceId}`)
-
- // 如果是当前心跳设备，停止心跳
- if (this.currentHeartbeatDeviceId === res.deviceId) {
- console.log(`[蓝牙调试] 停止心跳，设备: ${res.deviceId}`)
- this.stopHeartbeat()
- }
-
- // 从连接设备列表中移除
- this.connectedDevices = this.connectedDevices.filter(d => d.deviceId !== res.deviceId)
- if (this.currentDevice?.deviceId === res.deviceId) {
- this.currentDevice = null
- }
- this.isConnected = this.connectedDevices.length > 0
- } else {
- console.log(`[蓝牙调试] 设备连接成功: ${res.deviceId}`)
- }
-
- // 调用原始回调
- callback(res)
- }
-
- ww.onBLEConnectionStateChange && ww.onBLEConnectionStateChange(wrappedCallback)
- console.log(`[蓝牙调试] 连接状态变化监听器已设置`)
+ })) as any
+
+ if (state.available === true) {
+ result.bluetooth = 'granted'
+ } else if (state.available === false) {
+ result.bluetooth = 'denied'
+ } else {
+ result.bluetooth = 'notDetermined'
+ }
+ } else {
+ result.bluetooth = 'unavailable'
}
+ } catch (error) {
+ console.warn('蓝牙权限检查失败:', error)
+ result.bluetooth = 'notDetermined'
+ }
+
+ // 检查麦克风权限 - 企业微信可能不支持getSetting
+ try {
+ // 企业微信中麦克风权限检查方式不同
+ result.microphone = 'notDetermined'
+ console.log('[权限管理] 麦克风权限状态在企业微信中无法直接检查')
+ } catch (error) {
+ console.warn('麦克风权限检查失败:', error)
+ result.microphone = 'notDetermined'
+ }
+
+ console.log('[权限管理] 当前权限状态:', result)
+ return result
+ } catch (error) {
+ console.error('[权限管理] 权限检查过程中出错:', error)
+ return result
}
-
- // 清理监听器的方法
- clearEventListeners() {
- this.characteristicCallbacks.clear()
- this.connectionCallbacks.length = 0
- console.log(`[蓝牙调试] 事件监听器已清理`)
- }
-
- /**
- * 请求系统权限
- * @returns Promise
- */
- async requestPermissions(): Promise {
- const result: PermissionResult = {
- camera: 'notDetermined',
- location: 'notDetermined',
- bluetooth: 'notDetermined'
+ }
+
+ /**
+ * 打开应用设置页面
+ * @returns Promise
+ */
+ async openAppSetting(): Promise {
+ return new Promise((resolve, reject) => {
+ // 企业微信可能不支持openSetting，提供替代方案
+ console.log('[权限管理] 企业微信中无法直接打开设置页面，建议用户手动开启权限')
+
+ // 可以在这里添加用户提示逻辑
+ // 例如显示一个对话框，说明如何手动开启权限
+
+ resolve({ message: '请在企业微信设置中手动开启相关权限' })
+ })
+ }
+
+ /**
+ * 检查并请求必要权限
+ * @param requiredPermissions 需要的权限列表
+ * @returns Promise
+ */
+ async ensurePermissions(
+ requiredPermissions: (keyof PermissionResult)[] = ['bluetooth', 'location']
+ ): Promise {
+ try {
+ console.log('[权限管理] 开始检查必要权限:', requiredPermissions)
+
+ // 先检查当前权限状态
+ const currentPermissions = await this.checkPermissions()
+
+ // 检查哪些权限需要请求
+ const needRequest: (keyof PermissionResult)[] = []
+ for (const permission of requiredPermissions) {
+ if (
+ currentPermissions[permission] === 'denied' ||
+ currentPermissions[permission] === 'notDetermined'
+ ) {
+ needRequest.push(permission)
}
+ }
- try {
- // 请求相机权限 - 企业微信可能不支持authorize，使用其他方式
- try {
- // 尝试通过其他方式请求相机权限
- result.camera = 'notDetermined'
- console.log('[权限管理] 相机权限在企业微信中可能需要手动开启')
- } catch (error) {
- console.warn('相机权限检查失败:', error)
- result.camera = 'denied'
- }
+ if (needRequest.length === 0) {
+ console.log('[权限管理] 所有必要权限已获取')
+ return true
+ }
- // 请求地理位置权限
- try {
- if (ww.getLocation) {
- await new Promise((resolve, reject) => {
- ww.getLocation({
- type: 'gcj02' as any, // 类型断言
- success: () => {
- result.location = 'granted'
- resolve(true)
- },
- fail: (err: any) => {
- console.warn('地理位置权限请求失败:', err)
- result.location = 'denied'
- resolve(false)
- }
- })
- })
- } else {
- result.location = 'unavailable'
- }
- } catch (error) {
- console.warn('地理位置权限检查失败:', error)
- result.location = 'denied'
- }
-
- // 请求蓝牙权限
- try {
- if (ww.openBluetoothAdapter) {
- await new Promise((resolve, reject) => {
- ww.openBluetoothAdapter({
- success: () => {
- result.bluetooth = 'granted'
- resolve(true)
- },
- fail: (err: any) => {
- console.warn('蓝牙权限请求失败:', err)
- result.bluetooth = 'denied'
- resolve(false)
- }
- })
- })
- } else {
- result.bluetooth = 'unavailable'
- }
- } catch (error) {
- console.warn('蓝牙权限检查失败:', error)
- result.bluetooth = 'denied'
- }
+ console.log('[权限管理] 需要请求的权限:', needRequest)
- // 请求麦克风权限（如果支持）
- try {
- // 企业微信可能不支持authorize，使用其他方式
- result.microphone = 'notDetermined'
- console.log('[权限管理] 麦克风权限在企业微信中可能需要手动开启')
- } catch (error) {
- console.warn('麦克风权限检查失败:', error)
- result.microphone = 'denied'
- }
+ // 请求权限
+ const requestResult = await this.requestPermissions()
- console.log('[权限管理] 权限请求结果:', result)
- return result
+ // 再次检查权限状态
+ const finalPermissions = await this.checkPermissions()
- } catch (error) {
- console.error('[权限管理] 权限请求过程中出错:', error)
- return result
- }
- }
+ // 验证所有必要权限是否已获取
+ const allGranted = requiredPermissions.every(
+ (permission) => finalPermissions[permission] === 'granted'
+ )
- /**
- * 检查当前权限状态
- * @returns Promise
- */
- async checkPermissions(): Promise {
- const result: PermissionResult = {
- camera: 'notDetermined',
- location: 'notDetermined',
- bluetooth: 'notDetermined'
- }
+ if (allGranted) {
+ console.log('[权限管理] 所有必要权限已成功获取')
+ return true
+ } else {
+ console.warn('[权限管理] 部分权限获取失败:', finalPermissions)
- try {
- // 检查相机权限 - 企业微信可能不支持getSetting
- try {
- // 企业微信中相机权限检查方式不同
- result.camera = 'notDetermined'
- console.log('[权限管理] 相机权限状态在企业微信中无法直接检查')
- } catch (error) {
- console.warn('相机权限检查失败:', error)
- result.camera = 'notDetermined'
- }
-
- // 检查地理位置权限 - 企业微信可能不支持getSetting
- try {
- // 企业微信中地理位置权限检查方式不同
- result.location = 'notDetermined'
- console.log('[权限管理] 地理位置权限状态在企业微信中无法直接检查')
- } catch (error) {
- console.warn('地理位置权限检查失败:', error)
- result.location = 'notDetermined'
- }
-
- // 检查蓝牙权限
- try {
- if (ww.getBluetoothAdapterState) {
- const state = await new Promise((resolve, reject) => {
- ww.getBluetoothAdapterState({
- success: (res: any) => resolve(res),
- fail: (err: any) => reject(err)
- })
- }) as any
-
- if (state.available === true) {
- result.bluetooth = 'granted'
- } else if (state.available === false) {
- result.bluetooth = 'denied'
- } else {
- result.bluetooth = 'notDetermined'
- }
- } else {
- result.bluetooth = 'unavailable'
- }
- } catch (error) {
- console.warn('蓝牙权限检查失败:', error)
- result.bluetooth = 'notDetermined'
- }
+ // 提示用户手动开启权限
+ const failedPermissions = requiredPermissions.filter(
+ (permission) => finalPermissions[permission] !== 'granted'
+ )
- // 检查麦克风权限 - 企业微信可能不支持getSetting
- try {
- // 企业微信中麦克风权限检查方式不同
- result.microphone = 'notDetermined'
- console.log('[权限管理] 麦克风权限状态在企业微信中无法直接检查')
- } catch (error) {
- console.warn('麦克风权限检查失败:', error)
- result.microphone = 'notDetermined'
- }
+ console.warn('[权限管理] 以下权限获取失败，建议用户手动开启:', failedPermissions)
- console.log('[权限管理] 当前权限状态:', result)
- return result
+ // 可以在这里添加用户提示逻辑
+ // 例如显示一个对话框，引导用户去设置页面开启权限
- } catch (error) {
- console.error('[权限管理] 权限检查过程中出错:', error)
- return result
- }
+ return false
+ }
+ } catch (error) {
+ console.error('[权限管理] 权限确保过程中出错:', error)
+ return false
}
-
- /**
- * 打开应用设置页面
- * @returns Promise
- */
- async openAppSetting(): Promise {
- return new Promise((resolve, reject) => {
- // 企业微信可能不支持openSetting，提供替代方案
- console.log('[权限管理] 企业微信中无法直接打开设置页面，建议用户手动开启权限')
-
- // 可以在这里添加用户提示逻辑
- // 例如显示一个对话框，说明如何手动开启权限
-
- resolve({ message: '请在企业微信设置中手动开启相关权限' })
- })
+ }
+
+ // 实用方法
+ async init(): Promise {
+ try {
+ // 先确保必要权限
+ const hasPermissions = await this.ensurePermissions(['bluetooth'])
+ if (!hasPermissions) {
+ console.warn('[蓝牙初始化] 蓝牙权限不足，可能影响功能使用')
+ }
+
+ await this.checkSupport()
+ await this.getState()
+ this.isOpen = true
+ } catch (error) {
+ console.error('蓝牙初始化失败:', error)
+ throw error
}
-
- /**
- * 检查并请求必要权限
- * @param requiredPermissions 需要的权限列表
- * @returns Promise
- */
- async ensurePermissions(requiredPermissions: (keyof PermissionResult)[] = ['bluetooth', 'location']): Promise {
- try {
- console.log('[权限管理] 开始检查必要权限:', requiredPermissions)
-
- // 先检查当前权限状态
- const currentPermissions = await this.checkPermissions()
-
- // 检查哪些权限需要请求
- const needRequest: (keyof PermissionResult)[] = []
- for (const permission of requiredPermissions) {
- if (currentPermissions[permission] === 'denied' || currentPermissions[permission] === 'notDetermined') {
- needRequest.push(permission)
- }
- }
-
- if (needRequest.length === 0) {
- console.log('[权限管理] 所有必要权限已获取')
- return true
- }
-
- console.log('[权限管理] 需要请求的权限:', needRequest)
-
- // 请求权限
- const requestResult = await this.requestPermissions()
-
- // 再次检查权限状态
- const finalPermissions = await this.checkPermissions()
-
- // 验证所有必要权限是否已获取
- const allGranted = requiredPermissions.every(permission =>
- finalPermissions[permission] === 'granted'
- )
-
- if (allGranted) {
- console.log('[权限管理] 所有必要权限已成功获取')
- return true
- } else {
- console.warn('[权限管理] 部分权限获取失败:', finalPermissions)
-
- // 提示用户手动开启权限
- const failedPermissions = requiredPermissions.filter(permission =>
- finalPermissions[permission] !== 'granted'
- )
-
- console.warn('[权限管理] 以下权限获取失败，建议用户手动开启:', failedPermissions)
-
- // 可以在这里添加用户提示逻辑
- // 例如显示一个对话框，引导用户去设置页面开启权限
-
- return false
- }
-
- } catch (error) {
- console.error('[权限管理] 权限确保过程中出错:', error)
- return false
- }
+ }
+
+ async reset(): Promise {
+ try {
+ if (this.isDiscovering) {
+ await this.stopDiscovery()
+ }
+
+ // 断开所有连接
+ const disconnectPromises = this.connectedDevices.map((device) =>
+ this.disconnect(device.deviceId).catch((err) => console.warn('断开连接失败:', err))
+ )
+ await Promise.all(disconnectPromises)
+
+ this.clearDevices()
+
+ // 重新初始化
+ await this.init()
+ } catch (error) {
+ console.error('蓝牙重置失败:', error)
+ throw error
}
-
- // 实用方法
- async init(): Promise {
- try {
- // 先确保必要权限
- const hasPermissions = await this.ensurePermissions(['bluetooth'])
- if (!hasPermissions) {
- console.warn('[蓝牙初始化] 蓝牙权限不足，可能影响功能使用')
- }
-
- await this.checkSupport()
- await this.getState()
- this.isOpen = true
- } catch (error) {
- console.error('蓝牙初始化失败:', error)
- throw error
- }
+ }
+
+ clearDevices() {
+ this.discoveredDevices = []
+ this.connectedDevices = []
+ this.currentDevice = null
+ this.isConnected = false
+ this.characteristicCallbacks.clear()
+ this.connectionCallbacks.length = 0
+ }
+
+ // 便捷方法
+ async findDeviceByName(name: string): Promise {
+ await this.getDiscoveredDevices()
+ return (
+ this.discoveredDevices.find((device) => device.name === name || device.localName === name) ||
+ null
+ )
+ }
+
+ async connectByName(name: string): Promise {
+ const device = await this.findDeviceByName(name)
+ if (!device) {
+ throw new Error(`未找到名为 "${name}" 的设备`)
+ }
+ return this.connect(device.deviceId)
+ }
+
+ isDeviceConnected(deviceId: string): boolean {
+ return this.connectedDevices.some((device) => device.deviceId === deviceId)
+ }
+
+ getDeviceSignalStrength(deviceId: string): number | null {
+ const device = this.discoveredDevices.find((d) => d.deviceId === deviceId)
+ return device ? device.RSSI : null
+ }
+
+ // 电子锁快捷操作指令
+ private lockServiceId = '0000FFF0-0000-1000-8000-00805F9B34FB'
+ private lockWriteCharacteristicId = '0000FFF2-0000-1000-8000-00805F9B34FB' // 写特征值
+ private lockReadCharacteristicId = '0000FFF1-0000-1000-8000-00805F9B34FB' // 读特征值（用于notify）
+ private lockCallback: any = null
+
+ /**
+ * 初始化锁通信
+ * @param deviceId 设备ID
+ * @param callback 数据回调函数
+ */
+ async initLockCommunication(deviceId: string, callback?: (data: any) => void): Promise {
+ if (!this.isDeviceConnected(deviceId)) {
+ throw new Error('设备未连接')
}
- async reset(): Promise {
- try {
- if (this.isDiscovering) {
- await this.stopDiscovery()
- }
-
- // 断开所有连接
- const disconnectPromises = this.connectedDevices.map(device =>
- this.disconnect(device.deviceId).catch(err => console.warn('断开连接失败:', err))
- )
- await Promise.all(disconnectPromises)
-
- this.clearDevices()
+ this.lockCallback = callback
+
+ try {
+ // 1. 获取服务对应的所有特征值
+ const characteristics = await this.getCharacteristics(deviceId, this.lockServiceId)
+
+ // 打印所有特征值及其属性，用于调试
+ console.log(
+ `[蓝牙调试] 服务 ${this.lockServiceId} 下的所有特征值:`,
+ JSON.parse(JSON.stringify(characteristics))
+ )
+
+ // 2. 验证写特征值是否存在且可写
+ const writeCharacteristic = characteristics.find(
+ (c) => c.uuid.toUpperCase() === this.lockWriteCharacteristicId.toUpperCase()
+ )
+
+ if (!writeCharacteristic) {
+ console.error(`[蓝牙调试] 未找到写特征值: ${this.lockWriteCharacteristicId}`)
+ throw new Error(`设备服务中未找到写特征值`)
+ }
+
+ if (
+ !writeCharacteristic.properties.write &&
+ !writeCharacteristic.properties.writeNoResponse
+ ) {
+ console.error(`[蓝牙调试] 写特征值不支持写入操作:`, writeCharacteristic.properties)
+ throw new Error(`写特征值不支持写入操作`)
+ }
+
+ console.log(
+ `[蓝牙调试] 写特征值验证通过: ${this.lockWriteCharacteristicId}`,
+ writeCharacteristic.properties
+ )
+
+ // 添加延迟以确保连接稳定
+ await new Promise((resolve) => setTimeout(resolve, 500))
+
+ // 3. 检查是否存在预期的读特征值
+ const readCharacteristic = characteristics.find(
+ (c) => c.uuid.toUpperCase() === this.lockReadCharacteristicId.toUpperCase()
+ )
+
+ if (readCharacteristic && readCharacteristic.properties.notify) {
+ console.log(`[蓝牙调试] 使用预期的读特征值: ${this.lockReadCharacteristicId}`)
+
+ // 先设置监听回调
+ this.onCharacteristicValueChange((res: any) => {
+ // 确保监听的是正确的特征值
+ if (
+ res.deviceId === deviceId &&
+ res.serviceId.toUpperCase() === this.lockServiceId.toUpperCase() &&
+ res.characteristicId.toUpperCase() === this.lockReadCharacteristicId.toUpperCase()
+ ) {
+ console.log('[蓝牙调试] 收到锁响应数据')
+ this.handleLockResponse(res.value)
+ }
+ })
- // 重新初始化
- await this.init()
- } catch (error) {
- console.error('蓝牙重置失败:', error)
- throw error
+ // 开启读特征值的通知监听
+ await this.notifyCharacteristic(
+ deviceId,
+ this.lockServiceId,
+ this.lockReadCharacteristicId,
+ true
+ )
+ console.log(`[蓝牙调试] 通知监听设置成功，等待连接稳定...`)
+
+ // 等待更长时间确保蓝牙连接稳定，这很关键！
+ await new Promise((resolve) => setTimeout(resolve, 2000))
+ console.log(`[蓝牙调试] 连接稳定化完成，可以开始发送指令`)
+
+ // 启动心跳机制保持连接
+ this.startHeartbeat(deviceId)
+ } else {
+ // fallback: 查找任何支持 notify 的特征值
+ const notifyCharacteristic = characteristics.find((c) => c.properties.notify)
+
+ if (!notifyCharacteristic) {
+ console.error(
+ '[蓝牙调试] 未找到任何支持 "notify" 的特征值。请检查设备固件或确认通信协议。'
+ )
+ throw new Error(`该设备的服务中未找到支持通知(notify)的特征值`)
}
- }
-
- clearDevices() {
- this.discoveredDevices = []
- this.connectedDevices = []
- this.currentDevice = null
- this.isConnected = false
- this.characteristicCallbacks.clear()
- this.connectionCallbacks.length = 0
- }
- // 便捷方法
- async findDeviceByName(name: string): Promise {
- await this.getDiscoveredDevices()
- return this.discoveredDevices.find(device =>
- device.name === name || device.localName === name
- ) || null
+ const notifyCharacteristicId = notifyCharacteristic.uuid
+ console.warn(`[蓝牙调试] 未找到预期的读特征值，使用备选特征值: ${notifyCharacteristicId}`)
+
+ // 开启特征值监听
+ await this.notifyCharacteristic(deviceId, this.lockServiceId, notifyCharacteristicId, true)
+
+ // 监听特征值变化
+ this.onCharacteristicValueChange((res: any) => {
+ // 确保监听的是正确的特征值
+ if (
+ res.deviceId === deviceId &&
+ res.serviceId.toUpperCase() === this.lockServiceId.toUpperCase() &&
+ res.characteristicId.toUpperCase() === notifyCharacteristicId.toUpperCase()
+ ) {
+ this.handleLockResponse(res.value)
+ }
+ })
+ }
+ } catch (err: any) {
+ // 重新抛出错误，以便上层可以捕获
+ if (err.errMsg && err.errMsg.includes('notsupport')) {
+ throw new Error('当前环境不支持蓝牙通知功能，无法接收设备数据。')
+ }
+ throw err
}
-
- async connectByName(name: string): Promise {
- const device = await this.findDeviceByName(name)
- if (!device) {
- throw new Error(`未找到名为 "${name}" 的设备`)
+ }
+
+ /**
+ * 创建锁指令
+ */
+ private createLockInstruct(command: number, data: number[]): number[] {
+ const header = [0xaa, 0xbb]
+ let instruction: number[] = []
+ let payload: number[] = []
+
+ instruction = instruction.concat(header)
+ payload.push(command)
+ payload = payload.concat(data)
+ payload.unshift(payload.length + 2)
+ payload = this.doCrc(payload)
+ instruction = instruction.concat(payload)
+
+ return instruction
+ }
+
+ /**
+ * 执行CRC校验
+ */
+ private doCrc(data: number[]): number[] {
+ const crcResult = this.crc16ab(data, true, false)
+ return data.concat(crcResult)
+ }
+
+ /**
+ * CRC16校验算法
+ */
+ private crc16ab(data: number[], reverseResult: boolean, isHexString: boolean): number[] {
+ let crc = 0xffff
+ const polynomial = 0x1021
+
+ for (let i = 0; i < data.length; i++) {
+ const byte = isHexString ? parseInt(data[i].toString(), 16) : data[i]
+ for (let bit = 0; bit < 8; bit++) {
+ const bitValue = ((byte >> (7 - bit)) & 1) === 1
+ const crcBit = ((crc >> 15) & 1) === 1
+ crc <<= 1
+ if (crcBit !== bitValue) {
+ crc ^= polynomial
}
- return this.connect(device.deviceId)
+ }
}
- isDeviceConnected(deviceId: string): boolean {
- return this.connectedDevices.some(device => device.deviceId === deviceId)
+ const high = (crc & 0xff00) >> 8
+ const low = crc & 0xff
+ return reverseResult ? [low, high] : [high, low]
+ }
+
+ /**
+ * 提交锁指令
+ */
+ private async submitLockInstruction(deviceId: string, instruction: number[]): Promise {
+ const hexInstruction = instruction
+ .map((x) => `0x${x.toString(16).padStart(2, '0').toUpperCase()}`)
+ .join(' ')
+ console.log(`[蓝牙调试] 准备发送指令:`, hexInstruction)
+
+ // 详细解析指令结构
+ if (instruction.length >= 4) {
+ console.log(`[蓝牙调试] 指令结构解析:`)
+ console.log(
+ ` - 帧头: ${instruction[0].toString(16).padStart(2, '0')} ${instruction[1].toString(16).padStart(2, '0')} (应为 AA BB)`
+ )
+ console.log(
+ ` - 长度: ${instruction[2].toString(16).padStart(2, '0')} (${instruction[2]} 字节)`
+ )
+ console.log(
+ ` - 命令: ${instruction[3].toString(16).padStart(2, '0')} (0x${instruction[3].toString(16).toUpperCase()})`
+ )
+ if (instruction.length > 4) {
+ console.log(
+ ` - 数据: ${instruction
+ .slice(4, -2)
+ .map((x) => x.toString(16).padStart(2, '0'))
+ .join(' ')}`
+ )
+ console.log(
+ ` - CRC: ${instruction
+ .slice(-2)
+ .map((x) => x.toString(16).padStart(2, '0'))
+ .join(' ')}`
+ )
+ }
}
- getDeviceSignalStrength(deviceId: string): number | null {
- const device = this.discoveredDevices.find(d => d.deviceId === deviceId)
- return device ? device.RSSI : null
+ // 验证设备是否仍然连接
+ if (!this.isDeviceConnected(deviceId)) {
+ throw new Error('设备已断开连接，无法发送指令')
}
- // 电子锁快捷操作指令
- private lockServiceId = '0000FFF0-0000-1000-8000-00805F9B34FB'
- private lockWriteCharacteristicId = '0000FFF2-0000-1000-8000-00805F9B34FB' // 写特征值
- private lockReadCharacteristicId = '0000FFF1-0000-1000-8000-00805F9B34FB' // 读特征值（用于notify）
- private lockCallback: any = null
-
- /**
- * 初始化锁通信
- * @param deviceId 设备ID
- * @param callback 数据回调函数
- */
- async initLockCommunication(deviceId: string, callback?: (data: any) => void): Promise {
- if (!this.isDeviceConnected(deviceId)) {
- throw new Error('设备未连接');
- }
-
- this.lockCallback = callback;
-
- try {
- // 1. 获取服务对应的所有特征值
- const characteristics = await this.getCharacteristics(deviceId, this.lockServiceId);
-
- // 打印所有特征值及其属性，用于调试
- console.log(`[蓝牙调试] 服务 ${this.lockServiceId} 下的所有特征值:`, JSON.parse(JSON.stringify(characteristics)));
-
- // 2. 验证写特征值是否存在且可写
- const writeCharacteristic = characteristics.find(c =>
- c.uuid.toUpperCase() === this.lockWriteCharacteristicId.toUpperCase()
- );
-
- if (!writeCharacteristic) {
- console.error(`[蓝牙调试] 未找到写特征值: ${this.lockWriteCharacteristicId}`);
- throw new Error(`设备服务中未找到写特征值`);
- }
-
- if (!writeCharacteristic.properties.write && !writeCharacteristic.properties.writeNoResponse) {
- console.error(`[蓝牙调试] 写特征值不支持写入操作:`, writeCharacteristic.properties);
- throw new Error(`写特征值不支持写入操作`);
- }
-
- console.log(`[蓝牙调试] 写特征值验证通过: ${this.lockWriteCharacteristicId}`, writeCharacteristic.properties);
-
- // 添加延迟以确保连接稳定
- await new Promise(resolve => setTimeout(resolve, 500));
-
- // 3. 检查是否存在预期的读特征值
- const readCharacteristic = characteristics.find(c =>
- c.uuid.toUpperCase() === this.lockReadCharacteristicId.toUpperCase()
- );
-
- if (readCharacteristic && readCharacteristic.properties.notify) {
- console.log(`[蓝牙调试] 使用预期的读特征值: ${this.lockReadCharacteristicId}`);
-
- // 先设置监听回调
- this.onCharacteristicValueChange((res: any) => {
- // 确保监听的是正确的特征值
- if (res.deviceId === deviceId &&
- res.serviceId.toUpperCase() === this.lockServiceId.toUpperCase() &&
- res.characteristicId.toUpperCase() === this.lockReadCharacteristicId.toUpperCase()) {
- console.log('[蓝牙调试] 收到锁响应数据');
- this.handleLockResponse(res.value);
- }
- });
-
- // 开启读特征值的通知监听
- await this.notifyCharacteristic(deviceId, this.lockServiceId, this.lockReadCharacteristicId, true);
- console.log(`[蓝牙调试] 通知监听设置成功，等待连接稳定...`);
-
- // 等待更长时间确保蓝牙连接稳定，这很关键！
- await new Promise(resolve => setTimeout(resolve, 2000));
- console.log(`[蓝牙调试] 连接稳定化完成，可以开始发送指令`);
-
- // 启动心跳机制保持连接
- this.startHeartbeat(deviceId);
-
- } else {
- // fallback: 查找任何支持 notify 的特征值
- const notifyCharacteristic = characteristics.find(c => c.properties.notify);
-
- if (!notifyCharacteristic) {
- console.error('[蓝牙调试] 未找到任何支持 "notify" 的特征值。请检查设备固件或确认通信协议。');
- throw new Error(`该设备的服务中未找到支持通知(notify)的特征值`);
- }
-
- const notifyCharacteristicId = notifyCharacteristic.uuid;
- console.warn(`[蓝牙调试] 未找到预期的读特征值，使用备选特征值: ${notifyCharacteristicId}`);
-
- // 开启特征值监听
- await this.notifyCharacteristic(deviceId, this.lockServiceId, notifyCharacteristicId, true);
-
- // 监听特征值变化
- this.onCharacteristicValueChange((res: any) => {
- // 确保监听的是正确的特征值
- if (res.deviceId === deviceId &&
- res.serviceId.toUpperCase() === this.lockServiceId.toUpperCase() &&
- res.characteristicId.toUpperCase() === notifyCharacteristicId.toUpperCase()) {
- this.handleLockResponse(res.value);
- }
- });
- }
-
- } catch (err: any) {
- // 重新抛出错误，以便上层可以捕获
- if (err.errMsg && err.errMsg.includes('notsupport')) {
- throw new Error('当前环境不支持蓝牙通知功能，无法接收设备数据。');
- }
- throw err;
- }
+ // 在企业微信环境中，再次确认连接状态
+ try {
+ const connectedDevices = await this.getConnectedDevices()
+ const isConnected = connectedDevices.some((device) => device.deviceId === deviceId)
+ if (!isConnected) {
+ throw new Error('设备连接状态异常，请重新连接设备')
+ }
+ console.log(`[蓝牙调试] 设备连接状态确认正常`)
+ } catch (error) {
+ console.warn(`[蓝牙调试] 无法验证连接状态:`, error)
+ // 不阻塞流程，继续尝试发送
}
- /**
- * 创建锁指令
- */
- private createLockInstruct(command: number, data: number[]): number[] {
- const header = [0xaa, 0xbb]
- let instruction: number[] = []
- let payload: number[] = []
-
- instruction = instruction.concat(header)
- payload.push(command)
- payload = payload.concat(data)
- payload.unshift(payload.length + 2)
- payload = this.doCrc(payload)
- instruction = instruction.concat(payload)
-
- return instruction
+ // 验证指令数组
+ if (!instruction || instruction.length === 0) {
+ throw new Error('指令数据无效：指令数组为空')
}
- /**
- * 执行CRC校验
- */
- private doCrc(data: number[]): number[] {
- const crcResult = this.crc16ab(data, true, false)
- return data.concat(crcResult)
+ // 验证指令内容
+ for (let i = 0; i < instruction.length; i++) {
+ if (instruction[i] < 0 || instruction[i] > 255) {
+ throw new Error(`指令数据无效：第${i}个字节值${instruction[i]}超出范围[0-255]`)
+ }
}
- /**
- * CRC16校验算法
- */
- private crc16ab(data: number[], reverseResult: boolean, isHexString: boolean): number[] {
- let crc = 0xffff
- const polynomial = 0x1021
-
- for (let i = 0; i < data.length; i++) {
- const byte = isHexString ? parseInt(data[i].toString(), 16) : data[i]
- for (let bit = 0; bit < 8; bit++) {
- const bitValue = (byte >> (7 - bit) & 1) === 1
- const crcBit = (crc >> 15 & 1) === 1
- crc <<= 1
- if (crcBit !== bitValue) {
- crc ^= polynomial
- }
- }
- }
-
- const high = (crc & 0xff00) >> 8
- const low = crc & 0xff
- return reverseResult ? [low, high] : [high, low]
+ // 企业微信环境下，确保ArrayBuffer创建正确
+ let buffer: ArrayBuffer
+ try {
+ buffer = new Uint8Array(instruction).buffer
+ } catch (error) {
+ console.error(`[蓝牙调试] 创建ArrayBuffer失败:`, error)
+ throw new Error('指令数据格式转换失败')
}
- /**
- * 提交锁指令
- */
- private async submitLockInstruction(deviceId: string, instruction: number[]): Promise {
- const hexInstruction = instruction.map(x => `0x${x.toString(16).padStart(2, '0').toUpperCase()}`).join(' ')
- console.log(`[蓝牙调试] 准备发送指令:`, hexInstruction);
-
- // 详细解析指令结构
- if (instruction.length >= 4) {
- console.log(`[蓝牙调试] 指令结构解析:`);
- console.log(` - 帧头: ${instruction[0].toString(16).padStart(2, '0')} ${instruction[1].toString(16).padStart(2, '0')} (应为 AA BB)`);
- console.log(` - 长度: ${instruction[2].toString(16).padStart(2, '0')} (${instruction[2]} 字节)`);
- console.log(` - 命令: ${instruction[3].toString(16).padStart(2, '0')} (0x${instruction[3].toString(16).toUpperCase()})`);
- if (instruction.length > 4) {
- console.log(` - 数据: ${instruction.slice(4, -2).map(x => x.toString(16).padStart(2, '0')).join(' ')}`);
- console.log(` - CRC: ${instruction.slice(-2).map(x => x.toString(16).padStart(2, '0')).join(' ')}`);
- }
- }
-
- // 验证设备是否仍然连接
- if (!this.isDeviceConnected(deviceId)) {
- throw new Error('设备已断开连接，无法发送指令');
- }
-
- // 在企业微信环境中，再次确认连接状态
- try {
- const connectedDevices = await this.getConnectedDevices();
- const isConnected = connectedDevices.some(device => device.deviceId === deviceId);
- if (!isConnected) {
- throw new Error('设备连接状态异常，请重新连接设备');
- }
- console.log(`[蓝牙调试] 设备连接状态确认正常`);
- } catch (error) {
- console.warn(`[蓝牙调试] 无法验证连接状态:`, error);
- // 不阻塞流程，继续尝试发送
- }
-
- // 验证指令数组
- if (!instruction || instruction.length === 0) {
- throw new Error('指令数据无效：指令数组为空');
- }
-
- // 验证指令内容
- for (let i = 0; i < instruction.length; i++) {
- if (instruction[i] < 0 || instruction[i] > 255) {
- throw new Error(`指令数据无效：第${i}个字节值${instruction[i]}超出范围[0-255]`);
- }
- }
-
- // 企业微信环境下，确保ArrayBuffer创建正确
- let buffer: ArrayBuffer;
- try {
- buffer = new Uint8Array(instruction).buffer;
- } catch (error) {
- console.error(`[蓝牙调试] 创建ArrayBuffer失败:`, error);
- throw new Error('指令数据格式转换失败');
- }
-
- if (buffer.byteLength === 0) {
- throw new Error('指令数据无效：转换后的buffer为空');
- }
-
- // 企业微信可能对单次发送的数据大小有限制
- if (buffer.byteLength > 20) {
- console.warn(`[蓝牙调试] 指令长度 ${buffer.byteLength} 超过建议的20字节，可能导致发送失败`);
- }
-
- console.log(`[蓝牙调试] 指令字节长度: ${buffer.byteLength}`);
- console.log(`[蓝牙调试] 发送到设备: ${deviceId}`);
- console.log(`[蓝牙调试] 服务ID: ${this.lockServiceId}`);
- console.log(`[蓝牙调试] 写特征值ID: ${this.lockWriteCharacteristicId}`);
-
- try {
- const result = await this.writeCharacteristic(deviceId, this.lockServiceId, this.lockWriteCharacteristicId, buffer);
- console.log(`[蓝牙调试] 指令发送成功`);
- return result;
- } catch (error: any) {
- console.error(`[蓝牙调试] 指令发送失败:`, error);
-
- // 针对不同的错误类型提供更详细的错误信息
- if (error.message) {
- // 如果是我们自定义的错误消息，直接抛出
- if (error.message.includes('蓝牙写入失败') ||
- error.message.includes('设备已断开') ||
- error.message.includes('无效的特征值') ||
- error.message.includes('不允许写入')) {
- throw error;
- }
- }
-
- if (error.errMsg) {
- if (error.errMsg.includes('10008') || error.errCode === 10008) {
- // 10008 错误通常是连接问题
- throw new Error('蓝牙连接不稳定（错误码10008），建议：1.重新连接设备 2.确保设备距离足够近 3.检查设备是否被其他应用占用');
- } else if (error.errMsg.includes('10009')) {
- throw new Error('蓝牙服务不存在或已断开');
- } else if (error.errMsg.includes('10010')) {
- throw new Error('特征值不存在或不支持写入');
- } else if (error.errMsg.includes('system err')) {
- throw new Error('系统蓝牙错误，可能的原因：1.设备固件不兼容 2.特征值权限不足 3.企业微信蓝牙权限问题');
- }
- }
-
- throw error;
- }
+ if (buffer.byteLength === 0) {
+ throw new Error('指令数据无效：转换后的buffer为空')
}
- /**
- * 处理锁响应数据
- */
- private handleLockResponse(data: ArrayBuffer): void {
- // eslint-disable-next-line
- let hexData = [...this.arrayBufferToHex(data)] // 创建可修改的副本
- console.log(`[蓝牙调试] 收到原始数据:`, hexData.join(' '))
- this.logLockOperation('接收数据', `原始数据: ${hexData.join(' ')}`, 'info')
-
- let processCount = 0
- const maxProcessCount = 10 // 防止无限循环
-
- while (hexData.indexOf('aa') >= 0 && processCount < maxProcessCount) {
- const startIndex = hexData.indexOf('aa')
-
- // 检查数据长度是否足够
- if (startIndex + 2 >= hexData.length) {
- console.warn(`[蓝牙调试] 数据长度不足，无法解析`)
- break
- }
-
- const length = parseInt(hexData[startIndex + 2], 16)
-
- // 检查长度是否合理
- if (isNaN(length) || length <= 0 || length > 100) {
- console.warn(`[蓝牙调试] 无效的数据长度: ${length}`)
- // 跳过这个'aa'继续寻找下一个
- hexData.splice(startIndex, 1)
- processCount++
- continue
- }
-
- const endIndex = startIndex + length + 3
-
- // 检查是否有足够的数据
- if (endIndex > hexData.length) {
- console.warn(`[蓝牙调试] 数据包不完整，需要 ${endIndex} 但只有 ${hexData.length} 字节`)
- break
- }
-
- const instructHex = hexData.slice(startIndex, endIndex)
- console.log(`[蓝牙调试] 解析数据包:`, instructHex.join(' '))
-
- const result = this.parseLockResponse([...instructHex]) // 创建副本避免修改原数组
-
- if (this.lockCallback) {
- this.lockCallback(result)
- }
-
- // 移除已处理的数据，防止重复处理
- hexData.splice(startIndex, endIndex - startIndex)
- processCount++
- }
-
- if (processCount >= maxProcessCount) {
- console.error(`[蓝牙调试] 数据处理达到最大循环次数，可能存在问题`)
- }
+ // 企业微信可能对单次发送的数据大小有限制
+ if (buffer.byteLength > 20) {
+ console.warn(`[蓝牙调试] 指令长度 ${buffer.byteLength} 超过建议的20字节，可能导致发送失败`)
}
- /**
- * 解析锁响应
- */
- private parseLockResponse(instructArray: string[]): any {
- if (instructArray.shift() !== 'aa') {
- this.logLockOperation('解析响应', '数据头错误 - 缺少aa标识', 'error')
- return this.createCallData('-1', '-1', '数据错误')
+ console.log(`[蓝牙调试] 指令字节长度: ${buffer.byteLength}`)
+ console.log(`[蓝牙调试] 发送到设备: ${deviceId}`)
+ console.log(`[蓝牙调试] 服务ID: ${this.lockServiceId}`)
+ console.log(`[蓝牙调试] 写特征值ID: ${this.lockWriteCharacteristicId}`)
+
+ try {
+ const result = await this.writeCharacteristic(
+ deviceId,
+ this.lockServiceId,
+ this.lockWriteCharacteristicId,
+ buffer
+ )
+ console.log(`[蓝牙调试] 指令发送成功`)
+ return result
+ } catch (error: any) {
+ console.error(`[蓝牙调试] 指令发送失败:`, error)
+
+ // 针对不同的错误类型提供更详细的错误信息
+ if (error.message) {
+ // 如果是我们自定义的错误消息，直接抛出
+ if (
+ error.message.includes('蓝牙写入失败') ||
+ error.message.includes('设备已断开') ||
+ error.message.includes('无效的特征值') ||
+ error.message.includes('不允许写入')
+ ) {
+ throw error
}
- if (instructArray.shift() !== 'bb') {
- this.logLockOperation('解析响应', '数据头错误 - 缺少bb标识', 'error')
- return this.createCallData('-1', '-1', '数据错误')
+ }
+
+ if (error.errMsg) {
+ if (error.errMsg.includes('10008') || error.errCode === 10008) {
+ // 10008 错误通常是连接问题
+ throw new Error(
+ '蓝牙连接不稳定（错误码10008），建议：1.重新连接设备 2.确保设备距离足够近 3.检查设备是否被其他应用占用'
+ )
+ } else if (error.errMsg.includes('10009')) {
+ throw new Error('蓝牙服务不存在或已断开')
+ } else if (error.errMsg.includes('10010')) {
+ throw new Error('特征值不存在或不支持写入')
+ } else if (error.errMsg.includes('system err')) {
+ throw new Error(
+ '系统蓝牙错误，可能的原因：1.设备固件不兼容 2.特征值权限不足 3.企业微信蓝牙权限问题'
+ )
}
+ }
- const command = parseInt(instructArray[1], 16)
- this.logLockOperation('解析响应', `收到指令响应: 0x${command.toString(16)}`, 'info', { command, rawData: instructArray })
-
- switch (command) {
- case 0x8: // 锁状态指令
- const statusResult = instructArray[2] === '01'
- ? this.createCallData('08', '01', '手柄打开')
- : this.createCallData('08', '00', '手柄关闭')
- this.logLockOperation('获取状态', `锁状态: ${statusResult.msg}`, 'success', {
- status: statusResult.data,
- rawResponse: instructArray
- })
- return statusResult
-
- case 0x7: // 开锁指令
- let openResult
- if (instructArray[2] === '01') {
- openResult = this.createCallData('07', '01', '开锁成功')
- this.logLockOperation('开锁操作', '开锁成功', 'success', {
- result: '01',
- rawResponse: instructArray
- })
- } else if (instructArray[2] === '02') {
- // 按照微信小程序逻辑，02表示修改清除/开锁失败
- openResult = this.createCallData('07', '00', '开锁失败')
- this.logLockOperation('开锁操作', '开锁失败（修改清除）', 'warn', {
- result: '02',
- rawResponse: instructArray
- })
- } else {
- openResult = this.createCallData('07', '00', '开锁失败')
- this.logLockOperation('开锁操作', `开锁失败（响应码: ${instructArray[2]}）`, 'warn', {
- result: instructArray[2],
- rawResponse: instructArray
- })
- }
- return openResult
-
- case 0x12: // 设置锁ID指令
- const setIdResult = instructArray[2] === '01'
- ? this.createCallData('12', '01', '修改成功')
- : this.createCallData('12', '00', '修改失败')
- this.logLockOperation('设置锁ID', setIdResult.msg, setIdResult.data === '01' ? 'success' : 'error', {
- result: setIdResult.data,
- rawResponse: instructArray
- })
- return setIdResult
-
- case 0x11: // 获取锁ID指令
- if (instructArray[2] === '01') {
- const idData = instructArray.slice(3, 7)
- const idArray = this.hexToArray(idData)
- const lockId = this.bytesToInt(idArray)
- const getIdResult = this.createCallData('11', lockId, '获取成功')
- this.logLockOperation('获取锁ID', `锁ID: ${lockId}`, 'success', {
- lockId,
- hexData: idData,
- rawResponse: instructArray
- })
- return getIdResult
- } else {
- this.logLockOperation('获取锁ID', '获取锁ID失败', 'error', { rawResponse: instructArray })
- return this.createCallData('11', '00', '获取失败')
- }
-
- case 0x10: // 发送开锁密钥指令
- const keyResult = instructArray[2] === '01'
- ? this.createCallData('10', '01', '钥匙开锁')
- : this.createCallData('10', '00', '开锁失败')
- this.logLockOperation('密钥测试', keyResult.msg, keyResult.data === '01' ? 'success' : 'warn', {
- result: keyResult.data,
- rawResponse: instructArray
- })
- return keyResult
-
- case 0x5: // 设置蓝牙名称指令
- const nameResult = instructArray[2] === '01'
- ? this.createCallData('05', '01', '修改成功')
- : this.createCallData('05', '00', '修改失败')
- this.logLockOperation('设置蓝牙名称', nameResult.msg, nameResult.data === '01' ? 'success' : 'error')
- return nameResult
-
- case 0x22: // 设置任务时间指令
- const timeSetResult = instructArray[2] === '01'
- ? this.createCallData('22', '01', '修改成功')
- : this.createCallData('22', '00', '修改失败')
- this.logLockOperation('设置任务时间', timeSetResult.msg, timeSetResult.data === '01' ? 'success' : 'error')
- return timeSetResult
-
- case 0x23: // 设置任务权限指令
- const permissionResult = instructArray[2] === '01'
- ? this.createCallData('23', '01', '修改成功')
- : this.createCallData('23', '00', '修改失败')
- this.logLockOperation('设置任务权限', permissionResult.msg, permissionResult.data === '01' ? 'success' : 'error')
- return permissionResult
-
- case 0x0a: // 获取当前时间指令
- // 时间数据在instructArray[2]到instructArray[6]
- const timeData = instructArray.slice(2, 7)
- // 这里可以处理时间数据，暂时返回成功
- const timeResult = this.createCallData('0a', '01', '时间获取成功')
- this.logLockOperation('获取当前时间', '设备时间获取成功', 'success', { timeData })
- return timeResult
-
- case 0x2a: // 清除任务权限指令
- const clearResult = instructArray[2] === '01'
- ? this.createCallData('2A', '01', '清除成功')
- : this.createCallData('2A', '00', '清除失败')
- this.logLockOperation('清除任务权限', clearResult.msg, clearResult.data === '01' ? 'success' : 'error')
- return clearResult
-
- case 0xff: // 心跳响应
- // 心跳响应不记录日志，避免刷屏
- return this.createCallData('ff', '01', '心跳正常')
-
- case 0x16: // 可能是设备状态或版本信息响应
- // 根据设备固件，0x16可能是设备信息或状态响应
- const deviceInfoResult = this.createCallData('16', '01', '设备信息响应')
- this.logLockOperation('设备信息', '收到设备信息或状态响应 (0x16)', 'info', {
- rawResponse: instructArray,
- possibleInfo: '设备版本或状态信息'
- })
- return deviceInfoResult
- }
-
- this.logLockOperation('解析响应', `未知指令: 0x${command.toString(16)}`, 'warn', { command, rawData: instructArray })
- return this.createCallData('-1', '-1', '未知指令')
- }
-
- /**
- * 创建回调数据
- */
- private createCallData(code: string, data: any, msg: string): any {
- return { code, data, msg }
- }
-
- /**
- * ArrayBuffer转十六进制数组
- */
- private arrayBufferToHex(buffer: ArrayBuffer): string[] {
- return Array.from(new Uint8Array(buffer), byte =>
- ('00' + byte.toString(16)).slice(-2)
- )
- }
-
- /**
- * 十六进制数组转数字数组
- */
- private hexToArray(hexArray: string[]): number[] {
- return hexArray.map(hex => parseInt(hex, 16))
+ throw error
}
-
- /**
- * 字节数组转整数
- */
- private bytesToInt(bytes: number[]): number {
- const byte0 = bytes[3] & 0xff
- const byte1 = bytes[2] & 0xff
- const byte2 = bytes[1] & 0xff
- const byte3 = bytes[0] & 0xff
- return (byte3 << 24) | (byte2 << 16) | (byte1 << 8) | byte0
+ }
+
+ /**
+ * 处理锁响应数据
+ */
+ private handleLockResponse(data: ArrayBuffer): void {
+ // eslint-disable-next-line
+ let hexData = [...this.arrayBufferToHex(data)] // 创建可修改的副本
+ console.log(`[蓝牙调试] 收到原始数据:`, hexData.join(' '))
+ this.logLockOperation('接收数据', `原始数据: ${hexData.join(' ')}`, 'info')
+
+ let processCount = 0
+ const maxProcessCount = 10 // 防止无限循环
+
+ while (hexData.indexOf('aa') >= 0 && processCount < maxProcessCount) {
+ const startIndex = hexData.indexOf('aa')
+
+ // 检查数据长度是否足够
+ if (startIndex + 2 >= hexData.length) {
+ console.warn(`[蓝牙调试] 数据长度不足，无法解析`)
+ break
+ }
+
+ const length = parseInt(hexData[startIndex + 2], 16)
+
+ // 检查长度是否合理
+ if (isNaN(length) || length <= 0 || length > 100) {
+ console.warn(`[蓝牙调试] 无效的数据长度: ${length}`)
+ // 跳过这个'aa'继续寻找下一个
+ hexData.splice(startIndex, 1)
+ processCount++
+ continue
+ }
+
+ const endIndex = startIndex + length + 3
+
+ // 检查是否有足够的数据
+ if (endIndex > hexData.length) {
+ console.warn(`[蓝牙调试] 数据包不完整，需要 ${endIndex} 但只有 ${hexData.length} 字节`)
+ break
+ }
+
+ const instructHex = hexData.slice(startIndex, endIndex)
+ console.log(`[蓝牙调试] 解析数据包:`, instructHex.join(' '))
+
+ const result = this.parseLockResponse([...instructHex]) // 创建副本避免修改原数组
+
+ if (this.lockCallback) {
+ this.lockCallback(result)
+ }
+
+ // 移除已处理的数据，防止重复处理
+ hexData.splice(startIndex, endIndex - startIndex)
+ processCount++
}
- /**
- * 整数转4字节数组（大端序）
- */
- private intToBytes(value: number): number[] {
- const bytes: number[] = []
- bytes[3] = value & 0xff
- bytes[2] = (value >> 8) & 0xff
- bytes[1] = (value >> 16) & 0xff
- bytes[0] = (value >> 24) & 0xff
- return bytes
+ if (processCount >= maxProcessCount) {
+ console.error(`[蓝牙调试] 数据处理达到最大循环次数，可能存在问题`)
}
-
- /**
- * 整数转4字节数组（小端序）
- */
- private intToByte4R(value: number): number[] {
- const bytes: number[] = []
- bytes[0] = value & 0xff
- bytes[1] = (value >> 8) & 0xff
- bytes[2] = (value >> 16) & 0xff
- bytes[3] = (value >> 24) & 0xff
- return bytes
+ }
+
+ /**
+ * 解析锁响应
+ */
+ private parseLockResponse(instructArray: string[]): any {
+ if (instructArray.shift() !== 'aa') {
+ this.logLockOperation('解析响应', '数据头错误 - 缺少aa标识', 'error')
+ return this.createCallData('-1', '-1', '数据错误')
}
-
- /**
- * 字符串转Uint8数组
- */
- private stringToBytes(str: string): number[] {
- const result: number[] = []
- for (let i = 0; i < str.length; i++) {
- result[i] = str.charCodeAt(i)
- }
- return result
+ if (instructArray.shift() !== 'bb') {
+ this.logLockOperation('解析响应', '数据头错误 - 缺少bb标识', 'error')
+ return this.createCallData('-1', '-1', '数据错误')
}
- /**
- * 记录锁操作日志
- * @param operation 操作类型
- * @param message 消息内容
- * @param level 日志级别
- * @param data 额外数据
- */
- private logLockOperation(operation: string, message: string, level: 'info' | 'warn' | 'error' | 'success' = 'info', data?: any): void {
- const timestamp = new Date().toLocaleString('zh-CN')
- // const logEntry = {
- // timestamp,
- // operation,
- // message,
- // level,
- // data: data || null,
- // deviceId: this.currentHeartbeatDeviceId
- // }
-
- // 控制台输出
- const consoleMessage = `[${timestamp}] [锁操作-${operation}] ${message}`
-
- switch (level) {
- case 'info':
- console.info(consoleMessage, data)
- break
- case 'warn':
- console.warn(consoleMessage, data)
- break
- case 'error':
- console.error(consoleMessage, data)
- break
- case 'success':
- console.log(`✅ ${consoleMessage}`, data)
- break
- }
-
- // 可以在这里添加发送到后端的日志记录
- // await this.sendLogToServer(logEntry)
- }
-
- // 锁操作快捷方法
-
- /**
- * 开锁指令
- * @param deviceId 设备ID
- * @returns Promise
- */
- async openLock(deviceId: string): Promise {
- this.logLockOperation('开锁操作', `发送开锁指令到设备: ${deviceId}`, 'info')
- // 按照微信小程序的参数：[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
- const data = [0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
- const instruction = this.createLockInstruct(0x07, data)
-
- this.logLockOperation('开锁操作', '构建开锁指令', 'info', {
- command: '0x07',
- data: data.map(x => `0x${x.toString(16).toUpperCase()}`),
- fullInstruction: instruction.map(x => `0x${x.toString(16).padStart(2, '0').toUpperCase()}`)
+ const command = parseInt(instructArray[1], 16)
+ this.logLockOperation('解析响应', `收到指令响应: 0x${command.toString(16)}`, 'info', {
+ command,
+ rawData: instructArray
+ })
+
+ switch (command) {
+ case 0x8: // 锁状态指令
+ const statusResult =
+ instructArray[2] === '01'
+ ? this.createCallData('08', '01', '手柄打开')
+ : this.createCallData('08', '00', '手柄关闭')
+ this.logLockOperation('获取状态', `锁状态: ${statusResult.msg}`, 'success', {
+ status: statusResult.data,
+ rawResponse: instructArray
})
-
- try {
- const result = await this.submitLockInstruction(deviceId, instruction)
- this.logLockOperation('开锁操作', '开锁指令发送成功', 'success', {
- instruction: instruction.map(x => `0x${x.toString(16).padStart(2, '0').toUpperCase()}`)
- })
- return result
- } catch (error: any) {
- this.logLockOperation('开锁操作', `开锁指令发送失败: ${error.message}`, 'error', { error })
- throw error
+ return statusResult
+
+ case 0x7: // 开锁指令
+ let openResult
+ if (instructArray[2] === '01') {
+ openResult = this.createCallData('07', '01', '开锁成功')
+ this.logLockOperation('开锁操作', '开锁成功', 'success', {
+ result: '01',
+ rawResponse: instructArray
+ })
+ } else if (instructArray[2] === '02') {
+ // 按照微信小程序逻辑，02表示修改清除/开锁失败
+ openResult = this.createCallData('07', '00', '开锁失败')
+ this.logLockOperation('开锁操作', '开锁失败（修改清除）', 'warn', {
+ result: '02',
+ rawResponse: instructArray
+ })
+ } else {
+ openResult = this.createCallData('07', '00', '开锁失败')
+ this.logLockOperation('开锁操作', `开锁失败（响应码: ${instructArray[2]}）`, 'warn', {
+ result: instructArray[2],
+ rawResponse: instructArray
+ })
}
- }
-
- /**
- * 获取锁状态
- * @param deviceId 设备ID
- * @returns Promise
- */
- async getLockStatus(deviceId: string): Promise {
- this.logLockOperation('获取状态', `发送状态查询指令到设备: ${deviceId}`, 'info')
- const data: number[] = []
- const instruction = this.createLockInstruct(0x8, data)
- try {
- const result = await this.submitLockInstruction(deviceId, instruction)
- this.logLockOperation('获取状态', '状态查询指令发送成功', 'success', { instruction: instruction.map(x => x.toString(16)) })
- return result
- } catch (error: any) {
- this.logLockOperation('获取状态', `状态查询指令发送失败: ${error.message}`, 'error', { error })
- throw error
+ return openResult
+
+ case 0x12: // 设置锁ID指令
+ const setIdResult =
+ instructArray[2] === '01'
+ ? this.createCallData('12', '01', '修改成功')
+ : this.createCallData('12', '00', '修改失败')
+ this.logLockOperation(
+ '设置锁ID',
+ setIdResult.msg,
+ setIdResult.data === '01' ? 'success' : 'error',
+ {
+ result: setIdResult.data,
+ rawResponse: instructArray
+ }
+ )
+ return setIdResult
+
+ case 0x11: // 获取锁ID指令
+ if (instructArray[2] === '01') {
+ const idData = instructArray.slice(3, 7)
+ const idArray = this.hexToArray(idData)
+ const lockId = this.bytesToInt(idArray)
+ const getIdResult = this.createCallData('11', lockId, '获取成功')
+ this.logLockOperation('获取锁ID', `锁ID: ${lockId}`, 'success', {
+ lockId,
+ hexData: idData,
+ rawResponse: instructArray
+ })
+ return getIdResult
+ } else {
+ this.logLockOperation('获取锁ID', '获取锁ID失败', 'error', { rawResponse: instructArray })
+ return this.createCallData('11', '00', '获取失败')
}
- }
-
- /**
- * 发送心跳
- * @param deviceId 设备ID
- * @returns Promise
- */
- async sendHeartbeat(deviceId: string): Promise {
- const data: number[] = []
- const instruction = this.createLockInstruct(0xff, data)
- // 心跳发送不记录日志，避免刷屏
- try {
- const result = await this.submitLockInstruction(deviceId, instruction)
- return result
- } catch (error: any) {
- // 心跳失败也不记录日志，保持安静
- throw error
- }
+ case 0x10: // 发送开锁密钥指令
+ const keyResult =
+ instructArray[2] === '01'
+ ? this.createCallData('10', '01', '钥匙开锁')
+ : this.createCallData('10', '00', '开锁失败')
+ this.logLockOperation(
+ '密钥测试',
+ keyResult.msg,
+ keyResult.data === '01' ? 'success' : 'warn',
+ {
+ result: keyResult.data,
+ rawResponse: instructArray
+ }
+ )
+ return keyResult
+
+ case 0x5: // 设置蓝牙名称指令
+ const nameResult =
+ instructArray[2] === '01'
+ ? this.createCallData('05', '01', '修改成功')
+ : this.createCallData('05', '00', '修改失败')
+ this.logLockOperation(
+ '设置蓝牙名称',
+ nameResult.msg,
+ nameResult.data === '01' ? 'success' : 'error'
+ )
+ return nameResult
+
+ case 0x22: // 设置任务时间指令
+ const timeSetResult =
+ instructArray[2] === '01'
+ ? this.createCallData('22', '01', '修改成功')
+ : this.createCallData('22', '00', '修改失败')
+ this.logLockOperation(
+ '设置任务时间',
+ timeSetResult.msg,
+ timeSetResult.data === '01' ? 'success' : 'error'
+ )
+ return timeSetResult
+
+ case 0x23: // 设置任务权限指令
+ const permissionResult =
+ instructArray[2] === '01'
+ ? this.createCallData('23', '01', '修改成功')
+ : this.createCallData('23', '00', '修改失败')
+ this.logLockOperation(
+ '设置任务权限',
+ permissionResult.msg,
+ permissionResult.data === '01' ? 'success' : 'error'
+ )
+ return permissionResult
+
+ case 0x0a: // 获取当前时间指令
+ // 时间数据在instructArray[2]到instructArray[6]
+ const timeData = instructArray.slice(2, 7)
+ // 这里可以处理时间数据，暂时返回成功
+ const timeResult = this.createCallData('0a', '01', '时间获取成功')
+ this.logLockOperation('获取当前时间', '设备时间获取成功', 'success', { timeData })
+ return timeResult
+
+ case 0x2a: // 清除任务权限指令
+ const clearResult =
+ instructArray[2] === '01'
+ ? this.createCallData('2A', '01', '清除成功')
+ : this.createCallData('2A', '00', '清除失败')
+ this.logLockOperation(
+ '清除任务权限',
+ clearResult.msg,
+ clearResult.data === '01' ? 'success' : 'error'
+ )
+ return clearResult
+
+ case 0xff: // 心跳响应
+ // 心跳响应不记录日志，避免刷屏
+ return this.createCallData('ff', '01', '心跳正常')
+
+ case 0x16: // 可能是设备状态或版本信息响应
+ // 根据设备固件，0x16可能是设备信息或状态响应
+ const deviceInfoResult = this.createCallData('16', '01', '设备信息响应')
+ this.logLockOperation('设备信息', '收到设备信息或状态响应 (0x16)', 'info', {
+ rawResponse: instructArray,
+ possibleInfo: '设备版本或状态信息'
+ })
+ return deviceInfoResult
}
- /**
- * 启动心跳机制
- * @param deviceId 设备ID
- * @param interval 心跳间隔，默认2000ms（仿照微信小程序）
- */
- startHeartbeat(deviceId: string, interval: number = 2000): void {
- // 清理现有的心跳
- this.stopHeartbeat()
-
- this.currentHeartbeatDeviceId = deviceId
- // console.log(`[蓝牙调试] 启动心跳机制，设备: ${deviceId}, 间隔: ${interval}ms`)
-
- // 按照微信小程序的逻辑，心跳持续运行，不因其他指令而停止
- this.heartbeatInterval = setInterval(async () => {
- if (this.currentHeartbeatDeviceId && this.isDeviceConnected(this.currentHeartbeatDeviceId)) {
- try {
- // 静默发送心跳，不记录日志
- await this.sendHeartbeat(this.currentHeartbeatDeviceId)
- } catch (error: any) {
- // 心跳失败不记录日志，保持安静
- // 心跳失败可能表示连接有问题，但按微信小程序逻辑不立即停止
- }
- } else {
- // console.log(`[蓝牙调试] 设备已断开，停止心跳`)
- this.stopHeartbeat()
- }
- }, interval)
+ this.logLockOperation('解析响应', `未知指令: 0x${command.toString(16)}`, 'warn', {
+ command,
+ rawData: instructArray
+ })
+ return this.createCallData('-1', '-1', '未知指令')
+ }
+
+ /**
+ * 创建回调数据
+ */
+ private createCallData(code: string, data: any, msg: string): any {
+ return { code, data, msg }
+ }
+
+ /**
+ * ArrayBuffer转十六进制数组
+ */
+ private arrayBufferToHex(buffer: ArrayBuffer): string[] {
+ return Array.from(new Uint8Array(buffer), (byte) => ('00' + byte.toString(16)).slice(-2))
+ }
+
+ /**
+ * 十六进制数组转数字数组
+ */
+ private hexToArray(hexArray: string[]): number[] {
+ return hexArray.map((hex) => parseInt(hex, 16))
+ }
+
+ /**
+ * 字节数组转整数
+ */
+ private bytesToInt(bytes: number[]): number {
+ const byte0 = bytes[3] & 0xff
+ const byte1 = bytes[2] & 0xff
+ const byte2 = bytes[1] & 0xff
+ const byte3 = bytes[0] & 0xff
+ return (byte3 << 24) | (byte2 << 16) | (byte1 << 8) | byte0
+ }
+
+ /**
+ * 整数转4字节数组（大端序）
+ */
+ private intToBytes(value: number): number[] {
+ const bytes: number[] = []
+ bytes[3] = value & 0xff
+ bytes[2] = (value >> 8) & 0xff
+ bytes[1] = (value >> 16) & 0xff
+ bytes[0] = (value >> 24) & 0xff
+ return bytes
+ }
+
+ /**
+ * 整数转4字节数组（小端序）
+ */
+ private intToByte4R(value: number): number[] {
+ const bytes: number[] = []
+ bytes[0] = value & 0xff
+ bytes[1] = (value >> 8) & 0xff
+ bytes[2] = (value >> 16) & 0xff
+ bytes[3] = (value >> 24) & 0xff
+ return bytes
+ }
+
+ /**
+ * 字符串转Uint8数组
+ */
+ private stringToBytes(str: string): number[] {
+ const result: number[] = []
+ for (let i = 0; i < str.length; i++) {
+ result[i] = str.charCodeAt(i)
}
-
- /**
- * 停止心跳机制
- */
- stopHeartbeat(): void {
- if (this.heartbeatInterval) {
- clearInterval(this.heartbeatInterval)
- this.heartbeatInterval = null
- // console.log(`[蓝牙调试] 心跳机制已停止`)
- }
- this.currentHeartbeatDeviceId = null
+ return result
+ }
+
+ /**
+ * 记录锁操作日志
+ * @param operation 操作类型
+ * @param message 消息内容
+ * @param level 日志级别
+ * @param data 额外数据
+ */
+ private logLockOperation(
+ operation: string,
+ message: string,
+ level: 'info' | 'warn' | 'error' | 'success' = 'info',
+ data?: any
+ ): void {
+ const timestamp = new Date().toLocaleString('zh-CN')
+ // const logEntry = {
+ // timestamp,
+ // operation,
+ // message,
+ // level,
+ // data: data || null,
+ // deviceId: this.currentHeartbeatDeviceId
+ // }
+
+ // 控制台输出
+ const consoleMessage = `[${timestamp}] [锁操作-${operation}] ${message}`
+
+ switch (level) {
+ case 'info':
+ console.info(consoleMessage, data)
+ break
+ case 'warn':
+ console.warn(consoleMessage, data)
+ break
+ case 'error':
+ console.error(consoleMessage, data)
+ break
+ case 'success':
+ console.log(`✅ ${consoleMessage}`, data)
+ break
}
- /**
- * 设置蓝牙名称
- * @param deviceId 设备ID
- * @param name 蓝牙名称
- * @returns Promise
- */
- async setLockBluetoothName(deviceId: string, name: string): Promise {
- const nameData = this.stringToBytes(name)
- const instruction = this.createLockInstruct(0x5, nameData)
- return this.submitLockInstruction(deviceId, instruction)
+ // 可以在这里添加发送到后端的日志记录
+ // await this.sendLogToServer(logEntry)
+ }
+
+ // 锁操作快捷方法
+
+ /**
+ * 开锁指令
+ * @param deviceId 设备ID
+ * @returns Promise
+ */
+ async openLock(deviceId: string): Promise {
+ this.logLockOperation('开锁操作', `发送开锁指令到设备: ${deviceId}`, 'info')
+ // 按照微信小程序的参数：[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]
+ const data = [0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff]
+ const instruction = this.createLockInstruct(0x07, data)
+
+ this.logLockOperation('开锁操作', '构建开锁指令', 'info', {
+ command: '0x07',
+ data: data.map((x) => `0x${x.toString(16).toUpperCase()}`),
+ fullInstruction: instruction.map((x) => `0x${x.toString(16).padStart(2, '0').toUpperCase()}`)
+ })
+
+ try {
+ const result = await this.submitLockInstruction(deviceId, instruction)
+ this.logLockOperation('开锁操作', '开锁指令发送成功', 'success', {
+ instruction: instruction.map((x) => `0x${x.toString(16).padStart(2, '0').toUpperCase()}`)
+ })
+ return result
+ } catch (error: any) {
+ this.logLockOperation('开锁操作', `开锁指令发送失败: ${error.message}`, 'error', { error })
+ throw error
}
-
- /**
- * 获取锁ID
- * @param deviceId 设备ID
- * @returns Promise
- */
- async getLockId(deviceId: string): Promise {
- this.logLockOperation('获取锁ID', `发送锁ID查询指令到设备: ${deviceId}`, 'info')
- const data = [0xff, 0xff, 0xff, 0xff]
- const instruction = this.createLockInstruct(0x11, data)
- try {
- const result = await this.submitLockInstruction(deviceId, instruction)
- this.logLockOperation('获取锁ID', '锁ID查询指令发送成功', 'success', { instruction: instruction.map(x => x.toString(16)) })
- return result
- } catch (error: any) {
- this.logLockOperation('获取锁ID', `锁ID查询指令发送失败: ${error.message}`, 'error', { error })
- throw error
- }
+ }
+
+ /**
+ * 获取锁状态
+ * @param deviceId 设备ID
+ * @returns Promise
+ */
+ async getLockStatus(deviceId: string): Promise {
+ this.logLockOperation('获取状态', `发送状态查询指令到设备: ${deviceId}`, 'info')
+ const data: number[] = []
+ const instruction = this.createLockInstruct(0x8, data)
+ try {
+ const result = await this.submitLockInstruction(deviceId, instruction)
+ this.logLockOperation('获取状态', '状态查询指令发送成功', 'success', {
+ instruction: instruction.map((x) => x.toString(16))
+ })
+ return result
+ } catch (error: any) {
+ this.logLockOperation('获取状态', `状态查询指令发送失败: ${error.message}`, 'error', {
+ error
+ })
+ throw error
}
-
- /**
- * 设置锁ID
- * @param deviceId 设备ID
- * @param lockId 锁ID
- * @returns Promise
- */
- async setLockId(deviceId: string, lockId: number): Promise {
- this.logLockOperation('设置锁ID', `发送锁ID设置指令到设备: ${deviceId}, 新锁ID: ${lockId}`, 'info')
- const padding = [0xff, 0xff, 0xff, 0xff]
- const idBytes = this.intToBytes(lockId)
- const data = idBytes.concat(padding)
- const instruction = this.createLockInstruct(0x12, data)
- try {
- const result = await this.submitLockInstruction(deviceId, instruction)
- this.logLockOperation('设置锁ID', `锁ID设置指令发送成功, 目标ID: ${lockId}`, 'success', {
- lockId,
- instruction: instruction.map(x => x.toString(16)),
- idBytes
- })
- return result
- } catch (error: any) {
- this.logLockOperation('设置锁ID', `锁ID设置指令发送失败: ${error.message}`, 'error', { lockId, error })
- throw error
- }
+ }
+
+ /**
+ * 发送心跳
+ * @param deviceId 设备ID
+ * @returns Promise
+ */
+ async sendHeartbeat(deviceId: string): Promise {
+ const data: number[] = []
+ const instruction = this.createLockInstruct(0xff, data)
+
+ // 心跳发送不记录日志，避免刷屏
+ try {
+ const result = await this.submitLockInstruction(deviceId, instruction)
+ return result
+ } catch (error: any) {
+ // 心跳失败也不记录日志，保持安静
+ throw error
}
-
- /**
- * 发送开锁密钥（电子钥匙）
- * @param deviceId 设备ID
- * @returns Promise
- */
- async sendOpenKey(deviceId: string): Promise {
- this.logLockOperation('开锁密钥', `发送开锁密钥到设备: ${deviceId}`, 'info')
-
- // 检查连接状态
- if (!this.isDeviceConnected(deviceId)) {
- throw new Error('设备未连接，无法发送开锁密钥指令')
- }
-
- // 根据官方SDK文档：开电子钥匙锁芯，返回码10
- const data = [0x32, 0x00, 0xFF, 0xFF, 0xFF, 0xFF]
- const instruction = this.createLockInstruct(0x10, data)
-
- this.logLockOperation('开锁密钥', '构建开锁密钥指令', 'info', {
- command: '0x10',
- data: data.map(x => `0x${x.toString(16).toUpperCase()}`),
- fullInstruction: instruction.map(x => `0x${x.toString(16).padStart(2, '0').toUpperCase()}`)
- })
-
+ }
+
+ /**
+ * 启动心跳机制
+ * @param deviceId 设备ID
+ * @param interval 心跳间隔，默认2000ms（仿照微信小程序）
+ */
+ startHeartbeat(deviceId: string, interval: number = 2000): void {
+ // 清理现有的心跳
+ this.stopHeartbeat()
+
+ this.currentHeartbeatDeviceId = deviceId
+ // console.log(`[蓝牙调试] 启动心跳机制，设备: ${deviceId}, 间隔: ${interval}ms`)
+
+ // 按照微信小程序的逻辑，心跳持续运行，不因其他指令而停止
+ this.heartbeatInterval = setInterval(async () => {
+ if (this.currentHeartbeatDeviceId && this.isDeviceConnected(this.currentHeartbeatDeviceId)) {
try {
- // 发送前详细验证连接状态
- console.log(`[蓝牙调试] 发送开锁密钥前验证连接状态...`)
- const connectionBefore = await this.validateDeviceConnection(deviceId)
- console.log(`[蓝牙调试] 发送前连接验证结果: ${connectionBefore}`)
-
- if (!connectionBefore) {
- throw new Error('设备连接不稳定，无法发送开锁密钥指令')
- }
-
- const result = await this.submitLockInstruction(deviceId, instruction)
-
- // 发送后延迟检查连接状态（给设备一点时间响应）
- await new Promise(resolve => setTimeout(resolve, 500))
- const connectionAfter = await this.validateDeviceConnection(deviceId)
- console.log(`[蓝牙调试] 发送开锁密钥后连接验证结果: ${connectionAfter}`)
-
- if (!connectionAfter) {
- console.warn(`[蓝牙调试] 警告：发送开锁密钥后设备连接已断开`)
- this.logLockOperation('开锁密钥', '指令发送成功但设备连接已断开', 'warn')
- } else {
- this.logLockOperation('开锁密钥', '开锁密钥指令发送成功，连接保持正常', 'success', {
- instruction: instruction.map(x => `0x${x.toString(16).padStart(2, '0').toUpperCase()}`)
- })
- }
-
- return result
+ // 静默发送心跳，不记录日志
+ await this.sendHeartbeat(this.currentHeartbeatDeviceId)
} catch (error: any) {
- console.error(`[蓝牙调试] 开锁密钥发送过程中出错:`, error)
-
- // 检查是否是连接相关的错误
- if (error.message && error.message.includes('断开') ||
- error.errMsg && (error.errMsg.includes('10008') || error.errMsg.includes('10009'))) {
- this.logLockOperation('开锁密钥', `连接中断导致发送失败: ${error.message}`, 'error', {
- error,
- connectionStatus: this.isDeviceConnected(deviceId)
- })
- } else {
- this.logLockOperation('开锁密钥', `开锁密钥指令发送失败: ${error.message}`, 'error', { error })
- }
- throw error
+ // 心跳失败不记录日志，保持安静
+ // 心跳失败可能表示连接有问题，但按微信小程序逻辑不立即停止
}
+ } else {
+ // console.log(`[蓝牙调试] 设备已断开，停止心跳`)
+ this.stopHeartbeat()
+ }
+ }, interval)
+ }
+
+ /**
+ * 停止心跳机制
+ */
+ stopHeartbeat(): void {
+ if (this.heartbeatInterval) {
+ clearInterval(this.heartbeatInterval)
+ this.heartbeatInterval = null
+ // console.log(`[蓝牙调试] 心跳机制已停止`)
}
-
- /**
- * 设置任务权限
- * @param deviceId 设备ID
- * @param taskId 任务ID
- * @param permission 权限值
- * @returns Promise
- */
- async setTaskPermission(deviceId: string, taskId: number, permission: number): Promise {
- const padding = [0xff, 0xff, 0xff, 0xff]
- const idBytes = this.intToBytes(taskId)
- const data = idBytes.concat(padding)
- data.push(permission)
- const instruction = this.createLockInstruct(0x23, data)
- return this.submitLockInstruction(deviceId, instruction)
+ this.currentHeartbeatDeviceId = null
+ }
+
+ /**
+ * 设置蓝牙名称
+ * @param deviceId 设备ID
+ * @param name 蓝牙名称
+ * @returns Promise
+ */
+ async setLockBluetoothName(deviceId: string, name: string): Promise {
+ const nameData = this.stringToBytes(name)
+ const instruction = this.createLockInstruct(0x5, nameData)
+ return this.submitLockInstruction(deviceId, instruction)
+ }
+
+ /**
+ * 获取锁ID
+ * @param deviceId 设备ID
+ * @returns Promise
+ */
+ async getLockId(deviceId: string): Promise {
+ this.logLockOperation('获取锁ID', `发送锁ID查询指令到设备: ${deviceId}`, 'info')
+ const data = [0xff, 0xff, 0xff, 0xff]
+ const instruction = this.createLockInstruct(0x11, data)
+ try {
+ const result = await this.submitLockInstruction(deviceId, instruction)
+ this.logLockOperation('获取锁ID', '锁ID查询指令发送成功', 'success', {
+ instruction: instruction.map((x) => x.toString(16))
+ })
+ return result
+ } catch (error: any) {
+ this.logLockOperation('获取锁ID', `锁ID查询指令发送失败: ${error.message}`, 'error', {
+ error
+ })
+ throw error
}
-
- /**
- * 获取当前时间
- * @param deviceId 设备ID
- * @returns Promise
- */
- async getCurrentTime(deviceId: string): Promise {
- const data: number[] = []
- const instruction = this.createLockInstruct(0x0a, data)
- return this.submitLockInstruction(deviceId, instruction)
+ }
+
+ /**
+ * 设置锁ID
+ * @param deviceId 设备ID
+ * @param lockId 锁ID
+ * @returns Promise
+ */
+ async setLockId(deviceId: string, lockId: number): Promise {
+ this.logLockOperation(
+ '设置锁ID',
+ `发送锁ID设置指令到设备: ${deviceId}, 新锁ID: ${lockId}`,
+ 'info'
+ )
+ const padding = [0xff, 0xff, 0xff, 0xff]
+ const idBytes = this.intToBytes(lockId)
+ const data = idBytes.concat(padding)
+ const instruction = this.createLockInstruct(0x12, data)
+ try {
+ const result = await this.submitLockInstruction(deviceId, instruction)
+ this.logLockOperation('设置锁ID', `锁ID设置指令发送成功, 目标ID: ${lockId}`, 'success', {
+ lockId,
+ instruction: instruction.map((x) => x.toString(16)),
+ idBytes
+ })
+ return result
+ } catch (error: any) {
+ this.logLockOperation('设置锁ID', `锁ID设置指令发送失败: ${error.message}`, 'error', {
+ lockId,
+ error
+ })
+ throw error
}
-
- /**
- * 设置任务时间
- * @param deviceId 设备ID
- * @param timeHex 时间十六进制数组
- * @param duration 持续时间
- * @returns Promise
- */
- async setTaskTime(deviceId: string, timeHex: string[], duration: number): Promise {
- const timeData = this.hexToArray(timeHex)
- const durationBytes = this.intToByte4R(duration)
- const data = timeData.concat(durationBytes).concat([0xff])
- const instruction = this.createLockInstruct(0x22, data)
- return this.submitLockInstruction(deviceId, instruction)
+ }
+
+ /**
+ * 发送开锁密钥（电子钥匙）
+ * @param deviceId 设备ID
+ * @returns Promise
+ */
+ async sendOpenKey(deviceId: string): Promise {
+ this.logLockOperation('开锁密钥', `发送开锁密钥到设备: ${deviceId}`, 'info')
+
+ // 检查连接状态
+ if (!this.isDeviceConnected(deviceId)) {
+ throw new Error('设备未连接，无法发送开锁密钥指令')
}
- /**
- * 开始任务时间
- * @param deviceId 设备ID
- * @returns Promise
- */
- async startTaskTime(deviceId: string): Promise {
- // 先获取当前时间，然后设置任务时间
- await this.getCurrentTime(deviceId)
- // 注意：这里需要等待getCurrentTime的响应，然后调用setTaskTime
- // 由于异步特性，实际的时间设置逻辑需要在回调中处理
- return Promise.resolve()
+ // 根据官方SDK文档：开电子钥匙锁芯，返回码10
+ const data = [0x32, 0x00, 0xff, 0xff, 0xff, 0xff]
+ const instruction = this.createLockInstruct(0x10, data)
+
+ this.logLockOperation('开锁密钥', '构建开锁密钥指令', 'info', {
+ command: '0x10',
+ data: data.map((x) => `0x${x.toString(16).toUpperCase()}`),
+ fullInstruction: instruction.map((x) => `0x${x.toString(16).padStart(2, '0').toUpperCase()}`)
+ })
+
+ try {
+ // 发送前详细验证连接状态
+ console.log(`[蓝牙调试] 发送开锁密钥前验证连接状态...`)
+ const connectionBefore = await this.validateDeviceConnection(deviceId)
+ console.log(`[蓝牙调试] 发送前连接验证结果: ${connectionBefore}`)
+
+ if (!connectionBefore) {
+ throw new Error('设备连接不稳定，无法发送开锁密钥指令')
+ }
+
+ const result = await this.submitLockInstruction(deviceId, instruction)
+
+ // 发送后延迟检查连接状态（给设备一点时间响应）
+ await new Promise((resolve) => setTimeout(resolve, 500))
+ const connectionAfter = await this.validateDeviceConnection(deviceId)
+ console.log(`[蓝牙调试] 发送开锁密钥后连接验证结果: ${connectionAfter}`)
+
+ if (!connectionAfter) {
+ console.warn(`[蓝牙调试] 警告：发送开锁密钥后设备连接已断开`)
+ this.logLockOperation('开锁密钥', '指令发送成功但设备连接已断开', 'warn')
+ } else {
+ this.logLockOperation('开锁密钥', '开锁密钥指令发送成功，连接保持正常', 'success', {
+ instruction: instruction.map((x) => `0x${x.toString(16).padStart(2, '0').toUpperCase()}`)
+ })
+ }
+
+ return result
+ } catch (error: any) {
+ console.error(`[蓝牙调试] 开锁密钥发送过程中出错:`, error)
+
+ // 检查是否是连接相关的错误
+ if (
+ (error.message && error.message.includes('断开')) ||
+ (error.errMsg && (error.errMsg.includes('10008') || error.errMsg.includes('10009')))
+ ) {
+ this.logLockOperation('开锁密钥', `连接中断导致发送失败: ${error.message}`, 'error', {
+ error,
+ connectionStatus: this.isDeviceConnected(deviceId)
+ })
+ } else {
+ this.logLockOperation('开锁密钥', `开锁密钥指令发送失败: ${error.message}`, 'error', {
+ error
+ })
+ }
+ throw error
}
-
- /**
- * 清除任务权限
- * @param deviceId 设备ID
- * @returns Promise
- */
- async clearTaskPermission(deviceId: string): Promise {
- const data: number[] = []
- const instruction = this.createLockInstruct(0x2a, data)
- return this.submitLockInstruction(deviceId, instruction)
+ }
+
+ /**
+ * 设置任务权限
+ * @param deviceId 设备ID
+ * @param taskId 任务ID
+ * @param permission 权限值
+ * @returns Promise
+ */
+ async setTaskPermission(deviceId: string, taskId: number, permission: number): Promise {
+ const padding = [0xff, 0xff, 0xff, 0xff]
+ const idBytes = this.intToBytes(taskId)
+ const data = idBytes.concat(padding)
+ data.push(permission)
+ const instruction = this.createLockInstruct(0x23, data)
+ return this.submitLockInstruction(deviceId, instruction)
+ }
+
+ /**
+ * 获取当前时间
+ * @param deviceId 设备ID
+ * @returns Promise
+ */
+ async getCurrentTime(deviceId: string): Promise {
+ const data: number[] = []
+ const instruction = this.createLockInstruct(0x0a, data)
+ return this.submitLockInstruction(deviceId, instruction)
+ }
+
+ /**
+ * 设置任务时间
+ * @param deviceId 设备ID
+ * @param timeHex 时间十六进制数组
+ * @param duration 持续时间
+ * @returns Promise
+ */
+ async setTaskTime(deviceId: string, timeHex: string[], duration: number): Promise {
+ const timeData = this.hexToArray(timeHex)
+ const durationBytes = this.intToByte4R(duration)
+ const data = timeData.concat(durationBytes).concat([0xff])
+ const instruction = this.createLockInstruct(0x22, data)
+ return this.submitLockInstruction(deviceId, instruction)
+ }
+
+ /**
+ * 开始任务时间
+ * @param deviceId 设备ID
+ * @returns Promise
+ */
+ async startTaskTime(deviceId: string): Promise {
+ // 先获取当前时间，然后设置任务时间
+ await this.getCurrentTime(deviceId)
+ // 注意：这里需要等待getCurrentTime的响应，然后调用setTaskTime
+ // 由于异步特性，实际的时间设置逻辑需要在回调中处理
+ return Promise.resolve()
+ }
+
+ /**
+ * 清除任务权限
+ * @param deviceId 设备ID
+ * @returns Promise
+ */
+ async clearTaskPermission(deviceId: string): Promise {
+ const data: number[] = []
+ const instruction = this.createLockInstruct(0x2a, data)
+ return this.submitLockInstruction(deviceId, instruction)
+ }
+
+ /**
+ * 验证设备连接状态（用于指令发送前后的检查）
+ * @param deviceId 设备ID
+ * @returns Promise
+ */
+ async validateDeviceConnection(deviceId: string): Promise {
+ try {
+ // 1. 检查内部连接状态
+ const internalConnected = this.isDeviceConnected(deviceId)
+ console.log(`[蓝牙调试] 内部连接状态: ${internalConnected}`)
+
+ // 2. 通过系统API获取连接状态
+ const connectedDevices = await this.getConnectedDevices()
+ const systemConnected = connectedDevices.some((device) => device.deviceId === deviceId)
+ console.log(`[蓝牙调试] 系统连接状态: ${systemConnected}`)
+
+ // 3. 尝试读取特征值来验证连接（如果支持）
+ try {
+ const characteristics = await this.getCharacteristics(deviceId, this.lockServiceId)
+ const hasValidCharacteristics = characteristics && characteristics.length > 0
+ console.log(`[蓝牙调试] 特征值可访问性: ${hasValidCharacteristics}`)
+
+ return internalConnected && systemConnected && hasValidCharacteristics
+ } catch (charError) {
+ console.warn(`[蓝牙调试] 无法访问特征值，连接可能不稳定:`, charError)
+ return false
+ }
+ } catch (error) {
+ console.error(`[蓝牙调试] 连接验证失败:`, error)
+ return false
}
-
- /**
- * 验证设备连接状态（用于指令发送前后的检查）
- * @param deviceId 设备ID
- * @returns Promise
- */
- async validateDeviceConnection(deviceId: string): Promise {
- try {
- // 1. 检查内部连接状态
- const internalConnected = this.isDeviceConnected(deviceId)
- console.log(`[蓝牙调试] 内部连接状态: ${internalConnected}`)
-
- // 2. 通过系统API获取连接状态
- const connectedDevices = await this.getConnectedDevices()
- const systemConnected = connectedDevices.some(device => device.deviceId === deviceId)
- console.log(`[蓝牙调试] 系统连接状态: ${systemConnected}`)
-
- // 3. 尝试读取特征值来验证连接（如果支持）
- try {
- const characteristics = await this.getCharacteristics(deviceId, this.lockServiceId)
- const hasValidCharacteristics = characteristics && characteristics.length > 0
- console.log(`[蓝牙调试] 特征值可访问性: ${hasValidCharacteristics}`)
-
- return internalConnected && systemConnected && hasValidCharacteristics
- } catch (charError) {
- console.warn(`[蓝牙调试] 无法访问特征值，连接可能不稳定:`, charError)
- return false
- }
-
- } catch (error) {
- console.error(`[蓝牙调试] 连接验证失败:`, error)
- return false
- }
+ }
+
+ /**
+ * 验证蓝牙特征值配置
+ * @param deviceId 设备ID
+ * @returns Promise
+ */
+ async validateLockCharacteristics(deviceId: string): Promise {
+ try {
+ console.log(`[蓝牙调试] 开始验证设备特征值配置...`)
+
+ const characteristics = await this.getCharacteristics(deviceId, this.lockServiceId)
+ console.log(
+ `[蓝牙调试] 发现特征值:`,
+ characteristics.map((c) => ({
+ uuid: c.uuid,
+ properties: c.properties
+ }))
+ )
+
+ // 检查写特征值
+ const writeChar = characteristics.find(
+ (c) => c.uuid.toUpperCase() === this.lockWriteCharacteristicId.toUpperCase()
+ )
+
+ // 检查读特征值
+ const readChar = characteristics.find(
+ (c) => c.uuid.toUpperCase() === this.lockReadCharacteristicId.toUpperCase()
+ )
+
+ console.log(
+ `[蓝牙调试] 写特征值检查:`,
+ writeChar
+ ? `找到 ${writeChar.uuid} (write: ${writeChar.properties.write}, writeNoResponse: ${writeChar.properties.writeNoResponse || false})`
+ : '未找到'
+ )
+
+ console.log(
+ `[蓝牙调试] 读特征值检查:`,
+ readChar ? `找到 ${readChar.uuid} (notify: ${readChar.properties.notify})` : '未找到'
+ )
+
+ return !!(
+ writeChar &&
+ readChar &&
+ (writeChar.properties.write || writeChar.properties.writeNoResponse || false) &&
+ readChar.properties.notify
+ )
+ } catch (error) {
+ console.error(`[蓝牙调试] 特征值验证失败:`, error)
+ return false
}
-
- /**
- * 验证蓝牙特征值配置
- * @param deviceId 设备ID
- * @returns Promise
- */
- async validateLockCharacteristics(deviceId: string): Promise {
- try {
- console.log(`[蓝牙调试] 开始验证设备特征值配置...`);
-
- const characteristics = await this.getCharacteristics(deviceId, this.lockServiceId);
- console.log(`[蓝牙调试] 发现特征值:`, characteristics.map(c => ({
- uuid: c.uuid,
- properties: c.properties
- })));
-
- // 检查写特征值
- const writeChar = characteristics.find(c =>
- c.uuid.toUpperCase() === this.lockWriteCharacteristicId.toUpperCase()
- );
-
- // 检查读特征值
- const readChar = characteristics.find(c =>
- c.uuid.toUpperCase() === this.lockReadCharacteristicId.toUpperCase()
- );
-
- console.log(`[蓝牙调试] 写特征值检查:`, writeChar ?
- `找到 ${writeChar.uuid} (write: ${writeChar.properties.write}, writeNoResponse: ${writeChar.properties.writeNoResponse || false})` :
- '未找到'
- );
-
- console.log(`[蓝牙调试] 读特征值检查:`, readChar ?
- `找到 ${readChar.uuid} (notify: ${readChar.properties.notify})` :
- '未找到'
- );
-
- return !!(writeChar && readChar &&
- (writeChar.properties.write || (writeChar.properties.writeNoResponse || false)) &&
- readChar.properties.notify);
-
- } catch (error) {
- console.error(`[蓝牙调试] 特征值验证失败:`, error);
- return false;
- }
+ }
+
+ /**
+ * 完整的锁连接和初始化流程
+ * @param deviceName 设备名称或设备ID
+ * @param callback 数据回调
+ * @returns Promise
+ */
+ async connectAndInitLock(deviceName: string, callback?: (data: any) => void): Promise {
+ let deviceId: string
+
+ // 如果是设备名称，先查找设备
+ if (!deviceName.includes(':') && !deviceName.includes('-')) {
+ const device = await this.findDeviceByName(deviceName)
+ if (!device) {
+ throw new Error(`未找到设备: ${deviceName}`)
+ }
+ deviceId = device.deviceId
+ } else {
+ deviceId = deviceName
}
- /**
- * 完整的锁连接和初始化流程
- * @param deviceName 设备名称或设备ID
- * @param callback 数据回调
- * @returns Promise
- */
- async connectAndInitLock(deviceName: string, callback?: (data: any) => void): Promise {
- let deviceId: string
-
- // 如果是设备名称，先查找设备
- if (!deviceName.includes(':') && !deviceName.includes('-')) {
- const device = await this.findDeviceByName(deviceName)
- if (!device) {
- throw new Error(`未找到设备: ${deviceName}`)
- }
- deviceId = device.deviceId
- } else {
- deviceId = deviceName
- }
+ // 连接设备
+ await this.connect(deviceId)
- // 连接设备
- await this.connect(deviceId)
+ // 初始化锁通信
+ await this.initLockCommunication(deviceId, callback)
- // 初始化锁通信
- await this.initLockCommunication(deviceId, callback)
-
- return deviceId
- }
+ return deviceId
+ }
}
-
// 创建蓝牙实例
const bluetooth = new wwBluetooth()
// 扩展ww对象，添加蓝牙功能
const wwWithBluetooth = {
- ...ww,
- bluetooth,
-
- // 直接在ww上添加蓝牙方法以保持向后兼容
- getBluetoothAdapterState: bluetooth.getState.bind(bluetooth),
- openBluetoothAdapter: bluetooth.checkSupport.bind(bluetooth),
- startBluetoothDevicesDiscovery: bluetooth.discover.bind(bluetooth),
- stopBluetoothDevicesDiscovery: bluetooth.stopDiscovery.bind(bluetooth),
- getBluetoothDevices: bluetooth.getDiscoveredDevices.bind(bluetooth),
- getConnectedBluetoothDevices: bluetooth.getConnectedDevices.bind(bluetooth),
- createBLEConnection: bluetooth.connect.bind(bluetooth),
- closeBLEConnection: bluetooth.disconnect.bind(bluetooth),
-
- // 新增的蓝牙方法
- getBLEDeviceServices: bluetooth.getServices.bind(bluetooth),
- getBLEDeviceCharacteristics: bluetooth.getCharacteristics.bind(bluetooth),
- readBLECharacteristicValue: bluetooth.readCharacteristic.bind(bluetooth),
- writeBLECharacteristicValue: bluetooth.writeCharacteristic.bind(bluetooth),
- notifyBLECharacteristicValueChange: bluetooth.notifyCharacteristic.bind(bluetooth),
- onBLECharacteristicValueChange: bluetooth.onCharacteristicValueChange.bind(bluetooth),
- onBLEConnectionStateChange: bluetooth.onConnectionStateChange.bind(bluetooth),
-
- // 锁操作快捷方法
- initLockCommunication: bluetooth.initLockCommunication.bind(bluetooth),
- openLock: bluetooth.openLock.bind(bluetooth),
- getLockStatus: bluetooth.getLockStatus.bind(bluetooth),
- sendHeartbeat: bluetooth.sendHeartbeat.bind(bluetooth),
- startHeartbeat: bluetooth.startHeartbeat.bind(bluetooth),
- stopHeartbeat: bluetooth.stopHeartbeat.bind(bluetooth),
- setLockBluetoothName: bluetooth.setLockBluetoothName.bind(bluetooth),
- getLockId: bluetooth.getLockId.bind(bluetooth),
- setLockId: bluetooth.setLockId.bind(bluetooth),
- sendOpenKey: bluetooth.sendOpenKey.bind(bluetooth),
- getCurrentTime: bluetooth.getCurrentTime.bind(bluetooth),
- setTaskTime: bluetooth.setTaskTime.bind(bluetooth),
- startTaskTime: bluetooth.startTaskTime.bind(bluetooth),
- setTaskPermission: bluetooth.setTaskPermission.bind(bluetooth),
- clearTaskPermission: bluetooth.clearTaskPermission.bind(bluetooth),
- connectAndInitLock: bluetooth.connectAndInitLock.bind(bluetooth),
-
- // 权限管理方法
- requestPermissions: bluetooth.requestPermissions.bind(bluetooth),
- checkPermissions: bluetooth.checkPermissions.bind(bluetooth),
- openAppSetting: bluetooth.openAppSetting.bind(bluetooth),
- ensurePermissions: bluetooth.ensurePermissions.bind(bluetooth),
-
- // 暴露心跳状态
- get currentHeartbeatDeviceId() {
- return bluetooth.currentHeartbeatDeviceId
- }
+ ...ww,
+ bluetooth,
+
+ // 直接在ww上添加蓝牙方法以保持向后兼容
+ getBluetoothAdapterState: bluetooth.getState.bind(bluetooth),
+ openBluetoothAdapter: bluetooth.checkSupport.bind(bluetooth),
+ startBluetoothDevicesDiscovery: bluetooth.discover.bind(bluetooth),
+ stopBluetoothDevicesDiscovery: bluetooth.stopDiscovery.bind(bluetooth),
+ getBluetoothDevices: bluetooth.getDiscoveredDevices.bind(bluetooth),
+ getConnectedBluetoothDevices: bluetooth.getConnectedDevices.bind(bluetooth),
+ createBLEConnection: bluetooth.connect.bind(bluetooth),
+ closeBLEConnection: bluetooth.disconnect.bind(bluetooth),
+
+ // 新增的蓝牙方法
+ getBLEDeviceServices: bluetooth.getServices.bind(bluetooth),
+ getBLEDeviceCharacteristics: bluetooth.getCharacteristics.bind(bluetooth),
+ readBLECharacteristicValue: bluetooth.readCharacteristic.bind(bluetooth),
+ writeBLECharacteristicValue: bluetooth.writeCharacteristic.bind(bluetooth),
+ notifyBLECharacteristicValueChange: bluetooth.notifyCharacteristic.bind(bluetooth),
+ onBLECharacteristicValueChange: bluetooth.onCharacteristicValueChange.bind(bluetooth),
+ onBLEConnectionStateChange: bluetooth.onConnectionStateChange.bind(bluetooth),
+
+ // 锁操作快捷方法
+ initLockCommunication: bluetooth.initLockCommunication.bind(bluetooth),
+ openLock: bluetooth.openLock.bind(bluetooth),
+ getLockStatus: bluetooth.getLockStatus.bind(bluetooth),
+ sendHeartbeat: bluetooth.sendHeartbeat.bind(bluetooth),
+ startHeartbeat: bluetooth.startHeartbeat.bind(bluetooth),
+ stopHeartbeat: bluetooth.stopHeartbeat.bind(bluetooth),
+ setLockBluetoothName: bluetooth.setLockBluetoothName.bind(bluetooth),
+ getLockId: bluetooth.getLockId.bind(bluetooth),
+ setLockId: bluetooth.setLockId.bind(bluetooth),
+ sendOpenKey: bluetooth.sendOpenKey.bind(bluetooth),
+ getCurrentTime: bluetooth.getCurrentTime.bind(bluetooth),
+ setTaskTime: bluetooth.setTaskTime.bind(bluetooth),
+ startTaskTime: bluetooth.startTaskTime.bind(bluetooth),
+ setTaskPermission: bluetooth.setTaskPermission.bind(bluetooth),
+ clearTaskPermission: bluetooth.clearTaskPermission.bind(bluetooth),
+ connectAndInitLock: bluetooth.connectAndInitLock.bind(bluetooth),
+
+ // 权限管理方法
+ requestPermissions: bluetooth.requestPermissions.bind(bluetooth),
+ checkPermissions: bluetooth.checkPermissions.bind(bluetooth),
+ openAppSetting: bluetooth.openAppSetting.bind(bluetooth),
+ ensurePermissions: bluetooth.ensurePermissions.bind(bluetooth),
+
+ // 暴露心跳状态
+ get currentHeartbeatDeviceId() {
+ return bluetooth.currentHeartbeatDeviceId
+ }
}
export default wwWithBluetooth
export { bluetooth }
diff --git a/web/src/views/Login/Login.vue b/web/src/views/Login/Login.vue
index 3117ba8..237b4ef 100644
--- a/web/src/views/Login/Login.vue
+++ b/web/src/views/Login/Login.vue
@@ -1,9 +1,13 @@
-
请选择要绑定的锁具：
+
+ :class="`${prefixCls}__left flex-1 bg-gray-500 bg-opacity-20 relative p-30px lt-xl:hidden overflow-x-hidden overflow-y-auto`"
+ >
@@ -11,7 +15,11 @@
@@ -11,7 +15,11 @@
-
+
{{ t('login.welcome') }}
@@ -21,10 +29,13 @@
+ class="relative flex-1 p-30px dark:bg-[var(--login-bg-color)] lt-sm:p-10px overflow-x-hidden overflow-y-auto"
+ >
-
+
{{ underlineToHump(appStore.getTitle) }}
@@ -37,7 +48,8 @@
+
@@ -36,15 +54,18 @@
-
+
-
- {{users.find((user) => user.id === scope.row.operatorId)?.nickname}}
+ {{ users.find((user) => user.id === scope.row.operatorId)?.nickname }}
{{ getLifeLockStatus(scope.row.lifeLock, 1) }}
@@ -52,7 +73,7 @@
- {{users.find((user) => user.id === scope.row.verifierId)?.nickname}}
+ {{ users.find((user) => user.id === scope.row.verifierId)?.nickname }}
{{ getLifeLockStatus(scope.row.lifeLock, 3) }}
@@ -69,7 +90,7 @@
-
- {{users.find((u) => u.id === aff.userId)?.nickname}}
+
+ {{ users.find((u) => u.id === aff.userId)?.nickname }}
+
+
-
+
绑定
-
+
上锁
-
+
验证
-
+
解锁验证
-
+
解锁
@@ -275,7 +321,10 @@ const getInviteCode = (item) => {
diff --git a/web/src/views/lock/grouplock/components/PlanCard.vue b/web/src/views/lock/grouplock/components/PlanCard.vue
index c86e14f..82a6e22 100644
--- a/web/src/views/lock/grouplock/components/PlanCard.vue
+++ b/web/src/views/lock/grouplock/components/PlanCard.vue
@@ -17,12 +17,16 @@
- 责任人员
+
{{ underlineToHump(appStore.getTitle) }}
@@ -37,7 +48,8 @@
+ class="m-auto h-[calc(100%-60px)] w-[100%] flex items-center at-2xl:max-w-500px at-lg:max-w-500px at-md:max-w-500px at-xl:max-w-500px"
+ >
+
@@ -119,7 +116,7 @@
-
+
diff --git a/web/src/views/lock/grouplock/components/PCGroupLock.vue b/web/src/views/lock/grouplock/components/PCGroupLock.vue
index a09450d..8ad9e0a 100644
--- a/web/src/views/lock/grouplock/components/PCGroupLock.vue
+++ b/web/src/views/lock/grouplock/components/PCGroupLock.vue
@@ -2,8 +2,19 @@
-
@@ -20,8 +31,15 @@
任务: {{ isolationPlan.length }}
- {{users.find((user) => user.id === scope.row.operatorHelperId)?.nickname}}
+ {{ users.find((user) => user.id === scope.row.operatorHelperId)?.nickname }}
{{ getLifeLockStatus(scope.row.lifeLock, 2) }}
-
@@ -61,7 +82,7 @@
- {{users.find((user) => user.id === scope.row.verifierHelperId)?.nickname}}
+ {{ users.find((user) => user.id === scope.row.verifierHelperId)?.nickname }}
{{ getLifeLockStatus(scope.row.lifeLock, 4) }}
-
@@ -80,8 +101,13 @@
-
+
{{ role.label }}:
{{ getUserName(isolationPlan[0], role.key) }}
@@ -35,18 +39,26 @@
- 隔离点详情
+
+
@@ -58,66 +70,97 @@
- {{ getLockName(item.lockId) }}
+
- 受影响人员
+
+
-
-
+
{{
elLockStore.users.find((user) => user.id === scope.row.operatorId)?.nickname
- }}
+ }}
-
+
-
-
+
{{
elLockStore.users.find((user) => user.id === scope.row.operatorHelperId)?.nickname
- }}
+ }}
-
-
+
{{
elLockStore.users.find((user) => user.id === scope.row.verifierId)?.nickname
- }}
+ }}
-
+
-
-
+
{{
elLockStore.users.find((user) => user.id === scope.row.verifierHelperId)?.nickname
- }}
+ }}
@@ -145,8 +229,15 @@
-
+
-
+
@@ -178,32 +280,55 @@
{{ getPointName(pointId) }}
-
-
+
{{
users.find((u) => u.id === affected.userId)?.nickname
}}
-
-
+
- 绑定
+
-
+
- 上锁
+
-
+
- 验证
+
+
- 解锁验证
+
-
+
- 解锁
+
+
@@ -43,13 +60,18 @@
{{ scope.row.isolationPoint.ipName }}
-
-
@@ -59,7 +81,10 @@
{{
elLockStore.users.find((user) => user.id === item.userId)?.nickname
}}
-
@@ -73,53 +98,112 @@
{{ getGuideName(scope.row.guideId) }}
-
-
-
-
-
+
任务名称
@@ -165,9 +256,20 @@
添加检修任务指导书
-
-
+
+
删除
-
+
@@ -212,12 +337,26 @@
@@ -226,12 +365,26 @@
@@ -240,12 +393,26 @@
@@ -262,7 +429,11 @@
集中挂牌人
-
-
+
- {{ elLockStore.users.find((user) => user.id === item.operatorId)?.nickname || '未选择' }}
+ {{
+ elLockStore.users.find((user) => user.id === item.operatorId)?.nickname ||
+ '未选择'
+ }}
集中挂牌协助人
-
-
+
- {{ elLockStore.users.find((user) => user.id === item.operatorHelperId)?.nickname || '未选择' }}
+ {{
+ elLockStore.users.find((user) => user.id === item.operatorHelperId)
+ ?.nickname || '未选择'
+ }}
验证人
-
-
+
- {{ elLockStore.users.find((user) => user.id === item.verifierId)?.nickname || '未选择' }}
+ {{
+ elLockStore.users.find((user) => user.id === item.verifierId)?.nickname ||
+ '未选择'
+ }}
验证协助人
-
-
+
- {{ elLockStore.users.find((user) => user.id === item.verifierHelperId)?.nickname || '未选择' }}
+ {{
+ elLockStore.users.find((user) => user.id === item.verifierHelperId)
+ ?.nickname || '未选择'
+ }}
隔离点
-
-
+
@@ -277,9 +448,16 @@
{{ point?.ipName + '-' + point?.ipLocation + '(' + point?.ipNumber + ')' }}
+
详细任务
-
+
+ 确 定
+ 确 定
取 消
- 关 闭
+ 关 闭
@@ -690,7 +896,7 @@ const deletePlanItem = (index: number) => {
padding: 16px;
background: #f8f9fa;
border-radius: 8px;
-
+
.mobile-form-title {
font-size: 16px;
font-weight: 600;
@@ -704,7 +910,7 @@ const deletePlanItem = (index: number) => {
.mobile-input,
.mobile-select {
width: 100%;
-
+
:deep(.el-input__wrapper) {
border-radius: 6px;
}
diff --git a/web/src/views/lock/isolation/point/PointForm.vue b/web/src/views/lock/isolation/point/PointForm.vue
index 0062c6e..5942e4f 100644
--- a/web/src/views/lock/isolation/point/PointForm.vue
+++ b/web/src/views/lock/isolation/point/PointForm.vue
@@ -1,11 +1,20 @@
电子锁:
@@ -299,21 +477,36 @@
隔离点:
{{ detail.isolationPoint.ipName }}
-
任务状态:
-
受影响人:
-
-
@@ -326,14 +519,27 @@
- {{ elLockStore.users.find((user) => user.id === lifeLock.userId)?.nickname }}
-
+ {{
+ elLockStore.users.find((user) => user.id === lifeLock.userId)?.nickname
+ }}
+
+
-
-
+
@@ -105,13 +109,23 @@
-
+
@@ -230,11 +248,17 @@
-
+
-
+
@@ -273,13 +297,23 @@