@zeewain/3d-avatar-sdk 2.1.1 → 2.1.3

package/dist/index.umd.cjs

@@ -1029,7 +1029,7 @@
         },
         /** 生产环境配置 */
         prod: {
-            apiBaseUrl: 'https://aiip.zeewain.com'
+            apiBaseUrl: 'https://ai.zeewain3d.com'
         }
     };
     /**
@@ -1040,7 +1040,7 @@
      * @example
      * ```typescript
      * const config = getEnvConfig('prod');
-     * console.log(config.apiBaseUrl); // https://aiip.zeewain.com/api/dh-talker
+     * console.log(config.apiBaseUrl); // https://ai.zeewain3d.com/api/dh-talker
      * ```
      */
     function getEnvConfig(env = 'dev', withApiModule = true) {
@@ -1511,6 +1511,8 @@
      */
     var BroadcastTaskStatus;
     (function (BroadcastTaskStatus) {
+        /** 等待中（尚未开始请求） */
+        BroadcastTaskStatus["PENDING"] = "pending";
         /** 请求中 */
         BroadcastTaskStatus["REQUESTING"] = "requesting";
         /** 已完成 */
@@ -1576,7 +1578,7 @@
          * @override
          */
         handleCallback(operation, code, message, data) {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
             // 提取 isBroadcastCompleted 参数
             const { isBroadcastCompleted } = JSON.parse(data || '{}');
             // 先调用基类处理逻辑
@@ -1588,7 +1590,14 @@
                         if (isBroadcastCompleted) {
                             this.broadcastCompletedCount++;
                             const status = this.getStatus();
-                            if (((_a = status.queueInfo) === null || _a === void 0 ? void 0 : _a.completedTasks) === this.broadcastCompletedCount) {
+                            // 判断是否所有任务都已完成：
+                            // 1. 没有待请求的任务 (PENDING)
+                            // 2. 没有正在请求的任务 (REQUESTING)
+                            // 3. Unity播放完成次数等于已完成任务数
+                            const isAllTasksCompleted = ((_a = status.queueInfo) === null || _a === void 0 ? void 0 : _a.pendingTasks) === 0
+                                && ((_b = status.queueInfo) === null || _b === void 0 ? void 0 : _b.requestingTasks) === 0
+                                && ((_c = status.queueInfo) === null || _c === void 0 ? void 0 : _c.completedTasks) === this.broadcastCompletedCount;
+                            if (isAllTasksCompleted) {
                                 // 重置状态、计数
                                 this.isBroadcastingAudio = false;
                                 this.hasReceivedAudio = false;
@@ -1598,19 +1607,19 @@
                                 this.logger.warn('Broadcast all completed');
                             }
                             // this.logger.warn('AAAAAA', { status: this.getStatus(), broadcastCompletedCount: this.broadcastCompletedCount });
-                            (_c = (_b = this.callbacks).onFinish) === null || _c === void 0 ? void 0 : _c.call(_b);
+                            (_e = (_d = this.callbacks).onFinish) === null || _e === void 0 ? void 0 : _e.call(_d);
                         }
                         break;
                     case exports.BroadcastOperationType.PAUSE_BROADCAST:
-                        (_e = (_d = this.callbacks).onPause) === null || _e === void 0 ? void 0 : _e.call(_d);
+                        (_g = (_f = this.callbacks).onPause) === null || _g === void 0 ? void 0 : _g.call(_f);
                         this.logger.debug('Broadcast paused callback triggered');
                         break;
                     case exports.BroadcastOperationType.RESUME_BROADCAST:
-                        (_g = (_f = this.callbacks).onResume) === null || _g === void 0 ? void 0 : _g.call(_f);
+                        (_j = (_h = this.callbacks).onResume) === null || _j === void 0 ? void 0 : _j.call(_h);
                         this.logger.debug('Broadcast resumed callback triggered');
                         break;
                     case exports.BroadcastOperationType.STOP_BROADCAST:
-                        (_j = (_h = this.callbacks).onStop) === null || _j === void 0 ? void 0 : _j.call(_h);
+                        (_l = (_k = this.callbacks).onStop) === null || _l === void 0 ? void 0 : _l.call(_k);
                         this.logger.debug('Broadcast stopped callback triggered');
                         break;
                 }
@@ -1667,7 +1676,7 @@
                     // 重置序号计数器
                     this.taskSequence = 0;
                     this.currentSendingSequence = 0;
-                    // 通知Unity开始新任务（清空队列）
+                    // 通知Unity开始新任务（清空队列），这里不使用sendAsyncMessage，因为startBroadcast不需要等待完成，而是在任务播报完成后通过回调通知
                     this.sendMessage('StartBroadcast', {
                         callbackFun: this.uniqueCallbackName,
                         operationType: exports.BroadcastOperationType.START_BROADCAST,
@@ -1779,18 +1788,20 @@
          * @description 获取当前播报服务的状态信息，包括队列状态
          */
         getStatus() {
+            const pendingTasks = this.taskQueue.filter((t) => t.status === BroadcastTaskStatus.PENDING).length;
             const completedTasks = this.taskQueue.filter((t) => t.status === BroadcastTaskStatus.COMPLETED).length;
             const requestingTasks = this.taskQueue.filter((t) => t.status === BroadcastTaskStatus.REQUESTING).length;
             const failedTasks = this.taskQueue.filter((t) => t.status === BroadcastTaskStatus.FAILED).length;
             const totalPendingResponses = this.taskQueue.reduce((sum, t) => sum + t.pendingResponses.length, 0);
             const currentSendingSequence = this.currentSendingSequence;
-            const isGeneratingAudio = completedTasks + failedTasks !== this.taskQueue.length;
+            const isGeneratingAudio = pendingTasks + requestingTasks > 0;
             return {
                 isActive: this.isBroadcastingAudio || isGeneratingAudio, // 是否正在播报音频或正在生成音频
                 isGeneratingAudio,
                 hasReceivedAudio: this.hasReceivedAudio,
                 queueInfo: {
                     totalTasks: this.taskQueue.length,
+                    pendingTasks,
                     requestingTasks,
                     completedTasks,
                     failedTasks,
@@ -1824,7 +1835,7 @@
                 id: `broadcast_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
                 sequence: ++this.taskSequence,
                 params,
-                status: BroadcastTaskStatus.REQUESTING,
+                status: BroadcastTaskStatus.PENDING,
                 controller: new AbortController(),
                 pendingResponses: [],
                 isGenerationComplete: false,
@@ -1836,46 +1847,58 @@
         /**
          * 添加任务到队列
          * @param task - 播报任务
-         * @description 将任务添加到队列并立即开始请求
+         * @description 将任务添加到队列，只有当没有正在请求的任务时才开始请求（串行请求模式）
          * @private
          */
         addTaskToQueue(task) {
             this.taskQueue.push(task);
-            this.logger.debug('Task added to queue', { taskId: task.id, queueLength: this.taskQueue.length });
-            // 立即开始该任务的请求
-            this.startTaskRequest(task);
+            this.logger.debug('Task added to queue', { taskId: task.id, params: task.params, queueLength: this.taskQueue.length });
+            // 检查是否有正在请求的任务
+            const hasRequestingTask = this.taskQueue.some((t) => t.status === BroadcastTaskStatus.REQUESTING);
+            // 只有当没有正在请求的任务时，才开始当前任务的请求
+            if (!hasRequestingTask) {
+                this.startTaskRequest(task);
+            }
+            else {
+                this.logger.debug('Task queued, waiting for previous task to complete', {
+                    taskId: task.id,
+                    pendingTasks: this.taskQueue.filter((t) => t.status === BroadcastTaskStatus.PENDING).length
+                });
+            }
             // 开始处理队列
-            this.processQueue();
+            this.processTaskQueue();
         }
         /**
          * 处理队列
-         * @description 处理队列中的任务，发起请求生成音频
+         * @description 处理队列中的任务响应，按序号发送给unity播放
          * @private
          */
-        processQueue() {
+        processTaskQueue() {
             // 启动队列处理定时器（如果尚未启动）
             if (!this.queueProcessTimer) {
                 this.queueProcessTimer = setInterval(() => {
-                    this.processQueueStep();
+                    this.processTaskQueueStep();
                 }, 100); // 每100ms检查一次队列状态
             }
             // 立即处理一次
-            this.processQueueStep();
+            this.processTaskQueueStep();
         }
         /**
          * 队列处理步骤
-         * @description 处理队列中的单个步骤，包括发起请求和发送音频
+         * @description 处理队列中的单个步骤，按序号发送给unity播放
          * @private
          */
-        processQueueStep() {
-            // 按序号找到下一个要处理的任务
+        processTaskQueueStep() {
+            // 按序号找到下一个要处理的任务（只处理已开始请求的任务，排除 PENDING 状态）
             const nextTask = this.taskQueue.find((task) => task.sequence === this.currentSendingSequence + 1
+                && task.status !== BroadcastTaskStatus.PENDING
                 && task.pendingResponses.length > 0);
             if (nextTask) {
                 this.sendNextResponse(nextTask);
             }
-            // 如果队列中没有剩余任务，则停止定时器
-            const remainingTasks = this.taskQueue.filter(task => task.status !== BroadcastTaskStatus.COMPLETED
+            // 如果队列中没有剩余任务（排除待处理、已完成、失败和取消的任务），则停止定时器
+            const remainingTasks = this.taskQueue.filter(task => task.status !== BroadcastTaskStatus.PENDING
+                && task.status !== BroadcastTaskStatus.COMPLETED
                 && task.status !== BroadcastTaskStatus.FAILED
                 && task.status !== BroadcastTaskStatus.CANCELLED);
             if (remainingTasks.length === 0) {
@@ -1921,6 +1944,19 @@
                         body: JSON.stringify(requestBody),
                         signal: task.controller.signal,
                         openWhenHidden: true,
+                        /**
+                         * 连接建立时的回调，用于检查 HTTP 状态码
+                         * @param response - HTTP 响应对象
+                         * @throws {SDKError} 当 HTTP 状态码异常时抛出对应的 SDKError
+                         */
+                        onopen: (response) => __awaiter(this, void 0, void 0, function* () {
+                            // 检查 HTTP 状态码，处理 401 token 过期等异常
+                            if (!response.ok) {
+                                const error = this.createHttpError(response.status, response.statusText, task.id);
+                                this.handleTaskError(task, error);
+                                throw error;
+                            }
+                        }),
                         onmessage: (event) => {
                             this.handleTaskResponse(task, event.data);
                         },
@@ -1928,13 +1964,17 @@
                             this.handleTaskClose(task);
                         },
                         onerror: (error) => {
-                            this.handleTaskError(task, error);
-                            throw new Error(`Task ${task.id} request failed: ${error}`);
+                            // 将所有异常统一转换为 SDKError
+                            const sdkError = this.convertToSDKError(error, task.id);
+                            this.handleTaskError(task, sdkError);
+                            throw sdkError;
                         }
                     });
                 }
                 catch (error) {
-                    this.handleTaskError(task, error);
+                    // 将所有异常统一转换为 SDKError
+                    const sdkError = this.convertToSDKError(error, task.id);
+                    this.handleTaskError(task, sdkError);
                 }
             });
         }
@@ -1950,7 +1990,7 @@
                 const response = JSON.parse(data);
                 // 错误处理
                 if (response.code !== 0) {
-                    this.handleBroadcastError(response.code);
+                    this.handleBroadcastError(response.code, response.message);
                     return;
                 }
                 // 处理音频数据
@@ -1962,7 +2002,7 @@
                     }
                     // 添加处理后的响应对象到待发送队列
                     task.pendingResponses.push(response);
-                    this.logger.debug('Response added to task', { taskId: task.id, pendingCount: task.pendingResponses.length });
+                    this.logger.debug('Response added to task', { taskId: task.id, response, pendingCount: task.pendingResponses.length });
                     // 检查是否完成
                     if (response.data.done) {
                         task.isGenerationComplete = true;
@@ -1971,13 +2011,13 @@
                 }
             }
             catch (error) {
-                this.handleTaskError(task, error);
+                this.handleTaskError(task, new SDKError(exports.OperationErrorCode.OPERATION_FAILED, typeof error === 'string' ? error : (error.message || '播报服务错误')));
             }
         }
         /**
-         * 发送下一个响应
+         * 发送下一个响应给unity播放
          * @param task - 播报任务
-         * @description 发送任务中的第一个待发送响应到Unity，发送后立即删除
+         * @description 发送任务的响应数组中的第一个待发送响应到Unity（按顺序发送），发送后立即删除
          * @private
          */
         sendNextResponse(task) {
@@ -1992,7 +2032,7 @@
                 remainingResponses: task.pendingResponses.length,
                 voiceUrl: (_a = response.data) === null || _a === void 0 ? void 0 : _a.voiceUrl
             });
-            // 发送响应到Unity
+            // 发送响应到Unity，这里不使用sendAsyncMessage，因为appendBroadcast不需要等待完成，而是在任务播报完成后通过startBroadcast回调通知
             this.sendMessage('AppendBroadcast', {
                 response,
                 callbackFun: this.uniqueCallbackName,
@@ -2008,7 +2048,7 @@
         /**
          * 处理任务关闭
          * @param task - 播报任务
-         * @description 处理任务的流式连接关闭
+         * @description 处理任务的流式连接关闭，并启动下一个待处理任务的请求
          * @private
          */
         handleTaskClose(task) {
@@ -2017,20 +2057,26 @@
             if (!task.isGenerationComplete && task.status === BroadcastTaskStatus.REQUESTING) {
                 task.isGenerationComplete = true;
             }
+            // 当前任务请求完成后（流断开后），启动下一个待处理任务的请求
+            this.startNextPendingTask();
         }
         /**
          * 处理任务错误
          * @param task - 播报任务
          * @param error - 错误对象
-         * @description 处理任务执行过程中的错误
+         * @description 处理任务执行过程中的错误，防止重复触发错误回调，并启动下一个待处理任务
          * @private
          */
         handleTaskError(task, error) {
             var _a, _b;
+            // 如果任务已经是失败或取消状态，不再重复处理，防止回调被多次触发
+            if (task.status === BroadcastTaskStatus.FAILED || task.status === BroadcastTaskStatus.CANCELLED) {
+                return;
+            }
             task.status = BroadcastTaskStatus.FAILED;
             task.error = error;
             this.logger.error(`Task failed - ${task.id}`, error);
-            // 触发错误回调
+            // 触发错误回调（只触发一次）
             (_b = (_a = this.callbacks).onError) === null || _b === void 0 ? void 0 : _b.call(_a, error);
         }
         /**
@@ -2121,10 +2167,11 @@
         /**
          * 处理播报错误
          * @param errorCode - 错误码
+         * @param errorMessage - 错误消息
          * @description 处理播报过程中的错误
          * @private
          */
-        handleBroadcastError(errorCode) {
+        handleBroadcastError(errorCode, errorMessage) {
             // 用户权益额度不存在错误码 14001
             // 用户权益额度不足错误码 14002
             // 用户权益额度冻结失败 14003
@@ -2139,10 +2186,31 @@
                     this.handleError(new SDKError(exports.OperationErrorCode.BROADCAST_EQUITY_FREEZE_FAILED, '用户权益额度冻结失败'));
                     break;
                 default:
-                    this.handleError(new SDKError(exports.OperationErrorCode.OPERATION_FAILED, '播报服务错误'));
+                    this.handleError(new SDKError(exports.OperationErrorCode.OPERATION_FAILED, `${errorMessage}(${errorCode})` || `播报服务错误(${errorCode})`));
                     break;
             }
         }
+        /**
+         * 启动下一个待处理任务的请求
+         * @description 在当前任务请求完成或失败后，检查并启动下一个待处理任务
+         * @private
+         */
+        startNextPendingTask() {
+            // 查找下一个待处理的任务（按序号排序，取第一个 PENDING 状态的任务）
+            const nextPendingTask = this.taskQueue
+                .filter((t) => t.status === BroadcastTaskStatus.PENDING)
+                .sort((a, b) => a.sequence - b.sequence)[0];
+            if (nextPendingTask) {
+                this.logger.debug('Starting next pending task', {
+                    taskId: nextPendingTask.id,
+                    sequence: nextPendingTask.sequence
+                });
+                this.startTaskRequest(nextPendingTask);
+            }
+            else {
+                this.logger.debug('No pending tasks to start');
+            }
+        }
         /**
          * 清理队列处理定时器
          * @description 清理队列处理定时器
@@ -2152,7 +2220,73 @@
             if (this.queueProcessTimer) {
                 clearInterval(this.queueProcessTimer);
                 this.queueProcessTimer = null;
+                this.logger.debug('Queue process timer cleared');
+            }
+        }
+        /**
+         * 根据 HTTP 状态码创建对应的 SDKError
+         * @param status - HTTP 状态码
+         * @param statusText - HTTP 状态文本
+         * @param taskId - 任务 ID（用于日志记录）
+         * @returns SDKError 实例
+         * @description 将 HTTP 错误状态码映射为对应的 SDKError
+         * @private
+         */
+        createHttpError(status, statusText, taskId) {
+            this.logger.warn(`HTTP error occurred - Task: ${taskId}, Status: ${status}`, { status, statusText });
+            switch (status) {
+                case 401:
+                    // Token 过期或未授权
+                    return new SDKError(exports.NetworkErrorCode.UNAUTHORIZED, `Token 已过期或无效，请重新授权 (HTTP ${status})`);
+                case 403:
+                    // 禁止访问
+                    return new SDKError(exports.NetworkErrorCode.UNAUTHORIZED, `无权限访问该资源 (HTTP ${status})`);
+                case 404:
+                    // 资源不存在
+                    return new SDKError(exports.NetworkErrorCode.SERVER_ERROR, `请求的资源不存在 (HTTP ${status})`);
+                case 500:
+                case 502:
+                case 503:
+                case 504:
+                    // 服务器错误
+                    return new SDKError(exports.NetworkErrorCode.SERVER_ERROR, `服务器错误，请稍后重试 (HTTP ${status})`);
+                default:
+                    // 其他 HTTP 错误
+                    return new SDKError(exports.NetworkErrorCode.CONNECTION_FAILED, `网络请求失败: ${statusText || 'Unknown Error'} (HTTP ${status})`);
+            }
+        }
+        /**
+         * 将任意错误转换为 SDKError
+         * @param error - 原始错误对象
+         * @param taskId - 任务 ID（用于日志记录）
+         * @returns SDKError 实例
+         * @description 统一将各种类型的错误转换为 SDKError，便于上层统一处理
+         * @private
+         */
+        convertToSDKError(error, taskId) {
+            // 如果已经是 SDKError，直接返回
+            if (error instanceof SDKError) {
+                return error;
             }
+            // 如果是普通 Error 对象
+            if (error instanceof Error) {
+                // 检查是否是网络相关的错误
+                const errorMessage = error.message.toLowerCase();
+                if (errorMessage.includes('timeout') || errorMessage.includes('timed out')) {
+                    return new SDKError(exports.NetworkErrorCode.REQUEST_TIMEOUT, `请求超时 - Task: ${taskId}`, error);
+                }
+                if (errorMessage.includes('network') || errorMessage.includes('fetch') || errorMessage.includes('connection')) {
+                    return new SDKError(exports.NetworkErrorCode.CONNECTION_FAILED, `网络连接失败 - Task: ${taskId}: ${error.message}`, error);
+                }
+                if (errorMessage.includes('abort') || errorMessage.includes('cancel')) {
+                    return new SDKError(exports.OperationErrorCode.OPERATION_CANCELLED, `操作已取消 - Task: ${taskId}`, error);
+                }
+                // 默认作为操作失败处理
+                return new SDKError(exports.OperationErrorCode.OPERATION_FAILED, `播报任务执行失败 - Task: ${taskId}: ${error.message}`, error);
+            }
+            // 如果是字符串或其他类型
+            const errorMessage = String(error);
+            return new SDKError(exports.OperationErrorCode.OPERATION_FAILED, `播报任务执行失败 - Task: ${taskId}: ${errorMessage}`);
         }
     }
 
@@ -2279,6 +2413,7 @@
          */
         initGlobalConfig() {
             const config = ConfigManager.getInstance().getConfig();
+            const { assetsFrom } = config;
             const globalParams = {
                 token: config === null || config === void 0 ? void 0 : config.token,
                 apiBaseUrl: ConfigManager.getInstance().getApiBaseUrl(false),
@@ -2286,14 +2421,17 @@
                 // 純AB包方案在SDK 2.1.0 中已弃用
                 // assetsUrl: config?.assetsUrl
             };
-            const assetModuleParams = {
-                isZip: true,
-                assetBundlePath: config === null || config === void 0 ? void 0 : config.assetsUrl
-            };
             this.unityInstance.SendMessage('AvatarSDK', 'InitializeConfig', JSON.stringify(globalParams));
-            this.unityInstance.SendMessage('AvatarSDK', 'InitAssetBundleModule', JSON.stringify(assetModuleParams));
             console.warn('[ Send Unity message ]: AvatarSDK.InitializeConfig', globalParams);
-            console.warn('[ Send Unity message ]: AvatarSDK.InitAssetBundleModule', assetModuleParams);
+            //
+            if (assetsFrom !== 'cloud') {
+                const assetModuleParams = {
+                    isZip: true,
+                    assetBundlePath: config === null || config === void 0 ? void 0 : config.assetsUrl
+                };
+                this.unityInstance.SendMessage('AvatarSDK', 'InitAssetBundleModule', JSON.stringify(assetModuleParams));
+                console.warn('[ Send Unity message ]: AvatarSDK.InitAssetBundleModule', assetModuleParams);
+            }
         }
     }
 
@@ -2331,7 +2469,7 @@
      * SDK 版本号
      * @const {string} SDK_VERSION
      */
-    const SDK_VERSION = '2.1.1';
+    const SDK_VERSION = '2.1.3';
 
     /**
      * @fileoverview 统一的3D数字人SDK入口类
@@ -2397,14 +2535,16 @@
                     this.avatarService = new AvatarService({
                         unityInstance: this.unityInstance,
                         instanceId: this.instanceId,
-                        enableDebugLog: config.enableDebugLog
+                        enableDebugLog: config.enableDebugLog,
+                        timeout: config.operationTimeout
                     });
                     // 5. 创建带有唯一标识符的播报服务
                     this.broadcastService = new BroadcastService({
                         unityInstance: this.unityInstance,
                         instanceId: this.instanceId,
                         callbacks: config.broadcastCallbacks,
-                        enableDebugLog: config.enableDebugLog
+                        enableDebugLog: config.enableDebugLog,
+                        timeout: config.operationTimeout
                     });
                     // 6. 初始化数字人
                     const result = yield this.avatarService.initializeAvatar(avatarCode, cameraType);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@zeewain/3d-avatar-sdk",
   "type": "module",
-  "version": "2.1.1",
+  "version": "2.1.3",
   "description": "SDK for ZEE Avatar WebGL integration",
   "author": "ZEEWain",
   "license": "MIT",
@@ -55,6 +55,7 @@
     "release:patch": "release-it patch",
     "release:minor": "release-it minor",
     "release:major": "release-it major",
+    "release:dry:internal": "release-it --dry-run --config .release-it.internal.json",
     "release:dry": "release-it --dry-run",
     "release:internal": "release-it --config .release-it.internal.json",
     "release:alpha": "npm run release:internal -- --preRelease=alpha",