@fww_123/uni-ble-scanner 1.0.0

package/dist/index.js

@@ -0,0 +1,1818 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * 扫描状态
+ */
+exports.ScanState = void 0;
+(function (ScanState) {
+    ScanState["IDLE"] = "idle";
+    ScanState["SCANNING"] = "scanning";
+    ScanState["STOPPING"] = "stopping";
+    ScanState["ERROR"] = "error";
+})(exports.ScanState || (exports.ScanState = {}));
+/**
+ * 平台类型
+ */
+exports.Platform = void 0;
+(function (Platform) {
+    Platform["ANDROID"] = "android";
+    Platform["IOS"] = "ios";
+    Platform["HARMONY"] = "harmony";
+    Platform["UNKNOWN"] = "unknown";
+})(exports.Platform || (exports.Platform = {}));
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/**
+ * 错误码定义
+ */
+const ErrorCodes = {
+    // 通用错误
+    UNKNOWN_ERROR: 1000,
+    NOT_INITIALIZED: 1001,
+    ALREADY_SCANNING: 1002,
+    NOT_SCANNING: 1003,
+    PERMISSION_DENIED: 1004,
+    BLUETOOTH_DISABLED: 1005,
+    UNSUPPORTED_PLATFORM: 1006,
+    // 蓝牙特定错误
+    ADAPTER_NOT_AVAILABLE: 2001,
+    SCAN_FAILED: 2002,
+    DEVICE_NOT_FOUND: 2003,
+    CONNECTION_FAILED: 2004,
+    // 平台特定错误
+    ANDROID_ERROR: 3000,
+    IOS_ERROR: 4000,
+    HARMONY_ERROR: 5000,
+};
+/**
+ * 创建错误对象
+ */
+function createError(code, message, platformCode, originalError) {
+    return {
+        code,
+        message,
+        platformCode,
+        originalError
+    };
+}
+/**
+ * 通用错误
+ */
+const Errors = {
+    notInitialized: () => createError(ErrorCodes.NOT_INITIALIZED, '蓝牙适配器未初始化，请先调用 init()'),
+    alreadyScanning: () => createError(ErrorCodes.ALREADY_SCANNING, '扫描已在进行中'),
+    notScanning: () => createError(ErrorCodes.NOT_SCANNING, '扫描未在进行中'),
+    permissionDenied: () => createError(ErrorCodes.PERMISSION_DENIED, '蓝牙权限被拒绝'),
+    bluetoothDisabled: () => createError(ErrorCodes.BLUETOOTH_DISABLED, '蓝牙未开启'),
+    unsupportedPlatform: () => createError(ErrorCodes.UNSUPPORTED_PLATFORM, '当前平台不支持蓝牙功能'),
+    adapterNotAvailable: () => createError(ErrorCodes.ADAPTER_NOT_AVAILABLE, '蓝牙适配器不可用'),
+    scanFailed: (reason) => createError(ErrorCodes.SCAN_FAILED, `扫描失败: ${reason || '未知原因'}`),
+};
+/**
+ * 处理平台特定错误
+ */
+function handlePlatformError(error, platform) {
+    const platformCode = (error === null || error === void 0 ? void 0 : error.code) || (error === null || error === void 0 ? void 0 : error.errCode);
+    const message = (error === null || error === void 0 ? void 0 : error.message) || (error === null || error === void 0 ? void 0 : error.errMsg) || '未知错误';
+    let code = ErrorCodes.UNKNOWN_ERROR;
+    switch (platform) {
+        case 'android':
+            code = ErrorCodes.ANDROID_ERROR;
+            break;
+        case 'ios':
+            code = ErrorCodes.IOS_ERROR;
+            break;
+        case 'harmony':
+            code = ErrorCodes.HARMONY_ERROR;
+            break;
+    }
+    return createError(code, `${platform}平台错误: ${message}`, platformCode, error);
+}
+
+/**
+ * 解析广播数据
+ */
+function parseAdvertisementData(data) {
+    const result = {};
+    if (!data) {
+        return result;
+    }
+    let buffer;
+    if (typeof data === 'string') {
+        // Base64 解码
+        buffer = base64ToArrayBuffer(data);
+    }
+    else {
+        buffer = data;
+    }
+    const view = new DataView(buffer);
+    let offset = 0;
+    const manufacturerData = {};
+    const serviceUuids = [];
+    while (offset < view.byteLength) {
+        const length = view.getUint8(offset);
+        if (length === 0)
+            break;
+        const type = view.getUint8(offset + 1);
+        const dataOffset = offset + 2;
+        const dataLength = length - 1;
+        switch (type) {
+            case 0x01: // Flags
+                const flags = view.getUint8(dataOffset);
+                result.isConnectable = (flags & 0x02) !== 0;
+                break;
+            case 0x02: // 16-bit Service UUIDs (partial)
+            case 0x03: // 16-bit Service UUIDs (complete)
+                for (let i = 0; i < dataLength; i += 2) {
+                    const uuid = view.getUint16(dataOffset + i, true).toString(16).padStart(4, '0');
+                    serviceUuids.push(`0000${uuid}-0000-1000-8000-00805f9b34fb`);
+                }
+                break;
+            case 0x04: // 32-bit Service UUIDs (partial)
+            case 0x05: // 32-bit Service UUIDs (complete)
+                for (let i = 0; i < dataLength; i += 4) {
+                    const uuid = view.getUint32(dataOffset + i, true).toString(16).padStart(8, '0');
+                    serviceUuids.push(`${uuid}-0000-1000-8000-00805f9b34fb`);
+                }
+                break;
+            case 0x06: // 128-bit Service UUIDs (partial)
+            case 0x07: // 128-bit Service UUIDs (complete)
+                for (let i = 0; i < dataLength; i += 16) {
+                    const uuid = parseUUID(buffer.slice(dataOffset + i, dataOffset + i + 16));
+                    serviceUuids.push(uuid);
+                }
+                break;
+            case 0x08: // Shortened Local Name
+            case 0x09: // Complete Local Name
+                result.localName = decodeUTF8(buffer.slice(dataOffset, dataOffset + dataLength));
+                break;
+            case 0x0A: // TX Power Level
+                result.txPowerLevel = view.getInt8(dataOffset);
+                break;
+            case 0xFF: // Manufacturer Specific Data
+                const companyId = view.getUint16(dataOffset, true);
+                const companyIdHex = companyId.toString(16).padStart(4, '0');
+                manufacturerData[companyIdHex] = buffer.slice(dataOffset + 2, dataOffset + dataLength);
+                break;
+        }
+        offset += length + 1;
+    }
+    if (Object.keys(manufacturerData).length > 0) {
+        result.manufacturerData = manufacturerData;
+    }
+    if (serviceUuids.length > 0) {
+        result.serviceUuids = serviceUuids;
+    }
+    return result;
+}
+/**
+ * Base64 转 ArrayBuffer
+ */
+function base64ToArrayBuffer(base64) {
+    const binary = atob(base64);
+    const buffer = new ArrayBuffer(binary.length);
+    const view = new Uint8Array(buffer);
+    for (let i = 0; i < binary.length; i++) {
+        view[i] = binary.charCodeAt(i);
+    }
+    return buffer;
+}
+/**
+ * ArrayBuffer 转 Base64
+ */
+function arrayBufferToBase64(buffer) {
+    const bytes = new Uint8Array(buffer);
+    let binary = '';
+    for (let i = 0; i < bytes.byteLength; i++) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+}
+/**
+ * 解析 UUID
+ */
+function parseUUID(buffer) {
+    const view = new DataView(buffer);
+    const parts = [
+        view.getUint32(0, false).toString(16).padStart(8, '0'),
+        view.getUint16(4, false).toString(16).padStart(4, '0'),
+        view.getUint16(6, false).toString(16).padStart(4, '0'),
+        view.getUint16(8, false).toString(16).padStart(4, '0'),
+        view.getUint32(10, false).toString(16).padStart(8, '0') +
+            view.getUint16(14, false).toString(16).padStart(4, '0'),
+    ];
+    return `${parts[0]}-${parts[1]}-${parts[2]}-${parts[3]}-${parts[4]}`;
+}
+/**
+ * UTF-8 解码
+ */
+function decodeUTF8(buffer) {
+    const decoder = new TextDecoder('utf-8');
+    return decoder.decode(buffer);
+}
+/**
+ * 标准化设备数据
+ */
+function normalizeDeviceData(device) {
+    const normalized = {
+        deviceId: device.deviceId || '',
+        name: device.name || device.localName,
+        RSSI: device.RSSI || device.rssi || -100,
+    };
+    // 处理广播数据
+    if (device.advertisData) {
+        normalized.advertisData = device.advertisData;
+        if (typeof device.advertisData === 'string') {
+            normalized.advertisDataBase64 = device.advertisData;
+        }
+        else {
+            normalized.advertisDataBase64 = arrayBufferToBase64(device.advertisData);
+        }
+        // 解析广播数据
+        const parsed = parseAdvertisementData(device.advertisData);
+        Object.assign(normalized, parsed);
+    }
+    // 处理制造商数据
+    if (device.manufacturerData) {
+        normalized.manufacturerData = device.manufacturerData;
+    }
+    // 处理服务UUID
+    if (device.serviceUuids) {
+        normalized.serviceUuids = device.serviceUuids;
+    }
+    // 平台特定数据
+    normalized.platformData = {
+        raw: device,
+    };
+    return normalized;
+}
+/**
+ * 格式化 UUID (统一格式)
+ */
+function formatUUID(uuid) {
+    // 移除所有非十六进制字符
+    const clean = uuid.toLowerCase().replace(/[^0-9a-f]/g, '');
+    if (clean.length === 4) {
+        // 16-bit UUID
+        return `0000${clean}-0000-1000-8000-00805f9b34fb`;
+    }
+    else if (clean.length === 8) {
+        // 32-bit UUID
+        return `${clean}-0000-1000-8000-00805f9b34fb`;
+    }
+    else if (clean.length === 32) {
+        // 128-bit UUID
+        return `${clean.slice(0, 8)}-${clean.slice(8, 12)}-${clean.slice(12, 16)}-${clean.slice(16, 20)}-${clean.slice(20)}`;
+    }
+    return uuid;
+}
+/**
+ * 检查 UUID 是否匹配
+ */
+function matchUUID(uuid1, uuid2) {
+    return formatUUID(uuid1) === formatUUID(uuid2);
+}
+
+/**
+ * 扫描器基类
+ */
+class BaseScanner {
+    constructor() {
+        this.state = exports.ScanState.IDLE;
+        this.discoveredDevices = new Map();
+        this.callbacks = {};
+        this.options = {};
+        this.platformConfig = {};
+        this.initialized = false;
+        this.timeoutId = null;
+        this.adapterStateListeners = [];
+    }
+    /**
+     * 开始扫描
+     */
+    startScan() {
+        return __awaiter(this, arguments, void 0, function* (options = {}, callbacks = {}) {
+            var _a, _b;
+            if (this.state === exports.ScanState.SCANNING) {
+                throw Errors.alreadyScanning();
+            }
+            if (!this.initialized) {
+                throw Errors.notInitialized();
+            }
+            // 检查权限
+            const hasPermission = yield this.checkPermissions();
+            if (!hasPermission) {
+                const granted = yield this.requestPermissions();
+                if (!granted) {
+                    throw Errors.permissionDenied();
+                }
+            }
+            this.options = Object.assign(Object.assign({}, this.getDefaultOptions()), options);
+            this.callbacks = callbacks;
+            try {
+                this.setState(exports.ScanState.SCANNING);
+                // 清空之前的设备列表（如果不需要重复上报）
+                if (!this.options.allowDuplicates) {
+                    this.clearDevices();
+                }
+                // 设置超时
+                if (this.options.timeout && this.options.timeout > 0) {
+                    this.timeoutId = window.setTimeout(() => {
+                        this.handleTimeout();
+                    }, this.options.timeout);
+                }
+                yield this.startScanInternal();
+                (_b = (_a = this.callbacks).onScanStart) === null || _b === void 0 ? void 0 : _b.call(_a);
+            }
+            catch (error) {
+                this.setState(exports.ScanState.ERROR);
+                this.clearTimeout();
+                throw error;
+            }
+        });
+    }
+    /**
+     * 停止扫描
+     */
+    stopScan() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (this.state !== exports.ScanState.SCANNING) {
+                return;
+            }
+            this.setState(exports.ScanState.STOPPING);
+            this.clearTimeout();
+            try {
+                yield this.stopScanInternal();
+                this.setState(exports.ScanState.IDLE);
+                (_b = (_a = this.callbacks).onScanStop) === null || _b === void 0 ? void 0 : _b.call(_a);
+            }
+            catch (error) {
+                this.setState(exports.ScanState.ERROR);
+                throw error;
+            }
+        });
+    }
+    /**
+     * 获取已发现的设备列表
+     */
+    getDiscoveredDevices() {
+        return Array.from(this.discoveredDevices.values());
+    }
+    /**
+     * 清空设备列表
+     */
+    clearDevices() {
+        this.discoveredDevices.clear();
+    }
+    /**
+     * 获取当前扫描状态
+     */
+    getState() {
+        return this.state;
+    }
+    /**
+     * 销毁扫描器
+     */
+    destroy() {
+        this.stopScan();
+        this.clearDevices();
+        this.clearTimeout();
+        this.callbacks = {};
+        this.adapterStateListeners = [];
+        this.initialized = false;
+    }
+    /**
+     * 处理发现的设备
+     */
+    handleDeviceFound(rawDevice) {
+        var _a, _b;
+        try {
+            const device = normalizeDeviceData(rawDevice);
+            // 应用过滤器
+            if (!this.filterDevice(device)) {
+                return;
+            }
+            // 检查是否已存在
+            const existingDevice = this.discoveredDevices.get(device.deviceId);
+            if (existingDevice && !this.options.allowDuplicates) {
+                // 更新 RSSI
+                existingDevice.RSSI = device.RSSI;
+                return;
+            }
+            // 保存设备
+            this.discoveredDevices.set(device.deviceId, device);
+            // 触发回调
+            (_b = (_a = this.callbacks).onDeviceFound) === null || _b === void 0 ? void 0 : _b.call(_a, device);
+        }
+        catch (error) {
+            console.error('处理设备数据失败:', error);
+        }
+    }
+    /**
+     * 过滤设备
+     */
+    filterDevice(device) {
+        // 按名称过滤
+        if (this.options.nameFilter) {
+            const deviceName = device.name || '';
+            const filters = Array.isArray(this.options.nameFilter)
+                ? this.options.nameFilter
+                : [this.options.nameFilter];
+            const nameMatch = filters.some(filter => {
+                if (typeof filter === 'string') {
+                    return deviceName.includes(filter);
+                }
+                return filter.test(deviceName);
+            });
+            if (!nameMatch)
+                return false;
+        }
+        // 按信号强度过滤
+        if (this.options.rssiThreshold !== undefined) {
+            if (device.RSSI < this.options.rssiThreshold) {
+                return false;
+            }
+        }
+        // 按服务UUID过滤
+        if (this.options.services && this.options.services.length > 0) {
+            if (!device.serviceUuids)
+                return false;
+            const hasMatchingService = this.options.services.some(service => device.serviceUuids.some(uuid => uuid.toLowerCase().includes(service.toLowerCase())));
+            if (!hasMatchingService)
+                return false;
+        }
+        // 按制造商数据过滤
+        if (this.options.manufacturerFilter !== undefined) {
+            if (!device.manufacturerData)
+                return false;
+            const filters = Array.isArray(this.options.manufacturerFilter)
+                ? this.options.manufacturerFilter
+                : [this.options.manufacturerFilter];
+            const manufacturerIds = Object.keys(device.manufacturerData).map(id => parseInt(id, 16));
+            const hasMatchingManufacturer = filters.some(filter => manufacturerIds.includes(filter));
+            if (!hasMatchingManufacturer)
+                return false;
+        }
+        return true;
+    }
+    /**
+     * 处理超时
+     */
+    handleTimeout() {
+        var _a, _b;
+        this.stopScan();
+        (_b = (_a = this.callbacks).onTimeout) === null || _b === void 0 ? void 0 : _b.call(_a);
+    }
+    /**
+     * 处理错误
+     */
+    handleError(error) {
+        var _a, _b;
+        const bleError = handlePlatformError(error, this.getPlatform());
+        this.setState(exports.ScanState.ERROR);
+        (_b = (_a = this.callbacks).onError) === null || _b === void 0 ? void 0 : _b.call(_a, bleError);
+    }
+    /**
+     * 设置状态
+     */
+    setState(state) {
+        this.state = state;
+    }
+    /**
+     * 清除超时定时器
+     */
+    clearTimeout() {
+        if (this.timeoutId !== null) {
+            window.clearTimeout(this.timeoutId);
+            this.timeoutId = null;
+        }
+    }
+    /**
+     * 获取默认选项
+     */
+    getDefaultOptions() {
+        return {
+            timeout: 10000,
+            allowDuplicates: false,
+        };
+    }
+    /**
+     * 触发适配器状态变化
+     */
+    emitAdapterStateChange(state) {
+        this.adapterStateListeners.forEach(listener => listener(state));
+    }
+}
+
+/**
+ * 获取当前运行平台
+ */
+function getPlatform() {
+    var _a;
+    // #ifdef APP-PLUS
+    const systemInfo = uni.getSystemInfoSync();
+    const platform = ((_a = systemInfo.platform) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || '';
+    if (platform === 'android') {
+        return exports.Platform.ANDROID;
+    }
+    else if (platform === 'ios') {
+        return exports.Platform.IOS;
+    }
+    else if (platform === 'harmony' || platform === 'harmonyos') {
+        return exports.Platform.HARMONY;
+    }
+    // #endif
+    // #ifdef HARMONY
+    return exports.Platform.HARMONY;
+}
+/**
+ * 检查是否在指定平台运行
+ */
+function isPlatform(platform) {
+    return getPlatform() === platform;
+}
+/**
+ * 检查是否是移动端APP环境
+ */
+function isApp() {
+    // #ifdef APP-PLUS
+    return true;
+}
+/**
+ * 获取平台名称
+ */
+function getPlatformName() {
+    const platform = getPlatform();
+    switch (platform) {
+        case exports.Platform.ANDROID:
+            return 'Android';
+        case exports.Platform.IOS:
+            return 'iOS';
+        case exports.Platform.HARMONY:
+            return 'HarmonyOS';
+        default:
+            return 'Unknown';
+    }
+}
+
+/**
+ * 安卓权限列表
+ */
+const ANDROID_PERMISSIONS = {
+    // Android 12+ 需要的新权限
+    BLUETOOTH_SCAN: 'android.permission.BLUETOOTH_SCAN',
+    BLUETOOTH_CONNECT: 'android.permission.BLUETOOTH_CONNECT',
+    // Android 11 及以下需要的权限
+    BLUETOOTH: 'android.permission.BLUETOOTH',
+    BLUETOOTH_ADMIN: 'android.permission.BLUETOOTH_ADMIN',
+    // 位置权限（扫描需要）
+    ACCESS_FINE_LOCATION: 'android.permission.ACCESS_FINE_LOCATION'};
+/**
+ * iOS 不需要显式请求蓝牙权限，由系统自动处理
+ * 但需要在 Info.plist 中配置 NSBluetoothAlwaysUsageDescription
+ */
+/**
+ * 鸿蒙权限列表
+ */
+const HARMONY_PERMISSIONS = {
+    ACCESS_BLUETOOTH: 'ohos.permission.ACCESS_BLUETOOTH',
+    LOCATION: 'ohos.permission.LOCATION',
+    APPROXIMATELY_LOCATION: 'ohos.permission.APPROXIMATELY_LOCATION',
+};
+/**
+ * 检查权限
+ */
+function checkPermissions() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const platform = getPlatform();
+        switch (platform) {
+            case exports.Platform.ANDROID:
+                return checkAndroidPermissions();
+            case exports.Platform.IOS:
+                return checkIOSPermissions();
+            case exports.Platform.HARMONY:
+                return checkHarmonyPermissions();
+            default:
+                return false;
+        }
+    });
+}
+/**
+ * 请求权限
+ */
+function requestPermissions() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const platform = getPlatform();
+        switch (platform) {
+            case exports.Platform.ANDROID:
+                return requestAndroidPermissions();
+            case exports.Platform.IOS:
+                return requestIOSPermissions();
+            case exports.Platform.HARMONY:
+                return requestHarmonyPermissions();
+            default:
+                return false;
+        }
+    });
+}
+/**
+ * 检查安卓权限
+ */
+function checkAndroidPermissions() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve) => {
+            var _a;
+            // #ifdef APP-PLUS
+            const mainActivity = plus.android.runtimeMainActivity();
+            const PackageManager = plus.android.importClass('android.content.pm.PackageManager');
+            // 获取系统版本
+            const systemInfo = uni.getSystemInfoSync();
+            const osVersion = parseInt(((_a = systemInfo.system) === null || _a === void 0 ? void 0 : _a.split('.')[0]) || '0');
+            let permissions;
+            if (osVersion >= 12) {
+                // Android 12+ 使用新权限
+                permissions = [
+                    ANDROID_PERMISSIONS.BLUETOOTH_SCAN,
+                    ANDROID_PERMISSIONS.BLUETOOTH_CONNECT,
+                    ANDROID_PERMISSIONS.ACCESS_FINE_LOCATION,
+                ];
+            }
+            else {
+                // Android 11 及以下使用旧权限
+                permissions = [
+                    ANDROID_PERMISSIONS.BLUETOOTH,
+                    ANDROID_PERMISSIONS.BLUETOOTH_ADMIN,
+                    ANDROID_PERMISSIONS.ACCESS_FINE_LOCATION,
+                ];
+            }
+            for (const permission of permissions) {
+                const result = mainActivity.checkSelfPermission(permission);
+                if (result !== PackageManager.PERMISSION_GRANTED) {
+                    resolve(false);
+                    return;
+                }
+            }
+            resolve(true);
+            // #endif
+            // #ifndef APP-PLUS
+            resolve(true);
+            // #endif
+        });
+    });
+}
+/**
+ * 请求安卓权限
+ */
+function requestAndroidPermissions() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve) => {
+            var _a;
+            // #ifdef APP-PLUS
+            plus.android.runtimeMainActivity();
+            const systemInfo = uni.getSystemInfoSync();
+            const osVersion = parseInt(((_a = systemInfo.system) === null || _a === void 0 ? void 0 : _a.split('.')[0]) || '0');
+            let permissions;
+            if (osVersion >= 12) {
+                permissions = [
+                    ANDROID_PERMISSIONS.BLUETOOTH_SCAN,
+                    ANDROID_PERMISSIONS.BLUETOOTH_CONNECT,
+                    ANDROID_PERMISSIONS.ACCESS_FINE_LOCATION,
+                ];
+            }
+            else {
+                permissions = [
+                    ANDROID_PERMISSIONS.BLUETOOTH,
+                    ANDROID_PERMISSIONS.BLUETOOTH_ADMIN,
+                    ANDROID_PERMISSIONS.ACCESS_FINE_LOCATION,
+                ];
+            }
+            // 使用 uniapp 的权限请求API
+            uni.requestAndroidPermission(permissions[0], (result) => {
+                if (result.granted) {
+                    resolve(true);
+                }
+                else {
+                    resolve(false);
+                }
+            }, (error) => {
+                console.error('请求权限失败:', error);
+                resolve(false);
+            });
+            // #endif
+            // #ifndef APP-PLUS
+            resolve(true);
+            // #endif
+        });
+    });
+}
+/**
+ * 检查 iOS 权限
+ */
+function checkIOSPermissions() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // iOS 权限由系统自动管理
+        // 需要在 manifest.json 或原生工程中配置 Info.plist
+        return true;
+    });
+}
+/**
+ * 请求 iOS 权限
+ */
+function requestIOSPermissions() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // iOS 权限由系统自动管理
+        return true;
+    });
+}
+/**
+ * 检查鸿蒙权限
+ */
+function checkHarmonyPermissions() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // #ifdef HARMONY
+        // 鸿蒙权限检查逻辑
+        try {
+            const atManager = require('@ohos.abilityAccessCtrl').createAtManager();
+            const tokenId = require('@ohos.process').process.accessTokenId;
+            const permissions = [
+                HARMONY_PERMISSIONS.ACCESS_BLUETOOTH,
+                HARMONY_PERMISSIONS.LOCATION,
+            ];
+            for (const permission of permissions) {
+                const result = yield atManager.verifyAccessToken(tokenId, permission);
+                if (result !== 0) { // PERMISSION_GRANTED = 0
+                    return false;
+                }
+            }
+            return true;
+        }
+        catch (error) {
+            console.error('检查鸿蒙权限失败:', error);
+            return false;
+        }
+        // #endif
+        // #ifndef HARMONY
+        return true;
+        // #endif
+    });
+}
+/**
+ * 请求鸿蒙权限
+ */
+function requestHarmonyPermissions() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // #ifdef HARMONY
+        try {
+            const atManager = require('@ohos.abilityAccessCtrl').createAtManager();
+            const context = getContext(this);
+            const permissions = [
+                HARMONY_PERMISSIONS.ACCESS_BLUETOOTH,
+                HARMONY_PERMISSIONS.LOCATION,
+            ];
+            const result = yield atManager.requestPermissionsFromUser(context, permissions);
+            return result.authResults.every((authResult) => authResult === 0);
+        }
+        catch (error) {
+            console.error('请求鸿蒙权限失败:', error);
+            return false;
+        }
+        // #endif
+        // #ifndef HARMONY
+        return true;
+        // #endif
+    });
+}
+
+/**
+ * UniApp 蓝牙扫描器
+ * 支持安卓、iOS 和鸿蒙平台
+ */
+class UniAppScanner extends BaseScanner {
+    constructor() {
+        super(...arguments);
+        this.adapterStateChangeHandler = null;
+    }
+    getPlatform() {
+        var _a;
+        const systemInfo = uni.getSystemInfoSync();
+        const platform = ((_a = systemInfo.platform) === null || _a === void 0 ? void 0 : _a.toLowerCase()) || '';
+        if (platform === 'android') {
+            return exports.Platform.ANDROID;
+        }
+        else if (platform === 'ios') {
+            return exports.Platform.IOS;
+        }
+        else if (platform === 'harmony' || platform === 'harmonyos') {
+            return exports.Platform.HARMONY;
+        }
+        return exports.Platform.UNKNOWN;
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                // 打开蓝牙适配器
+                uni.openBluetoothAdapter({
+                    success: () => {
+                        this.initialized = true;
+                        resolve();
+                    },
+                    fail: (err) => {
+                        reject(createError(ErrorCodes.ADAPTER_NOT_AVAILABLE, `初始化蓝牙适配器失败: ${err.errMsg}`, err.errCode, err));
+                    },
+                });
+            });
+        });
+    }
+    startScanInternal() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                const scanOptions = {
+                    allowDuplicatesKey: this.options.allowDuplicates || false,
+                    success: () => {
+                        // 监听设备发现
+                        this.startDeviceDiscovery();
+                        resolve();
+                    },
+                    fail: (err) => {
+                        reject(Errors.scanFailed(err.errMsg));
+                    },
+                };
+                // 添加服务UUID过滤
+                if (this.options.services && this.options.services.length > 0) {
+                    scanOptions.services = this.options.services;
+                }
+                uni.startBluetoothDevicesDiscovery(scanOptions);
+            });
+        });
+    }
+    stopScanInternal() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                uni.stopBluetoothDevicesDiscovery({
+                    success: () => {
+                        this.stopDeviceDiscovery();
+                        resolve();
+                    },
+                    fail: (err) => {
+                        reject(Errors.scanFailed(err.errMsg));
+                    },
+                });
+            });
+        });
+    }
+    checkPermissions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return checkPermissions();
+        });
+    }
+    requestPermissions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return requestPermissions();
+        });
+    }
+    onAdapterStateChange(callback) {
+        this.adapterStateListeners.push(callback);
+        // 如果还没有监听，开始监听
+        if (!this.adapterStateChangeHandler) {
+            this.adapterStateChangeHandler = (res) => {
+                this.emitAdapterStateChange({
+                    available: res.available,
+                    discovering: res.discovering,
+                });
+            };
+            uni.onBluetoothAdapterStateChange(this.adapterStateChangeHandler);
+        }
+    }
+    destroy() {
+        super.destroy();
+        // 移除适配器状态监听
+        if (this.adapterStateChangeHandler) {
+            uni.offBluetoothAdapterStateChange(this.adapterStateChangeHandler);
+            this.adapterStateChangeHandler = null;
+        }
+        // 关闭蓝牙适配器
+        uni.closeBluetoothAdapter({
+            success: () => {
+                console.log('蓝牙适配器已关闭');
+            },
+            fail: (err) => {
+                console.error('关闭蓝牙适配器失败:', err);
+            },
+        });
+    }
+    /**
+     * 开始监听设备发现
+     */
+    startDeviceDiscovery() {
+        uni.onBluetoothDeviceFound((res) => {
+            const devices = res.devices || [];
+            devices.forEach((device) => {
+                this.handleDeviceFound(device);
+            });
+        });
+    }
+    /**
+     * 停止监听设备发现
+     */
+    stopDeviceDiscovery() {
+        uni.offBluetoothDeviceFound();
+    }
+    /**
+     * 获取蓝牙适配器状态
+     */
+    getAdapterState() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                uni.getBluetoothAdapterState({
+                    success: (res) => {
+                        resolve({
+                            available: res.available,
+                            discovering: res.discovering,
+                        });
+                    },
+                    fail: (err) => {
+                        reject(Errors.adapterNotAvailable());
+                    },
+                });
+            });
+        });
+    }
+}
+
+/**
+ * Android 原生蓝牙扫描器
+ * 使用 uni-app 的 Native.js 调用 Android 原生 API
+ */
+class AndroidNativeScanner extends BaseScanner {
+    constructor() {
+        super(...arguments);
+        this.bluetoothAdapter = null;
+        this.bluetoothLeScanner = null;
+        this.scanCallback = null;
+        this.adapterStateReceiver = null;
+        this.legacyScanCallback = null;
+    }
+    getPlatform() {
+        return exports.Platform.ANDROID;
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                try {
+                    // #ifdef APP-PLUS
+                    const mainActivity = plus.android.runtimeMainActivity();
+                    const BluetoothManager = plus.android.importClass('android.bluetooth.BluetoothManager');
+                    const bluetoothManager = mainActivity.getSystemService('bluetooth');
+                    this.bluetoothAdapter = bluetoothManager.getAdapter();
+                    if (!this.bluetoothAdapter) {
+                        reject(Errors.adapterNotAvailable());
+                        return;
+                    }
+                    if (!this.bluetoothAdapter.isEnabled()) {
+                        reject(Errors.bluetoothDisabled());
+                        return;
+                    }
+                    this.initialized = true;
+                    resolve();
+                    // #endif
+                    // #ifndef APP-PLUS
+                    reject(createError(ErrorCodes.UNSUPPORTED_PLATFORM, '非 APP 环境不支持原生 Android 扫描'));
+                    // #endif
+                }
+                catch (error) {
+                    reject(handlePlatformError(error, 'android'));
+                }
+            });
+        });
+    }
+    startScanInternal() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                var _a;
+                try {
+                    // #ifdef APP-PLUS
+                    const systemInfo = uni.getSystemInfoSync();
+                    const osVersion = parseInt(((_a = systemInfo.system) === null || _a === void 0 ? void 0 : _a.split('.')[0]) || '0');
+                    if (osVersion >= 21 && this.bluetoothAdapter.getBluetoothLeScanner) {
+                        // Android 5.0+ 使用新的扫描 API
+                        this.startNewScanAPI(resolve, reject);
+                    }
+                    else {
+                        // 旧版扫描 API
+                        this.startLegacyScan(resolve, reject);
+                    }
+                    // #endif
+                    // #ifndef APP-PLUS
+                    reject(Errors.unsupportedPlatform());
+                    // #endif
+                }
+                catch (error) {
+                    reject(handlePlatformError(error, 'android'));
+                }
+            });
+        });
+    }
+    stopScanInternal() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                try {
+                    // #ifdef APP-PLUS
+                    if (this.bluetoothLeScanner && this.scanCallback) {
+                        this.bluetoothLeScanner.stopScan(this.scanCallback);
+                    }
+                    else if (this.bluetoothAdapter) {
+                        this.bluetoothAdapter.stopLeScan(this.legacyScanCallback);
+                    }
+                    resolve();
+                    // #endif
+                    // #ifndef APP-PLUS
+                    reject(Errors.unsupportedPlatform());
+                    // #endif
+                }
+                catch (error) {
+                    reject(handlePlatformError(error, 'android'));
+                }
+            });
+        });
+    }
+    checkPermissions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            // #ifdef APP-PLUS
+            const mainActivity = plus.android.runtimeMainActivity();
+            const PackageManager = plus.android.importClass('android.content.pm.PackageManager');
+            const systemInfo = uni.getSystemInfoSync();
+            const osVersion = parseInt(((_a = systemInfo.system) === null || _a === void 0 ? void 0 : _a.split('.')[0]) || '0');
+            let permissions;
+            if (osVersion >= 12) {
+                permissions = [
+                    'android.permission.BLUETOOTH_SCAN',
+                    'android.permission.BLUETOOTH_CONNECT',
+                    'android.permission.ACCESS_FINE_LOCATION',
+                ];
+            }
+            else {
+                permissions = [
+                    'android.permission.BLUETOOTH',
+                    'android.permission.BLUETOOTH_ADMIN',
+                    'android.permission.ACCESS_FINE_LOCATION',
+                ];
+            }
+            for (const permission of permissions) {
+                const result = mainActivity.checkSelfPermission(permission);
+                if (result !== PackageManager.PERMISSION_GRANTED) {
+                    return false;
+                }
+            }
+            return true;
+            // #endif
+        });
+    }
+    requestPermissions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // #ifdef APP-PLUS
+            return new Promise((resolve) => {
+                var _a;
+                const systemInfo = uni.getSystemInfoSync();
+                const osVersion = parseInt(((_a = systemInfo.system) === null || _a === void 0 ? void 0 : _a.split('.')[0]) || '0');
+                let permissions;
+                if (osVersion >= 12) {
+                    permissions = [
+                        'android.permission.BLUETOOTH_SCAN',
+                        'android.permission.BLUETOOTH_CONNECT',
+                        'android.permission.ACCESS_FINE_LOCATION',
+                    ];
+                }
+                else {
+                    permissions = [
+                        'android.permission.BLUETOOTH',
+                        'android.permission.BLUETOOTH_ADMIN',
+                        'android.permission.ACCESS_FINE_LOCATION',
+                    ];
+                }
+                uni.requestAndroidPermission(permissions[0], (result) => {
+                    resolve(result.granted);
+                }, () => {
+                    resolve(false);
+                });
+            });
+            // #endif
+        });
+    }
+    onAdapterStateChange(callback) {
+        this.adapterStateListeners.push(callback);
+        // #ifdef APP-PLUS
+        if (!this.adapterStateReceiver) {
+            plus.android.runtimeMainActivity();
+            const IntentFilter = plus.android.importClass('android.content.IntentFilter');
+            const BluetoothAdapter = plus.android.importClass('android.bluetooth.BluetoothAdapter');
+            const filter = new IntentFilter();
+            filter.addAction(BluetoothAdapter.ACTION_STATE_CHANGED);
+            // 这里简化处理，实际应该创建 BroadcastReceiver
+            // 由于 Native.js 限制，建议使用 uni-app 的标准 API 监听状态
+        }
+        // #endif
+    }
+    destroy() {
+        super.destroy();
+        this.bluetoothAdapter = null;
+        this.bluetoothLeScanner = null;
+        this.scanCallback = null;
+    }
+    /**
+     * 使用新版扫描 API (Android 5.0+)
+     */
+    startNewScanAPI(resolve, reject) {
+        var _a;
+        // #ifdef APP-PLUS
+        try {
+            const ScanSettings = plus.android.importClass('android.bluetooth.le.ScanSettings');
+            const ScanFilter = plus.android.importClass('android.bluetooth.le.ScanFilter');
+            const ScanCallback = plus.android.importClass('android.bluetooth.le.ScanCallback');
+            this.bluetoothLeScanner = this.bluetoothAdapter.getBluetoothLeScanner();
+            // 构建扫描设置
+            const builder = new ScanSettings.Builder();
+            // 设置扫描模式
+            const scanMode = ((_a = this.platformConfig.android) === null || _a === void 0 ? void 0 : _a.scanMode) || ScanSettings.SCAN_MODE_LOW_LATENCY;
+            builder.setScanMode(scanMode);
+            const settings = builder.build();
+            // 构建扫描过滤器
+            const filters = [];
+            if (this.options.services && this.options.services.length > 0) {
+                // 可以添加服务 UUID 过滤
+            }
+            // 创建扫描回调
+            const self = this;
+            this.scanCallback = new ScanCallback({
+                onScanResult: (callbackType, result) => {
+                    const device = result.getDevice();
+                    const rssi = result.getRssi();
+                    const scanRecord = result.getScanRecord();
+                    self.handleDeviceFound({
+                        deviceId: device.getAddress(),
+                        name: device.getName(),
+                        RSSI: rssi,
+                        advertisData: scanRecord ? scanRecord.getBytes() : null,
+                    });
+                },
+                onBatchScanResults: (results) => {
+                    results.forEach((result) => {
+                        this.scanCallback.onScanResult(0, result);
+                    });
+                },
+                onScanFailed: (errorCode) => {
+                    reject(Errors.scanFailed(`错误码: ${errorCode}`));
+                },
+            });
+            this.bluetoothLeScanner.startScan(filters, settings, this.scanCallback);
+            resolve();
+        }
+        catch (error) {
+            reject(handlePlatformError(error, 'android'));
+        }
+        // #endif
+    }
+    /**
+     * 使用旧版扫描 API
+     */
+    startLegacyScan(resolve, reject) {
+        // #ifdef APP-PLUS
+        try {
+            const self = this;
+            this.legacyScanCallback = new plus.android.implements('android.bluetooth.BluetoothAdapter.LeScanCallback', {
+                onLeScan: (device, rssi, scanRecord) => {
+                    self.handleDeviceFound({
+                        deviceId: device.getAddress(),
+                        name: device.getName(),
+                        RSSI: rssi,
+                        advertisData: scanRecord,
+                    });
+                },
+            });
+            let serviceUuids = null;
+            if (this.options.services && this.options.services.length > 0) {
+                serviceUuids = this.options.services;
+            }
+            const started = this.bluetoothAdapter.startLeScan(serviceUuids, this.legacyScanCallback);
+            if (started) {
+                resolve();
+            }
+            else {
+                reject(Errors.scanFailed('启动扫描失败'));
+            }
+        }
+        catch (error) {
+            reject(handlePlatformError(error, 'android'));
+        }
+        // #endif
+    }
+}
+
+/**
+ * iOS 原生蓝牙扫描器
+ * 使用 uni-app 的 Native.js 调用 iOS CoreBluetooth API
+ */
+class IOSNativeScanner extends BaseScanner {
+    constructor() {
+        super(...arguments);
+        this.centralManager = null;
+        this.delegate = null;
+    }
+    getPlatform() {
+        return exports.Platform.IOS;
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                var _a;
+                try {
+                    // #ifdef APP-PLUS
+                    // 导入 iOS CoreBluetooth 框架
+                    const CBCentralManager = plus.ios.importClass('CBCentralManager');
+                    const CBUUID = plus.ios.importClass('CBUUID');
+                    const dispatch_queue_attr_make_with_qos_class = plus.ios.importClass('dispatch_queue_attr_make_with_qos_class');
+                    const dispatch_queue_create = plus.ios.importClass('dispatch_queue_create');
+                    // 创建队列
+                    const queue = dispatch_queue_create('com.ble.scanner', null);
+                    // 创建中央管理器
+                    this.centralManager = new CBCentralManager({
+                        queue: queue,
+                        options: {
+                            'CBCentralManagerOptionShowPowerAlertKey': true,
+                            'CBCentralManagerOptionRestoreIdentifierKey': (_a = this.platformConfig.ios) === null || _a === void 0 ? void 0 : _a.restoreIdentifier,
+                        },
+                    });
+                    if (!this.centralManager) {
+                        reject(Errors.adapterNotAvailable());
+                        return;
+                    }
+                    // 设置委托
+                    const self = this;
+                    this.delegate = plus.ios.implements('CBCentralManagerDelegate', {
+                        centralManagerDidUpdateState: (central) => {
+                            const state = central.state();
+                            // CBManagerStatePoweredOn = 5
+                            if (state === 5) {
+                                self.initialized = true;
+                                resolve();
+                            }
+                            else if (state === 4) { // CBManagerStatePoweredOff
+                                reject(Errors.bluetoothDisabled());
+                            }
+                            else {
+                                reject(createError(ErrorCodes.ADAPTER_NOT_AVAILABLE, `蓝牙适配器状态异常: ${state}`));
+                            }
+                        },
+                        centralManagerDidDiscoverPeripheralAdvertisementDataRSSI: (central, peripheral, advertisementData, RSSI) => {
+                            self.handlePeripheral(peripheral, advertisementData, RSSI);
+                        },
+                    });
+                    this.centralManager.setDelegate(this.delegate);
+                    // 检查当前状态
+                    const currentState = this.centralManager.state();
+                    if (currentState === 5) {
+                        this.initialized = true;
+                        resolve();
+                    }
+                    // 否则等待委托回调
+                    // #endif
+                    // #ifndef APP-PLUS
+                    reject(createError(ErrorCodes.UNSUPPORTED_PLATFORM, '非 APP 环境不支持原生 iOS 扫描'));
+                    // #endif
+                }
+                catch (error) {
+                    reject(handlePlatformError(error, 'ios'));
+                }
+            });
+        });
+    }
+    startScanInternal() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                try {
+                    // #ifdef APP-PLUS
+                    const CBUUID = plus.ios.importClass('CBUUID');
+                    const NSArray = plus.ios.importClass('NSArray');
+                    const NSMutableDictionary = plus.ios.importClass('NSMutableDictionary');
+                    // 构建服务 UUID 列表
+                    let serviceUUIDs = null;
+                    if (this.options.services && this.options.services.length > 0) {
+                        const uuids = [];
+                        this.options.services.forEach((uuid) => {
+                            const cbUuid = CBUUID.UUIDWithString(uuid);
+                            uuids.push(cbUuid);
+                        });
+                        serviceUUIDs = NSArray.arrayWithArray(uuids);
+                    }
+                    // 构建扫描选项
+                    const options = NSMutableDictionary.dictionary();
+                    options.setObjectForKey(this.options.allowDuplicates ? 1 : 0, 'CBCentralManagerScanOptionAllowDuplicatesKey');
+                    // 开始扫描
+                    this.centralManager.scanForPeripheralsWithServicesOptions(serviceUUIDs, options);
+                    resolve();
+                    // #endif
+                    // #ifndef APP-PLUS
+                    reject(Errors.unsupportedPlatform());
+                    // #endif
+                }
+                catch (error) {
+                    reject(handlePlatformError(error, 'ios'));
+                }
+            });
+        });
+    }
+    stopScanInternal() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                try {
+                    // #ifdef APP-PLUS
+                    if (this.centralManager) {
+                        this.centralManager.stopScan();
+                    }
+                    resolve();
+                    // #endif
+                    // #ifndef APP-PLUS
+                    reject(Errors.unsupportedPlatform());
+                    // #endif
+                }
+                catch (error) {
+                    reject(handlePlatformError(error, 'ios'));
+                }
+            });
+        });
+    }
+    checkPermissions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // iOS 权限由系统自动管理
+            // 需要在原生工程的 Info.plist 中配置 NSBluetoothAlwaysUsageDescription
+            return true;
+        });
+    }
+    requestPermissions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // iOS 权限由系统自动管理
+            return true;
+        });
+    }
+    onAdapterStateChange(callback) {
+        this.adapterStateListeners.push(callback);
+        // 委托中已处理状态变化
+    }
+    destroy() {
+        super.destroy();
+        // #ifdef APP-PLUS
+        if (this.centralManager) {
+            this.centralManager.stopScan();
+            plus.ios.deleteObject(this.centralManager);
+        }
+        if (this.delegate) {
+            plus.ios.deleteObject(this.delegate);
+        }
+        // #endif
+        this.centralManager = null;
+        this.delegate = null;
+    }
+    /**
+     * 处理发现的外设
+     */
+    handlePeripheral(peripheral, advertisementData, RSSI) {
+        try {
+            // #ifdef APP-PLUS
+            const deviceId = peripheral.identifier().UUIDString();
+            const name = peripheral.name();
+            // 解析广播数据
+            const localName = advertisementData.objectForKey('kCBAdvDataLocalName');
+            const serviceUUIDs = advertisementData.objectForKey('kCBAdvDataServiceUUIDs');
+            const manufacturerData = advertisementData.objectForKey('kCBAdvDataManufacturerData');
+            const isConnectable = advertisementData.objectForKey('kCBAdvDataIsConnectable');
+            const txPowerLevel = advertisementData.objectForKey('kCBAdvDataTxPowerLevel');
+            // 转换服务 UUID
+            const serviceUuids = [];
+            if (serviceUUIDs) {
+                const count = serviceUUIDs.count();
+                for (let i = 0; i < count; i++) {
+                    const uuid = serviceUUIDs.objectAtIndex(i).UUIDString();
+                    serviceUuids.push(uuid);
+                }
+            }
+            // 转换制造商数据
+            let manufacturerDataBuffer;
+            if (manufacturerData) {
+                const length = manufacturerData.length();
+                const bytes = new Uint8Array(length);
+                manufacturerData.getBytes(bytes);
+                manufacturerDataBuffer = bytes.buffer;
+            }
+            this.handleDeviceFound({
+                deviceId,
+                name: name || localName,
+                RSSI,
+                advertisData: manufacturerDataBuffer,
+                serviceUuids,
+                localName,
+                isConnectable,
+                txPowerLevel,
+            });
+            // #endif
+        }
+        catch (error) {
+            console.error('处理外设数据失败:', error);
+        }
+    }
+    /**
+     * 获取 iOS 蓝牙适配器状态
+     */
+    getAdapterState() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                // #ifdef APP-PLUS
+                try {
+                    const state = this.centralManager.state();
+                    // CBManagerStatePoweredOn = 5
+                    resolve({
+                        available: state === 5,
+                        discovering: this.state === 'scanning',
+                    });
+                }
+                catch (error) {
+                    reject(handlePlatformError(error, 'ios'));
+                }
+                // #endif
+                // #ifndef APP-PLUS
+                reject(Errors.unsupportedPlatform());
+                // #endif
+            });
+        });
+    }
+}
+
+/**
+ * 鸿蒙原生蓝牙扫描器
+ * 使用鸿蒙原生 API 进行蓝牙扫描
+ */
+class HarmonyNativeScanner extends BaseScanner {
+    constructor() {
+        super(...arguments);
+        this.bluetoothManager = null;
+        this.bleScanner = null;
+        this.scanCallback = null;
+    }
+    getPlatform() {
+        return exports.Platform.HARMONY;
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                try {
+                    // #ifdef HARMONY
+                    // 导入鸿蒙蓝牙模块
+                    const bluetooth = require('@ohos.bluetooth.ble');
+                    // 获取蓝牙管理器
+                    this.bluetoothManager = bluetooth.BLE;
+                    if (!this.bluetoothManager) {
+                        reject(Errors.adapterNotAvailable());
+                        return;
+                    }
+                    // 检查蓝牙是否开启
+                    const state = this.bluetoothManager.getState();
+                    if (state !== 2) { // STATE_ON = 2
+                        reject(Errors.bluetoothDisabled());
+                        return;
+                    }
+                    this.initialized = true;
+                    resolve();
+                    // #endif
+                    // #ifndef HARMONY
+                    reject(createError(ErrorCodes.UNSUPPORTED_PLATFORM, '非鸿蒙环境不支持原生鸿蒙扫描'));
+                    // #endif
+                }
+                catch (error) {
+                    reject(handlePlatformError(error, 'harmony'));
+                }
+            });
+        });
+    }
+    startScanInternal() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                try {
+                    // #ifdef HARMONY
+                    const bluetooth = require('@ohos.bluetooth.ble');
+                    // 构建扫描过滤器
+                    const filters = [];
+                    if (this.options.services && this.options.services.length > 0) {
+                        this.options.services.forEach((uuid) => {
+                            const filter = {
+                                serviceUuid: uuid,
+                            };
+                            filters.push(filter);
+                        });
+                    }
+                    if (this.options.nameFilter) {
+                        const names = Array.isArray(this.options.nameFilter)
+                            ? this.options.nameFilter
+                            : [this.options.nameFilter];
+                        names.forEach((name) => {
+                            if (typeof name === 'string') {
+                                filters.push({ deviceName: name });
+                            }
+                        });
+                    }
+                    // 构建扫描配置
+                    const scanOptions = {
+                        interval: 0,
+                        dutyMode: bluetooth.ScanDuty.SCAN_MODE_LOW_LATENCY,
+                        matchMode: bluetooth.MatchMode.MATCH_MODE_AGGRESSIVE,
+                    };
+                    // 创建扫描回调
+                    const self = this;
+                    this.scanCallback = {
+                        onScanResult: (result) => {
+                            const device = result.device;
+                            const data = result.data;
+                            const rssi = result.rssi;
+                            self.handleDeviceFound({
+                                deviceId: device.deviceId,
+                                name: device.deviceName,
+                                RSSI: rssi,
+                                advertisData: data,
+                                serviceUuids: result.serviceUuids,
+                            });
+                        },
+                        onScanFailed: (errorCode) => {
+                            console.error('扫描失败:', errorCode);
+                        },
+                    };
+                    // 开始扫描
+                    this.bluetoothManager.startBLEScan(filters, scanOptions, this.scanCallback);
+                    resolve();
+                    // #endif
+                    // #ifndef HARMONY
+                    reject(Errors.unsupportedPlatform());
+                    // #endif
+                }
+                catch (error) {
+                    reject(handlePlatformError(error, 'harmony'));
+                }
+            });
+        });
+    }
+    stopScanInternal() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                try {
+                    // #ifdef HARMONY
+                    if (this.bluetoothManager) {
+                        this.bluetoothManager.stopBLEScan();
+                    }
+                    resolve();
+                    // #endif
+                    // #ifndef HARMONY
+                    reject(Errors.unsupportedPlatform());
+                    // #endif
+                }
+                catch (error) {
+                    reject(handlePlatformError(error, 'harmony'));
+                }
+            });
+        });
+    }
+    checkPermissions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // #ifdef HARMONY
+            try {
+                const atManager = require('@ohos.abilityAccessCtrl').createAtManager();
+                const tokenId = require('@ohos.process').process.accessTokenId;
+                const permissions = [
+                    'ohos.permission.ACCESS_BLUETOOTH',
+                    'ohos.permission.LOCATION',
+                ];
+                for (const permission of permissions) {
+                    const result = yield atManager.verifyAccessToken(tokenId, permission);
+                    if (result !== 0) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            catch (error) {
+                console.error('检查权限失败:', error);
+                return false;
+            }
+            // #endif
+            // #ifndef HARMONY
+            return false;
+            // #endif
+        });
+    }
+    requestPermissions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // #ifdef HARMONY
+            try {
+                const atManager = require('@ohos.abilityAccessCtrl').createAtManager();
+                const context = getContext(this);
+                const permissions = [
+                    'ohos.permission.ACCESS_BLUETOOTH',
+                    'ohos.permission.LOCATION',
+                ];
+                const result = yield atManager.requestPermissionsFromUser(context, permissions);
+                return result.authResults.every((authResult) => authResult === 0);
+            }
+            catch (error) {
+                console.error('请求权限失败:', error);
+                return false;
+            }
+            // #endif
+            // #ifndef HARMONY
+            return false;
+            // #endif
+        });
+    }
+    onAdapterStateChange(callback) {
+        this.adapterStateListeners.push(callback);
+        // #ifdef HARMONY
+        try {
+            const bluetooth = require('@ohos.bluetooth.ble');
+            // 监听蓝牙状态变化
+            bluetooth.on('stateChange', (data) => {
+                this.emitAdapterStateChange({
+                    available: data.state === 2, // STATE_ON = 2
+                    discovering: this.state === 'scanning',
+                });
+            });
+        }
+        catch (error) {
+            console.error('监听状态变化失败:', error);
+        }
+        // #endif
+    }
+    destroy() {
+        super.destroy();
+        // #ifdef HARMONY
+        try {
+            const bluetooth = require('@ohos.bluetooth.ble');
+            // 停止扫描
+            if (this.bluetoothManager) {
+                this.bluetoothManager.stopBLEScan();
+            }
+            // 移除状态监听
+            bluetooth.off('stateChange');
+        }
+        catch (error) {
+            console.error('销毁失败:', error);
+        }
+        // #endif
+        this.bluetoothManager = null;
+        this.scanCallback = null;
+    }
+    /**
+     * 获取鸿蒙蓝牙适配器状态
+     */
+    getAdapterState() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                // #ifdef HARMONY
+                try {
+                    const state = this.bluetoothManager.getState();
+                    resolve({
+                        available: state === 2,
+                        discovering: this.state === 'scanning',
+                    });
+                }
+                catch (error) {
+                    reject(handlePlatformError(error, 'harmony'));
+                }
+                // #endif
+                // #ifndef HARMONY
+                reject(Errors.unsupportedPlatform());
+                // #endif
+            });
+        });
+    }
+}
+
+/**
+ * 创建蓝牙扫描器
+ * @param options 创建选项
+ * @returns 蓝牙扫描器实例
+ */
+function createScanner(options = {}) {
+    const { type = 'auto', platformConfig = {} } = options;
+    const platform = getPlatform();
+    const app = isApp();
+    // 根据类型和平台选择合适的扫描器
+    if (type === 'uniapp' || (type === 'auto' && !app)) {
+        // 使用 UniApp 标准 API
+        const scanner = new UniAppScanner();
+        Object.assign(scanner, { platformConfig });
+        return scanner;
+    }
+    if (type === 'native' || type === 'auto') {
+        // 使用原生 API
+        switch (platform) {
+            case exports.Platform.ANDROID:
+                const androidScanner = new AndroidNativeScanner();
+                Object.assign(androidScanner, { platformConfig });
+                return androidScanner;
+            case exports.Platform.IOS:
+                const iosScanner = new IOSNativeScanner();
+                Object.assign(iosScanner, { platformConfig });
+                return iosScanner;
+            case exports.Platform.HARMONY:
+                const harmonyScanner = new HarmonyNativeScanner();
+                Object.assign(harmonyScanner, { platformConfig });
+                return harmonyScanner;
+            default:
+                // 未知平台使用 UniApp API
+                const defaultScanner = new UniAppScanner();
+                Object.assign(defaultScanner, { platformConfig });
+                return defaultScanner;
+        }
+    }
+    // 默认使用 UniApp API
+    const defaultScanner = new UniAppScanner();
+    Object.assign(defaultScanner, { platformConfig });
+    return defaultScanner;
+}
+/**
+ * 创建 UniApp 扫描器
+ * 使用 UniApp 标准蓝牙 API，兼容所有平台
+ */
+function createUniAppScanner(platformConfig) {
+    return createScanner({ type: 'uniapp', platformConfig });
+}
+/**
+ * 创建原生扫描器
+ * 使用平台原生 API，功能更强大但需要特定条件
+ */
+function createNativeScanner(platformConfig) {
+    return createScanner({ type: 'native', platformConfig });
+}
+/**
+ * 检查当前环境是否支持蓝牙
+ */
+function isBluetoothSupported() {
+    // #ifdef APP-PLUS
+    return true;
+}
+
+// 导出枚举
+
+exports.AndroidNativeScanner = AndroidNativeScanner;
+exports.BaseScanner = BaseScanner;
+exports.ErrorCodes = ErrorCodes;
+exports.Errors = Errors;
+exports.HarmonyNativeScanner = HarmonyNativeScanner;
+exports.IOSNativeScanner = IOSNativeScanner;
+exports.UniAppScanner = UniAppScanner;
+exports.arrayBufferToBase64 = arrayBufferToBase64;
+exports.base64ToArrayBuffer = base64ToArrayBuffer;
+exports.checkPermissions = checkPermissions;
+exports.createError = createError;
+exports.createNativeScanner = createNativeScanner;
+exports.createScanner = createScanner;
+exports.createUniAppScanner = createUniAppScanner;
+exports.default = createScanner;
+exports.formatUUID = formatUUID;
+exports.getPlatform = getPlatform;
+exports.getPlatformName = getPlatformName;
+exports.isApp = isApp;
+exports.isBluetoothSupported = isBluetoothSupported;
+exports.isPlatform = isPlatform;
+exports.matchUUID = matchUUID;
+exports.parseAdvertisementData = parseAdvertisementData;
+exports.requestPermissions = requestPermissions;