@zeewain/3d-avatar-sdk 1.2.3 → 1.2.4-1

package/dist/index.es5.umd.js

@@ -13769,6 +13769,20 @@
 	 * @fileoverview 流式播报服务重构实现模块
 	 * @description 提供流式播报服务的重构实现，继承Unity基础服务，支持文本转语音和自定义音频播报
 	 */
+	/**
+	 * 播报任务状态枚举
+	 */
+	var BroadcastTaskStatus;
+	(function (BroadcastTaskStatus) {
+	  /** 请求中 */
+	  BroadcastTaskStatus["REQUESTING"] = "requesting";
+	  /** 已完成 */
+	  BroadcastTaskStatus["COMPLETED"] = "completed";
+	  /** 失败 */
+	  BroadcastTaskStatus["FAILED"] = "failed";
+	  /** 已取消 */
+	  BroadcastTaskStatus["CANCELLED"] = "cancelled";
+	})(BroadcastTaskStatus || (BroadcastTaskStatus = {}));
 	/**
 	 * 流式播报服务重构类
 	 * @class BroadcastServiceRefactored
@@ -13799,12 +13813,20 @@
 	    var _this = _super.call(this, config) || this;
 	    /** 事件回调函数集合 */
 	    _this.callbacks = {};
-	    /** 请求控制器，用于取消请求 */
-	    _this.activeController = null;
+	    /** 播报任务队列 */
+	    _this.taskQueue = [];
+	    /** 任务序号计数器 */
+	    _this.taskSequence = 0;
+	    /** 当前发送任务的序号 */
+	    _this.currentSendingSequence = 0;
 	    /** 是否正在生成音频 */
 	    _this.isGeneratingAudio = false;
 	    /** 是否已经收到音频 */
 	    _this.hasReceivedAudio = false;
+	    /** 队列处理定时器 */
+	    _this.queueProcessTimer = null;
+	    /** 主请求控制器（兼容性保留） */
+	    _this.activeController = null;
 	    _this.callbacks = config.callbacks || {};
 	    _this.logger.info('Broadcast service initialized', {
 	      config: config
@@ -13855,8 +13877,9 @@
 	  /**
 	   * 开始播报
 	   * @param params - 播报参数
+	   * @param isAppend - 是否追加播报
 	   * @returns Promise<void> 播报操作的Promise
-	   * @description 开始流式播报，支持文本转语音和自定义音频播报
+	   * @description 开始流式播报，支持文本转语音和自定义音频播报。使用队列机制确保音频按序播报
 	   * @throws {SDKError} 当参数验证失败或播报失败时抛出错误
 	   * @example
 	   * ```typescript
@@ -13870,49 +13893,40 @@
 	   *   isSubtitle: true
 	   * });
 	   *
-	   * // 自定义音频播报
+	   * // 追加播报（会进入队列按序播报）
 	   * await broadcastService.startBroadcast({
-	   *   type: BroadcastType.AUDIO,
+	   *   type: BroadcastType.TEXT,
 	   *   humanCode: 'human001',
-	   *   audioUrl: 'https://example.com/audio.mp3',
+	   *   text: '这是第二段内容',
+	   *   voiceCode: 'voice001',
 	   *   volume: 0.8,
-	   *   isSubtitle: false
-	   * });
+	   *   isSubtitle: true
+	   * }, true);
 	   * ```
 	   */
-	  BroadcastService.prototype.startBroadcast = function (params) {
+	  BroadcastService.prototype.startBroadcast = function (params, isAppend) {
 	    return __awaiter(this, void 0, void 0, function () {
-	      var apiUrl, requestBody, error_1;
-	      var _this = this;
+	      var task;
 	      var _a, _b;
 	      return __generator(this, function (_c) {
 	        switch (_c.label) {
 	          case 0:
 	            this.logger.info("Starting broadcast: ".concat(params.type), {
-	              humanCode: params.humanCode
+	              humanCode: params.humanCode,
+	              isAppend: isAppend,
+	              queueLength: this.taskQueue.length
 	            });
 	            // 验证参数
 	            this.validateBroadcastParams(params);
-	            // 先停止当前播报
+	            if (!!isAppend) return [3 /*break*/, 2];
+	            // 先停止当前播报并清空队列
 	            return [4 /*yield*/, this.stopBroadcast()];
 	          case 1:
-	            // 先停止当前播报
+	            // 先停止当前播报并清空队列
 	            _c.sent();
-	            // 创建新的请求控制器
-	            this.activeController = new AbortController();
-	            // 监听中断信号
-	            this.activeController.signal.addEventListener('abort', function () {
-	              var _a, _b;
-	              console.warn('abort');
-	              // 如果正在生成音频，触发中断回调
-	              if (_this.isGeneratingAudio) {
-	                (_b = (_a = _this.callbacks).onAbort) === null || _b === void 0 ? void 0 : _b.call(_a);
-	              }
-	              // 重置状态
-	              _this.isGeneratingAudio = false;
-	              _this.hasReceivedAudio = false;
-	              _this.activeController = null;
-	            });
+	            // 重置序号计数器
+	            this.taskSequence = 0;
+	            this.currentSendingSequence = 0;
 	            // 通知Unity开始新任务（清空队列）
 	            this.sendMessage('StartBroadcast', {
 	              callbackFun: this.uniqueCallbackName,
@@ -13920,100 +13934,19 @@
 	              motionList: params.motionList,
 	              motionPlayMode: params.motionPlayMode
 	            });
-	            _c.label = 2;
-	          case 2:
-	            _c.trys.push([2, 4,, 5]);
-	            apiUrl = "".concat(ConfigManager.getInstance().getApiBaseUrl(true)).concat(this.getBroadcastApiPath(params.type));
-	            requestBody = {
-	              humanCode: params.humanCode,
-	              speed: params.speed,
-	              volume: params.volume >= 0 ? params.volume * 100 : undefined,
-	              // 转换为百分比
-	              isSubtitle: params.isSubtitle
-	            };
-	            // 根据播报类型设置特定参数
-	            if (params.type === exports.BroadcastType.TEXT) {
-	              requestBody.text = params.text;
-	              requestBody.voiceCode = params.voiceCode;
-	            } else if (params.type === exports.BroadcastType.AUDIO) {
-	              requestBody.text = params.text;
-	              requestBody.audioUrl = params.audioUrl;
-	            }
-	            this.logger.debug('Sending broadcast request', {
-	              apiUrl: apiUrl,
-	              requestBody: requestBody
-	            });
 	            // 触发开始回调
 	            (_b = (_a = this.callbacks).onStart) === null || _b === void 0 ? void 0 : _b.call(_a);
 	            this.isGeneratingAudio = true;
-	            // 发起流式播报请求
-	            return [4 /*yield*/, fetchEventSource(apiUrl, {
-	              method: 'POST',
-	              headers: {
-	                'Content-Type': 'application/json',
-	                'x_auth_token': ConfigManager.getInstance().getToken()
-	              },
-	              body: JSON.stringify(requestBody),
-	              signal: this.activeController.signal,
-	              openWhenHidden: true,
-	              onmessage: function onmessage(event) {
-	                var response = JSON.parse(event.data);
-	                // 错误处理
-	                if (response.code !== 0) {
-	                  _this.handleBroadcastError(response.code);
-	                  return;
-	                }
-	                // 流式播报
-	                if (response.data) {
-	                  // 未完成播报时，更新任务ID
-	                  if (!response.data.done) {
-	                    _this.hasReceivedAudio = true;
-	                  }
-	                  // 自定义音频播报时，如果服务器未返回音频URL，使用传入的audioUrl
-	                  if (params.type === exports.BroadcastType.AUDIO && params.audioUrl && !response.data.voiceUrl) {
-	                    response.data.voiceUrl = params.audioUrl;
-	                  }
-	                  // 如果有音频URL，发送到Unity
-	                  if (response.data.voiceUrl) {
-	                    _this.sendMessage('AppendBroadcast', {
-	                      response: response,
-	                      callbackFun: _this.uniqueCallbackName,
-	                      operationType: exports.BroadcastOperationType.APPEND_BROADCAST
-	                    });
-	                  }
-	                  if (response.data.done) {
-	                    _this.isGeneratingAudio = false;
-	                    _this.hasReceivedAudio = false;
-	                    _this.activeController = null;
-	                  }
-	                }
-	              },
-	              onclose: function onclose() {
-	                var _a;
-	                // 如果不是由abort触发的关闭，需要处理
-	                if (_this.isGeneratingAudio) {
-	                  (_a = _this.activeController) === null || _a === void 0 ? void 0 : _a.abort();
-	                }
-	                // 流结束时调用完成回调
-	                _this.logger.debug('Broadcast stream closed');
-	              },
-	              onerror: function onerror(error) {
-	                _this.logger.error('Broadcast stream error', error);
-	                var sdkError = new SDKError(exports.OperationErrorCode.OPERATION_FAILED, '服务出错了', error);
-	                _this.handleError(sdkError);
-	                // 必须抛出错误，否则会循环重试请求
-	                throw new Error("\u670D\u52A1\u51FA\u9519\u4E86".concat(sdkError.message));
-	              }
-	            })];
-	          case 3:
-	            // 发起流式播报请求
-	            _c.sent();
-	            return [3 /*break*/, 5];
-	          case 4:
-	            error_1 = _c.sent();
-	            this.handleError(error_1);
-	            return [3 /*break*/, 5];
-	          case 5:
+	            _c.label = 2;
+	          case 2:
+	            task = this.createBroadcastTask(params);
+	            // 添加任务到队列
+	            this.addTaskToQueue(task);
+	            this.logger.debug('Broadcast task created and queued', {
+	              taskId: task.id,
+	              sequence: task.sequence,
+	              isAppend: isAppend
+	            });
 	            return [2 /*return*/];
 	        }
 	      });
@@ -14031,7 +13964,7 @@
 	   */
 	  BroadcastService.prototype.pauseBroadcast = function (resetIdle) {
 	    return __awaiter(this, void 0, void 0, function () {
-	      var error_2;
+	      var error_1;
 	      return __generator(this, function (_a) {
 	        switch (_a.label) {
 	          case 0:
@@ -14047,9 +13980,9 @@
 	            this.logger.info('Broadcast paused successfully');
 	            return [3 /*break*/, 4];
 	          case 3:
-	            error_2 = _a.sent();
-	            this.logger.error('Failed to pause broadcast', error_2);
-	            throw error_2;
+	            error_1 = _a.sent();
+	            this.logger.error('Failed to pause broadcast', error_1);
+	            throw error_1;
 	          case 4:
 	            return [2 /*return*/];
 	        }
@@ -14067,7 +14000,7 @@
 	   */
 	  BroadcastService.prototype.resumeBroadcast = function () {
 	    return __awaiter(this, void 0, void 0, function () {
-	      var error_3;
+	      var error_2;
 	      return __generator(this, function (_a) {
 	        switch (_a.label) {
 	          case 0:
@@ -14081,9 +14014,9 @@
 	            this.logger.info('Broadcast resumed successfully');
 	            return [3 /*break*/, 4];
 	          case 3:
-	            error_3 = _a.sent();
-	            this.logger.error('Failed to resume broadcast', error_3);
-	            throw error_3;
+	            error_2 = _a.sent();
+	            this.logger.error('Failed to resume broadcast', error_2);
+	            throw error_2;
 	          case 4:
 	            return [2 /*return*/];
 	        }
@@ -14101,16 +14034,18 @@
 	   */
 	  BroadcastService.prototype.stopBroadcast = function () {
 	    return __awaiter(this, void 0, void 0, function () {
-	      var error_4;
+	      var error_3;
 	      return __generator(this, function (_a) {
 	        switch (_a.label) {
 	          case 0:
-	            this.logger.info('Stopping broadcast');
-	            // 取消流式请求
-	            if (this.activeController) {
-	              this.activeController.abort();
-	              this.activeController = null;
-	            }
+	            this.logger.info('Stopping broadcast and clearing queue', {
+	              queueLength: this.taskQueue.length
+	            });
+	            // 取消所有队列中的任务
+	            this.cancelAllTasks();
+	            // 重置状态
+	            this.isGeneratingAudio = false;
+	            this.hasReceivedAudio = false;
 	            _a.label = 1;
 	          case 1:
 	            _a.trys.push([1, 3,, 4]);
@@ -14120,9 +14055,9 @@
 	            this.logger.info('Broadcast stopped successfully');
 	            return [3 /*break*/, 4];
 	          case 3:
-	            error_4 = _a.sent();
-	            this.logger.error('Failed to stop broadcast', error_4);
-	            throw error_4;
+	            error_3 = _a.sent();
+	            this.logger.error('Failed to stop broadcast', error_3);
+	            throw error_3;
 	          case 4:
 	            return [2 /*return*/];
 	        }
@@ -14141,15 +14076,31 @@
 	  /**
 	   * 获取播报状态
 	   * @returns 播报状态信息
-	   * @description 获取当前播报服务的状态信息
+	   * @description 获取当前播报服务的状态信息，包括队列状态
 	   */
 	  BroadcastService.prototype.getStatus = function () {
 	    return {
-	      isActive: this.activeController !== null,
+	      isActive: this.taskQueue.length > 0 || this.isGeneratingAudio,
 	      isGeneratingAudio: this.isGeneratingAudio,
 	      hasReceivedAudio: this.hasReceivedAudio,
 	      pendingCallbacks: this.getPendingCallbackCount(),
-	      hasController: this.activeController !== null
+	      hasController: this.activeController !== null,
+	      queueInfo: {
+	        totalTasks: this.taskQueue.length,
+	        requestingTasks: this.taskQueue.filter(function (t) {
+	          return t.status === BroadcastTaskStatus.REQUESTING;
+	        }).length,
+	        completedTasks: this.taskQueue.filter(function (t) {
+	          return t.status === BroadcastTaskStatus.COMPLETED;
+	        }).length,
+	        failedTasks: this.taskQueue.filter(function (t) {
+	          return t.status === BroadcastTaskStatus.FAILED;
+	        }).length,
+	        totalPendingResponses: this.taskQueue.reduce(function (sum, t) {
+	          return sum + t.pendingResponses.length;
+	        }, 0),
+	        currentSendingSequence: this.currentSendingSequence
+	      }
 	    };
 	  };
 	  /**
@@ -14157,15 +14108,307 @@
 	   * @description 清理所有资源和回调
 	   */
 	  BroadcastService.prototype.destroy = function () {
-	    // 停止当前播报
-	    if (this.activeController) {
-	      this.activeController.abort();
-	      this.activeController = null;
+	    // 清理队列处理定时器
+	    if (this.queueProcessTimer) {
+	      clearInterval(this.queueProcessTimer);
+	      this.queueProcessTimer = null;
 	    }
+	    // 取消所有任务
+	    this.cancelAllTasks();
 	    // 调用基类销毁方法
 	    _super.prototype.destroy.call(this);
 	    this.logger.info('Broadcast service destroyed');
 	  };
+	  /**
+	   * 创建播报任务
+	   * @param params - 播报参数
+	   * @returns IBroadcastTask 播报任务对象
+	   * @description 创建新的播报任务并分配唯一ID和序号
+	   * @private
+	   */
+	  BroadcastService.prototype.createBroadcastTask = function (params) {
+	    var task = {
+	      id: "broadcast_".concat(Date.now(), "_").concat(Math.random().toString(36).substring(2, 9)),
+	      sequence: ++this.taskSequence,
+	      params: params,
+	      status: BroadcastTaskStatus.REQUESTING,
+	      controller: new AbortController(),
+	      pendingResponses: [],
+	      isGenerationComplete: false,
+	      createdAt: new Date()
+	    };
+	    this.logger.debug('Created broadcast task', {
+	      taskId: task.id,
+	      sequence: task.sequence
+	    });
+	    return task;
+	  };
+	  /**
+	   * 添加任务到队列
+	   * @param task - 播报任务
+	   * @description 将任务添加到队列并立即开始请求
+	   * @private
+	   */
+	  BroadcastService.prototype.addTaskToQueue = function (task) {
+	    this.taskQueue.push(task);
+	    this.logger.debug('Task added to queue', {
+	      taskId: task.id,
+	      queueLength: this.taskQueue.length
+	    });
+	    // 立即开始该任务的请求
+	    this.startTaskRequest(task);
+	    // 开始处理队列
+	    this.processQueue();
+	  };
+	  /**
+	   * 处理队列
+	   * @description 处理队列中的任务，发起请求生成音频
+	   * @private
+	   */
+	  BroadcastService.prototype.processQueue = function () {
+	    var _this = this;
+	    // 启动队列处理定时器（如果尚未启动）
+	    if (!this.queueProcessTimer) {
+	      this.queueProcessTimer = setInterval(function () {
+	        _this.processQueueStep();
+	      }, 100); // 每100ms检查一次队列状态
+	    }
+	    // 立即处理一次
+	    this.processQueueStep();
+	  };
+	  /**
+	   * 队列处理步骤
+	   * @description 处理队列中的单个步骤，包括发起请求和发送音频
+	   * @private
+	   */
+	  BroadcastService.prototype.processQueueStep = function () {
+	    var _this = this;
+	    // 按序号找到下一个要处理的任务
+	    var nextTask = this.taskQueue.find(function (task) {
+	      return task.sequence === _this.currentSendingSequence + 1 && task.pendingResponses.length > 0;
+	    });
+	    if (nextTask) {
+	      this.sendNextResponse(nextTask);
+	    }
+	    // 清理已完成的任务
+	    this.cleanupCompletedTasks();
+	    // 如果队列为空，停止定时器
+	    if (this.taskQueue.length === 0 && this.queueProcessTimer) {
+	      clearInterval(this.queueProcessTimer);
+	      this.queueProcessTimer = null;
+	    }
+	  };
+	  /**
+	   * 开始任务请求
+	   * @param task - 播报任务
+	   * @description 为任务发起流式请求生成音频
+	   * @private
+	   */
+	  BroadcastService.prototype.startTaskRequest = function (task) {
+	    return __awaiter(this, void 0, void 0, function () {
+	      var apiUrl, requestBody;
+	      var _this = this;
+	      return __generator(this, function (_a) {
+	        task.status = BroadcastTaskStatus.REQUESTING;
+	        this.logger.debug('Starting task request', {
+	          taskId: task.id
+	        });
+	        try {
+	          apiUrl = "".concat(ConfigManager.getInstance().getApiBaseUrl(true)).concat(this.getBroadcastApiPath(task.params.type));
+	          requestBody = {
+	            humanCode: task.params.humanCode,
+	            speed: task.params.speed,
+	            volume: task.params.volume >= 0 ? task.params.volume * 100 : undefined,
+	            isSubtitle: task.params.isSubtitle
+	          };
+	          // 根据播报类型设置特定参数
+	          if (task.params.type === exports.BroadcastType.TEXT) {
+	            requestBody.text = task.params.text;
+	            requestBody.voiceCode = task.params.voiceCode;
+	          } else if (task.params.type === exports.BroadcastType.AUDIO) {
+	            requestBody.text = task.params.text;
+	            requestBody.audioUrl = task.params.audioUrl;
+	          }
+	          // 发起流式请求
+	          fetchEventSource(apiUrl, {
+	            method: 'POST',
+	            headers: {
+	              'Content-Type': 'application/json',
+	              'x_auth_token': ConfigManager.getInstance().getToken()
+	            },
+	            body: JSON.stringify(requestBody),
+	            signal: task.controller.signal,
+	            openWhenHidden: true,
+	            onmessage: function onmessage(event) {
+	              _this.handleTaskResponse(task, event.data);
+	            },
+	            onclose: function onclose() {
+	              _this.handleTaskClose(task);
+	            },
+	            onerror: function onerror(error) {
+	              _this.handleTaskError(task, error);
+	              throw new Error("Task ".concat(task.id, " request failed: ").concat(error));
+	            }
+	          });
+	        } catch (error) {
+	          this.handleTaskError(task, error);
+	        }
+	        return [2 /*return*/];
+	      });
+	    });
+	  };
+	  /**
+	   * 处理任务响应
+	   * @param task - 播报任务
+	   * @param data - 响应数据
+	   * @description 处理任务的流式响应数据
+	   * @private
+	   */
+	  BroadcastService.prototype.handleTaskResponse = function (task, data) {
+	    try {
+	      var response = JSON.parse(data);
+	      // 错误处理
+	      if (response.code !== 0) {
+	        this.handleBroadcastError(response.code);
+	        return;
+	      }
+	      // 处理音频数据
+	      if (response.data) {
+	        // 自定义音频播报时，如果服务器未返回音频URL，使用传入的audioUrl
+	        if (task.params.type === exports.BroadcastType.AUDIO && task.params.audioUrl && !response.data.voiceUrl) {
+	          response.data.voiceUrl = task.params.audioUrl;
+	        }
+	        // 添加处理后的响应对象到待发送队列
+	        task.pendingResponses.push(response);
+	        this.logger.debug('Response added to task', {
+	          taskId: task.id,
+	          pendingCount: task.pendingResponses.length
+	        });
+	        // 检查是否完成
+	        if (response.data.done) {
+	          task.isGenerationComplete = true;
+	          this.logger.debug('Task generation completed', {
+	            taskId: task.id,
+	            totalResponses: task.pendingResponses.length
+	          });
+	        }
+	      }
+	    } catch (error) {
+	      this.handleTaskError(task, error);
+	    }
+	  };
+	  /**
+	   * 发送下一个响应
+	   * @param task - 播报任务
+	   * @description 发送任务中的第一个待发送响应到Unity，发送后立即删除
+	   * @private
+	   */
+	  BroadcastService.prototype.sendNextResponse = function (task) {
+	    var _a;
+	    if (task.pendingResponses.length === 0) {
+	      return;
+	    }
+	    // 取出第一个待发送的响应
+	    var response = task.pendingResponses.shift();
+	    this.logger.debug('Sending response to Unity', {
+	      taskId: task.id,
+	      remainingResponses: task.pendingResponses.length,
+	      voiceUrl: (_a = response.data) === null || _a === void 0 ? void 0 : _a.voiceUrl
+	    });
+	    // 发送响应到Unity
+	    this.sendMessage('AppendBroadcast', {
+	      response: response,
+	      callbackFun: this.uniqueCallbackName,
+	      operationType: exports.BroadcastOperationType.APPEND_BROADCAST
+	    });
+	    // 如果任务已完成且没有更多待发送响应，标记任务完成并推进序号
+	    if (task.isGenerationComplete && task.pendingResponses.length === 0) {
+	      task.status = BroadcastTaskStatus.COMPLETED;
+	      this.currentSendingSequence = task.sequence;
+	      this.logger.debug('Task completed', {
+	        taskId: task.id
+	      });
+	    }
+	  };
+	  /**
+	   * 处理任务关闭
+	   * @param task - 播报任务
+	   * @description 处理任务的流式连接关闭
+	   * @private
+	   */
+	  BroadcastService.prototype.handleTaskClose = function (task) {
+	    this.logger.debug('Task stream closed', {
+	      taskId: task.id
+	    });
+	    // 如果还没有标记为完成，则标记为完成
+	    if (!task.isGenerationComplete && task.status === BroadcastTaskStatus.REQUESTING) {
+	      task.isGenerationComplete = true;
+	    }
+	  };
+	  /**
+	   * 处理任务错误
+	   * @param task - 播报任务
+	   * @param error - 错误对象
+	   * @description 处理任务执行过程中的错误
+	   * @private
+	   */
+	  BroadcastService.prototype.handleTaskError = function (task, error) {
+	    var _a, _b;
+	    task.status = BroadcastTaskStatus.FAILED;
+	    task.error = error;
+	    this.logger.error("Task failed - ".concat(task.id), error);
+	    // 触发错误回调
+	    (_b = (_a = this.callbacks).onError) === null || _b === void 0 ? void 0 : _b.call(_a, error);
+	  };
+	  /**
+	   * 清理已完成的任务
+	   * @description 从队列中移除已完成、失败或取消的任务
+	   * @private
+	   */
+	  BroadcastService.prototype.cleanupCompletedTasks = function () {
+	    var beforeLength = this.taskQueue.length;
+	    this.taskQueue = this.taskQueue.filter(function (task) {
+	      return task.status !== BroadcastTaskStatus.COMPLETED && task.status !== BroadcastTaskStatus.FAILED && task.status !== BroadcastTaskStatus.CANCELLED;
+	    });
+	    var removedCount = beforeLength - this.taskQueue.length;
+	    if (removedCount > 0) {
+	      this.logger.debug('Cleaned up completed tasks', {
+	        removedCount: removedCount,
+	        remainingTasks: this.taskQueue.length
+	      });
+	    }
+	  };
+	  /**
+	   * 取消所有任务
+	   * @description 取消队列中的所有任务
+	   * @private
+	   */
+	  BroadcastService.prototype.cancelAllTasks = function () {
+	    var e_1, _a;
+	    try {
+	      for (var _b = __values(this.taskQueue), _c = _b.next(); !_c.done; _c = _b.next()) {
+	        var task = _c.value;
+	        if (task.status !== BroadcastTaskStatus.COMPLETED && task.status !== BroadcastTaskStatus.FAILED) {
+	          task.controller.abort();
+	          task.status = BroadcastTaskStatus.CANCELLED;
+	        }
+	      }
+	    } catch (e_1_1) {
+	      e_1 = {
+	        error: e_1_1
+	      };
+	    } finally {
+	      try {
+	        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+	      } finally {
+	        if (e_1) throw e_1.error;
+	      }
+	    }
+	    this.taskQueue = [];
+	    this.taskSequence = 0;
+	    this.currentSendingSequence = 0;
+	    this.logger.debug('All tasks cancelled and queue cleared');
+	  };
 	  Object.defineProperty(BroadcastService.prototype, "callbackFunctionName", {
 	    /** 全局回调函数名称 */
 	    get: function get() {