@fww_123/uni-ble-scanner 1.0.0

package/src/platforms/android-native.ts

@@ -0,0 +1,300 @@
+import { BaseScanner } from '../core/base-scanner';
+import {
+  Platform,
+  AdapterState,
+  BLEError,
+  PlatformConfig,
+} from '../types';
+import { Errors, createError, ErrorCodes, handlePlatformError } from '../utils/errors';
+
+/**
+ * Android 原生蓝牙扫描器
+ * 使用 uni-app 的 Native.js 调用 Android 原生 API
+ */
+export class AndroidNativeScanner extends BaseScanner {
+  private bluetoothAdapter: any = null;
+  private bluetoothLeScanner: any = null;
+  private scanCallback: any = null;
+  private adapterStateReceiver: any = null;
+
+  getPlatform(): Platform {
+    return Platform.ANDROID;
+  }
+
+  async init(): Promise<void> {
+    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'));
+      }
+    });
+  }
+
+  protected async startScanInternal(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      try {
+        // #ifdef APP-PLUS
+        const systemInfo = uni.getSystemInfoSync();
+        const osVersion = parseInt(systemInfo.system?.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'));
+      }
+    });
+  }
+
+  protected async stopScanInternal(): Promise<void> {
+    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'));
+      }
+    });
+  }
+
+  async checkPermissions(): Promise<boolean> {
+    // #ifdef APP-PLUS
+    const mainActivity = plus.android.runtimeMainActivity();
+    const PackageManager = plus.android.importClass('android.content.pm.PackageManager');
+    
+    const systemInfo = uni.getSystemInfoSync();
+    const osVersion = parseInt(systemInfo.system?.split('.')[0] || '0');
+    
+    let permissions: string[];
+    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
+    
+    // #ifndef APP-PLUS
+    return false;
+    // #endif
+  }
+
+  async requestPermissions(): Promise<boolean> {
+    // #ifdef APP-PLUS
+    return new Promise((resolve) => {
+      const systemInfo = uni.getSystemInfoSync();
+      const osVersion = parseInt(systemInfo.system?.split('.')[0] || '0');
+      
+      let permissions: string[];
+      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: any) => {
+          resolve(result.granted);
+        },
+        () => {
+          resolve(false);
+        }
+      );
+    });
+    // #endif
+    
+    // #ifndef APP-PLUS
+    return false;
+    // #endif
+  }
+
+  onAdapterStateChange(callback: (state: AdapterState) => void): void {
+    this.adapterStateListeners.push(callback);
+    
+    // #ifdef APP-PLUS
+    if (!this.adapterStateReceiver) {
+      const mainActivity = 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(): void {
+    super.destroy();
+    this.bluetoothAdapter = null;
+    this.bluetoothLeScanner = null;
+    this.scanCallback = null;
+  }
+
+  /**
+   * 使用新版扫描 API (Android 5.0+)
+   */
+  private startNewScanAPI(resolve: () => void, reject: (error: BLEError) => void): void {
+    // #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 = this.platformConfig.android?.scanMode || ScanSettings.SCAN_MODE_LOW_LATENCY;
+      builder.setScanMode(scanMode);
+      
+      const settings = builder.build();
+      
+      // 构建扫描过滤器
+      const filters: any[] = [];
+      if (this.options.services && this.options.services.length > 0) {
+        // 可以添加服务 UUID 过滤
+      }
+      
+      // 创建扫描回调
+      const self = this;
+      this.scanCallback = new ScanCallback({
+        onScanResult: (callbackType: number, result: any) => {
+          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: any[]) => {
+          results.forEach((result) => {
+            this.scanCallback.onScanResult(0, result);
+          });
+        },
+        onScanFailed: (errorCode: number) => {
+          reject(Errors.scanFailed(`错误码: ${errorCode}`));
+        },
+      });
+      
+      this.bluetoothLeScanner.startScan(filters, settings, this.scanCallback);
+      resolve();
+    } catch (error) {
+      reject(handlePlatformError(error, 'android'));
+    }
+    // #endif
+  }
+
+  /**
+   * 使用旧版扫描 API
+   */
+  private startLegacyScan(resolve: () => void, reject: (error: BLEError) => void): void {
+    // #ifdef APP-PLUS
+    try {
+      const self = this;
+      this.legacyScanCallback = new plus.android.implements('android.bluetooth.BluetoothAdapter.LeScanCallback', {
+        onLeScan: (device: any, rssi: number, scanRecord: number[]) => {
+          self.handleDeviceFound({
+            deviceId: device.getAddress(),
+            name: device.getName(),
+            RSSI: rssi,
+            advertisData: scanRecord,
+          });
+        },
+      });
+      
+      let serviceUuids: string[] | null = 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
+  }
+
+  private legacyScanCallback: any = null;
+}

package/src/platforms/harmony-native.ts

@@ -0,0 +1,267 @@
+import { BaseScanner } from '../core/base-scanner';
+import {
+  Platform,
+  AdapterState,
+  BLEError,
+  PlatformConfig,
+} from '../types';
+import { Errors, createError, ErrorCodes, handlePlatformError } from '../utils/errors';
+
+/**
+ * 鸿蒙原生蓝牙扫描器
+ * 使用鸿蒙原生 API 进行蓝牙扫描
+ */
+export class HarmonyNativeScanner extends BaseScanner {
+  private bluetoothManager: any = null;
+  private bleScanner: any = null;
+  private scanCallback: any = null;
+
+  getPlatform(): Platform {
+    return Platform.HARMONY;
+  }
+
+  async init(): Promise<void> {
+    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'));
+      }
+    });
+  }
+
+  protected async startScanInternal(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      try {
+        // #ifdef HARMONY
+        const bluetooth = require('@ohos.bluetooth.ble');
+        
+        // 构建扫描过滤器
+        const filters: any[] = [];
+        
+        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: any) => {
+            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: number) => {
+            console.error('扫描失败:', errorCode);
+          },
+        };
+        
+        // 开始扫描
+        this.bluetoothManager.startBLEScan(filters, scanOptions, this.scanCallback);
+        resolve();
+        // #endif
+        
+        // #ifndef HARMONY
+        reject(Errors.unsupportedPlatform());
+        // #endif
+      } catch (error) {
+        reject(handlePlatformError(error, 'harmony'));
+      }
+    });
+  }
+
+  protected async stopScanInternal(): Promise<void> {
+    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'));
+      }
+    });
+  }
+
+  async checkPermissions(): Promise<boolean> {
+    // #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 = await atManager.verifyAccessToken(tokenId, permission);
+        if (result !== 0) {
+          return false;
+        }
+      }
+      return true;
+    } catch (error) {
+      console.error('检查权限失败:', error);
+      return false;
+    }
+    // #endif
+    
+    // #ifndef HARMONY
+    return false;
+    // #endif
+  }
+
+  async requestPermissions(): Promise<boolean> {
+    // #ifdef HARMONY
+    try {
+      const atManager = require('@ohos.abilityAccessCtrl').createAtManager();
+      const context = getContext(this);
+      
+      const permissions = [
+        'ohos.permission.ACCESS_BLUETOOTH',
+        'ohos.permission.LOCATION',
+      ];
+      
+      const result = await atManager.requestPermissionsFromUser(context, permissions);
+      return result.authResults.every((authResult: number) => authResult === 0);
+    } catch (error) {
+      console.error('请求权限失败:', error);
+      return false;
+    }
+    // #endif
+    
+    // #ifndef HARMONY
+    return false;
+    // #endif
+  }
+
+  onAdapterStateChange(callback: (state: AdapterState) => void): void {
+    this.adapterStateListeners.push(callback);
+    
+    // #ifdef HARMONY
+    try {
+      const bluetooth = require('@ohos.bluetooth.ble');
+      
+      // 监听蓝牙状态变化
+      bluetooth.on('stateChange', (data: any) => {
+        this.emitAdapterStateChange({
+          available: data.state === 2, // STATE_ON = 2
+          discovering: this.state === 'scanning',
+        });
+      });
+    } catch (error) {
+      console.error('监听状态变化失败:', error);
+    }
+    // #endif
+  }
+
+  destroy(): void {
+    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;
+  }
+
+  /**
+   * 获取鸿蒙蓝牙适配器状态
+   */
+  async getAdapterState(): Promise<AdapterState> {
+    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
+    });
+  }
+}