taro-bluetooth-print 2.3.1 → 2.4.0

package/src/services/PrintHistory.ts

@@ -0,0 +1,336 @@
+/**
+ * Print History Service
+ *
+ * Tracks all print jobs with timestamps, status, and metadata.
+ * Provides querying and analytics capabilities.
+ *
+ * @example
+ * ```typescript
+ * const history = new PrintHistory();
+ * history.addJob({ data, status: 'completed' });
+ * const recentJobs = history.getRecent(10);
+ * ```
+ */
+
+import { Logger } from '@/utils/logger';
+import { PrintJobStatus, PrintJobPriority } from '@/queue/PrintQueue';
+
+/**
+ * Print history entry
+ */
+export interface PrintHistoryEntry {
+  /** Unique entry ID */
+  id: string;
+  /** Job ID from PrintJobManager */
+  jobId?: string;
+  /** Print data size in bytes */
+  dataSize: number;
+  /** Job status */
+  status: PrintJobStatus | 'unknown';
+  /** Priority */
+  priority: PrintJobPriority;
+  /** Creation timestamp */
+  createdAt: number;
+  /** Start timestamp */
+  startedAt?: number;
+  /** Completion timestamp */
+  completedAt?: number;
+  /** Duration in milliseconds */
+  duration?: number;
+  /** Error message if failed */
+  error?: string;
+  /** Device ID */
+  deviceId?: string;
+  /** Device name */
+  deviceName?: string;
+  /** Metadata */
+  metadata?: Record<string, unknown>;
+}
+
+/**
+ * History statistics
+ */
+export interface PrintHistoryStats {
+  /** Total jobs */
+  total: number;
+  /** Completed jobs */
+  completed: number;
+  /** Failed jobs */
+  failed: number;
+  /** Cancelled jobs */
+  cancelled: number;
+  /** Average duration in ms */
+  avgDuration: number;
+  /** Total bytes printed */
+  totalBytes: number;
+  /** Success rate */
+  successRate: number;
+}
+
+/**
+ * Query options for history
+ */
+export interface HistoryQueryOptions {
+  /** Start date filter */
+  startDate?: number;
+  /** End date filter */
+  endDate?: number;
+  /** Status filter */
+  status?: PrintJobStatus | PrintJobStatus[];
+  /** Device ID filter */
+  deviceId?: string;
+  /** Limit results */
+  limit?: number;
+  /** Offset for pagination */
+  offset?: number;
+}
+
+/**
+ * Print History Service
+ */
+export class PrintHistory {
+  private readonly logger = Logger.scope('PrintHistory');
+  private readonly entries: Map<string, PrintHistoryEntry> = new Map();
+  private counter = 0;
+  private readonly maxEntries: number;
+
+  /**
+   * Creates a new PrintHistory instance
+   * @param maxEntries - Maximum number of entries to keep (default: 1000)
+   */
+  constructor(maxEntries = 1000) {
+    this.maxEntries = maxEntries;
+  }
+
+  /**
+   * Add a new print job to history
+   */
+  addJob(params: {
+    jobId?: string;
+    data: Uint8Array;
+    status: PrintJobStatus | 'unknown';
+    priority?: PrintJobPriority;
+    deviceId?: string;
+    deviceName?: string;
+    metadata?: Record<string, unknown>;
+  }): string {
+    const id = this.generateId();
+    const now = Date.now();
+
+    const entry: PrintHistoryEntry = {
+      id,
+      jobId: params.jobId,
+      dataSize: params.data.length,
+      status: params.status,
+      priority: params.priority ?? PrintJobPriority.NORMAL,
+      createdAt: now,
+      deviceId: params.deviceId,
+      deviceName: params.deviceName,
+      metadata: params.metadata,
+    };
+
+    this.entries.set(id, entry);
+    this.enforceMaxEntries();
+
+    this.logger.debug(`History entry added: ${id}`);
+    return id;
+  }
+
+  /**
+   * Update job status
+   */
+  updateJob(id: string, updates: Partial<{
+    status: PrintJobStatus | 'unknown';
+    startedAt: number;
+    completedAt: number;
+    error: string;
+  }>): void {
+    const entry = this.entries.get(id);
+    if (!entry) {
+      this.logger.warn(`History entry not found: ${id}`);
+      return;
+    }
+
+    Object.assign(entry, updates);
+
+    if (updates.startedAt) {
+      entry.startedAt = updates.startedAt;
+    }
+
+    if (updates.completedAt) {
+      entry.completedAt = updates.completedAt;
+      if (entry.startedAt) {
+        entry.duration = updates.completedAt - entry.startedAt;
+      }
+    }
+
+    if (updates.error) {
+      entry.error = updates.error;
+    }
+
+    if (updates.status) {
+      entry.status = updates.status;
+    }
+
+    this.logger.debug(`History entry updated: ${id}`);
+  }
+
+  /**
+   * Get entry by ID
+   */
+  getEntry(id: string): PrintHistoryEntry | undefined {
+    return this.entries.get(id);
+  }
+
+  /**
+   * Get recent jobs
+   */
+  getRecent(count = 10): PrintHistoryEntry[] {
+    return Array.from(this.entries.values())
+      .sort((a, b) => b.createdAt - a.createdAt)
+      .slice(0, count);
+  }
+
+  /**
+   * Query history with filters
+   */
+  query(options: HistoryQueryOptions = {}): PrintHistoryEntry[] {
+    let results = Array.from(this.entries.values());
+
+    if (options.startDate) {
+      results = results.filter(e => e.createdAt >= options.startDate!);
+    }
+
+    if (options.endDate) {
+      results = results.filter(e => e.createdAt <= options.endDate!);
+    }
+
+    if (options.status) {
+      const statuses = Array.isArray(options.status) ? options.status : [options.status];
+      results = results.filter(e => statuses.includes(e.status as PrintJobStatus));
+    }
+
+    if (options.deviceId) {
+      results = results.filter(e => e.deviceId === options.deviceId);
+    }
+
+    // Sort by creation date descending
+    results.sort((a, b) => b.createdAt - a.createdAt);
+
+    // Pagination
+    if (options.offset) {
+      results = results.slice(options.offset);
+    }
+
+    if (options.limit) {
+      results = results.slice(0, options.limit);
+    }
+
+    return results;
+  }
+
+  /**
+   * Get statistics
+   */
+  getStats(options?: { days?: number }): PrintHistoryStats {
+    let entries = Array.from(this.entries.values());
+
+    // Filter by days if specified
+    if (options?.days) {
+      const cutoff = Date.now() - options.days * 24 * 60 * 60 * 1000;
+      entries = entries.filter(e => e.createdAt >= cutoff);
+    }
+
+    const completed = entries.filter(e => e.status === PrintJobStatus.COMPLETED);
+    const failed = entries.filter(e => 
+      e.status === PrintJobStatus.FAILED || e.error
+    );
+    const cancelled = entries.filter(e => e.status === PrintJobStatus.CANCELLED);
+
+    const totalDuration = completed
+      .filter(e => e.duration !== undefined)
+      .reduce((sum, e) => sum + (e.duration || 0), 0);
+
+    const totalBytes = entries.reduce((sum, e) => sum + e.dataSize, 0);
+
+    return {
+      total: entries.length,
+      completed: completed.length,
+      failed: failed.length,
+      cancelled: cancelled.length,
+      avgDuration: completed.length > 0 ? totalDuration / completed.length : 0,
+      totalBytes,
+      successRate: entries.length > 0 ? (completed.length / entries.length) * 100 : 0,
+    };
+  }
+
+  /**
+   * Clear all history
+   */
+  clear(): void {
+    this.entries.clear();
+    this.logger.info('Print history cleared');
+  }
+
+  /**
+   * Export history as JSON
+   */
+  export(): string {
+    return JSON.stringify(Array.from(this.entries.values()), null, 2);
+  }
+
+  /**
+   * Import history from JSON
+   */
+  import(json: string): number {
+    try {
+      const data = JSON.parse(json) as PrintHistoryEntry[];
+      let imported = 0;
+
+      for (const entry of data) {
+        if (entry.id && entry.dataSize) {
+          this.entries.set(entry.id, entry);
+          imported++;
+        }
+      }
+
+      this.enforceMaxEntries();
+      this.logger.info(`Imported ${imported} history entries`);
+      return imported;
+    } catch (error) {
+      this.logger.error('Failed to import history:', error);
+      return 0;
+    }
+  }
+
+  /**
+   * Generate unique ID
+   */
+  private generateId(): string {
+    this.counter++;
+    return `history_${Date.now()}_${this.counter}`;
+  }
+
+  /**
+   * Enforce maximum entries limit
+   */
+  private enforceMaxEntries(): void {
+    if (this.entries.size <= this.maxEntries) {
+      return;
+    }
+
+    // Remove oldest entries
+    const sorted = Array.from(this.entries.entries())
+      .sort((a, b) => a[1].createdAt - b[1].createdAt);
+
+    const toRemove = sorted.slice(0, this.entries.size - this.maxEntries);
+    for (const [id] of toRemove) {
+      this.entries.delete(id);
+    }
+
+    this.logger.debug(`Pruned ${toRemove.length} old history entries`);
+  }
+}
+
+// Export singleton instance
+export const printHistory = new PrintHistory();

package/src/services/PrintJobManager.ts

@@ -1,7 +1,8 @@
 /**
  * Print Job Manager Service
  *
- * Manages print jobs, including pause/resume/cancel functionality
+ * Manages print jobs, including pause/resume/cancel functionality.
+ * Supports job state persistence for resume capability.
  */
 
 import type { IPrinterAdapter } from '@/types';
@@ -37,8 +38,19 @@ interface SavedJobState {
  * Print Job Manager implementation
  */
 export class PrintJobManager implements IPrintJobManager {
-  /** 内存中的任务状态存储（可被子类或外部替换为持久化方案） */
-  private static jobStateStore: Map<string, SavedJobState> = new Map();
+  /** Instance-level job state storage (per-printer support) */
+  private instanceJobStateStore: Map<string, SavedJobState> = new Map();
+  
+  /** Static job state store for backward compatibility */
+  private static _jobStateStore: Map<string, SavedJobState> = new Map();
+  
+  /**
+   * Get the static job state store (for backward compatibility)
+   * @deprecated Use instance-level store instead for multi-printer support
+   */
+  private static get jobStateStore(): Map<string, SavedJobState> {
+    return PrintJobManager._jobStateStore;
+  }
   private adapter: IPrinterAdapter;
   private connectionManager: IConnectionManager;
   private jobBuffer: Uint8Array | null = null;
@@ -221,8 +233,8 @@ export class PrintJobManager implements IPrintJobManager {
   /**
    * Saves the current job state for resume later.
    *
-   * 默认实现使用内存存储。如需持久化（如 localStorage），
-   * 可通过 setSaveHandler/setLoadHandler 自定义。
+   * Uses instance-level storage by default. Falls back to static store
+   * for backward compatibility.
    */
   private saveJobState(): void {
     if (!this.jobBuffer || !this.jobId) {
@@ -230,14 +242,16 @@ export class PrintJobManager implements IPrintJobManager {
     }
 
     try {
-      const state = {
+      const state: SavedJobState = {
         jobId: this.jobId,
         jobBuffer: Array.from(this.jobBuffer),
         jobOffset: this.jobOffset,
-        adapterOptions: this.adapterOptions,
+        adapterOptions: { ...this.adapterOptions },
         timestamp: Date.now(),
       };
 
+      // Save to both instance and static store for backward compatibility
+      this.instanceJobStateStore.set(this.jobId, state);
       PrintJobManager.jobStateStore.set(this.jobId, state);
 
       this.logger.debug(
@@ -257,13 +271,17 @@ export class PrintJobManager implements IPrintJobManager {
     try {
       this.logger.debug(`Loading job state for ${jobId}`);
 
-      const savedState = PrintJobManager.jobStateStore.get(jobId);
+      // Try instance store first, then fall back to static store
+      let savedState = this.instanceJobStateStore.get(jobId);
+      if (!savedState) {
+        savedState = PrintJobManager.jobStateStore.get(jobId);
+      }
 
       if (savedState) {
         this.jobId = savedState.jobId;
         this.jobBuffer = new Uint8Array(savedState.jobBuffer);
         this.jobOffset = savedState.jobOffset;
-        this.adapterOptions = savedState.adapterOptions;
+        this.adapterOptions = { ...savedState.adapterOptions };
         this._isPaused = true;
         this._isInProgress = true;
         this.logger.info(
@@ -288,6 +306,8 @@ export class PrintJobManager implements IPrintJobManager {
   private clearJobState(): void {
     if (this.jobId) {
       this.logger.debug(`Clearing job state for ${this.jobId}`);
+      // Clear from both stores
+      this.instanceJobStateStore.delete(this.jobId);
       PrintJobManager.jobStateStore.delete(this.jobId);
     }
 
@@ -297,6 +317,46 @@ export class PrintJobManager implements IPrintJobManager {
     this.adapterOptions = {};
   }
 
+  /**
+   * Cleanup resources and clear all job state.
+   * Call this when the printer is no longer needed.
+   */
+  destroy(): void {
+    this.cancel();
+    this.instanceJobStateStore.clear();
+    this.onProgress = undefined;
+    this.onJobStateChange = undefined;
+    this.logger.info('PrintJobManager destroyed');
+  }
+
+  /**
+   * Clean up expired job states from static store.
+   * Call this periodically to prevent memory leaks.
+   * 
+   * @param maxAge - Maximum age in ms (default: 1 hour)
+   */
+  static cleanupExpiredJobs(maxAge = 3600000): number {
+    const now = Date.now();
+    let cleaned = 0;
+
+    for (const [jobId, state] of PrintJobManager.jobStateStore.entries()) {
+      if (now - state.timestamp > maxAge) {
+        PrintJobManager.jobStateStore.delete(jobId);
+        cleaned++;
+      }
+    }
+
+    return cleaned;
+  }
+
+  /**
+   * Get count of pending job states in static store.
+   * Useful for debugging memory usage.
+   */
+  static getStaticStoreSize(): number {
+    return PrintJobManager.jobStateStore.size;
+  }
+
   /**
    * Emits job state change event
    *