agora-foundation 3.8.2 → 3.9.0-alpha

package/lib-es/decorator/log/handler.js

@@ -1,77 +1,69 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import "core-js/modules/es.array.concat.js";
-import "core-js/modules/es.date.to-string.js";
-import "core-js/modules/es.function.name.js";
+import "core-js/modules/es.date.now.js";
 import { Result } from '../../utilities/interceptor';
-import { randomString } from '../../utilities/misc';
 import { InvocationEventType } from '../type';
 import { serialize, serializeArgs } from './log-serializer';
-var formatCallLog = function formatCallLog(identifier, args) {
-  var msg = '';
+var InvocationEventTypeToString = _defineProperty(_defineProperty({}, InvocationEventType.API_CALL, '[API Call]'), InvocationEventType.API_RETURN, '[API Return]');
+
+// 方法返回错误码时对应的描述
+var ReasonCodeToString = _defineProperty(_defineProperty({}, -1, 'FAILED'), 0, 'SUCCESS');
+var formatLogHead = function formatLogHead(identifier, tag, args, argsNames) {
+  var elapsed = Date.now() - identifier.startTs;
+  var parameters = '[parameters: []]';
+  var duration = "[duration: ".concat(elapsed, "ms]");
   if (args !== null && args !== void 0 && args.length) {
-    msg += "[parameters: ".concat(serializeArgs(args), "]");
+    parameters = "[parameters: [".concat(serializeArgs(args, argsNames), "]]");
   }
-  return "".concat(identifier.methodName, " [API Call]").concat(msg, "[traceId: ").concat(identifier.traceId, "]");
+  return "".concat(identifier.methodName, ": ").concat(tag, " ").concat(parameters, " ").concat(duration);
 };
-
-// const formatReturnLog = (
-//   identifier: { className: string; methodName: string; traceId: string },
-//   elapsed: number,
-//   args?: unknown[],
-//   returnValue?: unknown,
-//   thrown?: Error,
-// ) => {
-//   let msg = '';
-//   if (args?.length) {
-//     msg += `[parameters: ${serializeArgs(args)}]`;
-//   }
-
-//   if (thrown) {
-//     msg += `[throw: ${thrown.name}]`;
-//     msg += `[message: ${thrown.message}]`;
-//   } else if (typeof returnValue !== 'undefined') {
-//     msg += `[return: ${serialize(returnValue)}]`;
-//   }
-
-//   return `${identifier.methodName} [API Call]${msg}[elapsed: ${elapsed}ms]`;
-// };
-
-export var createLogHandler = function createLogHandler(holder) {
+var formatLogReturn = function formatLogReturn(returnValue) {
+  return "[message: { return: ".concat(serialize(returnValue), " }]");
+};
+var formatLogReason = function formatLogReason(reasonCode) {
+  return "[message: { reason: ".concat(reasonCode, ": ").concat(ReasonCodeToString[reasonCode] || 'UNKNOWN', " }]");
+};
+var formatLogError = function formatLogError(error) {
+  return "[message: { error: { code: ".concat(error.code, ", message: ").concat(error.message, " } }]");
+};
+var printReturnOrReason = function printReturnOrReason(logger, returnValue, getMsg, isShowReasonCode) {
+  if (isShowReasonCode && typeof returnValue === 'number' && returnValue !== 0) {
+    var msgBody = " ".concat(formatLogReason(returnValue));
+    logger.warn(getMsg(msgBody));
+  } else {
+    var _msgBody = " ".concat(formatLogReturn(returnValue));
+    logger.info(getMsg(_msgBody));
+  }
+};
+export var createLogHandler = function createLogHandler(holder, isErrorCodeByReturnValue) {
   return function (evt) {
-    if (evt.type === InvocationEventType.PRE) {
-      var _evt$arguments;
-      evt.context.start = new Date().getTime();
-      evt.context.traceId = randomString(5);
-      var msg = formatCallLog({
-        className: evt["class"],
-        methodName: evt.method,
-        traceId: evt.context.traceId
-      }, (_evt$arguments = evt.arguments) !== null && _evt$arguments !== void 0 ? _evt$arguments : []);
-      holder.logger.info(msg);
-    } else {
-      var elapsed = new Date().getTime() - evt.context.start;
-      // const msg = formatReturnLog(
-      //   {
-      //     className: evt.class,
-      //     methodName: evt.method,
-      //     traceId: evt.context.traceId,
-      //   },
-      //   elapsed,
-      //   evt.arguments ?? [],
-      //   evt.return,
-      //   evt.error,
-      // );
-      // if (evt.error) {
-      //   holder.logger.error(msg);
-      // } else {
-      //   holder.logger.info(msg);
-      // }
-
+    var _evt$arguments, _evt$argumentNames;
+    var msgHead = formatLogHead({
+      className: evt["class"],
+      methodName: evt.method,
+      startTs: evt.context.start,
+      isThenable: evt.context.isThenable
+    }, InvocationEventTypeToString[evt.type], (_evt$arguments = evt.arguments) !== null && _evt$arguments !== void 0 ? _evt$arguments : [], (_evt$argumentNames = evt.argumentNames) !== null && _evt$argumentNames !== void 0 ? _evt$argumentNames : []);
+    var msgFoot = " [traceId: ".concat(evt.context.traceId, "]");
+    var getMsg = function getMsg() {
+      var msgBody = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+      return "".concat(msgHead).concat(msgBody).concat(msgFoot);
+    };
+    if (evt.type === InvocationEventType.API_CALL) {
+      if (evt.context.isThenable === true) {
+        // 异步方法只打印调用信息, 在 API_RETURN 时打印返回值等信息
+        holder.logger.info(getMsg());
+      } else {
+        // 同步方法的打印内容包含返回值, 错误码等信息(如果有的话)
+        printReturnOrReason(holder.logger, evt["return"], getMsg, isErrorCodeByReturnValue);
+      }
+    } else if (evt.type === InvocationEventType.API_RETURN) {
       if (evt.error) {
-        var _msg = "".concat(evt.method, " [throw: ").concat(evt.error.name, "][message: ").concat(evt.error.message, "][elapsed: ").concat(elapsed, "ms][traceId: ").concat(evt.context.traceId, "]");
-        holder.logger.error(_msg);
+        var msgBody = " ".concat(formatLogError(evt.error));
+        holder.logger.error(getMsg(msgBody));
       } else {
-        var _msg2 = "".concat(evt.method, " [return: ").concat(serialize(evt["return"]), "][elapsed: ").concat(elapsed, "ms][traceId: ").concat(evt.context.traceId, "]");
-        holder.logger.info(_msg2);
+        // 异步方法在此处打印返回值, 错误码等信息(如果有的话)
+        printReturnOrReason(holder.logger, evt["return"], getMsg, isErrorCodeByReturnValue);
       }
     }
     return Result.CONTINUE;

package/lib-es/decorator/log/index.js

@@ -1,3 +1,4 @@
+import _typeof from "@babel/runtime/helpers/typeof";
 import "core-js/modules/es.function.name.js";
 import { proxyMethod } from '../proxy';
 import { createLogHandler } from './handler';
@@ -8,7 +9,7 @@ import { getLogger } from '../../logger';
  * @param targetOrProto The class or prototype that the method belongs to.
  * @param methodName The name of the method.
  */
-var _trace = function _trace(originalMethod, context) {
+var _trace = function _trace(originalMethod, context, paramNames, isErrorCodeByReturnValue) {
   var methodName = String(context.name);
   if (context.kind === 'method') {
     context.addInitializer(function () {
@@ -20,9 +21,53 @@ var _trace = function _trace(originalMethod, context) {
       if (!this.logger) {
         this.logger = logger;
       }
-      var handler = createLogHandler(this);
-      this[context.name] = proxyMethod(this[context.name], this, methodName, handler);
+      var handler = createLogHandler(this, isErrorCodeByReturnValue);
+      this[context.name] = proxyMethod(this[context.name], this, methodName, handler, paramNames);
     });
   }
 };
-export var trace = _trace;
+
+/**
+ * @description
+ * 函数入参使用参数范型, 支持以下三种用法:
+ * 1. 直接作为装饰器使用: `@trace method() {}`
+ * 2. 作为工厂函数使用, 支持传入参数名称数组, 标识返回值是否是错误码(可选), 返回装饰器函数 `@trace(['param1', 'param2'], bolean?)`
+ * 3. 作为工厂函数使用, 仅标识返回值是否是错误码, 返回装饰器函数 `@trace(boolean)`
+ * @example
+ * `@trace method() {}`
+ * `@trace(['name1', 'name2']) method(name1: string, name2: number) {}`
+ * `@trace(['name1', 'name2'], true) method(name1: string, name2: number) {}`
+ * `@trace(true) method() {}`
+ */
+
+/**
+ * @description 仅标识返回值是否是错误码, 返回装饰器函数 `@trace(boolean)`
+ * @param isErrorCodeByReturnValue - 返回值是否是错误码
+ */
+
+/**
+ * @description 作为工厂函数使用, 支持传入参数名称数组, 标识返回值是否是错误码(可选), 返回装饰器函数 `@trace(['param1', 'param2'], bolean?)`
+ * @param paramNames - 参数名称数组
+ * @param [isErrorCodeByReturnValue] - 返回值是否是错误码（可选）
+ */
+
+function trace() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+  if (args.length === 2 && _typeof(args[1]) === 'object') {
+    // 直接作为装饰器使用
+    _trace(args[0], args[1]);
+  } else if (args.length === 1 && typeof args[0] === 'boolean') {
+    // 作为工厂函数使用, 仅标识返回值是否是错误码
+    return function (originalMethod, context) {
+      _trace(originalMethod, context, undefined, args[0]);
+    };
+  } else {
+    // 作为工厂函数使用, 支持传入参数名称数组, 标识返回值是否是错误码(可选)
+    return function (originalMethod, context) {
+      _trace(originalMethod, context, args[0], args[1]);
+    };
+  }
+}
+export { trace };

package/lib-es/decorator/log/log-serializer.js

@@ -1,3 +1,4 @@
+import "core-js/modules/es.array.concat.js";
 import "core-js/modules/es.array.join.js";
 import "core-js/modules/es.array.map.js";
 import "core-js/modules/es.object.to-string.js";
@@ -10,6 +11,18 @@ export var serialize = function serialize(data) {
   }
   return "".concat(jsonstring(data));
 };
-export var serializeArgs = function serializeArgs(args) {
-  return "".concat(args.map(serialize).join(' '));
+export var serializeArgs = function serializeArgs(args, argsNames) {
+  if (argsNames) {
+    var lastIndex = args.length - 1;
+    var str = '';
+    for (var i = 0; i < args.length; i++) {
+      var key = argsNames[i] ? "".concat(argsNames[i], ": ") : '';
+      str += "".concat(key).concat(serialize(args[i]));
+      if (i < lastIndex) {
+        str += ', ';
+      }
+    }
+    return str;
+  }
+  return "".concat(args.map(serialize).join(', '));
 };

package/lib-es/decorator/proxy.js

@@ -11,6 +11,7 @@ import "core-js/modules/es.array.concat.js";
 import "core-js/modules/es.array.for-each.js";
 import "core-js/modules/es.array.index-of.js";
 import "core-js/modules/es.array.push.js";
+import "core-js/modules/es.date.now.js";
 import "core-js/modules/es.function.name.js";
 import "core-js/modules/es.object.define-property.js";
 import "core-js/modules/es.object.get-own-property-descriptor.js";
@@ -24,28 +25,27 @@ import "core-js/modules/es.reflect.construct.js";
 import "core-js/modules/esnext.iterator.constructor.js";
 import "core-js/modules/esnext.iterator.for-each.js";
 import "core-js/modules/web.dom-collections.for-each.js";
+import { randomString } from '../utilities/misc';
 import { InvocationEventType } from './type';
 var failQuitely = function failQuitely(func, args) {
   try {
     return func.apply(void 0, _toConsumableArray(args));
   } catch (e) {}
 };
-var invokeMethod = function invokeMethod(instance, method, proto, propertyName, args, hanlder) {
+var invokeMethod = function invokeMethod(instance, method, proto, propertyName, args, hanlder, paramNames) {
   var context = {};
-  failQuitely(hanlder, [{
-    type: InvocationEventType.PRE,
-    arguments: args,
-    method: propertyName,
-    "class": proto.constructor.__$$className || proto.constructor.name,
-    context: context
-  }]);
+  context.start = Date.now();
+  context.traceId = randomString(5);
 
   // provide a way for invoking method regardless it is async or sync function, attach the return value and the error(if it occurred) to the event object
   var returnVal = method.apply(instance, args);
-  var post = function post(val, error) {
+  var isThenable = returnVal && !!returnVal.then;
+  context.isThenable = isThenable;
+  var post = function post(type, val, error) {
     failQuitely(hanlder, [{
-      type: InvocationEventType.POST,
+      type: type,
       arguments: args,
+      argumentNames: paramNames,
       "return": val,
       method: propertyName,
       "class": proto.constructor.__$$className || proto.constructor.name,
@@ -53,7 +53,9 @@ var invokeMethod = function invokeMethod(instance, method, proto, propertyName,
       error: error
     }]);
   };
-  var isThenable = returnVal && !!returnVal.then;
+
+  // 同步/异步函数调用结束时输出日志,（异步函数函数不等待异步结束）
+  post(InvocationEventType.API_CALL, returnVal);
   if (isThenable) {
     // capture async return and potential error
     var rtnTemp, errTemp;
@@ -62,19 +64,17 @@ var invokeMethod = function invokeMethod(instance, method, proto, propertyName,
     })["catch"](function (e) {
       errTemp = e;
     })["finally"](function () {
-      post(rtnTemp, errTemp);
+      post(InvocationEventType.API_RETURN, rtnTemp, errTemp);
     });
-  } else {
-    post(returnVal);
   }
   return returnVal;
 };
-export var proxyMethod = function proxyMethod(method, proto, propertyName, handler) {
+export var proxyMethod = function proxyMethod(method, proto, propertyName, handler, paramNames) {
   return function () {
     for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
       args[_key] = arguments[_key];
     }
-    return invokeMethod(this, method, proto, propertyName, args, handler);
+    return invokeMethod(this, method, proto, propertyName, args, handler, paramNames);
   };
 };
 var getMethods = function getMethods(target) {

package/lib-es/decorator/type.js

@@ -1,6 +1,6 @@
 export var InvocationEventType = /*#__PURE__*/function (InvocationEventType) {
-  InvocationEventType[InvocationEventType["PRE"] = 0] = "PRE";
-  InvocationEventType[InvocationEventType["POST"] = 1] = "POST";
+  InvocationEventType[InvocationEventType["API_CALL"] = 0] = "API_CALL";
+  InvocationEventType[InvocationEventType["API_RETURN"] = 1] = "API_RETURN";
   return InvocationEventType;
 }({});
 

package/lib-es/utilities/desc-type.js

@@ -1,3 +1,3 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import { FcrApplicationPlatform } from './env';
-export var FcrApplicationPlatformDescType = _defineProperty(_defineProperty(_defineProperty(_defineProperty({}, FcrApplicationPlatform.WEB_DESKTOP, 'webDesktop'), FcrApplicationPlatform.MACOS, 'macOS'), FcrApplicationPlatform.WINDOWS, 'windows'), FcrApplicationPlatform.WEB_MOBILE, 'webMobile');
+export var FcrApplicationPlatformDescType = _defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, FcrApplicationPlatform.WEB_DESKTOP, 'webDesktop'), FcrApplicationPlatform.MACOS, 'macOS'), FcrApplicationPlatform.WINDOWS, 'windows'), FcrApplicationPlatform.WEB_MOBILE, 'webMobile'), FcrApplicationPlatform.HARMONY, 'harmony');

package/lib-es/utilities/env.js

@@ -18,6 +18,7 @@ export var FcrApplicationPlatform = /*#__PURE__*/function (FcrApplicationPlatfor
   FcrApplicationPlatform[FcrApplicationPlatform["MACOS"] = 2] = "MACOS";
   FcrApplicationPlatform[FcrApplicationPlatform["WINDOWS"] = 3] = "WINDOWS";
   FcrApplicationPlatform[FcrApplicationPlatform["WEB_MOBILE"] = 6] = "WEB_MOBILE";
+  FcrApplicationPlatform[FcrApplicationPlatform["HARMONY"] = 7] = "HARMONY";
   return FcrApplicationPlatform;
 }({});
 export var getPlatform = function getPlatform() {

package/lib-es/utilities/error/agora-error.js

@@ -0,0 +1,140 @@
+import "core-js/modules/es.reflect.construct.js";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _wrapNativeSuper from "@babel/runtime/helpers/wrapNativeSuper";
+import "core-js/modules/es.error.cause.js";
+import "core-js/modules/es.error.to-string.js";
+import "core-js/modules/es.array.concat.js";
+import "core-js/modules/es.array.filter.js";
+import "core-js/modules/es.array.find.js";
+import "core-js/modules/es.array.slice.js";
+import "core-js/modules/es.number.constructor.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.object.values.js";
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.filter.js";
+import "core-js/modules/esnext.iterator.find.js";
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+import padStart from 'lodash/padStart';
+import padEnd from 'lodash/padEnd';
+import { DetailErrorCode, ErrorServiceType } from './error-code';
+export var AgoraError = /*#__PURE__*/function (_Error) {
+  function AgoraError(params) {
+    var _this;
+    _classCallCheck(this, AgoraError);
+    _this = _callSuper(this, AgoraError, [params.message]);
+    _this._code = params.code;
+    _this._message = params.message;
+    _this._cause = params.cause || '';
+    return _this;
+  }
+  _inherits(AgoraError, _Error);
+  return _createClass(AgoraError, [{
+    key: "code",
+    get: function get() {
+      return this._code;
+    }
+  }, {
+    key: "message",
+    get: function get() {
+      return this._message;
+    }
+  }], [{
+    key: "createCode",
+    value: function createCode(_ref) {
+      var serviceCode = _ref.serviceCode,
+        moduleCode = _ref.moduleCode,
+        detailCode = _ref.detailCode;
+      // 生成9位数错误代码：前3位是错误类型，中间3位是模块代码，后3位是具体错误代码
+      var errorType = padEnd(String(serviceCode), 3, '0'); // 如：'100'
+      var moduleStr = padStart(String(moduleCode), 3, '0'); // 如：'020'
+      var errorCode = padStart(String(detailCode), 3, '0'); // 如：'001'
+
+      return Number("".concat(errorType).concat(moduleStr).concat(errorCode)); // 如：'100020001'
+    }
+  }, {
+    key: "getServiceType",
+    value: function getServiceType(errorCode) {
+      var str = String(errorCode);
+      if (str.length !== 9) {
+        return undefined;
+      }
+      var servicePrefix = str.slice(0, 3);
+      var serviceTypes = Object.values(ErrorServiceType).filter(function (v) {
+        return typeof v === 'number';
+      });
+      return serviceTypes.find(function (type) {
+        return padEnd(String(type), 3, '0') === servicePrefix;
+      });
+    }
+  }, {
+    key: "create",
+    value: function create(service, module, errorCode, message, cause) {
+      var domain = getDomain(service);
+      var fullMessage = "domain: ".concat(domain, ", info: ").concat(message);
+      var fullCode = AgoraError.createCode({
+        serviceCode: service,
+        moduleCode: module,
+        detailCode: errorCode
+      });
+      var causeMessage = '';
+      if (cause instanceof Error) {
+        causeMessage = cause.message;
+      } else if (cause) {
+        causeMessage = String(cause);
+      }
+      return new AgoraError({
+        code: fullCode,
+        message: fullMessage,
+        cause: causeMessage
+      });
+    }
+  }, {
+    key: "createWithAny",
+    value: function createWithAny(error, message) {
+      if (error instanceof AgoraError) {
+        return error;
+      } else {
+        var code = DetailErrorCode.UNDEFINED_ERROR;
+        if (error instanceof Error) {
+          if (error.cause) {
+            message = message + ", error cause: ".concat(error.cause);
+          }
+        }
+        var agoraError = new AgoraError({
+          code: code,
+          message: message
+        });
+        return agoraError;
+      }
+    }
+  }]);
+}(/*#__PURE__*/_wrapNativeSuper(Error));
+var getDomain = function getDomain(service) {
+  switch (service) {
+    case ErrorServiceType.RTE_CLIENT:
+      return 'RTE-CLIENT';
+    case ErrorServiceType.RTE_SERVER:
+      return 'RTE-SRV';
+    case ErrorServiceType.NATIVE_RTC:
+      return 'RTC';
+    case ErrorServiceType.WEB_RTC:
+      return 'WebRTC';
+    case ErrorServiceType.RTM_SDK:
+      return 'RTM';
+    case ErrorServiceType.FCR_CLIENT:
+      return 'CORE-CLIENT';
+    case ErrorServiceType.FCR_SERVER:
+      return 'CORE-SRV';
+    case ErrorServiceType.FCR_UI_SCENE:
+      return 'UI-SCENE';
+    case ErrorServiceType.DEMO_SERVER:
+      return 'DEMO-SRV';
+    default:
+      return 'UNDEFINED';
+  }
+};

package/lib-es/utilities/error/error-code.js

@@ -0,0 +1,74 @@
+export var ErrorServiceType = /*#__PURE__*/function (ErrorServiceType) {
+  ErrorServiceType[ErrorServiceType["RTE_CLIENT"] = 1] = "RTE_CLIENT";
+  ErrorServiceType[ErrorServiceType["RTE_SERVER"] = 2] = "RTE_SERVER";
+  ErrorServiceType[ErrorServiceType["NATIVE_RTC"] = 3] = "NATIVE_RTC";
+  ErrorServiceType[ErrorServiceType["WEB_RTC"] = 4] = "WEB_RTC";
+  ErrorServiceType[ErrorServiceType["RTM_SDK"] = 5] = "RTM_SDK";
+  ErrorServiceType[ErrorServiceType["FCR_CLIENT"] = 6] = "FCR_CLIENT";
+  ErrorServiceType[ErrorServiceType["FCR_SERVER"] = 7] = "FCR_SERVER";
+  ErrorServiceType[ErrorServiceType["FCR_UI_SCENE"] = 8] = "FCR_UI_SCENE";
+  ErrorServiceType[ErrorServiceType["DEMO_SERVER"] = 9] = "DEMO_SERVER";
+  return ErrorServiceType;
+}({});
+export var ErrorModuleCode = /*#__PURE__*/function (ErrorModuleCode) {
+  ErrorModuleCode[ErrorModuleCode["NO_MODULE"] = 0] = "NO_MODULE";
+  ErrorModuleCode[ErrorModuleCode["RTE_ENGINE"] = 10] = "RTE_ENGINE";
+  ErrorModuleCode[ErrorModuleCode["RTE_SCENE"] = 20] = "RTE_SCENE";
+  ErrorModuleCode[ErrorModuleCode["RTE_SCENE_LOCAL_USER"] = 21] = "RTE_SCENE_LOCAL_USER";
+  ErrorModuleCode[ErrorModuleCode["RTE_SCENE_STREAM_PLAYER"] = 22] = "RTE_SCENE_STREAM_PLAYER";
+  ErrorModuleCode[ErrorModuleCode["RTE_MEDIA"] = 30] = "RTE_MEDIA";
+  ErrorModuleCode[ErrorModuleCode["RTE_MEDIA_CAMERA"] = 31] = "RTE_MEDIA_CAMERA";
+  ErrorModuleCode[ErrorModuleCode["RTE_MEDIA_MICROPHONE"] = 32] = "RTE_MEDIA_MICROPHONE";
+  ErrorModuleCode[ErrorModuleCode["RTE_MEDIA_LOOPBACK"] = 33] = "RTE_MEDIA_LOOPBACK";
+  ErrorModuleCode[ErrorModuleCode["RTE_MEDIA_SCREEN"] = 34] = "RTE_MEDIA_SCREEN";
+  ErrorModuleCode[ErrorModuleCode["RTE_MONITOR"] = 40] = "RTE_MONITOR";
+  ErrorModuleCode[ErrorModuleCode["RTE_AP_DETECTOR"] = 50] = "RTE_AP_DETECTOR";
+  // FcrCoreModuleErrorCode
+  ErrorModuleCode[ErrorModuleCode["FCR_ENGINE"] = 10] = "FCR_ENGINE";
+  ErrorModuleCode[ErrorModuleCode["FCR_ENGINE_PEER_SESSION"] = 11] = "FCR_ENGINE_PEER_SESSION";
+  ErrorModuleCode[ErrorModuleCode["FCR_ROOM"] = 20] = "FCR_ROOM";
+  ErrorModuleCode[ErrorModuleCode["FCR_ROOM_USER"] = 21] = "FCR_ROOM_USER";
+  ErrorModuleCode[ErrorModuleCode["FCR_STREAM"] = 22] = "FCR_STREAM";
+  ErrorModuleCode[ErrorModuleCode["FCR_ROOM_STREAM"] = 22] = "FCR_ROOM_STREAM";
+  ErrorModuleCode[ErrorModuleCode["FCR_ROOM_GROUP"] = 23] = "FCR_ROOM_GROUP";
+  ErrorModuleCode[ErrorModuleCode["FCR_ROOM_CHATROOM"] = 24] = "FCR_ROOM_CHATROOM";
+  ErrorModuleCode[ErrorModuleCode["FCR_ROOM_SESSION"] = 25] = "FCR_ROOM_SESSION";
+  ErrorModuleCode[ErrorModuleCode["FCR_ROOM_PRIVILEGE"] = 26] = "FCR_ROOM_PRIVILEGE";
+  ErrorModuleCode[ErrorModuleCode["FCR_ROOM_WHITEBOARD"] = 27] = "FCR_ROOM_WHITEBOARD";
+  ErrorModuleCode[ErrorModuleCode["FCR_ROOM_CONNECTOR"] = 28] = "FCR_ROOM_CONNECTOR";
+  ErrorModuleCode[ErrorModuleCode["FCR_ROOM_INTERPRETER"] = 29] = "FCR_ROOM_INTERPRETER";
+  ErrorModuleCode[ErrorModuleCode["FCR_MEDIA_CONTROL"] = 30] = "FCR_MEDIA_CONTROL";
+  ErrorModuleCode[ErrorModuleCode["FCR_MEDIA_CONTROL_CAMERA"] = 31] = "FCR_MEDIA_CONTROL_CAMERA";
+  ErrorModuleCode[ErrorModuleCode["FCR_MEDIA_CONTROL_MICROPHONE"] = 32] = "FCR_MEDIA_CONTROL_MICROPHONE";
+  ErrorModuleCode[ErrorModuleCode["FCR_MEDIA_CONTROL_LOOPBACK"] = 33] = "FCR_MEDIA_CONTROL_LOOPBACK";
+  ErrorModuleCode[ErrorModuleCode["FCR_MEDIA_CONTROL_SCREEN"] = 34] = "FCR_MEDIA_CONTROL_SCREEN";
+  ErrorModuleCode[ErrorModuleCode["FCR_ROOM_STT"] = 35] = "FCR_ROOM_STT";
+  ErrorModuleCode[ErrorModuleCode["FCR_MONITOR"] = 40] = "FCR_MONITOR";
+  ErrorModuleCode[ErrorModuleCode["FCR_ROOM_LIVE_STREAMING"] = 41] = "FCR_ROOM_LIVE_STREAMING";
+  // FcrUISceneModuleErrorCode
+  ErrorModuleCode[ErrorModuleCode["FCR_UI_SCENE_CREATOR"] = 10] = "FCR_UI_SCENE_CREATOR";
+  return ErrorModuleCode;
+}({});
+export var DetailErrorCode = /*#__PURE__*/function (DetailErrorCode) {
+  DetailErrorCode[DetailErrorCode["UNDEFINED"] = 1] = "UNDEFINED";
+  DetailErrorCode[DetailErrorCode["UNDEFINED_ERROR"] = 1] = "UNDEFINED_ERROR";
+  DetailErrorCode[DetailErrorCode["INVALID_PARAMS"] = 10] = "INVALID_PARAMS";
+  DetailErrorCode[DetailErrorCode["JSON_PARSE_ERROR"] = 11] = "JSON_PARSE_ERROR";
+  DetailErrorCode[DetailErrorCode["LOCAL_HTTP_REQUEST_FAILED"] = 12] = "LOCAL_HTTP_REQUEST_FAILED";
+  DetailErrorCode[DetailErrorCode["NOT_LOGGED_IN"] = 13] = "NOT_LOGGED_IN";
+  DetailErrorCode[DetailErrorCode["NOT_JOINED_ROOM"] = 14] = "NOT_JOINED_ROOM";
+  DetailErrorCode[DetailErrorCode["EXPIRED"] = 15] = "EXPIRED";
+  DetailErrorCode[DetailErrorCode["JOIN_CONFLICT"] = 15] = "JOIN_CONFLICT";
+  DetailErrorCode[DetailErrorCode["UNAUTHORIZED"] = 16] = "UNAUTHORIZED";
+  DetailErrorCode[DetailErrorCode["JOIN_FAILED"] = 21] = "JOIN_FAILED";
+  DetailErrorCode[DetailErrorCode["JOIN_TIMEOUT"] = 22] = "JOIN_TIMEOUT";
+  DetailErrorCode[DetailErrorCode["AP_DETECT_FAILED"] = 51] = "AP_DETECT_FAILED";
+  DetailErrorCode[DetailErrorCode["PROCESS_START_FAILED"] = 81] = "PROCESS_START_FAILED";
+  DetailErrorCode[DetailErrorCode["WINDOW_HIDDEN_BEFORE_JOIN"] = 82] = "WINDOW_HIDDEN_BEFORE_JOIN";
+  DetailErrorCode[DetailErrorCode["WINDOW_CLOSED_BEFORE_JOIN"] = 83] = "WINDOW_CLOSED_BEFORE_JOIN";
+  DetailErrorCode[DetailErrorCode["LAUNCH_IN_PROGRESS"] = 84] = "LAUNCH_IN_PROGRESS";
+  DetailErrorCode[DetailErrorCode["PROCESS_CRASHED"] = 86] = "PROCESS_CRASHED";
+  DetailErrorCode[DetailErrorCode["PROCESS_NOT_RESPONDING"] = 87] = "PROCESS_NOT_RESPONDING";
+  DetailErrorCode[DetailErrorCode["JOIN_RTC_TIMEOUT"] = 10] = "JOIN_RTC_TIMEOUT";
+  return DetailErrorCode;
+}({});