@tencentcloud/trtc-cloud-wx 0.0.20-beta.4 → 0.0.20-beta.5

package/src/TaskMachine.ts

@@ -0,0 +1,372 @@
+export enum Handletype {
+  setPusher = 'setPusher',
+  setPlayer = 'setPlayer'
+}
+// 数字越高，set优先级越高
+export const TaskMap = {
+  enterRoom: {priority: 0, type: Handletype.setPusher},
+  switchRole: {priority: 1, type: Handletype.setPusher},
+  startLocalPreview: {priority: 0, type: Handletype.setPusher},
+  stopLocalPreview: {priority: 0, type: Handletype.setPusher},
+  muteLocalVideo: {priority: 1, type: Handletype.setPusher},
+  setVideoEncoderParam: {priority: 0, type: Handletype.setPusher},
+  setLocalRenderParams: {priority: 0, type: Handletype.setPusher},
+  startLocalAudio: {priority: 0, type: Handletype.setPusher},
+  stopLocalAudio: {priority: 0, type: Handletype.setPusher},
+  muteLocalAudio: {priority: 1, type: Handletype.setPusher},
+  switchCamera: {priority: 0, type: Handletype.setPusher},
+  setBeautyStyle: {priority: 0, type: Handletype.setPusher},
+  exitRoom: {priority: 9, type: Handletype.setPusher},
+  startRemoteView: {priority: 0, type: Handletype.setPlayer},
+  updateRemoteView: {priority: 0, type: Handletype.setPlayer},
+  stopAllRemoteView: {priority: 1, type: Handletype.setPlayer},
+  muteRemoteVideoStream: {priority: 1, type: Handletype.setPlayer},
+  muteAllRemoteVideoStreams: {priority: 1, type: Handletype.setPlayer},
+  setRemoteRenderParams: {priority: 0, type: Handletype.setPlayer},
+  muteRemoteAudio: {priority: 1, type: Handletype.setPlayer},
+  muteAllRemoteAudio: {priority: 1, type: Handletype.setPlayer},
+}
+interface TaskOptions {
+  ctx: any;
+  priority?: number;
+  action: Function;
+  args: any;
+  resolve: Function;
+  reject: Function;
+  name: string;
+}
+class Task {
+  public ctx: any;
+
+  public priority: number;
+
+  public action: Function
+
+  public sequenceNumber: number
+
+  public args: any
+
+  public resolve: Function
+
+  public reject: Function
+
+  public name: string
+
+  public single: boolean
+
+  public type: Handletype
+
+  public result: any
+
+  public err: any
+
+  static nextSequenceNumber = 0;
+
+
+  constructor(optinos: TaskOptions) {
+    const {
+      priority = 0, action, args, resolve, reject, ctx, name
+    } = optinos
+    this.ctx = ctx
+    this.priority = priority
+    this.action = action
+    this.args = args
+    this.resolve = resolve
+    this.reject = reject
+    this.name = name
+    this.single = this.whetherSingle(name)
+    this.type = TaskMap[name]?.type || Handletype.setPusher
+    this.sequenceNumber = Task.nextSequenceNumber++
+  }
+
+  whetherSingle(funName: string): boolean {
+    switch (funName) {
+      case 'enterRoom':
+        return true
+      default:
+        return false
+    }
+  }
+}
+
+export enum TaskQueueState {
+  IDLE = 'idle',
+  PENDING = 'pending',
+  PROCESS = 'process',
+}
+
+export enum TaskQueueEvent {
+  SET = 'SET',
+  SETPROCESS = 'SETPROCESS',
+  SETDONE = 'SETDONE',
+}
+
+export class TaskMachine {
+  public state: TaskQueueState;
+
+  private isProcessing = false; // 表示 pusherTaskQueue 是否正在处理
+
+  private pusherDomReady = false
+
+  private pusherTaskQueue = [] as Task[]; // 存储所有 pusher 任务
+
+  private playerTasks: Record<
+    string, {taskQueue: Task[]; isProcessing: boolean; domReady: boolean}
+  > = {}; // 存储每个 player 的任务队列
+
+  constructor() {
+    this.state = TaskQueueState.IDLE
+  }
+
+  reset(): void {
+    this.state = TaskQueueState.IDLE
+    this.resetPusherTasks()
+    for (const key in this.playerTasks) {
+      if (this.playerTasks[key]) {
+        this.resetPlayerTasks(key)
+      }
+    }
+    this.playerTasks = {}
+  }
+
+  resetPusherTasks(): void {
+    this.isProcessing = false
+    this.pusherDomReady = false
+    this.pusherTaskQueue.forEach((task) => {
+      task.resolve()
+    })
+    this.pusherTaskQueue.length = 0
+  }
+
+  resetPlayerTasks(view: string): void {
+    if (this.playerTasks[view]) {
+      this.playerTasks[view].taskQueue.forEach(task => {
+        task.resolve()
+      })
+      this.playerTasks[view].taskQueue.length = 0
+      this.playerTasks[view].isProcessing = false
+      this.playerTasks[view].domReady = false
+    }
+  }
+
+  setPusherDomReady(isReady: boolean): boolean {
+    this.pusherDomReady = isReady
+    if (!isReady) {
+      this.resetPusherTasks()
+    }
+    return this.pusherDomReady
+  }
+
+  setPlayerDomReady(view: string, isReady: boolean): void {
+    if (!this.playerTasks[view]) {
+      this.playerTasks[view] = {taskQueue: [], isProcessing: false, domReady: false}
+    }
+    this.playerTasks[view].domReady = isReady
+    if (isReady) {
+      this.processPlayerTasks(view)
+    } else {
+      this.resetPlayerTasks(view)
+    }
+  }
+
+  send(event: TaskQueueEvent, view?: string): void {
+    switch (this.state) {
+      case TaskQueueState.IDLE:
+        if (event === TaskQueueEvent.SET) {
+          this.state = TaskQueueState.PENDING
+          if (view) {
+            this.processPlayerTasks(view)
+          } else {
+            this.processPusherTasks()
+          }
+        }
+        break
+      case TaskQueueState.PENDING:
+        if (event === TaskQueueEvent.SETPROCESS) {
+          if (view) {
+            this.processPlayerTasks(view)
+          } else {
+            this.processPusherTasks()
+          }
+        }
+        if (event === TaskQueueEvent.SETDONE) {
+          this.state = TaskQueueState.IDLE
+        }
+        break
+      case TaskQueueState.PROCESS:
+        if (event === TaskQueueEvent.SETDONE) {
+          this.state = TaskQueueState.IDLE
+        }
+        break
+      default:
+        break
+    }
+  }
+
+  addTask(task: Task): void {
+    if (task.type === Handletype.setPusher) {
+      this.addPusherTask(task)
+    } else {
+      this.addPlayerTask(task.args.view, task)
+    }
+  }
+
+  private addPusherTask(task: Task): void {
+    this.addTaskToQueue(task, this.pusherTaskQueue)
+    if (this.state === TaskQueueState.PROCESS && !this.isProcessing) {
+      this.processPusherTasks()
+    } else if (this.state === TaskQueueState.IDLE) {
+      this.send(TaskQueueEvent.SET)
+    } else if (this.state === TaskQueueState.PENDING) {
+      this.send(TaskQueueEvent.SETPROCESS)
+    }
+  }
+
+  private addPlayerTask(view: string, task: Task): void {
+    if (!this.playerTasks[view]) {
+      this.playerTasks[view] = {taskQueue: [], isProcessing: false, domReady: false}
+    }
+    this.addTaskToQueue(task, this.playerTasks[view].taskQueue)
+    if (this.state === TaskQueueState.PROCESS && !this.playerTasks[view].isProcessing) {
+      this.processPlayerTasks(view)
+    } else if (this.state === TaskQueueState.IDLE) {
+      this.send(TaskQueueEvent.SET, view)
+    } else if (this.state === TaskQueueState.PENDING) {
+      this.send(TaskQueueEvent.SETPROCESS, view)
+    }
+  }
+
+  private addTaskToQueue(task: Task, queue: Task[]): void {
+    queue.push(task)
+    queue.sort((a, b) => {
+      if (a.priority !== b.priority) {
+        return a.priority - b.priority
+      }
+      return a.sequenceNumber - b.sequenceNumber
+    })
+  }
+
+  /**
+   * 处理任务队列
+   * @param taskQueue
+   * @param isProcessing
+   * @param domReady
+   * @param setProcessing
+   * @returns
+   */
+  private async processTasks(
+    taskQueue: Task[],
+    isProcessing: boolean,
+    domReady: boolean,
+    setProcessing: (value: boolean) => void,
+    view?: string
+  ): Promise<void> {
+    if (isProcessing || !domReady || taskQueue.length === 0) return
+    setProcessing(true)
+    this.state = TaskQueueState.PROCESS
+
+    const currentTasks = [...taskQueue]
+    taskQueue.length = 0
+    const singleTasks = currentTasks.filter(task => task.single)
+    const exceptSingleTask = currentTasks.filter(task => !task.single)
+
+    for (const task of singleTasks) {
+      try {
+        task.result = await task.action.call(task.ctx, task.args, task.name, TaskMap[task.name].type)
+      } catch (err) {
+        task.err = err
+      }
+    }
+
+    const params = exceptSingleTask.reduce(
+      (acc, cur) => {
+        const params = cur.args.params
+        return {...acc, ...(typeof params === 'function' ? params() : params)}
+      }, {}
+    )
+    const task = exceptSingleTask[0]
+    const sequenceTask = currentTasks.sort((a, b) => a.sequenceNumber - b.sequenceNumber)
+    try {
+      let r = null
+      if (task) {
+        view
+          ? r = await task.action.call(
+            task.ctx,
+            {params, streamId: task.args.streamId, view},
+            task.name,
+            Handletype.setPlayer
+          )
+          : r = await task.action.call(task.ctx, {params}, task.name, Handletype.setPusher)
+      }
+
+      for (const task of sequenceTask) {
+        if (task.err) {
+          task.reject(task.err)
+        } else {
+          task.resolve(task.result || r)
+        }
+      }
+    } catch (err) {
+      for (const task of sequenceTask) {
+        task.reject(err)
+      }
+    }
+
+    setProcessing(false)
+    this.send(TaskQueueEvent.SETDONE, view)
+
+    if (taskQueue.length > 0) {
+      Promise.resolve().then(() => {
+        this.processTasks(taskQueue, isProcessing, domReady, setProcessing, view)
+      }).catch(console.error)
+    }
+  }
+
+  private async processPusherTasks(): Promise<void> {
+    await this.processTasks(
+      this.pusherTaskQueue,
+      this.isProcessing,
+      this.pusherDomReady,
+      (value) => { this.isProcessing = value }
+    )
+  }
+
+  private async processPlayerTasks(view: string): Promise<void> {
+    if (!this.playerTasks[view]) return
+    await this.processTasks(
+      this.playerTasks[view].taskQueue,
+      this.playerTasks[view].isProcessing,
+      this.playerTasks[view].domReady,
+      (value) => { this.playerTasks[view].isProcessing = value },
+      view
+    )
+  }
+}
+export const taskMachine = new TaskMachine()
+interface TaskParams {
+  params: any;
+  funName: string;
+}
+
+export const setHandle = (target: any, key: string, descriptor: PropertyDescriptor): PropertyDescriptor => {
+  const originalMethod = descriptor.value
+  descriptor.value = function (...args: any): Promise<any> {
+    const [params, funName] = args
+    return new Promise((resolve, reject) => {
+      try {
+        taskMachine.addTask(new Task({
+          ctx: this,
+          priority: TaskMap[funName]?.priority || 0,
+          action: originalMethod,
+          args: params,
+          name: funName,
+          resolve,
+          reject
+        }))
+      } catch (error) {
+        reject(error)
+      }
+    })
+  }
+  return descriptor
+}