@fww_123/uni-ble-scanner 1.0.0

package/src/platforms/ios-native.ts

@@ -0,0 +1,264 @@
+import { BaseScanner } from '../core/base-scanner';
+import {
+  Platform,
+  AdapterState,
+  BLEError,
+  PlatformConfig,
+} from '../types';
+import { Errors, createError, ErrorCodes, handlePlatformError } from '../utils/errors';
+
+/**
+ * iOS 原生蓝牙扫描器
+ * 使用 uni-app 的 Native.js 调用 iOS CoreBluetooth API
+ */
+export class IOSNativeScanner extends BaseScanner {
+  private centralManager: any = null;
+  private delegate: any = null;
+
+  getPlatform(): Platform {
+    return Platform.IOS;
+  }
+
+  async init(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      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': this.platformConfig.ios?.restoreIdentifier,
+          },
+        });
+        
+        if (!this.centralManager) {
+          reject(Errors.adapterNotAvailable());
+          return;
+        }
+        
+        // 设置委托
+        const self = this;
+        this.delegate = plus.ios.implements('CBCentralManagerDelegate', {
+          centralManagerDidUpdateState: (central: any) => {
+            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: any,
+            peripheral: any,
+            advertisementData: any,
+            RSSI: number
+          ) => {
+            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'));
+      }
+    });
+  }
+
+  protected async startScanInternal(): Promise<void> {
+    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: any = null;
+        if (this.options.services && this.options.services.length > 0) {
+          const uuids: any[] = [];
+          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'));
+      }
+    });
+  }
+
+  protected async stopScanInternal(): Promise<void> {
+    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'));
+      }
+    });
+  }
+
+  async checkPermissions(): Promise<boolean> {
+    // iOS 权限由系统自动管理
+    // 需要在原生工程的 Info.plist 中配置 NSBluetoothAlwaysUsageDescription
+    return true;
+  }
+
+  async requestPermissions(): Promise<boolean> {
+    // iOS 权限由系统自动管理
+    return true;
+  }
+
+  onAdapterStateChange(callback: (state: AdapterState) => void): void {
+    this.adapterStateListeners.push(callback);
+    
+    // 委托中已处理状态变化
+  }
+
+  destroy(): void {
+    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;
+  }
+
+  /**
+   * 处理发现的外设
+   */
+  private handlePeripheral(peripheral: any, advertisementData: any, RSSI: number): void {
+    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: string[] = [];
+      if (serviceUUIDs) {
+        const count = serviceUUIDs.count();
+        for (let i = 0; i < count; i++) {
+          const uuid = serviceUUIDs.objectAtIndex(i).UUIDString();
+          serviceUuids.push(uuid);
+        }
+      }
+      
+      // 转换制造商数据
+      let manufacturerDataBuffer: ArrayBuffer | undefined;
+      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 蓝牙适配器状态
+   */
+  async getAdapterState(): Promise<AdapterState> {
+    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
+    });
+  }
+}

package/src/platforms/uniapp-scanner.ts

@@ -0,0 +1,171 @@
+import { BaseScanner } from '../core/base-scanner';
+import {
+  Platform,
+  AdapterState,
+  BLEError,
+  PlatformConfig,
+} from '../types';
+import { Errors, createError, ErrorCodes } from '../utils/errors';
+import { checkPermissions, requestPermissions } from '../utils/permissions';
+
+/**
+ * UniApp 蓝牙扫描器
+ * 支持安卓、iOS 和鸿蒙平台
+ */
+export class UniAppScanner extends BaseScanner {
+  private adapterStateChangeHandler: ((res: any) => void) | null = null;
+
+  getPlatform(): Platform {
+    const systemInfo = uni.getSystemInfoSync();
+    const platform = systemInfo.platform?.toLowerCase() || '';
+    
+    if (platform === 'android') {
+      return Platform.ANDROID;
+    } else if (platform === 'ios') {
+      return Platform.IOS;
+    } else if (platform === 'harmony' || platform === 'harmonyos') {
+      return Platform.HARMONY;
+    }
+    
+    return Platform.UNKNOWN;
+  }
+
+  async init(): Promise<void> {
+    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
+          ));
+        },
+      });
+    });
+  }
+
+  protected async startScanInternal(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const scanOptions: UniApp.StartBluetoothDevicesDiscoveryOptions = {
+        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);
+    });
+  }
+
+  protected async stopScanInternal(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      uni.stopBluetoothDevicesDiscovery({
+        success: () => {
+          this.stopDeviceDiscovery();
+          resolve();
+        },
+        fail: (err) => {
+          reject(Errors.scanFailed(err.errMsg));
+        },
+      });
+    });
+  }
+
+  async checkPermissions(): Promise<boolean> {
+    return checkPermissions();
+  }
+
+  async requestPermissions(): Promise<boolean> {
+    return requestPermissions();
+  }
+
+  onAdapterStateChange(callback: (state: AdapterState) => void): void {
+    this.adapterStateListeners.push(callback);
+    
+    // 如果还没有监听，开始监听
+    if (!this.adapterStateChangeHandler) {
+      this.adapterStateChangeHandler = (res) => {
+        this.emitAdapterStateChange({
+          available: res.available,
+          discovering: res.discovering,
+        });
+      };
+      
+      uni.onBluetoothAdapterStateChange(this.adapterStateChangeHandler);
+    }
+  }
+
+  destroy(): void {
+    super.destroy();
+    
+    // 移除适配器状态监听
+    if (this.adapterStateChangeHandler) {
+      uni.offBluetoothAdapterStateChange(this.adapterStateChangeHandler);
+      this.adapterStateChangeHandler = null;
+    }
+    
+    // 关闭蓝牙适配器
+    uni.closeBluetoothAdapter({
+      success: () => {
+        console.log('蓝牙适配器已关闭');
+      },
+      fail: (err) => {
+        console.error('关闭蓝牙适配器失败:', err);
+      },
+    });
+  }
+
+  /**
+   * 开始监听设备发现
+   */
+  private startDeviceDiscovery(): void {
+    uni.onBluetoothDeviceFound((res) => {
+      const devices = res.devices || [];
+      devices.forEach((device) => {
+        this.handleDeviceFound(device);
+      });
+    });
+  }
+
+  /**
+   * 停止监听设备发现
+   */
+  private stopDeviceDiscovery(): void {
+    uni.offBluetoothDeviceFound();
+  }
+
+  /**
+   * 获取蓝牙适配器状态
+   */
+  async getAdapterState(): Promise<AdapterState> {
+    return new Promise((resolve, reject) => {
+      uni.getBluetoothAdapterState({
+        success: (res) => {
+          resolve({
+            available: res.available,
+            discovering: res.discovering,
+          });
+        },
+        fail: (err) => {
+          reject(Errors.adapterNotAvailable());
+        },
+      });
+    });
+  }
+}

package/src/types/global.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 全局类型声明
+ */
+
+/// <reference path="./uni-types.d.ts" />
+
+// 扩展 Window 接口
+declare interface Window {
+  setTimeout(callback: Function, ms?: number): number;
+  clearTimeout(timeoutId: number): void;
+  setInterval(callback: Function, ms?: number): number;
+  clearInterval(intervalId: number): void;
+}
+
+// 声明全局 uni 对象
+// @ts-ignore
+declare const uni: UniNamespace.Uni;
+
+// @ts-ignore
+declare const plus: PlusNamespace.PlusStatic;
+
+// 条件编译标记（用于 IDE 识别）
+declare const __UNI_PLATFORM__: string;
+declare const __VUE_OPTIONS_API__: boolean;
+declare const __VUE_PROD_DEVTOOLS__: boolean;

package/src/types/uni-types.d.ts

@@ -0,0 +1,83 @@
+/**
+ * UniApp 全局类型声明
+ */
+
+declare const uni: UniNamespace.Uni;
+declare const plus: PlusNamespace.PlusStatic;
+
+declare namespace UniNamespace {
+  interface Uni {
+    getSystemInfoSync(): SystemInfo;
+    openBluetoothAdapter(options: {
+      success?: (res: any) => void;
+      fail?: (err: any) => void;
+      complete?: (res: any) => void;
+    }): void;
+    closeBluetoothAdapter(options: {
+      success?: (res: any) => void;
+      fail?: (err: any) => void;
+      complete?: (res: any) => void;
+    }): void;
+    getBluetoothAdapterState(options: {
+      success?: (res: {
+        available: boolean;
+        discovering: boolean;
+      }) => void;
+      fail?: (err: any) => void;
+      complete?: (res: any) => void;
+    }): void;
+    startBluetoothDevicesDiscovery(options: StartBluetoothDevicesDiscoveryOptions): void;
+    stopBluetoothDevicesDiscovery(options: {
+      success?: (res: any) => void;
+      fail?: (err: any) => void;
+      complete?: (res: any) => void;
+    }): void;
+    onBluetoothDeviceFound(callback: (res: { devices: any[] }) => void): void;
+    offBluetoothDeviceFound(callback?: (res: any) => void): void;
+    onBluetoothAdapterStateChange(callback: (res: {
+      available: boolean;
+      discovering: boolean;
+    }) => void): void;
+    offBluetoothAdapterStateChange(callback?: (res: any) => void): void;
+    requestAndroidPermission(
+      permission: string,
+      success?: (result: { granted: boolean }) => void,
+      fail?: (error: any) => void
+    ): void;
+    showToast(options: {
+      title: string;
+      icon?: 'success' | 'loading' | 'none';
+      duration?: number;
+    }): void;
+  }
+
+  interface SystemInfo {
+    platform?: string;
+    system?: string;
+  }
+
+  interface StartBluetoothDevicesDiscoveryOptions {
+    services?: string[];
+    allowDuplicatesKey?: boolean;
+    interval?: number;
+    success?: (res: any) => void;
+    fail?: (err: any) => void;
+    complete?: (res: any) => void;
+  }
+}
+
+declare namespace PlusNamespace {
+  interface PlusStatic {
+    android: {
+      runtimeMainActivity(): any;
+      importClass(className: string): any;
+    };
+    ios: {
+      importClass(className: string): any;
+      implements(protocol: string, methods: Record<string, Function>): any;
+      deleteObject(obj: any): void;
+    };
+  }
+}
+
+declare function getContext(obj: any): any;