@ives_xxz/framework 1.0.0

package/utils/FWTask.ts

@@ -0,0 +1,223 @@
+import { FWEventDefine } from '../define/FWEventDefine';
+import { FWSystemDefine } from '../define/FWSystemDefine';
+import FWLog from '../log/FWLog';
+
+export default class FWTask implements FW.Task {
+  private taskQueue: FW.TaskGenerator[] = [];
+  private status: FWSystemDefine.FWTaskStatus = FWSystemDefine.FWTaskStatus.IDLE;
+  private isPaused = false;
+  private frameBudget: number;
+  private tasksFrameCount: number;
+  private taskCounter: number;
+  private totalTaskDuration: number;
+  private taskStartTime: string;
+  private log: boolean;
+  private performanceData: {
+    frameTimes: number[];
+    detailedFrames: FW.FrameDetail[];
+    events: FW.TaskEvent[];
+  };
+
+  readonly id: number;
+
+  constructor(options: FW.TaskOptions) {
+    this.id = options.taskId || Date.now();
+    this.taskCounter = 0;
+    this.totalTaskDuration = 0;
+    this.log = options.log ?? true;
+    this.frameBudget = options.frameBudget ?? 16;
+    this.tasksFrameCount = options.tasksFrameCount ?? 3;
+    this.performanceData = {
+      frameTimes: [],
+      detailedFrames: [],
+      events: [],
+    };
+  }
+
+  async start(generator: FW.TaskFunction): Promise<FW.Task> {
+    this.reset();
+    const taskId = `TaskId:${this.id}->TaskCounter${this.taskCounter++}`;
+    const gen = generator();
+    (gen as any).taskId = taskId;
+    this.taskQueue = [gen];
+    this.status = FWSystemDefine.FWTaskStatus.RUNNING;
+    this.recordEvent({
+      type: FWEventDefine.TaskEvent.START,
+      message: '任务开始',
+      taskId,
+    });
+    this.taskStartTime = FW.Entry.timeMgr.getTime();
+    await this.executeFrame();
+    return this;
+  }
+
+  async add(generator: FW.TaskFunction): Promise<FW.Task> {
+    const taskId = `TaskId:${this.id}->TaskCounter${this.taskCounter++}`;
+    const gen = generator();
+    (gen as any).taskId = taskId;
+    this.taskQueue.push(gen);
+    this.recordEvent({
+      type: FWEventDefine.TaskEvent.PROGRESS,
+      message: '新任务加入队列',
+      taskId,
+    });
+    if (this.status !== FWSystemDefine.FWTaskStatus.RUNNING && !this.isPaused) {
+      this.status = FWSystemDefine.FWTaskStatus.RUNNING;
+      await this.executeFrame();
+    }
+    return this;
+  }
+
+  pause(): void {
+    this.isPaused = true;
+    this.status = FWSystemDefine.FWTaskStatus.PAUSED;
+    this.recordEvent({
+      type: FWEventDefine.TaskEvent.PAUSE,
+      message: '任务已暂停',
+    });
+  }
+
+  resume(): void {
+    if (this.taskQueue.length === 0) return;
+
+    this.isPaused = false;
+    this.status = FWSystemDefine.FWTaskStatus.RUNNING;
+    this.recordEvent({
+      type: FWEventDefine.TaskEvent.PROGRESS,
+      message: '任务已恢复',
+    });
+    this.executeFrame();
+  }
+
+  reset(): void {
+    this.taskQueue = [];
+    this.status = FWSystemDefine.FWTaskStatus.IDLE;
+    this.isPaused = false;
+    this.performanceData = {
+      frameTimes: [],
+      detailedFrames: [],
+      events: [],
+    };
+  }
+
+  getStatus(): FWSystemDefine.FWTaskStatus {
+    return this.status;
+  }
+
+  private async executeFrame(): Promise<void> {
+    if (this.isPaused || this.taskQueue.length === 0) return;
+
+    const frameStart = performance.now();
+    let processed = 0;
+    let frameTasks: FW.TaskExecutionRecord[] = [];
+    const startTime = FW.Entry.timeMgr.getTime();
+
+    while (
+      this.taskQueue.length > 0 &&
+      processed < this.tasksFrameCount &&
+      performance.now() - frameStart < this.frameBudget
+    ) {
+      const task = this.taskQueue[0];
+
+      const taskId = (task as any).taskId || `id-${processed}`;
+
+      const result = await task.next();
+
+      if (result.done) {
+        this.taskQueue.shift();
+        this.recordEvent({
+          type: FWEventDefine.TaskEvent.COMPLETE,
+          progress: 1,
+          message: '任务完成',
+          taskId,
+        });
+      } else if (result.value) {
+        this.recordEvent({
+          ...result.value,
+          taskId,
+        });
+      }
+
+      frameTasks.push({
+        taskId: taskId,
+        result: result.done ? FWEventDefine.TaskEvent.COMPLETE : FWEventDefine.TaskEvent.YIELDED,
+        message: (result?.value as any)?.message,
+      });
+
+      processed++;
+    }
+
+    const frameTime = performance.now() - frameStart;
+    this.totalTaskDuration += frameTime;
+    this.performanceData.frameTimes.push(frameTime);
+    this.performanceData.detailedFrames.push({
+      frameStart: startTime,
+      frameEnd: FW.Entry.timeMgr.getTime(),
+      frameTime: frameTime,
+      tasksProcessed: processed,
+      tasks: frameTasks,
+      frameBudget: this.frameBudget,
+      frameBudgetUsed: frameTime / this.frameBudget,
+    });
+
+    if (this.taskQueue.length === 0) {
+      this.status = FWSystemDefine.FWTaskStatus.COMPLETED;
+      this.recordEvent({
+        type: FWEventDefine.TaskEvent.ALL_COMPLETE,
+        progress: 1,
+        message: '所有任务完成',
+      });
+      FWLog.system('任务性能报告->', this.getPerformanceReport());
+      return;
+    }
+
+    requestAnimationFrame(async () => await this.executeFrame());
+  }
+
+  getPerformanceReport(): FW.PerformanceReport {
+    const frameTimes = this.performanceData.frameTimes;
+    const avgFrameTime = frameTimes.reduce((sum, t) => sum + t, 0) / frameTimes.length || 0;
+
+    const frameDurations = [];
+    for (let i = 1; i < frameTimes.length; i++) {
+      frameDurations.push(frameTimes[i] - frameTimes[i - 1]);
+    }
+    const avgFrameDuration =
+      frameDurations.reduce((sum, d) => sum + d, 0) / frameDurations.length || 0;
+    const frameJitter =
+      frameDurations.reduce((sum, d) => sum + Math.abs(d - avgFrameDuration), 0) /
+        frameDurations.length || 0;
+
+    const budgetUsage =
+      this.performanceData.detailedFrames
+        .map((f) => f.frameBudgetUsed)
+        .reduce((sum, u) => sum + u, 0) / this.performanceData.detailedFrames.length || 0;
+
+    return {
+      startTime: this.taskStartTime,
+      endTime: FW.Entry.timeMgr.getTime(),
+      totalTasks: this.performanceData.detailedFrames.length,
+      totalFrames: frameTimes.length,
+      totalDuration: Number((this.totalTaskDuration / 1000).toFixed(2)),
+      avgFrameTime: avgFrameTime,
+      longestFrame: Math.max(...frameTimes),
+      shortestFrame: Math.min(...frameTimes),
+      frameJitter: frameJitter,
+      budgetUsage: budgetUsage,
+      timeline: this.performanceData.events.map((e) => ({
+        taskId: e.taskId,
+        type: e.type,
+        progress: e.progress,
+        message: e.message,
+      })),
+      frameDetails: [...this.performanceData.detailedFrames],
+    };
+  }
+
+  private recordEvent(event: FW.TaskEvent): void {
+    this.performanceData.events.push(event);
+    if (this.log) {
+      FWLog.debug(`[任务${this.id}]`, event.message || `${event.type} ${event.progress}%`);
+    }
+  }
+}

package/utils/FWTask.ts.meta

@@ -0,0 +1,10 @@
+{
+  "ver": "1.1.0",
+  "uuid": "f84e273f-f5fb-4938-a45d-0d22c7cb05c1",
+  "importer": "typescript",
+  "isPlugin": false,
+  "loadPluginInWeb": true,
+  "loadPluginInNative": true,
+  "loadPluginInEditor": false,
+  "subMetas": {}
+}

package/utils.meta

@@ -0,0 +1,13 @@
+{
+  "ver": "1.1.3",
+  "uuid": "8f19d5ca-c389-4ba5-8a8c-6cd9e75a256f",
+  "importer": "folder",
+  "isBundle": false,
+  "bundleName": "",
+  "priority": 1,
+  "compressionType": {},
+  "optimizeHotUpdate": {},
+  "inlineSpriteFrames": {},
+  "isRemoteBundle": {},
+  "subMetas": {}
+}