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

package/dist/index.es5.umd.js

@@ -13256,7 +13256,7 @@
 	  },
 	  /** 生产环境配置 */
 	  prod: {
-	    apiBaseUrl: 'https://aiip.zeewain.com'
+	    apiBaseUrl: 'https://ai.zeewain3d.com'
 	  }
 	};
 	/**
@@ -13267,7 +13267,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, withApiModule) {
@@ -13766,6 +13766,8 @@
 	 */
 	var BroadcastTaskStatus;
 	(function (BroadcastTaskStatus) {
+	  /** 等待中（尚未开始请求） */
+	  BroadcastTaskStatus["PENDING"] = "pending";
 	  /** 请求中 */
 	  BroadcastTaskStatus["REQUESTING"] = "requesting";
 	  /** 已完成 */
@@ -13835,7 +13837,7 @@
 	   * @override
 	   */
 	  BroadcastService.prototype.handleCallback = function (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 参数
 	    var isBroadcastCompleted = JSON.parse(data || '{}').isBroadcastCompleted;
 	    // 先调用基类处理逻辑
@@ -13847,7 +13849,12 @@
 	          if (isBroadcastCompleted) {
 	            this.broadcastCompletedCount++;
 	            var status_1 = this.getStatus();
-	            if (((_a = status_1.queueInfo) === null || _a === void 0 ? void 0 : _a.completedTasks) === this.broadcastCompletedCount) {
+	            // 判断是否所有任务都已完成：
+	            // 1. 没有待请求的任务 (PENDING)
+	            // 2. 没有正在请求的任务 (REQUESTING)
+	            // 3. Unity播放完成次数等于已完成任务数
+	            var isAllTasksCompleted = ((_a = status_1.queueInfo) === null || _a === void 0 ? void 0 : _a.pendingTasks) === 0 && ((_b = status_1.queueInfo) === null || _b === void 0 ? void 0 : _b.requestingTasks) === 0 && ((_c = status_1.queueInfo) === null || _c === void 0 ? void 0 : _c.completedTasks) === this.broadcastCompletedCount;
+	            if (isAllTasksCompleted) {
 	              // 重置状态、计数
 	              this.isBroadcastingAudio = false;
 	              this.hasReceivedAudio = false;
@@ -13857,19 +13864,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;
 	      }
@@ -13931,7 +13938,7 @@
 	            // 重置序号计数器
 	            this.taskSequence = 0;
 	            this.currentSendingSequence = 0;
-	            // 通知Unity开始新任务（清空队列）
+	            // 通知Unity开始新任务（清空队列），这里不使用sendAsyncMessage，因为startBroadcast不需要等待完成，而是在任务播报完成后通过回调通知
 	            this.sendMessage('StartBroadcast', {
 	              callbackFun: this.uniqueCallbackName,
 	              operationType: exports.BroadcastOperationType.START_BROADCAST,
@@ -14084,6 +14091,9 @@
 	   * @description 获取当前播报服务的状态信息，包括队列状态
 	   */
 	  BroadcastService.prototype.getStatus = function () {
+	    var pendingTasks = this.taskQueue.filter(function (t) {
+	      return t.status === BroadcastTaskStatus.PENDING;
+	    }).length;
 	    var completedTasks = this.taskQueue.filter(function (t) {
 	      return t.status === BroadcastTaskStatus.COMPLETED;
 	    }).length;
@@ -14097,7 +14107,7 @@
 	      return sum + t.pendingResponses.length;
 	    }, 0);
 	    var currentSendingSequence = this.currentSendingSequence;
-	    var isGeneratingAudio = completedTasks + failedTasks !== this.taskQueue.length;
+	    var isGeneratingAudio = pendingTasks + requestingTasks > 0;
 	    return {
 	      isActive: this.isBroadcastingAudio || isGeneratingAudio,
 	      // 是否正在播报音频或正在生成音频
@@ -14105,6 +14115,7 @@
 	      hasReceivedAudio: this.hasReceivedAudio,
 	      queueInfo: {
 	        totalTasks: this.taskQueue.length,
+	        pendingTasks: pendingTasks,
 	        requestingTasks: requestingTasks,
 	        completedTasks: completedTasks,
 	        failedTasks: failedTasks,
@@ -14138,7 +14149,7 @@
 	      id: "broadcast_".concat(Date.now(), "_").concat(Math.random().toString(36).substring(2, 9)),
 	      sequence: ++this.taskSequence,
 	      params: params,
-	      status: BroadcastTaskStatus.REQUESTING,
+	      status: BroadcastTaskStatus.PENDING,
 	      controller: new AbortController(),
 	      pendingResponses: [],
 	      isGenerationComplete: false,
@@ -14153,53 +14164,67 @@
 	  /**
 	   * 添加任务到队列
 	   * @param task - 播报任务
-	   * @description 将任务添加到队列并立即开始请求
+	   * @description 将任务添加到队列，只有当没有正在请求的任务时才开始请求（串行请求模式）
 	   * @private
 	   */
 	  BroadcastService.prototype.addTaskToQueue = function (task) {
 	    this.taskQueue.push(task);
 	    this.logger.debug('Task added to queue', {
 	      taskId: task.id,
+	      params: task.params,
 	      queueLength: this.taskQueue.length
 	    });
-	    // 立即开始该任务的请求
-	    this.startTaskRequest(task);
+	    // 检查是否有正在请求的任务
+	    var hasRequestingTask = this.taskQueue.some(function (t) {
+	      return 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(function (t) {
+	          return t.status === BroadcastTaskStatus.PENDING;
+	        }).length
+	      });
+	    }
 	    // 开始处理队列
-	    this.processQueue();
+	    this.processTaskQueue();
 	  };
 	  /**
 	   * 处理队列
-	   * @description 处理队列中的任务，发起请求生成音频
+	   * @description 处理队列中的任务响应，按序号发送给unity播放
 	   * @private
 	   */
-	  BroadcastService.prototype.processQueue = function () {
+	  BroadcastService.prototype.processTaskQueue = function () {
 	    var _this = this;
 	    // 启动队列处理定时器（如果尚未启动）
 	    if (!this.queueProcessTimer) {
 	      this.queueProcessTimer = setInterval(function () {
-	        _this.processQueueStep();
+	        _this.processTaskQueueStep();
 	      }, 100); // 每100ms检查一次队列状态
 	    }
 	    // 立即处理一次
-	    this.processQueueStep();
+	    this.processTaskQueueStep();
 	  };
 	  /**
 	   * 队列处理步骤
-	   * @description 处理队列中的单个步骤，包括发起请求和发送音频
+	   * @description 处理队列中的单个步骤，按序号发送给unity播放
 	   * @private
 	   */
-	  BroadcastService.prototype.processQueueStep = function () {
+	  BroadcastService.prototype.processTaskQueueStep = function () {
 	    var _this = this;
-	    // 按序号找到下一个要处理的任务
+	    // 按序号找到下一个要处理的任务（只处理已开始请求的任务，排除 PENDING 状态）
 	    var nextTask = this.taskQueue.find(function (task) {
-	      return task.sequence === _this.currentSendingSequence + 1 && task.pendingResponses.length > 0;
+	      return task.sequence === _this.currentSendingSequence + 1 && task.status !== BroadcastTaskStatus.PENDING && task.pendingResponses.length > 0;
 	    });
 	    if (nextTask) {
 	      this.sendNextResponse(nextTask);
 	    }
-	    // 如果队列中没有剩余任务，则停止定时器
+	    // 如果队列中没有剩余任务（排除待处理、已完成、失败和取消的任务），则停止定时器
 	    var remainingTasks = this.taskQueue.filter(function (task) {
-	      return task.status !== BroadcastTaskStatus.COMPLETED && task.status !== BroadcastTaskStatus.FAILED && task.status !== BroadcastTaskStatus.CANCELLED;
+	      return task.status !== BroadcastTaskStatus.PENDING && task.status !== BroadcastTaskStatus.COMPLETED && task.status !== BroadcastTaskStatus.FAILED && task.status !== BroadcastTaskStatus.CANCELLED;
 	    });
 	    if (remainingTasks.length === 0) {
 	      this.clearQueueProcessTimer();
@@ -14213,7 +14238,7 @@
 	   */
 	  BroadcastService.prototype.startTaskRequest = function (task) {
 	    return __awaiter(this, void 0, void 0, function () {
-	      var apiUrl, requestBody;
+	      var apiUrl, requestBody, sdkError;
 	      var _this = this;
 	      var _a;
 	      return __generator(this, function (_b) {
@@ -14248,6 +14273,25 @@
 	            body: JSON.stringify(requestBody),
 	            signal: task.controller.signal,
 	            openWhenHidden: true,
+	            /**
+	             * 连接建立时的回调，用于检查 HTTP 状态码
+	             * @param response - HTTP 响应对象
+	             * @throws {SDKError} 当 HTTP 状态码异常时抛出对应的 SDKError
+	             */
+	            onopen: function onopen(response) {
+	              return __awaiter(_this, void 0, void 0, function () {
+	                var error;
+	                return __generator(this, function (_a) {
+	                  // 检查 HTTP 状态码，处理 401 token 过期等异常
+	                  if (!response.ok) {
+	                    error = this.createHttpError(response.status, response.statusText, task.id);
+	                    this.handleTaskError(task, error);
+	                    throw error;
+	                  }
+	                  return [2 /*return*/];
+	                });
+	              });
+	            },
 	            onmessage: function onmessage(event) {
 	              _this.handleTaskResponse(task, event.data);
 	            },
@@ -14255,12 +14299,15 @@
 	              _this.handleTaskClose(task);
 	            },
 	            onerror: function onerror(error) {
-	              _this.handleTaskError(task, error);
-	              throw new Error("Task ".concat(task.id, " request failed: ").concat(error));
+	              // 将所有异常统一转换为 SDKError
+	              var sdkError = _this.convertToSDKError(error, task.id);
+	              _this.handleTaskError(task, sdkError);
+	              throw sdkError;
 	            }
 	          });
 	        } catch (error) {
-	          this.handleTaskError(task, error);
+	          sdkError = this.convertToSDKError(error, task.id);
+	          this.handleTaskError(task, sdkError);
 	        }
 	        return [2 /*return*/];
 	      });
@@ -14278,7 +14325,7 @@
 	      var response = JSON.parse(data);
 	      // 错误处理
 	      if (response.code !== 0) {
-	        this.handleBroadcastError(response.code);
+	        this.handleBroadcastError(response.code, response.message);
 	        return;
 	      }
 	      // 处理音频数据
@@ -14292,6 +14339,7 @@
 	        task.pendingResponses.push(response);
 	        this.logger.debug('Response added to task', {
 	          taskId: task.id,
+	          response: response,
 	          pendingCount: task.pendingResponses.length
 	        });
 	        // 检查是否完成
@@ -14304,13 +14352,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
 	   */
 	  BroadcastService.prototype.sendNextResponse = function (task) {
@@ -14325,7 +14373,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: response,
 	      callbackFun: this.uniqueCallbackName,
@@ -14343,7 +14391,7 @@
 	  /**
 	   * 处理任务关闭
 	   * @param task - 播报任务
-	   * @description 处理任务的流式连接关闭
+	   * @description 处理任务的流式连接关闭，并启动下一个待处理任务的请求
 	   * @private
 	   */
 	  BroadcastService.prototype.handleTaskClose = function (task) {
@@ -14354,20 +14402,26 @@
 	    if (!task.isGenerationComplete && task.status === BroadcastTaskStatus.REQUESTING) {
 	      task.isGenerationComplete = true;
 	    }
+	    // 当前任务请求完成后（流断开后），启动下一个待处理任务的请求
+	    this.startNextPendingTask();
 	  };
 	  /**
 	   * 处理任务错误
 	   * @param task - 播报任务
 	   * @param error - 错误对象
-	   * @description 处理任务执行过程中的错误
+	   * @description 处理任务执行过程中的错误，防止重复触发错误回调，并启动下一个待处理任务
 	   * @private
 	   */
 	  BroadcastService.prototype.handleTaskError = function (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 - ".concat(task.id), error);
-	    // 触发错误回调
+	    // 触发错误回调（只触发一次）
 	    (_b = (_a = this.callbacks).onError) === null || _b === void 0 ? void 0 : _b.call(_a, error);
 	  };
 	  /**
@@ -14478,10 +14532,11 @@
 	  /**
 	   * 处理播报错误
 	   * @param errorCode - 错误码
+	   * @param errorMessage - 错误消息
 	   * @description 处理播报过程中的错误
 	   * @private
 	   */
-	  BroadcastService.prototype.handleBroadcastError = function (errorCode) {
+	  BroadcastService.prototype.handleBroadcastError = function (errorCode, errorMessage) {
 	    // 用户权益额度不存在错误码 14001
 	    // 用户权益额度不足错误码 14002
 	    // 用户权益额度冻结失败 14003
@@ -14496,10 +14551,32 @@
 	        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, "".concat(errorMessage, "(").concat(errorCode, ")") || "\u64AD\u62A5\u670D\u52A1\u9519\u8BEF(".concat(errorCode, ")")));
 	        break;
 	    }
 	  };
+	  /**
+	   * 启动下一个待处理任务的请求
+	   * @description 在当前任务请求完成或失败后，检查并启动下一个待处理任务
+	   * @private
+	   */
+	  BroadcastService.prototype.startNextPendingTask = function () {
+	    // 查找下一个待处理的任务（按序号排序，取第一个 PENDING 状态的任务）
+	    var nextPendingTask = this.taskQueue.filter(function (t) {
+	      return t.status === BroadcastTaskStatus.PENDING;
+	    }).sort(function (a, b) {
+	      return 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 清理队列处理定时器
@@ -14509,8 +14586,77 @@
 	    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
+	   */
+	  BroadcastService.prototype.createHttpError = function (status, statusText, taskId) {
+	    this.logger.warn("HTTP error occurred - Task: ".concat(taskId, ", Status: ").concat(status), {
+	      status: status,
+	      statusText: statusText
+	    });
+	    switch (status) {
+	      case 401:
+	        // Token 过期或未授权
+	        return new SDKError(exports.NetworkErrorCode.UNAUTHORIZED, "Token \u5DF2\u8FC7\u671F\u6216\u65E0\u6548\uFF0C\u8BF7\u91CD\u65B0\u6388\u6743 (HTTP ".concat(status, ")"));
+	      case 403:
+	        // 禁止访问
+	        return new SDKError(exports.NetworkErrorCode.UNAUTHORIZED, "\u65E0\u6743\u9650\u8BBF\u95EE\u8BE5\u8D44\u6E90 (HTTP ".concat(status, ")"));
+	      case 404:
+	        // 资源不存在
+	        return new SDKError(exports.NetworkErrorCode.SERVER_ERROR, "\u8BF7\u6C42\u7684\u8D44\u6E90\u4E0D\u5B58\u5728 (HTTP ".concat(status, ")"));
+	      case 500:
+	      case 502:
+	      case 503:
+	      case 504:
+	        // 服务器错误
+	        return new SDKError(exports.NetworkErrorCode.SERVER_ERROR, "\u670D\u52A1\u5668\u9519\u8BEF\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5 (HTTP ".concat(status, ")"));
+	      default:
+	        // 其他 HTTP 错误
+	        return new SDKError(exports.NetworkErrorCode.CONNECTION_FAILED, "\u7F51\u7EDC\u8BF7\u6C42\u5931\u8D25: ".concat(statusText || 'Unknown Error', " (HTTP ").concat(status, ")"));
+	    }
+	  };
+	  /**
+	   * 将任意错误转换为 SDKError
+	   * @param error - 原始错误对象
+	   * @param taskId - 任务 ID（用于日志记录）
+	   * @returns SDKError 实例
+	   * @description 统一将各种类型的错误转换为 SDKError，便于上层统一处理
+	   * @private
+	   */
+	  BroadcastService.prototype.convertToSDKError = function (error, taskId) {
+	    // 如果已经是 SDKError，直接返回
+	    if (error instanceof SDKError) {
+	      return error;
+	    }
+	    // 如果是普通 Error 对象
+	    if (error instanceof Error) {
+	      // 检查是否是网络相关的错误
+	      var errorMessage_1 = error.message.toLowerCase();
+	      if (errorMessage_1.includes('timeout') || errorMessage_1.includes('timed out')) {
+	        return new SDKError(exports.NetworkErrorCode.REQUEST_TIMEOUT, "\u8BF7\u6C42\u8D85\u65F6 - Task: ".concat(taskId), error);
+	      }
+	      if (errorMessage_1.includes('network') || errorMessage_1.includes('fetch') || errorMessage_1.includes('connection')) {
+	        return new SDKError(exports.NetworkErrorCode.CONNECTION_FAILED, "\u7F51\u7EDC\u8FDE\u63A5\u5931\u8D25 - Task: ".concat(taskId, ": ").concat(error.message), error);
+	      }
+	      if (errorMessage_1.includes('abort') || errorMessage_1.includes('cancel')) {
+	        return new SDKError(exports.OperationErrorCode.OPERATION_CANCELLED, "\u64CD\u4F5C\u5DF2\u53D6\u6D88 - Task: ".concat(taskId), error);
+	      }
+	      // 默认作为操作失败处理
+	      return new SDKError(exports.OperationErrorCode.OPERATION_FAILED, "\u64AD\u62A5\u4EFB\u52A1\u6267\u884C\u5931\u8D25 - Task: ".concat(taskId, ": ").concat(error.message), error);
+	    }
+	    // 如果是字符串或其他类型
+	    var errorMessage = String(error);
+	    return new SDKError(exports.OperationErrorCode.OPERATION_FAILED, "\u64AD\u62A5\u4EFB\u52A1\u6267\u884C\u5931\u8D25 - Task: ".concat(taskId, ": ").concat(errorMessage));
+	  };
 	  return BroadcastService;
 	}(UnityBaseService);
 
@@ -14648,6 +14794,7 @@
 	   */
 	  ZEEAvatarLoader.prototype.initGlobalConfig = function () {
 	    var config = ConfigManager.getInstance().getConfig();
+	    var assetsFrom = config.assetsFrom;
 	    var globalParams = {
 	      token: config === null || config === void 0 ? void 0 : config.token,
 	      apiBaseUrl: ConfigManager.getInstance().getApiBaseUrl(false),
@@ -14655,14 +14802,17 @@
 	      // 純AB包方案在SDK 2.1.0 中已弃用
 	      // assetsUrl: config?.assetsUrl
 	    };
-	    var 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') {
+	      var 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);
+	    }
 	  };
 	  return ZEEAvatarLoader;
 	}();