taro-bluetooth-print 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Your Name
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

package/README.md

@@ -0,0 +1,201 @@
+# Taro 蓝牙打印库
+
+一个基于 Taro.js 的跨平台蓝牙打印库，支持微信小程序、H5、React Native 和鸿蒙等多平台，支持 ESC/POS 指令，可用于连接蓝牙打印机并发送打印数据。
+
+## 特性
+
+- 支持多平台：微信小程序、H5、React Native、鸿蒙OS
+- 支持 ESC/POS 打印指令
+- 提供简洁易用的 API
+- 支持打印文本、图片、条形码、二维码、收据等
+- 支持文本格式化（对齐、加粗、下划线等）
+- 支持打印模板系统，便于重用
+- TypeScript 支持
+
+## 安装
+
+```bash
+npm install taro-bluetooth-print --save
+# 或
+yarn add taro-bluetooth-print
+```
+
+## 使用示例
+
+### 基本使用
+
+```typescript
+import Taro from '@tarojs/taro';
+import TaroBluePrint from 'taro-bluetooth-print';
+
+// 初始化打印库
+const printer = new TaroBluePrint();
+
+// 扫描并连接打印机
+async function scanAndConnect() {
+  await printer.bluetooth.init();
+  await printer.bluetooth.startDiscovery();
+  
+  Taro.showLoading({ title: '搜索打印机...' });
+  
+  // 等待2秒钟搜索设备
+  await new Promise(resolve => setTimeout(resolve, 2000));
+  
+  const devices = await printer.bluetooth.getDiscoveredDevices();
+  await printer.bluetooth.stopDiscovery();
+  
+  Taro.hideLoading();
+  
+  if (devices.length === 0) {
+    Taro.showToast({ title: '未找到打印机', icon: 'none' });
+    return;
+  }
+  
+  // 显示设备列表让用户选择
+  const list = devices.map(device => ({
+    text: device.name || '未知设备',
+    value: device.deviceId
+  }));
+  
+  Taro.showActionSheet({
+    itemList: list.map(item => item.text),
+    success: async (res) => {
+      const deviceId = list[res.tapIndex].value;
+      
+      Taro.showLoading({ title: '连接中...' });
+      const connected = await printer.bluetooth.connect(deviceId);
+      Taro.hideLoading();
+      
+      if (connected) {
+        Taro.showToast({ title: '连接成功' });
+        
+        // 打印测试页
+        const printResult = await printer.printer.printTestPage();
+        
+        if (printResult) {
+          Taro.showToast({ title: '打印成功' });
+        } else {
+          Taro.showToast({ title: '打印失败', icon: 'none' });
+        }
+        
+        // 断开连接
+        await printer.bluetooth.disconnect();
+      } else {
+        Taro.showToast({ title: '连接失败', icon: 'none' });
+      }
+    }
+  });
+}
+
+// 调用扫描并连接
+scanAndConnect();
+```
+
+### 打印文本
+
+```typescript
+await printer.printer.printText('Hello, World!', {
+  align: 'center',
+  bold: true,
+  doubleHeight: true
+});
+```
+
+### 打印图片
+
+```typescript
+await printer.printer.printImage('https://example.com/logo.png', {
+  maxWidth: 300,
+  dithering: true
+});
+
+// 或打印Base64图片
+await printer.printer.printImage('data:image/png;base64,...', {
+  maxWidth: 300
+});
+```
+
+### 打印收据
+
+```typescript
+await printer.printer.printReceipt({
+  title: '收据',
+  merchant: '示例商店',
+  items: [
+    { name: '商品1', price: 10.5, quantity: 2 },
+    { name: '商品2', price: 5.0, quantity: 1 }
+  ],
+  total: 26.0,
+  date: '2023-09-28 15:30:45',
+  footer: '感谢您的惠顾，欢迎再次光临！',
+  logo: 'https://example.com/logo.png' // 可选
+});
+```
+
+### 打印条形码
+
+```typescript
+await printer.printer.printBarcode('123456789', {
+  height: 80,
+  align: 'center'
+});
+```
+
+### 打印二维码
+
+```typescript
+await printer.printer.printQRCode('https://example.com', {
+  size: 8,
+  align: 'center'
+});
+```
+
+### 使用打印模板
+
+```typescript
+import { ReceiptTemplate } from 'taro-bluetooth-print/dist/printer/template';
+
+// 创建收据模板
+const receiptTemplate = new ReceiptTemplate({
+  title: '收据',
+  merchant: '示例商店',
+  items: [
+    { name: '商品1', price: 10.5, quantity: 2 },
+    { name: '商品2', price: 5.0, quantity: 1 }
+  ],
+  total: 26.0,
+  date: '2023-09-28 15:30:45',
+  footer: '感谢您的惠顾，欢迎再次光临！'
+});
+
+// 构建模板命令
+const commands = await receiptTemplate.build();
+
+// 发送打印命令
+await printer.printer.sendCommands(commands);
+```
+
+## API 文档
+
+请查看完整的API文档以了解更多详情：[API文档](https://github.com/yourusername/taro-bluetooth-print/blob/main/docs/API.md)
+
+## 平台支持
+
+| 功能 | 微信小程序 | H5 | React Native | 鸿蒙OS |
+| --- | --- | --- | --- | --- |
+| 设备扫描 | ✓ | ✓* | ✓ | ✓ |
+| 设备连接 | ✓ | ✓* | ✓ | ✓ |
+| 文本打印 | ✓ | ✓ | ✓ | ✓ |
+| 图片打印 | ✓ | ✓ | ✓ | ✓ |
+| 条码打印 | ✓ | ✓ | ✓ | ✓ |
+| 二维码打印 | ✓ | ✓ | ✓ | ✓ |
+
+*注意：H5 环境需要支持 Web Bluetooth API 的浏览器。目前 Chrome、Edge、Opera 等基于 Chromium 的浏览器支持此功能，且需要在 HTTPS 环境下使用。
+
+## 许可证
+
+MIT
+
+## 贡献
+
+欢迎提交 Issue 和 PR！

package/dist/bluetooth/adapter.d.ts

@@ -0,0 +1,31 @@
+export declare enum Platform {
+    WEAPP = "weapp",
+    H5 = "h5",
+    RN = "rn",
+    HARMONY = "harmony"
+}
+export interface BluetoothDevice {
+    deviceId: string;
+    name: string;
+    RSSI?: number;
+    advertisData?: ArrayBuffer;
+    deviceName?: string;
+    localName?: string;
+}
+export interface BluetoothAdapter {
+    init(): Promise<boolean>;
+    getAdapterState(): Promise<any>;
+    startDiscovery(): Promise<boolean>;
+    stopDiscovery(): Promise<boolean>;
+    getDiscoveredDevices(): Promise<BluetoothDevice[]>;
+    connect(deviceId: string): Promise<boolean>;
+    disconnect(deviceId?: string): Promise<boolean>;
+    getServices(deviceId: string): Promise<any>;
+    getCharacteristics(deviceId: string, serviceId: string): Promise<any>;
+    write(deviceId: string, serviceId: string, characteristicId: string, data: ArrayBuffer): Promise<boolean>;
+    read(deviceId: string, serviceId: string, characteristicId: string): Promise<ArrayBuffer>;
+    notifyCharacteristicValueChange(deviceId: string, serviceId: string, characteristicId: string, state: boolean): Promise<boolean>;
+    destroy(): Promise<boolean>;
+}
+export declare function getCurrentPlatform(): Platform;
+export declare function getAdapter(): BluetoothAdapter;

package/dist/bluetooth/adapter.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAdapter = exports.getCurrentPlatform = exports.Platform = void 0;
+var Platform;
+(function (Platform) {
+    Platform["WEAPP"] = "weapp";
+    Platform["H5"] = "h5";
+    Platform["RN"] = "rn";
+    Platform["HARMONY"] = "harmony";
+})(Platform = exports.Platform || (exports.Platform = {}));
+function getCurrentPlatform() {
+    if (process.env.TARO_ENV === 'weapp') {
+        return Platform.WEAPP;
+    }
+    else if (process.env.TARO_ENV === 'h5') {
+        return Platform.H5;
+    }
+    else if (process.env.TARO_ENV === 'rn') {
+        return Platform.RN;
+    }
+    else if (process.env.TARO_ENV === 'harmony') {
+        return Platform.HARMONY;
+    }
+    throw new Error('不支持的平台');
+}
+exports.getCurrentPlatform = getCurrentPlatform;
+function getAdapter() {
+    const platform = getCurrentPlatform();
+    switch (platform) {
+        case Platform.WEAPP:
+            const { WeappBluetoothAdapter } = require('./weapp');
+            return new WeappBluetoothAdapter();
+        case Platform.H5:
+            const { H5BluetoothAdapter } = require('./h5');
+            return new H5BluetoothAdapter();
+        case Platform.RN:
+            const { RNBluetoothAdapter } = require('./rn');
+            return new RNBluetoothAdapter();
+        case Platform.HARMONY:
+            const { HarmonyBluetoothAdapter } = require('./harmony');
+            return new HarmonyBluetoothAdapter();
+        default:
+            throw new Error('不支持的平台');
+    }
+}
+exports.getAdapter = getAdapter;
+//# sourceMappingURL=adapter.js.map

package/dist/bluetooth/adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.js","sourceRoot":"","sources":["../../src/bluetooth/adapter.ts"],"names":[],"mappings":";;;AAEA,IAAY,QAKX;AALD,WAAY,QAAQ;IAClB,2BAAe,CAAA;IACf,qBAAS,CAAA;IACT,qBAAS,CAAA;IACT,+BAAmB,CAAA;AACrB,CAAC,EALW,QAAQ,GAAR,gBAAQ,KAAR,gBAAQ,QAKnB;AAoDD,SAAgB,kBAAkB;IAChC,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,OAAO,EAAE;QACpC,OAAO,QAAQ,CAAC,KAAK,CAAC;KACvB;SAAM,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,IAAI,EAAE;QACxC,OAAO,QAAQ,CAAC,EAAE,CAAC;KACpB;SAAM,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,IAAI,EAAE;QACxC,OAAO,QAAQ,CAAC,EAAE,CAAC;KACpB;SAAM,IAAI,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,SAAS,EAAE;QAC7C,OAAO,QAAQ,CAAC,OAAO,CAAC;KACzB;IACD,MAAM,IAAI,KAAK,CAAC,QAAQ,CAAC,CAAC;AAC5B,CAAC;AAXD,gDAWC;AAED,SAAgB,UAAU;IACxB,MAAM,QAAQ,GAAG,kBAAkB,EAAE,CAAC;IAEtC,QAAQ,QAAQ,EAAE;QAChB,KAAK,QAAQ,CAAC,KAAK;YACjB,MAAM,EAAE,qBAAqB,EAAE,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;YACrD,OAAO,IAAI,qBAAqB,EAAE,CAAC;QACrC,KAAK,QAAQ,CAAC,EAAE;YACd,MAAM,EAAE,kBAAkB,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;YAC/C,OAAO,IAAI,kBAAkB,EAAE,CAAC;QAClC,KAAK,QAAQ,CAAC,EAAE;YACd,MAAM,EAAE,kBAAkB,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;YAC/C,OAAO,IAAI,kBAAkB,EAAE,CAAC;QAClC,KAAK,QAAQ,CAAC,OAAO;YACnB,MAAM,EAAE,uBAAuB,EAAE,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;YACzD,OAAO,IAAI,uBAAuB,EAAE,CAAC;QACvC;YACE,MAAM,IAAI,KAAK,CAAC,QAAQ,CAAC,CAAC;KAC7B;AACH,CAAC;AAnBD,gCAmBC"}

package/dist/bluetooth/h5.d.ts

@@ -0,0 +1,66 @@
+import { BluetoothAdapter, BluetoothDevice } from './adapter';
+declare global {
+    interface Navigator {
+        bluetooth?: {
+            requestDevice(options?: any): Promise<any>;
+            getAvailability(): Promise<boolean>;
+        };
+    }
+    interface BluetoothRemoteGATTServer {
+        connected: boolean;
+        device: any;
+        connect(): Promise<BluetoothRemoteGATTServer>;
+        disconnect(): void;
+        getPrimaryServices(service?: BluetoothServiceUUID): Promise<BluetoothRemoteGATTService[]>;
+    }
+    interface BluetoothRemoteGATTService {
+        uuid: string;
+        device: any;
+        isPrimary: boolean;
+        getCharacteristics(characteristic?: BluetoothCharacteristicUUID): Promise<BluetoothRemoteGATTCharacteristic[]>;
+    }
+    interface BluetoothRemoteGATTCharacteristic {
+        uuid: string;
+        service: BluetoothRemoteGATTService;
+        properties: {
+            broadcast: boolean;
+            read: boolean;
+            writeWithoutResponse: boolean;
+            write: boolean;
+            notify: boolean;
+            indicate: boolean;
+            authenticatedSignedWrites: boolean;
+            reliableWrite: boolean;
+            writableAuxiliaries: boolean;
+        };
+        readValue(): Promise<DataView>;
+        writeValue(value: BufferSource): Promise<void>;
+        startNotifications(): Promise<BluetoothRemoteGATTCharacteristic>;
+        stopNotifications(): Promise<BluetoothRemoteGATTCharacteristic>;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener(type: string, callback: EventListenerOrEventListenerObject, options?: EventListenerOptions | boolean): void;
+    }
+    type BluetoothServiceUUID = string | number;
+    type BluetoothCharacteristicUUID = string | number;
+}
+export declare class H5BluetoothAdapter implements BluetoothAdapter {
+    private bluetooth;
+    private device;
+    private gattServer;
+    private services;
+    private characteristics;
+    private eventListeners;
+    init(): Promise<boolean>;
+    getAdapterState(): Promise<any>;
+    startDiscovery(): Promise<boolean>;
+    stopDiscovery(): Promise<boolean>;
+    getDiscoveredDevices(): Promise<BluetoothDevice[]>;
+    connect(deviceId: string): Promise<boolean>;
+    disconnect(deviceId?: string): Promise<boolean>;
+    getServices(deviceId: string): Promise<any>;
+    getCharacteristics(deviceId: string, serviceId: string): Promise<any>;
+    write(deviceId: string, serviceId: string, characteristicId: string, data: ArrayBuffer): Promise<boolean>;
+    read(deviceId: string, serviceId: string, characteristicId: string): Promise<ArrayBuffer>;
+    notifyCharacteristicValueChange(deviceId: string, serviceId: string, characteristicId: string, state: boolean): Promise<boolean>;
+    destroy(): Promise<boolean>;
+}

package/dist/bluetooth/h5.js

@@ -0,0 +1,302 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.H5BluetoothAdapter = void 0;
+const logger_1 = require("../utils/logger");
+class H5BluetoothAdapter {
+    constructor() {
+        this.bluetooth = null;
+        this.device = null;
+        this.gattServer = null;
+        this.services = new Map();
+        this.characteristics = new Map();
+        this.eventListeners = new Map();
+    }
+    async init() {
+        try {
+            if (!navigator.bluetooth) {
+                throw new Error('当前浏览器不支持Web Bluetooth API');
+            }
+            // 检查蓝牙是否可用
+            const available = await navigator.bluetooth.getAvailability();
+            if (!available) {
+                throw new Error('蓝牙不可用');
+            }
+            this.bluetooth = navigator.bluetooth;
+            return true;
+        }
+        catch (error) {
+            logger_1.logger.error('初始化蓝牙模块失败', error);
+            return false;
+        }
+    }
+    async getAdapterState() {
+        var _a;
+        try {
+            if (!this.bluetooth) {
+                throw new Error('蓝牙模块未初始化');
+            }
+            const available = await ((_a = navigator.bluetooth) === null || _a === void 0 ? void 0 : _a.getAvailability());
+            return { available: available || false };
+        }
+        catch (error) {
+            logger_1.logger.error('获取蓝牙适配器状态失败', error);
+            throw error;
+        }
+    }
+    async startDiscovery() {
+        try {
+            if (!this.bluetooth) {
+                await this.init();
+            }
+            // 打印机通常使用的服务 (这些值可能需要根据具体打印机调整)
+            const printerServices = [
+                '000018f0-0000-1000-8000-00805f9b34fb',
+                '49535343-fe7d-4ae5-8fa9-9fafd205e455',
+                '00001101-0000-1000-8000-00805f9b34fb',
+                '0000180a-0000-1000-8000-00805f9b34fb' // 设备信息服务
+            ];
+            // Web Bluetooth API使用requestDevice方法触发设备选择
+            this.device = await this.bluetooth.requestDevice({
+                // 过滤器用于找到打印机设备
+                filters: [
+                    { services: printerServices },
+                    { namePrefix: 'Printer' },
+                    { namePrefix: 'printer' },
+                    { namePrefix: 'POS' },
+                    { namePrefix: 'pos' },
+                    { namePrefix: 'BT' }
+                ],
+                // 添加可选服务以便于访问
+                optionalServices: printerServices
+            });
+            if (this.device) {
+                return true;
+            }
+            return false;
+        }
+        catch (error) {
+            logger_1.logger.error('开始搜索蓝牙设备失败', error);
+            return false;
+        }
+    }
+    async stopDiscovery() {
+        // Web Bluetooth API没有停止搜索的方法，因为搜索已经在设备选择完成后结束
+        return true;
+    }
+    async getDiscoveredDevices() {
+        if (!this.device) {
+            return [];
+        }
+        return [{
+                deviceId: this.device.id,
+                name: this.device.name || '未知设备',
+                deviceName: this.device.name
+            }];
+    }
+    async connect(deviceId) {
+        var _a;
+        try {
+            if (!this.device || this.device.id !== deviceId) {
+                logger_1.logger.error('设备未找到或ID不匹配');
+                return false;
+            }
+            // 连接到GATT服务器
+            this.gattServer = await this.device.gatt.connect();
+            // 连接后自动发现服务
+            if (this.gattServer) {
+                await this.getServices(deviceId);
+            }
+            return ((_a = this.gattServer) === null || _a === void 0 ? void 0 : _a.connected) || false;
+        }
+        catch (error) {
+            logger_1.logger.error('连接蓝牙设备失败', error);
+            return false;
+        }
+    }
+    async disconnect(deviceId) {
+        try {
+            if (this.gattServer && this.gattServer.connected) {
+                this.gattServer.disconnect();
+                this.services.clear();
+                this.characteristics.clear();
+            }
+            return true;
+        }
+        catch (error) {
+            logger_1.logger.error('断开蓝牙连接失败', error);
+            return false;
+        }
+    }
+    async getServices(deviceId) {
+        try {
+            if (!this.gattServer) {
+                throw new Error('未连接到GATT服务器');
+            }
+            const services = await this.gattServer.getPrimaryServices();
+            const result = { services: [] };
+            for (const service of services) {
+                this.services.set(service.uuid, service);
+                result.services.push({
+                    uuid: service.uuid,
+                    isPrimary: service.isPrimary
+                });
+                // 自动获取每个服务的特征值
+                await this.getCharacteristics(deviceId, service.uuid);
+            }
+            return result;
+        }
+        catch (error) {
+            logger_1.logger.error('获取服务失败', error);
+            throw error;
+        }
+    }
+    async getCharacteristics(deviceId, serviceId) {
+        try {
+            const service = this.services.get(serviceId);
+            if (!service) {
+                throw new Error(`服务${serviceId}未找到`);
+            }
+            const characteristics = await service.getCharacteristics();
+            const result = { characteristics: [] };
+            if (!this.characteristics.has(serviceId)) {
+                this.characteristics.set(serviceId, new Map());
+            }
+            const serviceChars = this.characteristics.get(serviceId);
+            for (const char of characteristics) {
+                serviceChars.set(char.uuid, char);
+                result.characteristics.push({
+                    uuid: char.uuid,
+                    properties: {
+                        read: char.properties.read,
+                        write: char.properties.write,
+                        notify: char.properties.notify,
+                        writeWithoutResponse: char.properties.writeWithoutResponse
+                    }
+                });
+            }
+            return result;
+        }
+        catch (error) {
+            logger_1.logger.error('获取特征值失败', error);
+            throw error;
+        }
+    }
+    async write(deviceId, serviceId, characteristicId, data) {
+        try {
+            if (!this.characteristics.has(serviceId)) {
+                await this.getCharacteristics(deviceId, serviceId);
+            }
+            const serviceChars = this.characteristics.get(serviceId);
+            if (!serviceChars) {
+                throw new Error(`服务${serviceId}的特征值未找到`);
+            }
+            const characteristic = serviceChars.get(characteristicId);
+            if (!characteristic) {
+                throw new Error(`特征值${characteristicId}未找到`);
+            }
+            await characteristic.writeValue(data);
+            return true;
+        }
+        catch (error) {
+            logger_1.logger.error('写入数据失败', error);
+            return false;
+        }
+    }
+    async read(deviceId, serviceId, characteristicId) {
+        try {
+            if (!this.characteristics.has(serviceId)) {
+                await this.getCharacteristics(deviceId, serviceId);
+            }
+            const serviceChars = this.characteristics.get(serviceId);
+            if (!serviceChars) {
+                throw new Error(`服务${serviceId}的特征值未找到`);
+            }
+            const characteristic = serviceChars.get(characteristicId);
+            if (!characteristic) {
+                throw new Error(`特征值${characteristicId}未找到`);
+            }
+            const value = await characteristic.readValue();
+            return value.buffer;
+        }
+        catch (error) {
+            logger_1.logger.error('读取数据失败', error);
+            throw error;
+        }
+    }
+    async notifyCharacteristicValueChange(deviceId, serviceId, characteristicId, state) {
+        try {
+            if (!this.characteristics.has(serviceId)) {
+                await this.getCharacteristics(deviceId, serviceId);
+            }
+            const serviceChars = this.characteristics.get(serviceId);
+            if (!serviceChars) {
+                throw new Error(`服务${serviceId}的特征值未找到`);
+            }
+            const characteristic = serviceChars.get(characteristicId);
+            if (!characteristic) {
+                throw new Error(`特征值${characteristicId}未找到`);
+            }
+            if (state) {
+                await characteristic.startNotifications();
+                // 创建并存储事件监听器，以便以后可以移除
+                const listenerKey = `${deviceId}_${serviceId}_${characteristicId}`;
+                // 创建类型安全的事件监听器
+                const listener = function (event) {
+                    // 安全地转换类型
+                    if (event.target && event.target instanceof EventTarget) {
+                        // Web Bluetooth API中，值在characteristicvaluechanged事件中
+                        if ('readValue' in event.target) {
+                            try {
+                                const characteristic = event.target;
+                                characteristic.readValue().then((dataView) => {
+                                    logger_1.logger.debug('特征值变化:', new Uint8Array(dataView.buffer));
+                                });
+                            }
+                            catch (error) {
+                                logger_1.logger.error('读取特征值变化失败', error);
+                            }
+                        }
+                    }
+                };
+                this.eventListeners.set(listenerKey, listener);
+                // 添加通知事件监听器
+                characteristic.addEventListener('characteristicvaluechanged', this.eventListeners.get(listenerKey));
+            }
+            else {
+                await characteristic.stopNotifications();
+                // 获取并移除事件监听器
+                const listenerKey = `${deviceId}_${serviceId}_${characteristicId}`;
+                const listener = this.eventListeners.get(listenerKey);
+                if (listener) {
+                    characteristic.removeEventListener('characteristicvaluechanged', listener);
+                    this.eventListeners.delete(listenerKey);
+                }
+            }
+            return true;
+        }
+        catch (error) {
+            logger_1.logger.error('监听特征值变化失败', error);
+            return false;
+        }
+    }
+    async destroy() {
+        try {
+            if (this.gattServer && this.gattServer.connected) {
+                this.gattServer.disconnect();
+            }
+            // 清除所有事件监听器
+            this.eventListeners.clear();
+            this.device = null;
+            this.gattServer = null;
+            this.services.clear();
+            this.characteristics.clear();
+            return true;
+        }
+        catch (error) {
+            logger_1.logger.error('销毁蓝牙适配器失败', error);
+            return false;
+        }
+    }
+}
+exports.H5BluetoothAdapter = H5BluetoothAdapter;
+//# sourceMappingURL=h5.js.map