taro-bluetooth-print 2.10.2 → 2.12.0

package/src/adapters/ChunkWriteStrategy.ts

@@ -54,7 +54,7 @@ export interface AdaptiveWriteConfig {
  * Default adaptive write configuration
  */
 export const DEFAULT_ADAPTIVE_CONFIG: AdaptiveWriteConfig = {
-  defaultChunkSize: 20,
+  defaultChunkSize: 50, // 增加初始 chunk size，减少 BLE 通信开销
   defaultDelay: 20,
   defaultRetries: 3,
   minChunkSize: 10,
@@ -62,7 +62,7 @@ export const DEFAULT_ADAPTIVE_CONFIG: AdaptiveWriteConfig = {
   maxDelay: 200,
   successThreshold: 3,
   failureThreshold: 2,
-  connectionCheckInterval: 5,
+  connectionCheckInterval: 10, // 增加连接检查间隔，减少不必要的检查
 };
 
 /**
@@ -116,12 +116,31 @@ export abstract class ChunkWriteStrategy<TOptions = void> {
     // default: no connection check
   }
 
+  /** Step size for increasing chunk size on success (bytes) */
+  private static readonly CHUNK_SIZE_STEP = 5;
+  /** Delay backoff multiplier on failure */
+  private static readonly DELAY_BACKOFF_FACTOR = 1.5;
+  /** Delay recovery divisor on success */
+  private static readonly DELAY_RECOVERY_FACTOR = 1.2;
+  /** Timeout base (ms) for computeTimeoutMs */
+  private static readonly TIMEOUT_BASE_MS = 1000;
+  /** Timeout per-byte factor (ms) for computeTimeoutMs */
+  private static readonly TIMEOUT_PER_BYTE_MS = 5;
+  /** Maximum timeout (ms) for computeTimeoutMs */
+  private static readonly TIMEOUT_MAX_MS = 10000;
+
   /**
    * Compute chunk write timeout based on chunk size.
    * Override to customize timeout formula per platform.
    */
   protected computeTimeoutMs(chunkLength: number): number {
-    return Math.max(1000, Math.min(10000, 1000 + chunkLength * 5));
+    return Math.max(
+      ChunkWriteStrategy.TIMEOUT_BASE_MS,
+      Math.min(
+        ChunkWriteStrategy.TIMEOUT_MAX_MS,
+        ChunkWriteStrategy.TIMEOUT_BASE_MS + chunkLength * ChunkWriteStrategy.TIMEOUT_PER_BYTE_MS
+      )
+    );
   }
 
   /**
@@ -150,99 +169,236 @@ export abstract class ChunkWriteStrategy<TOptions = void> {
   ): Promise<void> {
     const data = new Uint8Array(buffer);
 
-    const chunkSize = Math.max(
-      1,
-      Math.min(256, adapterOptions.chunkSize ?? this.config.defaultChunkSize)
-    );
-    const delay = Math.max(10, Math.min(100, adapterOptions.delay ?? this.config.defaultDelay));
-    const retries = Math.max(1, Math.min(10, adapterOptions.retries ?? this.config.defaultRetries));
-
-    const maxChunkSize = this.getMaxChunkSize(context.deviceId);
-
-    let currentChunkSize = chunkSize;
-    let baseDelay = delay;
-    let totalChunks = Math.ceil(data.length / currentChunkSize);
-
-    this.logger.debug(`Writing ${data.length} bytes in ${totalChunks} chunks`);
-
     if (data.length === 0) {
       this.logger.warn('No data to write');
       return;
     }
 
+    // Initialize transmission parameters
+    const params = this.initializeTransmissionParams(data, adapterOptions);
+    const maxChunkSize = this.getMaxChunkSize(context.deviceId);
+
     // Adaptive transmission state
-    let successCount = 0;
-    let consecutiveFailures = 0;
-    const { minChunkSize, maxDelay, successThreshold, failureThreshold, connectionCheckInterval } =
-      this.config;
+    const adaptiveState = {
+      successCount: 0,
+      consecutiveFailures: 0,
+      currentChunkSize: params.chunkSize,
+      baseDelay: params.delay,
+    };
 
-    for (let i = 0; i < data.length; i += currentChunkSize) {
+    this.logger.debug(
+      `Writing ${data.length} bytes with initial chunkSize=${adaptiveState.currentChunkSize}, delay=${adaptiveState.baseDelay}ms`
+    );
+
+    // Main transmission loop
+    for (let i = 0; i < data.length; i += adaptiveState.currentChunkSize) {
       // Periodic connection state check
-      if (i > 0 && Math.floor(i / currentChunkSize) % connectionCheckInterval === 0) {
-        await this.checkConnection(context.deviceId);
+      await this.maybeCheckConnection(i, adaptiveState.currentChunkSize, context.deviceId);
+
+      // Write current chunk with retries
+      const chunkNum = Math.floor(i / adaptiveState.currentChunkSize) + 1;
+      const writeSuccess = await this.writeChunkWithRetries(
+        data,
+        i,
+        adaptiveState.currentChunkSize,
+        context,
+        chunkNum,
+        params.retries,
+        adaptiveState.baseDelay,
+        platformOptions
+      );
+
+      if (!writeSuccess) {
+        // All retries exhausted - error already thrown
+        return;
       }
 
-      const chunk = data.slice(i, i + currentChunkSize);
-      const chunkNum = Math.floor(i / currentChunkSize) + 1;
-      let attempt = 0;
-      let writeSuccess = false;
-
-      while (attempt <= retries) {
-        const writeResult = await this.writeSingleChunk(chunk, context, platformOptions);
-
-        if (writeResult.success) {
-          this.logger.debug(`Chunk ${chunkNum}/${totalChunks} written successfully`);
-          writeSuccess = true;
-          break;
-        }
-
-        attempt++;
-        if (attempt > retries) {
-          this.logger.error(`Chunk ${chunkNum} failed after ${retries} retries`);
-          throw new BluetoothPrintError(
-            ErrorCode.WRITE_FAILED,
-            `Failed to write chunk ${chunkNum}/${totalChunks}`,
-            writeResult.error ?? new Error('Unknown write error')
-          );
-        }
-
-        this.logger.warn(`Chunk ${chunkNum} write failed, retry ${attempt}/${retries}`);
-
-        const retryDelay = baseDelay * Math.pow(2, attempt - 1);
-        await new Promise(r => setTimeout(r, Math.min(retryDelay, maxDelay)));
+      // Adaptive adjustment
+      this.adjustTransmissionParams(
+        adaptiveState,
+        writeSuccess,
+        maxChunkSize,
+        params.minChunkSize,
+        params.maxDelay,
+        params.successThreshold,
+        params.failureThreshold,
+        chunkNum,
+        i,
+        data.length
+      );
+
+      // Inter-chunk delay
+      await this.maybeDelay(
+        i,
+        adaptiveState.currentChunkSize,
+        data.length,
+        adaptiveState.baseDelay
+      );
+    }
+
+    this.logger.info(`Successfully wrote ${data.length} bytes`);
+  }
+
+  /**
+   * Initialize transmission parameters from adapter options
+   */
+  private initializeTransmissionParams(
+    _data: Uint8Array,
+    options: IAdapterOptions
+  ): {
+    chunkSize: number;
+    delay: number;
+    retries: number;
+    minChunkSize: number;
+    maxDelay: number;
+    successThreshold: number;
+    failureThreshold: number;
+  } {
+    const chunkSize = Math.max(1, Math.min(256, options.chunkSize ?? this.config.defaultChunkSize));
+    const delay = Math.max(10, Math.min(100, options.delay ?? this.config.defaultDelay));
+    const retries = Math.max(1, Math.min(10, options.retries ?? this.config.defaultRetries));
+
+    return {
+      chunkSize,
+      delay,
+      retries,
+      minChunkSize: this.config.minChunkSize,
+      maxDelay: this.config.maxDelay,
+      successThreshold: this.config.successThreshold,
+      failureThreshold: this.config.failureThreshold,
+    };
+  }
+
+  /**
+   * Check connection periodically based on interval
+   */
+  private async maybeCheckConnection(
+    currentIndex: number,
+    chunkSize: number,
+    deviceId: string
+  ): Promise<void> {
+    if (
+      currentIndex > 0 &&
+      Math.floor(currentIndex / chunkSize) % this.config.connectionCheckInterval === 0
+    ) {
+      await this.checkConnection(deviceId);
+    }
+  }
+
+  /**
+   * Write a single chunk with retry logic
+   * @returns true if successful, false if all retries exhausted (error thrown)
+   */
+  private async writeChunkWithRetries(
+    data: Uint8Array,
+    startIndex: number,
+    chunkSize: number,
+    context: ChunkWriteContext,
+    chunkNum: number,
+    maxRetries: number,
+    baseDelay: number,
+    platformOptions?: TOptions
+  ): Promise<boolean> {
+    const chunk = data.slice(startIndex, startIndex + chunkSize);
+    const totalChunks = Math.ceil(data.length / chunkSize);
+
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      const writeResult = await this.writeSingleChunk(chunk, context, platformOptions);
+
+      if (writeResult.success) {
+        this.logger.debug(`Chunk ${chunkNum}/${totalChunks} written successfully`);
+        return true;
       }
 
-      // Adaptive chunk size and delay adjustment
-      if (writeSuccess) {
-        successCount++;
-        consecutiveFailures = 0;
-
-        if (successCount % successThreshold === 0 && currentChunkSize < maxChunkSize) {
-          currentChunkSize = Math.min(maxChunkSize, currentChunkSize + 5);
-          baseDelay = Math.max(baseDelay / 1.2, delay);
-          totalChunks =
-            Math.ceil((data.length - i - currentChunkSize) / currentChunkSize) + chunkNum;
-          this.logger.debug(`Increased chunk size to ${currentChunkSize}, delay to ${baseDelay}`);
-        }
-      } else {
-        consecutiveFailures++;
-
-        if (consecutiveFailures >= failureThreshold && currentChunkSize > minChunkSize) {
-          currentChunkSize = Math.max(minChunkSize, currentChunkSize - 5);
-          baseDelay = Math.min(baseDelay * 1.5, maxDelay);
-          totalChunks =
-            Math.ceil((data.length - i - currentChunkSize) / currentChunkSize) + chunkNum;
-          this.logger.debug(`Decreased chunk size to ${currentChunkSize}, delay to ${baseDelay}`);
-          consecutiveFailures = 0;
-        }
+      if (attempt >= maxRetries) {
+        this.logger.error(`Chunk ${chunkNum} failed after ${maxRetries} retries`);
+        throw new BluetoothPrintError(
+          ErrorCode.WRITE_FAILED,
+          `Failed to write chunk ${chunkNum}/${totalChunks}`,
+          writeResult.error ?? new Error('Unknown write error')
+        );
+      }
+
+      this.logger.warn(`Chunk ${chunkNum} write failed, retry ${attempt + 1}/${maxRetries}`);
+
+      // Exponential backoff
+      const retryDelay = baseDelay * Math.pow(2, attempt);
+      await new Promise(r => setTimeout(r, Math.min(retryDelay, this.config.maxDelay)));
+    }
+
+    return false; // Unreachable, but satisfies TypeScript
+  }
+
+  /**
+   * Adjust chunk size and delay based on success/failure
+   */
+  private adjustTransmissionParams(
+    state: {
+      successCount: number;
+      consecutiveFailures: number;
+      currentChunkSize: number;
+      baseDelay: number;
+    },
+    writeSuccess: boolean,
+    maxChunkSize: number,
+    minChunkSize: number,
+    maxDelay: number,
+    successThreshold: number,
+    failureThreshold: number,
+    _chunkNum: number,
+    _currentIndex: number,
+    _totalLength: number
+  ): void {
+    if (writeSuccess) {
+      state.successCount++;
+      state.consecutiveFailures = 0;
+
+      // Increase chunk size on sustained success
+      if (state.successCount % successThreshold === 0 && state.currentChunkSize < maxChunkSize) {
+        state.currentChunkSize = Math.min(
+          maxChunkSize,
+          state.currentChunkSize + ChunkWriteStrategy.CHUNK_SIZE_STEP
+        );
+        state.baseDelay = Math.max(
+          state.baseDelay / ChunkWriteStrategy.DELAY_RECOVERY_FACTOR,
+          this.config.defaultDelay
+        );
+        this.logger.debug(
+          `Increased chunk size to ${state.currentChunkSize}, delay to ${state.baseDelay}ms`
+        );
       }
+    } else {
+      state.consecutiveFailures++;
 
-      // Inter-chunk delay to prevent BLE congestion
-      if (i + currentChunkSize < data.length) {
-        await new Promise(r => setTimeout(r, baseDelay));
+      // Decrease chunk size on sustained failure
+      if (state.consecutiveFailures >= failureThreshold && state.currentChunkSize > minChunkSize) {
+        state.currentChunkSize = Math.max(
+          minChunkSize,
+          state.currentChunkSize - ChunkWriteStrategy.CHUNK_SIZE_STEP
+        );
+        state.baseDelay = Math.min(
+          state.baseDelay * ChunkWriteStrategy.DELAY_BACKOFF_FACTOR,
+          maxDelay
+        );
+        this.logger.debug(
+          `Decreased chunk size to ${state.currentChunkSize}, delay to ${state.baseDelay}ms`
+        );
+        state.consecutiveFailures = 0;
       }
     }
+  }
 
-    this.logger.info(`Successfully wrote ${data.length} bytes`);
+  /**
+   * Apply inter-chunk delay to prevent BLE congestion
+   */
+  private async maybeDelay(
+    currentIndex: number,
+    chunkSize: number,
+    totalLength: number,
+    delay: number
+  ): Promise<void> {
+    if (currentIndex + chunkSize < totalLength) {
+      await new Promise(r => setTimeout(r, delay));
+    }
   }
 }

package/src/adapters/QQAdapter.ts

@@ -5,9 +5,8 @@
 
 import { MiniProgramAdapter, MiniProgramBLEApi } from './BaseAdapter';
 
-// Declare QQ global for TypeScript
-// eslint-disable-next-line @typescript-eslint/no-empty-object-type
-interface QQGlobal extends MiniProgramBLEApi {}
+// QQ global type for TypeScript
+type QQGlobal = MiniProgramBLEApi;
 
 declare const qq: QQGlobal;
 

package/src/adapters/ReactNativeAdapter.ts

@@ -193,13 +193,14 @@ export class ReactNativeAdapter extends BaseAdapter implements IPrinterAdapter {
    *
    * @param options - Configuration options
    * @param options.bleManager - BLE Manager instance (e.g., from react-native-ble-plx)
-   * @throws {Error} If bleManager is not provided or not supported
+   * @throws {BluetoothPrintError} If bleManager is not provided or not supported
    */
   constructor(options: { bleManager: BLEManager }) {
     super();
 
     if (!options?.bleManager) {
-      throw new Error(
+      throw new BluetoothPrintError(
+        ErrorCode.INVALID_CONFIGURATION,
         'ReactNativeAdapter requires a bleManager instance (e.g., react-native-ble-plx). ' +
           'Please pass { bleManager: yourBleManager } in the constructor.'
       );
@@ -251,26 +252,7 @@ export class ReactNativeAdapter extends BaseAdapter implements IPrinterAdapter {
       this.updateState(PrinterState.DISCONNECTED);
       this.cleanupDevice(deviceId);
 
-      const errorMsg = normalizeError(error).message;
-      if (errorMsg.includes('timeout')) {
-        throw new BluetoothPrintError(
-          ErrorCode.CONNECTION_TIMEOUT,
-          `Connection to device ${deviceId} timed out`,
-          normalizeError(error)
-        );
-      } else if (errorMsg.includes('not found') || errorMsg.includes('not exist')) {
-        throw new BluetoothPrintError(
-          ErrorCode.DEVICE_NOT_FOUND,
-          `Device ${deviceId} not found`,
-          normalizeError(error)
-        );
-      }
-
-      throw new BluetoothPrintError(
-        ErrorCode.CONNECTION_FAILED,
-        `Failed to connect to device ${deviceId}`,
-        normalizeError(error)
-      );
+      throw this.classifyConnectionError(error, deviceId);
     }
   }
 
@@ -370,7 +352,6 @@ export class ReactNativeAdapter extends BaseAdapter implements IPrinterAdapter {
       try {
         this.bleManager.startDeviceScan(null, { allowDuplicates: false }, (error: unknown) => {
           if (error) {
-            // eslint-disable-next-line @typescript-eslint/no-base-to-string
             reject(normalizeError(error));
           }
         });
@@ -398,47 +379,21 @@ export class ReactNativeAdapter extends BaseAdapter implements IPrinterAdapter {
    * @param device - Connected device object
    */
   private async discoverServices(deviceId: string, _device: RNDevice): Promise<void> {
-    Logger.scope('ReactNativeAdapter').debug('Discovering services for device:', deviceId);
-
-    try {
+    await this.discoverAndCacheServices(deviceId, async () => {
       const servicesResult = await (this.bleManager.discoverAllServicesAndCharacteristicsForDevice(
         deviceId
       ) as Promise<{ services: RNService[] }>);
 
       const services = servicesResult.services || [];
 
-      for (const service of services) {
-        const writeChar = service.characteristics.find(
-          (c: RNCharacteristic) => c.isWritableWithResponse || c.isWritableWithoutResponse
-        );
-
-        if (writeChar) {
-          this.serviceCache.set(deviceId, {
-            serviceId: service.uuid,
-            characteristicId: writeChar.uuid,
-          });
-          Logger.scope('ReactNativeAdapter').info('Found writeable characteristic:', {
-            service: service.uuid,
-            characteristic: writeChar.uuid,
-          });
-          return;
-        }
-      }
-
-      throw new BluetoothPrintError(
-        ErrorCode.CHARACTERISTIC_NOT_FOUND,
-        'No writeable characteristic found. Make sure the device is a supported printer.'
-      );
-    } catch (error) {
-      if (error instanceof BluetoothPrintError) {
-        throw error;
-      }
-      throw new BluetoothPrintError(
-        ErrorCode.SERVICE_DISCOVERY_FAILED,
-        'Failed to discover device services',
-        normalizeError(error)
-      );
-    }
+      return services.map(service => ({
+        serviceId: service.uuid,
+        characteristics: service.characteristics.map((c: RNCharacteristic) => ({
+          characteristicId: c.uuid,
+          isWritable: c.isWritableWithResponse || c.isWritableWithoutResponse,
+        })),
+      }));
+    });
   }
 
   /**

package/src/adapters/TaroAdapter.ts

@@ -5,9 +5,8 @@
 
 import { MiniProgramAdapter, MiniProgramBLEApi } from './BaseAdapter';
 
-// Declare Taro global for TypeScript
-// eslint-disable-next-line @typescript-eslint/no-empty-object-type
-interface TaroGlobal extends MiniProgramBLEApi {}
+// Taro global type for TypeScript
+type TaroGlobal = MiniProgramBLEApi;
 
 declare const Taro: TaroGlobal;
 

package/src/adapters/WebBluetoothAdapter.ts

@@ -413,9 +413,7 @@ export class WebBluetoothAdapter extends BaseAdapter {
     }
 
     // Use device.id if available, otherwise fall back to generated ID
-    const deviceId = device.id || this.generateFallbackDeviceId(device);
-
-    return deviceId;
+    return device.id || this.generateFallbackDeviceId(device);
   }
 
   /**

package/src/barcode/BarcodeGenerator.ts

@@ -566,8 +566,7 @@ export class BarcodeGenerator implements IBarcodeGenerator {
    */
   private validateCode39(content: string, errors: ValidationResult['errors']): void {
     // Code 39 supports: 0-9, A-Z, space, - . $ / + %
-    // eslint-disable-next-line no-useless-escape
-    const validChars = /^[0-9A-Z\s\-.$\/+%]+$/;
+    const validChars = /^[0-9A-Z\s\-.$/+%]+$/;
     if (!validChars.test(content.toUpperCase())) {
       errors.push({
         field: 'content',