Merge remote-tracking branch 'origin/master'

chenyao

2025-11-19 28179be2881f3a6af9975136c013b0f0ca2298df

Merge remote-tracking branch 'origin/master'

 package.json

@@ -75,7 +75,6 @@
    "@dcloudio/uni-mp-xhs": "3.0.0-4070520250711001",
    "@dcloudio/uni-quickapp-webview": "3.0.0-4070520250711001",
    "@dcloudio/uni-ui": "^1.5.11",
    "@trtc/calls-uikit-vue": "^4.2.4",
    "dayjs": "^1.11.18",
    "js-audio-recorder": "^1.0.7",
    "js-base64": "^3.7.4",
@@ -83,6 +82,7 @@
    "leaflet": "^1.9.4",
    "pinia": "2.2.4",
    "pinia-plugin-persistedstate": "4.1.3",
    "trtc-sdk-v5": "^5.14.1",
    "uview-plus": "^3.5.41",
    "vue": "3.4.21",
    "vue-i18n": "9.1.9",

 pnpm-lock.yaml

@@ -59,9 +59,6 @@
  '@dcloudio/uni-ui':
    specifier: ^1.5.11
    version: 1.5.11
  '@trtc/calls-uikit-vue':
    specifier: ^4.2.4
    version: 4.2.4
  dayjs:
    specifier: ^1.11.18
    version: 1.11.18
@@ -83,6 +80,9 @@
  pinia-plugin-persistedstate:
    specifier: 4.1.3
    version: 4.1.3(pinia@2.2.4)
  trtc-sdk-v5:
    specifier: ^5.14.1
    version: 5.14.1
  uview-plus:
    specifier: ^3.5.41
    version: 3.5.41
@@ -3904,39 +3904,10 @@
      picomatch: 4.0.3
    dev: true

  /@tencentcloud/lite-chat@1.6.1:
    resolution: {integrity: sha512-+L+pB7caVRCe11054j2gVEr6mVi2AeChCMu85qAhOqnjD7lm6lsAtnLL2a60Emb+GpsiRQhrcFwBkkPArMcJAg==}
    dev: false

  /@tencentcloud/tui-core-lite@1.0.0:
    resolution: {integrity: sha512-+nmOWQ415Kz6aYJDv4EIdnaLk69SPWscZqmIhQp9GhNGFVq4/u+gC/sWvGHEOICJncFjM4dUxBg9EFfzD78rGQ==}
    dependencies:
      '@tencentcloud/lite-chat': 1.6.1
    dev: false

  /@tootallnate/once@1.1.2:
    resolution: {integrity: sha512-RbzJvlNzmRq5c3O09UipeuXno4tA1FE6ikOjxZK0tuxVv3412l64l5t1W5pj4+rJq9vpkm/kwiR07aZXnsKPxw==}
    engines: {node: '>= 6'}
    dev: true

  /@trtc/call-engine-lite-js@3.4.7:
    resolution: {integrity: sha512-3XxfducL+PzAML8psinqyPBk1v7QRzb4vMzOo5iHM4uYv0Gh7lc3U8PvGUqrAw0+oSB6zLbAtYIS7zTim3I2GA==}
    dependencies:
      '@tencentcloud/lite-chat': 1.6.1
      core-js: 3.45.1
      eventemitter3: 4.0.7
      rtc-detect: 0.0.5
      trtc-cloud-js-sdk: 2.9.3
      tuikit-logger: 0.0.4-beta.1
    dev: false

  /@trtc/calls-uikit-vue@4.2.4:
    resolution: {integrity: sha512-dXWdRadnx8fKvRiZiFmkwUkT53BzodDucW9x4JpNDU4V7JP5k8u6/APK6xzO563TLTBG72FkxByy8t1Z9ZUfCQ==}
    dependencies:
      '@tencentcloud/lite-chat': 1.6.1
      '@tencentcloud/tui-core-lite': 1.0.0
      '@trtc/call-engine-lite-js': 3.4.7
    dev: false

  /@types/babel__core@7.20.5:
    resolution: {integrity: sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==}
@@ -4471,7 +4442,7 @@
    engines: {node: ^14.18.0 || >=16.0.0}
    peerDependencies:
      vite: ^4.0.0 || ^5.0.0
      vue: ^3.0.0
      vue: 3.4.21
    dependencies:
      '@babel/core': 7.28.4
      '@babel/plugin-transform-typescript': 7.28.0(@babel/core@7.28.4)
@@ -4487,7 +4458,7 @@
    engines: {node: ^18.0.0 || >=20.0.0}
    peerDependencies:
      vite: ^5.0.0
      vue: ^3.2.25
      vue: 3.4.21
    dependencies:
      vite: 5.2.8(sass@1.79.6)(terser@5.44.0)
      vue: 3.4.21(typescript@5.9.3)
@@ -4637,7 +4608,7 @@
  /@vue/devtools-core@7.7.7(vite@5.2.8)(vue@3.4.21):
    resolution: {integrity: sha512-9z9TLbfC+AjAi1PQyWX+OErjIaJmdFlbDHcD+cAMYKY6Bh5VlsAtCeGyRMrXwIlMEQPukvnWt3gZBLwTAIMKzQ==}
    peerDependencies:
      vue: ^3.0.0
      vue: 3.4.21
    dependencies:
      '@vue/devtools-kit': 7.7.7
      '@vue/devtools-shared': 7.7.7
@@ -6436,10 +6407,6 @@
    resolution: {integrity: sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==}
    engines: {node: '>= 0.6'}
    dev: true

  /eventemitter3@4.0.7:
    resolution: {integrity: sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==}
    dev: false

  /eventemitter3@5.0.1:
    resolution: {integrity: sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA==}
@@ -9196,7 +9163,7 @@
    peerDependencies:
      '@vue/composition-api': ^1.4.0
      typescript: '>=4.4.4'
      vue: ^2.6.14 || ^3.3.0
      vue: 3.4.21
    peerDependenciesMeta:
      '@vue/composition-api':
        optional: true
@@ -9755,10 +9722,6 @@
    transitivePeerDependencies:
      - supports-color
    dev: true

  /rtc-detect@0.0.5:
    resolution: {integrity: sha512-VANIELbaoIkZRj4gyiCCbTM+/ASy0eNgF35jCs+rrGxzYvD7YIBajEbGGZeh+5ZCNAX8/rT8IVRdpuallf174Q==}
    dev: false

  /run-parallel@1.2.0:
    resolution: {integrity: sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==}
@@ -10467,14 +10430,8 @@
      punycode: 2.3.1
    dev: true

  /trtc-cloud-js-sdk@2.9.3:
    resolution: {integrity: sha512-4pZmNNoD1RjmhCIEA1HVRe/NIWDO8+w9hBpy8fJYa2B07la4Xc7QzCHnVZb7JgNoa6f3MVfUuOrtyrMsUMnt/Q==}
    dependencies:
      trtc-sdk-v5: 5.11.1
    dev: false

  /trtc-sdk-v5@5.11.1:
    resolution: {integrity: sha512-7EPZx3UUrvBAU9HynXsIcgI91wYWTYKbEkYUp186EDwgVEzc+v4uDL0427AY1PBI8tgf2ednO4qFk/C8crTSPQ==}
  /trtc-sdk-v5@5.14.1:
    resolution: {integrity: sha512-FqHgzKD/A+2LwfbpBbPjMxeQUcgxENeeTMDYcDD9OM8mW68DcG4jQgyXyar5LRD4BInN1AIJKHyD5LJOUzS0wg==}
    dependencies:
      webrtc-adapter: 8.2.4
    dev: false
@@ -10496,10 +10453,6 @@
      picomatch: 4.0.3
      typescript: 5.9.3
    dev: true

  /tuikit-logger@0.0.4-beta.1:
    resolution: {integrity: sha512-Ky83B1p88xakmfZ2f92cU0YxfolyxnQBv14tQpvnuHcMTnVR2Rjy8tityDGwF+pnxrAhJ7H7OPB/4rFdWVncIw==}
    dev: false

  /type-check@0.4.0:
    resolution: {integrity: sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==}
@@ -10869,7 +10822,7 @@
    peerDependencies:
      '@babel/parser': ^7.15.8
      '@nuxt/kit': ^3.2.2 || ^4.0.0
      vue: 2 || 3
      vue: 3.4.21
    peerDependenciesMeta:
      '@babel/parser':
        optional: true
@@ -11109,7 +11062,7 @@
    requiresBuild: true
    peerDependencies:
      '@vue/composition-api': ^1.0.0-rc.1
      vue: ^3.0.0-0 || ^2.6.0
      vue: 3.4.21
    peerDependenciesMeta:
      '@vue/composition-api':
        optional: true
@@ -11137,7 +11090,7 @@
  /vue-flow-layout@0.1.1(vue@3.4.21):
    resolution: {integrity: sha512-JdgRRUVrN0Y2GosA0M68DEbKlXMqJ7FQgsK8CjQD2vxvNSqAU6PZEpi4cfcTVtfM2GVOMjHo7GKKLbXxOBqDqA==}
    peerDependencies:
      vue: ^3.4.37
      vue: 3.4.21
    dependencies:
      vue: 3.4.21(typescript@5.9.3)
    dev: true
@@ -11146,7 +11099,7 @@
    resolution: {integrity: sha512-JeRdNVxS2OGp1E+pye5XB6+M6BBkHwAv9C80Q7+kzoMdUDGRna06tjC0vCB/jDX9aWrl5swxOMFcyAr7or8XTA==}
    engines: {node: '>= 10'}
    peerDependencies:
      vue: ^3.0.0
      vue: 3.4.21
    dependencies:
      '@intlify/core-base': 9.1.9
      '@intlify/shared': 9.1.9
@@ -11158,7 +11111,7 @@
  /vue-router@4.5.1(vue@3.4.21):
    resolution: {integrity: sha512-ogAF3P97NPm8fJsE4by9dwSYtDwXIY1nFY9T6DyQnGHd1E2Da94w9JIolpe42LJGIl0DwOHBi8TcRPlPGwbTtw==}
    peerDependencies:
      vue: ^3.2.0
      vue: 3.4.21
    dependencies:
      '@vue/devtools-api': 6.6.4
      vue: 3.4.21(typescript@5.9.3)

 src/App.vue

@@ -1,56 +1,12 @@
<script setup>
import {onHide, onLaunch, onShow} from "@dcloudio/uni-app";
import {useAppStore, useUserStore} from "@/store";
import {mpUpdate} from "@/utils/index";
import {genTestUserSig} from '@/utils/voiceCallByTX/GenerateTestUserSig.js';
// #ifdef H5
import {  TUICallKitAPI } from '@trtc/calls-uikit-vue'
// #endif
import {useGlobalWS} from "@/hooks/useGlobalWS.js";

const appStore = useAppStore();
const userStore = useUserStore();

onLaunch(() => {
  // 初始化系统信息
  appStore.initSystemInfo();

  // #ifdef MP-WEIXIN
  mpUpdate();
  // #endif
});

const userId = computed(() => userStore?.userInfo?.user_id)

function initVoiceCallFromApp() {
  const TUICallKit = uni.requireNativePlugin('TencentCloud-TUICallKit');
  const {userSig, SDKAppID} = genTestUserSig(userId.value);
  uni.$TUICallKit = TUICallKit;
  uni.$TUICallKit.login({
    SDKAppID,
    userID: userId.value,
    userSig: userSig,
  })
}

async function initVoiceCallFromH5() {
  const {userSig, SDKAppID} = genTestUserSig(userId.value)
  await TUICallKitAPI.init({
    userID: userId.value,
    userSig,
    SDKAppID,
  })
}

// 初始化登陆腾讯音频平台
watch(userId, () => {
  if (!userId.value) return
  // #ifdef H5
  initVoiceCallFromH5()
  // #endif

  // #ifdef APP-PLUS
  initVoiceCallFromApp()
  // #endif
}, {immediate: true})
useGlobalWS()

onShow(() => {
  console.log("App Show");
@@ -59,6 +15,17 @@
onHide(() => {
  console.log("App Hide");
});

onLaunch(() => {
  // 初始化系统信息
  appStore.initSystemInfo();
  if (!userStore.userInfo) {
    //不存在则跳转至登录页
    uni.reLaunch({
      url: "/pages/login/index",
    })
  }
});
</script>

<style lang="scss">
@@ -66,7 +33,7 @@
@import "uview-plus/index.scss";
@import "@/static/styles/common.scss";

.TUICallKit-mobile{
.TUICallKit-mobile {
  position: fixed;
  left: 0;
  top: 0;

 src/api/user/index.js

@@ -68,4 +68,13 @@
      newPassword1,
    },
  });
};
};

// 发送通话信息
export const sendVoiceCallApi = (data) => {
  return request({
    url: `/drone-device-core/dp/call/sendVoiceCall`,
    method: 'post',
    data
  })
}

 src/components/WebViewPlus.vue

@@ -1,15 +1,10 @@
<template>
  <web-view :src="src" @message="viewMessage" :allow="allow"/>
  <!--  #ifdef WEB  -->
  <TUICallKit/>
  <!--  #endif WEB  -->
</template>


<script setup>
// #ifdef WEB
import {TUICallKit} from "@trtc/calls-uikit-vue";
// #endif


const allow = "accelerometer;ambient-light-sensor;autoplay;battery;camera;clipboard-read;clipboard-write;cross-origin-isolated;display-capture;document-domain;encrypted-media;execution-while-not-rendered;execution-while-out-of-viewport;fullscreen;gamepad;geolocation;gyroscope;hid;idle-detection;local-fonts;magnetometer;microphone;midi;payment;picture-in-picture;publickey-credentials-get;screen-wake-lock;serial;speaker-selection;storage-access;sync-xhr;usb;web-share;xr-spatial-tracking"
const src = defineModel("src");

 src/config/env.js

@@ -1,5 +1,4 @@

// 不同的环境变量配置
// 如果是打包app,需要改这里，h5不需要改这里
const development = {
  VITE_APP_ENV:'development',
  // 开发环境这里改为自己的
@@ -7,18 +6,21 @@
  VITE_APP_WEBVIEW_URL: 'http://localhost:5173/drone-app-web-view/#/webViewWrapper',
  VITE_API_BASE_URL: 'https://wrj.shuixiongit.com/api',
  // VITE_API_BASE_URL: 'https://aisky.org.cn/api',
  VITE_APP_WS_API_URL:'wss://wrj.shuixiongit.com/drone-wss/api/v1/ws'
}

const test = {
  VITE_APP_ENV:'test',
  VITE_APP_WEBVIEW_URL: 'https://wrj.shuixiongit.com/drone-app-web-view/#/webViewWrapper',
  VITE_API_BASE_URL: 'https://wrj.shuixiongit.com/api',
  VITE_APP_WS_API_URL:'wss://wrj.shuixiongit.com/drone-wss/api/v1/ws'
}

const production = {
  VITE_APP_ENV:'production',
  VITE_APP_WEBVIEW_URL: 'https://aisky.org.cn/drone-app-web-view/#/webViewWrapper',
  VITE_API_BASE_URL: 'https://aisky.org.cn/api',
  VITE_APP_WS_API_URL:'wss://wrj.shuixiongit.com/drone-wss/api/v1/ws'
}

export default {

 src/hooks/useGlobalWS.js

New file
@@ -0,0 +1,70 @@
import {useUserStore} from "@/store/index.js";
import {getEnvObj} from "@/utils/index.js";
import {enterRoom} from "@/utils/voiceCallByTX/index.js";

let socketTask = null

export function useGlobalWS() {
    const userStore = useUserStore();
    const userId = computed(() => userStore?.userInfo?.user_id)
    const access_token = computed(() => userStore?.userInfo?.access_token)
    const {VITE_APP_WS_API_URL} = getEnvObj()

    // 消息处理
    function messageHandler(payload) {
        switch (payload.biz_code) {
            case 'JOB_ISREFRESH':
                break
            case 'DEVICE_ISREFRESH':
                break
            case 'DOWNLOAD_PROGRESS':
                break
            case 'LOGOUT_USER':
                userStore.setUserInfo(null)
                uni.reLaunch({
                    url: '/pages/login/index'
                })
                break
            case 'VoiceCall':
                enterRoom(payload, userId.value)
                break
            default:
                break;
        }
    }

    // 关闭ws
    function closeWS() {
        socketTask?.close({
            success: () => {
                console.log('ws关闭连接');
            },
        })
    }

    // 初始化ws
    function initWS() {
        // 关闭，再连接ws
        closeWS()
        if (!access_token.value) return
        const url = VITE_APP_WS_API_URL
            + `?x-auth-token=${encodeURI(access_token?.value)}`
            + `&model_type=3&workspace-id=${userId.value}`
        // 创建连接
        socketTask = uni.connectSocket({
            url: url,
            success: () => {
                console.log('ws连接成功');
            },
            fail: (err) => {
                console.error('ws连接失败:', err);
            }
        });
        // 消息监听
        socketTask.onMessage((result) => {
            messageHandler(JSON.parse(result.data))
        })
    }

    watch(access_token, initWS, {immediate: true})
}

 src/manifest.json

@@ -69,17 +69,17 @@
            }
        },
        "nativePlugins" : {
            "TencentCloud-TUICallKit" : {
            "TRTCCloudUniPlugin-TRTCCloudImpl" : {
                "__plugin_info__" : {
                    "name" : "【官方】腾讯云音视频通话插件TencentCloud-TUICallKit",
                    "description" : "TUICallKit 是腾讯云官方推出的音视频通话插件，支持 1v1 通话和群组通话，并提供“类微信\"的 UI 交互，开发者仅需三个 API 就可实现。",
                    "name" : "【官方】腾讯云实时音视频SDK",
                    "description" : "uni-app TRTC SDK 是腾讯云实时音视频通讯解决方案在 uni-app 上的 SDK，提供实时音视频服务",
                    "platforms" : "Android,iOS",
                    "url" : "https://ext.dcloud.net.cn/plugin?id=9035",
                    "url" : "https://ext.dcloud.net.cn/plugin?id=7774",
                    "android_package_name" : "uni.app.UNI0981D7F",
                    "ios_bundle_id" : "uni.app.UNI0981D7F",
                    "ios_bundle_id" : "",
                    "isCloud" : true,
                    "bought" : 1,
                    "pid" : "9035",
                    "pid" : "7774",
                    "parameters" : {}
                }
            }

 src/pages/work/index.vue

@@ -1,6 +1,6 @@
<template>
    <view class="eventTickets">
        <WebViewPlus  ref="sWebViewRef" :src="`${viewUrl}`" @webMessage="onPostMessage" />
        <WebViewPlus ref="sWebViewRef" :src="`${viewUrl}`" @webMessage="onPostMessage" />

    </view>

@@ -16,12 +16,14 @@
    } from "@/hooks/index.js";
    const sWebViewRef = ref(null);
    // const viewUrl = getWebViewUrl('/work', {})
const updateKey = ref(0)
const viewUrl = computed(() => {
  return getWebViewUrl(  '/work', { updateKey: updateKey.value })
})
    function onPostMessage(data) {
    const updateKey = ref(0)
    const viewUrl = computed(() => {
        return getWebViewUrl('/work', {
            updateKey: updateKey.value
        })
    })

    function onPostMessage(data) {
        if (data.type === 'jumpMapNav') {
            uni.navigateTo({
                url: `/subPackages/workDetail/mapWork/index?currentItem=${data.eventNum}`
@@ -29,7 +31,7 @@

        } else if (data.type === 'workid') {
            uni.navigateTo({
                url: `/subPackages/workDetail/index?eventNum=${data.eventNum}`
                url: `/subPackages/workDetail/index?eventNum=${data.eventNum}&totalNum=${data.totalNum}&keyword=${data.keyword}&aiType=${data.aiType}`
            });
        } else if (data.type === 'bigImage') {
            uni.navigateTo({
@@ -41,13 +43,11 @@
    }
    const isApp = ref(false)
    onShow(() => {
          const joinParams = uni.getStorageSync('joinParams');
          if (joinParams) {
            // 使用后清除
            console.log('是否打印', updateKey.value)
            updateKey.value = updateKey.value + 1
            uni.removeStorageSync('joinParams');
          }
        const joinParams = uni.getStorageSync('joinParams');
        if (joinParams) {
            updateKey.value = updateKey.value + 1
            uni.removeStorageSync('joinParams');
        }
        uni.setTabBarItem({
            index: 2, // Tab 的索引（从0开始）
            // text: '新建工单',
@@ -73,4 +73,4 @@
        height: 100%;

    }
</style>
</style>

 src/subPackages/workDetail/index.vue

@@ -15,7 +15,7 @@
    const viewUrl = ref('')
    onLoad( (options) => {
        const eventNum= options.eventNum;
        viewUrl.value = getWebViewUrl('/workDetail', {eventNum:eventNum})
        viewUrl.value = getWebViewUrl('/workDetail', {eventNum:eventNum,totalNum:options.totalNum,keyword:options.keyword,aiType:options.aiType})
    });

    function onPostMessage(data) {

 src/utils/common/index.js

@@ -49,8 +49,7 @@
  }
}
export function getEnvObj() {
  const envName = JSON.parse(__APP_ENV__?.UNI_CUSTOM_DEFINE||null)?.ENV_NAME
  return configEnv[envName || import.meta.env.VITE_APP_ENV] || {}
  return configEnv[__APP_ENV__?.ENV_NAME] || {}
}
export function getWebViewUrl (targetUrl, otherParams) {
  const userStore = useUserStore()

 src/utils/voiceCallByTX/TrtcCloud/._lib

Binary files differ

 src/utils/voiceCallByTX/TrtcCloud/PaxHeader/lib

Binary files differ

 src/utils/voiceCallByTX/TrtcCloud/lib/._TrtcCloudImpl.js

Binary files differ

 src/utils/voiceCallByTX/TrtcCloud/lib/._TrtcCode.js

Binary files differ

 src/utils/voiceCallByTX/TrtcCloud/lib/._TrtcDefines.js

Binary files differ

 src/utils/voiceCallByTX/TrtcCloud/lib/._constants.js

Binary files differ

 src/utils/voiceCallByTX/TrtcCloud/lib/._index.js

Binary files differ

 src/utils/voiceCallByTX/TrtcCloud/lib/PaxHeader/TrtcCloudImpl.js

Binary files differ

 src/utils/voiceCallByTX/TrtcCloud/lib/PaxHeader/TrtcCode.js

Binary files differ

 src/utils/voiceCallByTX/TrtcCloud/lib/PaxHeader/TrtcDefines.js

Binary files differ

 src/utils/voiceCallByTX/TrtcCloud/lib/PaxHeader/constants.js

Binary files differ

 src/utils/voiceCallByTX/TrtcCloud/lib/PaxHeader/index.js

Binary files differ

 src/utils/voiceCallByTX/TrtcCloud/lib/TrtcCloudImpl.js

New file
@@ -0,0 +1,790 @@
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
import { NAME } from './constants.js';
import { TRTCRoleType, TRTCAudioQuality, TRTCVideoRotation, TRTCVideoFillMode, TRTCVideoMirrorType, TRTCVideoStreamType, TRTCAppScene, TRTCAudioRoute, TRTCBeautyStyle, } from './TrtcDefines.js';
import TrtcError, { TXLiteJSError, generateError_ } from './TrtcCode.js';
const TrtcNativeTrtcCloudModule = uni.requireNativePlugin('TRTCCloudUniPlugin-TRTCCloudImpl');
const TXAudioEffectManagerModule = uni.requireNativePlugin('TRTCCloudUniPlugin-TRTCCloudImpl-TXAudioEffectManagerModule');
const TrtcEvent = uni.requireNativePlugin('globalEvent');
let trtcCloud = null; // trtcCloud 单例
export default class TrtcCloudImpl {
    constructor() {
        this.listenersMap_ = new Map();
    }
    static _createInstance() {
        try {
            if (trtcCloud) {
                return trtcCloud;
            }
            TrtcNativeTrtcCloudModule.sharedInstance();
            trtcCloud = new TrtcCloudImpl();
            return trtcCloud;
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    static _getInstance() {
        if (trtcCloud) {
            return trtcCloud;
        }
        throw new TrtcError({
            code: TXLiteJSError.INVALID_OPERATION,
            message: 'get trtcCloud failed, please create trtcCloud first',
        });
    }
    static _destroyInstance() {
        try {
            trtcCloud = null;
            TrtcNativeTrtcCloudModule.destroySharedInstance();
        }
        catch (error) {
            throw new TrtcError({
                code: error.code || TXLiteJSError.UNKNOWN,
                message: error.message,
                name: error.name,
            });
        }
    }
    // 截图保存
    // async saveImage_(base64Data) {
    //   return new Promise((resolve, reject) => {
    //     let bitmap = new plus.nativeObj.Bitmap();
    //     bitmap.loadBase64Data(base64Data, () => {
    //       const url = "_doc/" + new Date().getTime() + ".png";  // url为时间戳命名方式
    //       console.log('saveHeadImgFile', url);
    //       bitmap.save(url, { overwrite: true }, (i) => {
    //         uni.saveImageToPhotosAlbum({
    //           filePath: url,
    //           success: function() {
    //             uni.showToast({
    //               title: '图片保存成功',
    //               icon: 'none'
    //             })
    //             bitmap.clear();
    //             resolve({ code: 0, message: '图片保存成功' });
    //           }
    //         });
    //       }, (e) => {
    //         uni.showToast({
    //           title: '图片保存失败, 请重新截图',
    //           icon: 'none'
    //         })
    //         bitmap.clear();
    //         resolve({ code: -1, message: '图片保存失败, 请重新截图' });
    //       });
    //     });
    //   });
    // }
    on(event, callback) {
        if (typeof event !== NAME.STRING || typeof callback !== NAME.FUNCTION) {
            throw new TrtcError({
                code: TXLiteJSError.INVALID_PARAMETER,
                message: `${NAME.LOG_PREFIX} please check the on method parameter types. event type is a ${typeof event}; callback type is a ${typeof callback}`,
            });
        }
        const nativeListener = (res) => __awaiter(this, void 0, void 0, function* () {
            const { data = [] } = res;
            const code = data[0];
            const message = data[1];
            const extraInfo = data[2];
            switch (event) {
                case 'onEnterRoom': {
                    const result = code;
                    callback(result);
                    break;
                }
                case 'onExitRoom': {
                    const reason = code;
                    callback(reason);
                    break;
                }
                case 'onFirstVideoFrame': {
                    const userId = code;
                    const streamType = data[1];
                    const width = data[2];
                    const height = data[3];
                    callback({ userId, streamType, width, height });
                    break;
                }
                case 'onFirstAudioFrame': {
                    const userId = code;
                    callback(userId);
                    break;
                }
                case 'onMicDidReady': {
                    callback();
                    break;
                }
                case 'onCameraDidReady': {
                    callback();
                    break;
                }
                case 'onNetworkQuality': {
                    const localQuality = data[0];
                    const remoteQuality = data[1];
                    callback({ localQuality, remoteQuality });
                    break;
                }
                case 'onRemoteUserEnterRoom': {
                    const userId = code;
                    callback(userId);
                    break;
                }
                case 'onRemoteUserLeaveRoom': {
                    const userId = code;
                    const reason = message;
                    callback({ userId, reason });
                    break;
                }
                case 'onSendFirstLocalAudioFrame': {
                    callback();
                    break;
                }
                case 'onSendFirstLocalVideoFrame': {
                    const streamType = code;
                    callback(streamType);
                    break;
                }
                case 'onStatistics': {
                    const statics = data[0];
                    callback(statics);
                    break;
                }
                case 'onUserAudioAvailable': {
                    const userId = code;
                    const available = message;
                    callback({ userId, available });
                    break;
                }
                case 'onUserVideoAvailable': {
                    const userId = code;
                    const available = message;
                    callback({ userId, available });
                    break;
                }
                case 'onUserVoiceVolume': {
                    const userVolumes = data[0];
                    const totalVolume = data[1];
                    callback({ userVolumes, totalVolume });
                    break;
                }
                case 'onSwitchRole': {
                    callback({ code, message });
                    break;
                }
                case 'onScreenCaptureStarted': {
                    callback({ code, message });
                    break;
                }
                case 'onScreenCapturePaused': {
                    callback({ code, message });
                    break;
                }
                case 'onScreenCaptureResumed': {
                    callback({ code, message });
                    break;
                }
                case 'onScreenCaptureStopped': {
                    callback({ code, message });
                    break;
                }
                case 'onUserSubStreamAvailable': {
                    const userId = code;
                    const available = message;
                    callback({ userId, available });
                    break;
                }
                case 'onSnapshotComplete': {
                    // base64 直接保存到本地图库
                    // const { code: snapShotCode, message: msg } = await this.saveImage_(code);
                    // callback({ snapShotCode, message: msg });
                    callback({ base64Data: code, message });
                    break;
                }
                case 'onUserVideoSizeChanged': {
                    callback(data);
                    break;
                }
                case 'onStart': {
                    callback({ id: code, errCode: message });
                    break;
                }
                case 'onPlayProgress': {
                    callback({ id: code, curPtsMS: message, durationMS: extraInfo });
                    break;
                }
                case 'onComplete': {
                    callback({ id: code, errCode: message });
                    break;
                }
                case 'onConnectOtherRoom': {
                    // 拿不到 userid, 为了和 native 参数保持一致，所以空字符串代替
                    callback({ userId: '', errCode: code, errMsg: message });
                    break;
                }
                case 'onDisconnectOtherRoom': {
                    callback({ errCode: code, errMsg: message });
                    break;
                }
                case 'onError': {
                    console.error(`onError: ${code}, ${message}, ${extraInfo}`);
                    callback(generateError_({ message }, code, extraInfo));
                    break;
                }
                case 'onRecvCustomCmdMsg': {
                    const userId = code;
                    const cmdID = data[1] || 0;
                    const seq = data[2] || 0;
                    const message = data[3] || "";
                    console.error(`onRecvCustomCmdMsg: ${userId}, ${cmdID}, ${seq}, ${message}`);
                    callback({ userId, cmdID, seq, message });
                    break;
                }
                default: {
                    callback({ code, message, extraInfo });
                }
            }
        });
        this.listenersMap_.set(event, nativeListener); // 多次设置同一个事件时，后面的 callback 覆盖前面
        TrtcEvent.addEventListener(event, nativeListener);
    }
    off(event) {
        if (typeof event !== NAME.STRING) {
            throw new TrtcError({
                code: TXLiteJSError.INVALID_PARAMETER,
                message: `${NAME.LOG_PREFIX} please check the off method parameter types. event type is a ${typeof event} not a ${NAME.STRING}`,
            });
        }
        try {
            if (event === '*') {
                this.listenersMap_.forEach((value, key) => {
                    TrtcEvent.removeEventListener(key, value);
                });
                this.listenersMap_.clear();
            }
            else {
                TrtcEvent.removeEventListener(event, this.listenersMap_.get(event));
                this.listenersMap_.delete(event);
            }
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    enterRoom(params, scene) {
        if (scene !== TRTCAppScene.TRTCAppSceneVideoCall && scene !== TRTCAppScene.TRTCAppSceneLIVE && scene !== TRTCAppScene.TRTCAppSceneAudioCall && scene !== TRTCAppScene.TRTCAppSceneVoiceChatRoom) {
            throw new TrtcError({
                code: TXLiteJSError.INVALID_PARAMETER,
                message: `${NAME.LOG_PREFIX} please check the enterRoom method parameters. scene is not of TRTCAppScene`,
            });
        }
        try {
            const enterRoomParams = Object.assign(Object.assign({}, params), { role: params.role || TRTCRoleType.TRTCRoleAnchor, appScene: scene });
            TrtcNativeTrtcCloudModule.enterRoom(enterRoomParams);
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    exitRoom() {
        try {
            TrtcNativeTrtcCloudModule.exitRoom();
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    connectOtherRoom(params) {
        try {
            TrtcNativeTrtcCloudModule.connectOtherRoom(params);
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    disconnectOtherRoom() {
        try {
            TrtcNativeTrtcCloudModule.disconnectOtherRoom();
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    switchRole(role) {
        if (role !== TRTCRoleType.TRTCRoleAnchor && role !== TRTCRoleType.TRTCRoleAudience) {
            throw new TrtcError({
                code: TXLiteJSError.INVALID_PARAMETER,
                message: `${NAME.LOG_PREFIX} please check the switchRole method parameter. role is not of TRTCRoleType`,
            });
        }
        try {
            role && TrtcNativeTrtcCloudModule.switchRole(role);
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    startLocalPreview(isFrontCamera = true, viewId) {
        if (typeof isFrontCamera !== NAME.BOOLEAN || !viewId || typeof viewId !== NAME.STRING) {
            throw new TrtcError({
                code: TXLiteJSError.INVALID_PARAMETER,
                message: `${NAME.LOG_PREFIX} please check the startLocalPreview method parameters`,
            });
        }
        try {
            let param = { isFrontCamera: !!isFrontCamera };
            param = viewId ? Object.assign(Object.assign({}, param), { userId: viewId }) : param;
            TrtcNativeTrtcCloudModule.startLocalPreview(param);
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    setVideoEncoderParam(param) {
        try {
            TrtcNativeTrtcCloudModule.setVideoEncoderParam(param);
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    stopLocalPreview() {
        try {
            TrtcNativeTrtcCloudModule.stopLocalPreview();
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    switchCamera(isFrontCamera) {
        if (typeof isFrontCamera !== NAME.BOOLEAN) {
            throw new TrtcError({
                code: TXLiteJSError.INVALID_PARAMETER,
                message: `${NAME.LOG_PREFIX} please check the switchCamera method parameter`,
            });
        }
        try {
            TrtcNativeTrtcCloudModule.switchCamera(isFrontCamera);
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    setLocalRenderParams(params) {
        try {
            const { rotation = TRTCVideoRotation.TRTCVideoRotation_0, fillMode = TRTCVideoFillMode.TRTCVideoFillMode_Fill, mirrorType = TRTCVideoMirrorType.TRTCVideoMirrorType_Auto } = params;
            TrtcNativeTrtcCloudModule.setLocalRenderParams({
                rotation,
                fillMode,
                mirrorType,
            });
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    muteLocalVideo(streamType, mute) {
        if (streamType !== TRTCVideoStreamType.TRTCVideoStreamTypeBig && streamType !== TRTCVideoStreamType.TRTCVideoStreamTypeSub || typeof mute !== NAME.BOOLEAN) {
            throw new TrtcError({
                code: TXLiteJSError.INVALID_PARAMETER,
                message: `${NAME.LOG_PREFIX} please check the muteLocalVideo method parameters`,
            });
        }
        try {
            TrtcNativeTrtcCloudModule.muteLocalVideo({ streamType, mute: !!mute });
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    startRemoteView(userId, streamType, viewId) {
        if (!userId || streamType !== TRTCVideoStreamType.TRTCVideoStreamTypeBig && streamType !== TRTCVideoStreamType.TRTCVideoStreamTypeSmall && streamType !== TRTCVideoStreamType.TRTCVideoStreamTypeSub || !viewId) {
            throw new TrtcError({
                code: TXLiteJSError.INVALID_PARAMETER,
                message: `${NAME.LOG_PREFIX} please check the startRemoteView method parameters`,
            });
        }
        try {
            TrtcNativeTrtcCloudModule.startRemoteView({ userId, streamType, viewId });
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    stopRemoteView(userId, streamType) {
        if (!userId || streamType !== TRTCVideoStreamType.TRTCVideoStreamTypeBig && streamType !== TRTCVideoStreamType.TRTCVideoStreamTypeSmall && streamType !== TRTCVideoStreamType.TRTCVideoStreamTypeSub) {
            throw new TrtcError({
                code: TXLiteJSError.INVALID_PARAMETER,
                message: `${NAME.LOG_PREFIX} please check the stopRemoteView method parameters`,
            });
        }
        try {
            TrtcNativeTrtcCloudModule.stopRemoteView({ userId, streamType });
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    // 远端渲染设置
    setRemoteRenderParams(userId, streamType, params) {
        try {
            if (!userId || (streamType !== TRTCVideoStreamType.TRTCVideoStreamTypeBig && streamType !== TRTCVideoStreamType.TRTCVideoStreamTypeSub)) {
                throw new TrtcError({
                    code: TXLiteJSError.INVALID_PARAMETER,
                    message: `${NAME.LOG_PREFIX} please check the snapshotVideo method parameters`,
                });
            }
            const { rotation = TRTCVideoRotation.TRTCVideoRotation_0, fillMode = TRTCVideoFillMode.TRTCVideoFillMode_Fill, mirrorType = TRTCVideoMirrorType.TRTCVideoMirrorType_Auto } = params;
            TrtcNativeTrtcCloudModule.setRemoteRenderParams({
                userId,
                streamType,
                rotation,
                fillMode,
                mirrorType
            });
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    // 设置视频编码器输出的画面方向
    setVideoEncoderRotation(rotation) {
        if (typeof rotation !== NAME.NUMBER) {
            throw new TrtcError({
                code: TXLiteJSError.INVALID_PARAMETER,
                message: `${NAME.LOG_PREFIX} please check the setVideoEncoderRotation method parameter`,
            });
        }
        try {
            TrtcNativeTrtcCloudModule.setVideoEncoderRotation(rotation);
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    // 设置编码器输出的画面镜像模式
    setVideoEncoderMirror(mirror) {
        if (typeof mirror !== NAME.BOOLEAN) {
            throw new TrtcError({
                code: TXLiteJSError.INVALID_PARAMETER,
                message: `${NAME.LOG_PREFIX} please check the setVideoEncoderMirror method parameter`,
            });
        }
        try {
            TrtcNativeTrtcCloudModule.setVideoEncoderMirror(mirror);
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    // 设置重力感应的适配模式
    setGSensorMode(mode) {
        if (typeof mode !== NAME.NUMBER) {
            throw new TrtcError({
                code: TXLiteJSError.INVALID_PARAMETER,
                message: `${NAME.LOG_PREFIX} please check the setGSensorMode method parameter`,
            });
        }
        try {
            TrtcNativeTrtcCloudModule.setGSensorMode(mode);
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    // 截图
    snapshotVideo(userId, streamType, sourceType) {
        if (streamType !== TRTCVideoStreamType.TRTCVideoStreamTypeBig && streamType !== TRTCVideoStreamType.TRTCVideoStreamTypeSub) {
            throw new TrtcError({
                code: TXLiteJSError.INVALID_PARAMETER,
                message: `${NAME.LOG_PREFIX} please check the snapshotVideo method parameters`,
            });
        }
        try {
            TrtcNativeTrtcCloudModule.snapshotVideo({ userId: userId || null, streamType, sourceType });
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    startLocalAudio(quality = TRTCAudioQuality.TRTCAudioQualityDefault) {
        if (quality !== TRTCAudioQuality.TRTCAudioQualitySpeech && quality !== TRTCAudioQuality.TRTCAudioQualityDefault && quality !== TRTCAudioQuality.TRTCAudioQualityMusic) {
            throw new TrtcError({
                code: TXLiteJSError.INVALID_PARAMETER,
                message: `${NAME.LOG_PREFIX} please check the startLocalAudio method parameters`,
            });
        }
        try {
            TrtcNativeTrtcCloudModule.startLocalAudio(quality);
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    stopLocalAudio() {
        try {
            TrtcNativeTrtcCloudModule.stopLocalAudio();
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    muteLocalAudio(mute) {
        if (typeof mute !== NAME.BOOLEAN) {
            throw new TrtcError({
                code: TXLiteJSError.INVALID_PARAMETER,
                message: `${NAME.LOG_PREFIX} please check the muteLocalAudio method parameters, mute type is a ${typeof mute} not a ${NAME.BOOLEAN}`,
            });
        }
        try {
            TrtcNativeTrtcCloudModule.muteLocalAudio(!!mute);
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    muteRemoteAudio(userId, mute) {
        if (typeof mute !== NAME.BOOLEAN || !userId) {
            throw new TrtcError({
                code: TXLiteJSError.INVALID_PARAMETER,
                message: `${NAME.LOG_PREFIX} please check the muteRemoteAudio method parameters`,
            });
        }
        try {
            TrtcNativeTrtcCloudModule.muteRemoteAudio({ userId, mute: !!mute });
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    muteAllRemoteAudio(mute) {
        if (typeof mute !== NAME.BOOLEAN) {
            throw new TrtcError({
                code: TXLiteJSError.INVALID_PARAMETER,
                message: `${NAME.LOG_PREFIX} please check the muteAllRemoteAudio method parameters, mute type is a ${typeof mute} not a ${NAME.BOOLEAN}`,
            });
        }
        try {
            TrtcNativeTrtcCloudModule.muteAllRemoteAudio(!!mute);
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    setAudioRoute(route) {
        if (route !== TRTCAudioRoute.TRTCAudioRouteSpeaker && route !== TRTCAudioRoute.TRTCAudioRouteEarpiece) {
            throw new TrtcError({
                code: TXLiteJSError.INVALID_PARAMETER,
                message: `${NAME.LOG_PREFIX} please check the setAudioRoute method parameter, route is not of TRTCAudioRoute`,
            });
        }
        try {
            TrtcNativeTrtcCloudModule.setAudioRoute(route);
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    enableAudioVolumeEvaluation(interval) {
        if (typeof interval !== NAME.NUMBER) {
            throw new TrtcError({
                code: TXLiteJSError.INVALID_PARAMETER,
                message: `${NAME.LOG_PREFIX} please check the enableAudioVolumeEvaluation method parameter, interval type is a ${typeof interval} not a ${NAME.NUMBER}`,
            });
        }
        try {
            interval > 0 && TrtcNativeTrtcCloudModule.enableAudioVolumeEvaluation(interval);
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    // ///////////////////////////////////////////////////////////////////////////////
    //
    //                      美颜 + 水印
    //
    // ///////////////////////////////////////////////////////////////////////////////
    setBeautyStyle(beautyStyle) {
        if (beautyStyle !== TRTCBeautyStyle.TRTCBeautyStyleSmooth && beautyStyle !== TRTCBeautyStyle.TRTCBeautyStyleNature && beautyStyle !== TRTCBeautyStyle.TRTCBeautyStylePitu) {
            throw new TrtcError({
                code: TXLiteJSError.INVALID_PARAMETER,
                message: `${NAME.LOG_PREFIX} please check the setBeautyStyle method parameter, beautyStyle is not of TRTCBeautyStyle`,
            });
        }
        try {
            TrtcNativeTrtcCloudModule.setBeautyStyle(beautyStyle);
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    setBeautyLevel(beautyLevel) {
        if (typeof beautyLevel !== NAME.NUMBER || (beautyLevel < 0 || beautyLevel > 9)) {
            throw new TrtcError({
                code: TXLiteJSError.INVALID_PARAMETER,
                message: `${NAME.LOG_PREFIX} please check the setBeautyLevel method parameter, beautyLevel should in the range 0-9`,
            });
        }
        try {
            TrtcNativeTrtcCloudModule.setBeautyLevel(beautyLevel);
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    // ///////////////////////////////////////////////////////////////////////////////
    //
    //                      背景音效
    //
    // ///////////////////////////////////////////////////////////////////////////////
    startPlayMusic(musicParam) {
        try {
            const { id = 0 } = musicParam || {};
            TXAudioEffectManagerModule.startPlayMusic(Object.assign(Object.assign({}, musicParam), { ID: id })); // v1.2.0 的 iOS 解析的是 ID, v1.2.1 插件进行了修复
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    stopPlayMusic(id) {
        try {
            TXAudioEffectManagerModule.stopPlayMusic(id);
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    pausePlayMusic(id) {
        try {
            TXAudioEffectManagerModule.pausePlayMusic(id);
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    resumePlayMusic(id) {
        try {
            TXAudioEffectManagerModule.resumePlayMusic(id);
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    // ///////////////////////////////////////////////////////////////////////////////
    //
    //                      屏幕分享
    //
    // ///////////////////////////////////////////////////////////////////////////////
    setSubStreamEncoderParam(param) {
        try {
            TrtcNativeTrtcCloudModule.setSubStreamEncoderParam(param);
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    startScreenCapture(streamType = TRTCVideoStreamType.TRTCVideoStreamTypeSub, encParams = {}, shareParams = {}) {
        try {
            let platform = uni.getSystemInfoSync().platform;
            if ((streamType !== TRTCVideoStreamType.TRTCVideoStreamTypeSub && streamType !== TRTCVideoStreamType.TRTCVideoStreamTypeBig)) {
                streamType = TRTCVideoStreamType.TRTCVideoStreamTypeSub;
            }
            const { enableForegroundService = true, appGroup } = shareParams; // 默认开启前台服务, 避免退后台后进程被杀
            const screenCaptureParams = Object.assign({ streamType }, encParams);
            if (platform === NAME.ANDROID) {
                TrtcNativeTrtcCloudModule.startScreenCapture(Object.assign(Object.assign({}, screenCaptureParams), { enableForegroundService }));
            }
            if (platform === NAME.IOS) {
                if (typeof appGroup === 'string' && appGroup.length) {
                    // 开始全系统的屏幕分享（仅支持 iOS 11.0 及以上系统）
                    const params = { streamType, encParams, appGroup };
                    TrtcNativeTrtcCloudModule.startScreenCaptureByReplaykit(params);
                }
                else {
                    // 开始应用内的屏幕分享（仅支持 iOS 13.0 及以上系统）
                    TrtcNativeTrtcCloudModule.startScreenCaptureInApp(screenCaptureParams);
                }
            }
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    stopScreenCapture() {
        try {
            TrtcNativeTrtcCloudModule.stopScreenCapture();
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    pauseScreenCapture() {
        try {
            TrtcNativeTrtcCloudModule.pauseScreenCapture();
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    resumeScreenCapture() {
        try {
            TrtcNativeTrtcCloudModule.resumeScreenCapture();
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    callExperimentalAPI(params) {
        try {
            TrtcNativeTrtcCloudModule.callExperimentalAPI(params);
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    setSystemVolumeType(type) {
        try {
            TrtcNativeTrtcCloudModule.setSystemVolumeType(type);
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    setVideoMuteImage(fps, image) {
        const params = {
            fps,
            filePath: image,
        };
        try {
            TrtcNativeTrtcCloudModule.setVideoMuteImage(params);
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    enableEncSmallVideoStream(enable, smallVideoEncParam) {
        const params = Object.assign({ enable }, smallVideoEncParam);
        try {
            TrtcNativeTrtcCloudModule.enableEncSmallVideoStream(params);
        }
        catch (error) {
            throw generateError_(error);
        }
    }
    sendCustomCmdMsg(params) {
        try {
            TrtcNativeTrtcCloudModule.sendCustomCmdMsg(params);
        }
        catch (error) {
            throw generateError_(error);
        }
    }
}

 src/utils/voiceCallByTX/TrtcCloud/lib/TrtcCode.js

New file
@@ -0,0 +1,612 @@
import { NAME, errorCodeUrl } from './constants.js';
/**
 * @namespace ErrorCode
 *
 * @description 错误码、警告码和事件列表
 */
/////////////////////////////////////////////////////////////////////////////////
//
//                     （一）错误码（严重）
//
/////////////////////////////////////////////////////////////////////////////////
/**
 * @memberof ErrorCode
 * @typedef 错误码（严重）
 * @description SDK 错误码（严重）对照表
 * | 符号 | 值 | 含义 |
 * |---|---|---|
 * |ERR_NULL|0|无错误|
 * |ERR_ROOM_ENTER_FAIL|-3301|进入房间失败|
 * |ERR_ENTER_ROOM_PARAM_NULL|-3316|进房参数为空，请检查 enterRoom:appScene: 接口调用是否传入有效的 param|
 * |ERR_SDK_APPID_INVALID|-3317|进房参数 sdkAppId 错误|
 * |ERR_ROOM_ID_INVALID|-3318|进房参数 roomId 错误|
 * |ERR_USER_ID_INVALID|-3319|进房参数 userID 不正确|
 * |ERR_USER_SIG_INVALID|-3320|进房参数 userSig 不正确|
 * |ERR_ROOM_REQUEST_ENTER_ROOM_TIMEOUT|-3308|请求进房超时，请检查网络|
 * |ERR_SERVER_INFO_SERVICE_SUSPENDED|-100013|服务不可用。请检查：套餐包剩余分钟数是否大于0，腾讯云账号是否欠费|
 * |ERR_ROOM_REQUEST_QUIT_ROOM_TIMEOUT|-3325|请求退房超时|
 * |ERR_CAMERA_START_FAIL|-1301|打开摄像头失败，例如在 Windows 或 Mac 设备，摄像头的配置程序（驱动程序）异常，禁用后重新启用设备，或者重启机器，或者更新配置程序|
 * |ERR_CAMERA_NOT_AUTHORIZED|-1314|摄像头设备未授权，通常在移动设备出现，可能是权限被用户拒绝了|
 * |ERR_CAMERA_SET_PARAM_FAIL|-1315|摄像头参数设置出错（参数不支持或其它）|
 * |ERR_CAMERA_OCCUPY|-1316|摄像头正在被占用中，可尝试打开其他摄像头|
 * |ERR_MIC_START_FAIL|-1302|打开麦克风失败，例如在 Windows 或 Mac 设备，麦克风的配置程序（驱动程序）异常，禁用后重新启用设备，或者重启机器，或者更新配置程序|
 * |ERR_MIC_NOT_AUTHORIZED|-1317|麦克风设备未授权，通常在移动设备出现，可能是权限被用户拒绝了|
 * |ERR_MIC_SET_PARAM_FAIL|-1318|麦克风设置参数失败|
 * |ERR_MIC_OCCUPY|-1319|麦克风正在被占用中，例如移动设备正在通话时，打开麦克风会失败|
 * |ERR_MIC_STOP_FAIL|-1320|停止麦克风失败|
 * |ERR_SPEAKER_START_FAIL|-1321|打开扬声器失败，例如在 Windows 或 Mac 设备，扬声器的配置程序（驱动程序）异常，禁用后重新启用设备，或者重启机器，或者更新配置程序|
 * |ERR_SPEAKER_SET_PARAM_FAIL|-1322|扬声器设置参数失败|
 * |ERR_SPEAKER_STOP_FAIL|-1323|停止扬声器失败|
 * |ERR_SCREEN_CAPTURE_START_FAIL|-1308|开始录屏失败，如果在移动设备出现，可能是权限被用户拒绝了，如果在 Windows 或 Mac 系统的设备出现，请检查录屏接口的参数是否符合要求|
 * |ERR_SCREEN_CAPTURE_UNSURPORT|-1309|录屏失败，在 Android 平台，需要5.0以上的系统|
 * |ERR_SERVER_CENTER_NO_PRIVILEDGE_PUSH_SUB_VIDEO|-102015|没有权限上行辅路|
 * |ERR_SERVER_CENTER_ANOTHER_USER_PUSH_SUB_VIDEO|-102016|其他用户正在上行辅路|
 * |ERR_VIDEO_ENCODE_FAIL|-1303|视频帧编码失败，例如 iOS 设备切换到其他应用时，硬编码器可能被系统释放，再切换回来时，硬编码器重启前，可能会抛出|
 * |ERR_UNSUPPORTED_RESOLUTION|-1305|不支持的视频分辨率|
 * |ERR_AUDIO_ENCODE_FAIL|-1304|音频帧编码失败，例如传入自定义音频数据，SDK 无法处理|
 * |ERR_UNSUPPORTED_SAMPLERATE|-1306|不支持的音频采样率|
 * |ERR_PIXEL_FORMAT_UNSUPPORTED|-1327|设置的 pixel format 不支持|
 * |ERR_BUFFER_TYPE_UNSUPPORTED|-1328|设置的 buffer type 不支持|
 * |ERR_PUBLISH_CDN_STREAM_REQUEST_TIME_OUT|-3321|旁路转推请求超时|
 * |ERR_CLOUD_MIX_TRANSCODING_REQUEST_TIME_OUT|-3322|云端混流请求超时|
 * |ERR_PUBLISH_CDN_STREAM_SERVER_FAILED|-3323|旁路转推回包异常|
 * |ERR_CLOUD_MIX_TRANSCODING_SERVER_FAILED|-3324|云端混流回包异常|
 * |ERR_ROOM_REQUEST_START_PUBLISHING_TIMEOUT|-3333|开始向腾讯云的直播 CDN 推流信令超时|
 * |ERR_ROOM_REQUEST_START_PUBLISHING_ERROR|-3334|开始向腾讯云的直播 CDN 推流信令异常|
 * |ERR_ROOM_REQUEST_STOP_PUBLISHING_TIMEOUT|-3335|停止向腾讯云的直播 CDN 推流信令超时|
 * |ERR_ROOM_REQUEST_STOP_PUBLISHING_ERROR|-3336|停止向腾讯云的直播 CDN 推流信令异常|
 * |ERR_ROOM_REQUEST_CONN_ROOM_TIMEOUT|-3326|请求连麦超时|
 * |ERR_ROOM_REQUEST_DISCONN_ROOM_TIMEOUT|-3327|请求退出连麦超时|
 * |ERR_ROOM_REQUEST_CONN_ROOM_INVALID_PARAM|-3328|无效参数|
 * |ERR_CONNECT_OTHER_ROOM_AS_AUDIENCE|-3330|当前是观众角色，不能请求或断开跨房连麦，需要先 switchRole() 到主播|
 * |ERR_SERVER_CENTER_CONN_ROOM_NOT_SUPPORT|-102031|不支持跨房间连麦|
 * |ERR_SERVER_CENTER_CONN_ROOM_REACH_MAX_NUM|-102032|达到跨房间连麦上限|
 * |ERR_SERVER_CENTER_CONN_ROOM_REACH_MAX_RETRY_TIMES|-102033|跨房间连麦重试次数耗尽|
 * |ERR_SERVER_CENTER_CONN_ROOM_REQ_TIMEOUT|-102034|跨房间连麦请求超时|
 * |ERR_SERVER_CENTER_CONN_ROOM_REQ|-102035|跨房间连麦请求格式错误|
 * |ERR_SERVER_CENTER_CONN_ROOM_NO_SIG|-102036|跨房间连麦无签名|
 * |ERR_SERVER_CENTER_CONN_ROOM_DECRYPT_SIG|-102037|跨房间连麦签名解密失败|
 * |ERR_SERVER_CENTER_CONN_ROOM_NO_KEY|-102038|未找到跨房间连麦签名解密密钥|
 * |ERR_SERVER_CENTER_CONN_ROOM_PARSE_SIG|-102039|跨房间连麦签名解析错误|
 * |ERR_SERVER_CENTER_CONN_ROOM_INVALID_SIG_TIME|-102040|跨房间连麦签名时间戳错误|
 * |ERR_SERVER_CENTER_CONN_ROOM_SIG_GROUPID|-102041|跨房间连麦签名不匹配|
 * |ERR_SERVER_CENTER_CONN_ROOM_NOT_CONNED|-102042|本房间无连麦|
 * |ERR_SERVER_CENTER_CONN_ROOM_USER_NOT_CONNED|-102043|本用户未发起连麦|
 * |ERR_SERVER_CENTER_CONN_ROOM_FAILED|-102044|跨房间连麦失败|
 * |ERR_SERVER_CENTER_CONN_ROOM_CANCEL_FAILED|-102045|取消跨房间连麦失败|
 * |ERR_SERVER_CENTER_CONN_ROOM_CONNED_ROOM_NOT_EXIST|-102046|被连麦房间不存在|
 * |ERR_SERVER_CENTER_CONN_ROOM_CONNED_REACH_MAX_ROOM|-102047|被连麦房间达到连麦上限|
 * |ERR_SERVER_CENTER_CONN_ROOM_CONNED_USER_NOT_EXIST|-102048|被连麦用户不存在|
 * |ERR_SERVER_CENTER_CONN_ROOM_CONNED_USER_DELETED|-102049|被连麦用户已被删除|
 * |ERR_SERVER_CENTER_CONN_ROOM_CONNED_USER_FULL|-102050|被连麦用户达到资源上限|
 * |ERR_SERVER_CENTER_CONN_ROOM_INVALID_SEQ|-102051|连麦请求序号错乱|
 */
export const TXLiteAVError = {
    /** 无错误 */
    ERR_NULL: 0,
    /** 进入房间失败 */
    ERR_ROOM_ENTER_FAIL: -3301,
    /** 进房参数为空，请检查 enterRoom:appScene: 接口调用是否传入有效的 param */
    ERR_ENTER_ROOM_PARAM_NULL: -3316,
    /** 进房参数 sdkAppId 错误 */
    ERR_SDK_APPID_INVALID: -3317,
    /** 进房参数 roomId 错误 */
    ERR_ROOM_ID_INVALID: -3318,
    /** 进房参数 userID 不正确 */
    ERR_USER_ID_INVALID: -3319,
    /** 进房参数 userSig 不正确 */
    ERR_USER_SIG_INVALID: -3320,
    /** 请求进房超时，请检查网络 */
    ERR_ROOM_REQUEST_ENTER_ROOM_TIMEOUT: -3308,
    /** 服务不可用。请检查：套餐包剩余分钟数是否大于0，腾讯云账号是否欠费 */
    ERR_SERVER_INFO_SERVICE_SUSPENDED: -100013,
    /** 请求退房超时 */
    ERR_ROOM_REQUEST_QUIT_ROOM_TIMEOUT: -3325,
    /** 打开摄像头失败，例如在 Windows 或 Mac 设备，摄像头的配置程序（驱动程序）异常，禁用后重新启用设备，或者重启机器，或者更新配置程序 */
    ERR_CAMERA_START_FAIL: -1301,
    /** 摄像头设备未授权，通常在移动设备出现，可能是权限被用户拒绝了 */
    ERR_CAMERA_NOT_AUTHORIZED: -1314,
    /** 摄像头参数设置出错（参数不支持或其它） */
    ERR_CAMERA_SET_PARAM_FAIL: -1315,
    /** 摄像头正在被占用中，可尝试打开其他摄像头 */
    ERR_CAMERA_OCCUPY: -1316,
    /** 打开麦克风失败，例如在 Windows 或 Mac 设备，麦克风的配置程序（驱动程序）异常，禁用后重新启用设备，或者重启机器，或者更新配置程序 */
    ERR_MIC_START_FAIL: -1302,
    /** 麦克风设备未授权，通常在移动设备出现，可能是权限被用户拒绝了 */
    ERR_MIC_NOT_AUTHORIZED: -1317,
    /** 麦克风设置参数失败 */
    ERR_MIC_SET_PARAM_FAIL: -1318,
    /** 麦克风正在被占用中，例如移动设备正在通话时，打开麦克风会失败 */
    ERR_MIC_OCCUPY: -1319,
    /** 停止麦克风失败 */
    ERR_MIC_STOP_FAIL: -1320,
    /** 打开扬声器失败，例如在 Windows 或 Mac 设备，扬声器的配置程序（驱动程序）异常，禁用后重新启用设备，或者重启机器，或者更新配置程序 */
    ERR_SPEAKER_START_FAIL: -1321,
    /** 扬声器设置参数失败 */
    ERR_SPEAKER_SET_PARAM_FAIL: -1322,
    /** 停止扬声器失败 */
    ERR_SPEAKER_STOP_FAIL: -1323,
    /** 开始录屏失败，如果在移动设备出现，可能是权限被用户拒绝了，如果在 Windows 或 Mac 系统的设备出现，请检查录屏接口的参数是否符合要求 */
    ERR_SCREEN_CAPTURE_START_FAIL: -1308,
    /** 录屏失败，在 Android 平台，需要5.0以上的系统 */
    ERR_SCREEN_CAPTURE_UNSURPORT: -1309,
    /** 没有权限上行辅路 */
    ERR_SERVER_CENTER_NO_PRIVILEDGE_PUSH_SUB_VIDEO: -102015,
    /** 其他用户正在上行辅路 */
    ERR_SERVER_CENTER_ANOTHER_USER_PUSH_SUB_VIDEO: -102016,
    /** 视频帧编码失败，例如 iOS 设备切换到其他应用时，硬编码器可能被系统释放，再切换回来时，硬编码器重启前，可能会抛出 */
    ERR_VIDEO_ENCODE_FAIL: -1303,
    /** 音频帧编码失败，例如传入自定义音频数据，SDK 无法处理 */
    ERR_AUDIO_ENCODE_FAIL: -1304,
    /** 不支持的视频分辨率 */
    ERR_UNSUPPORTED_RESOLUTION: -1305,
    /** 不支持的音频采样率 */
    ERR_UNSUPPORTED_SAMPLERATE: -1306,
    /** 设置的 pixel format 不支持 */
    ERR_PIXEL_FORMAT_UNSUPPORTED: -1327,
    /** 设置的 buffer type 不支持 */
    ERR_BUFFER_TYPE_UNSUPPORTED: -1328,
    /** 旁路转推请求超时 */
    ERR_PUBLISH_CDN_STREAM_REQUEST_TIME_OUT: -3321,
    /** 云端混流请求超时 */
    ERR_CLOUD_MIX_TRANSCODING_REQUEST_TIME_OUT: -3322,
    /** 旁路转推回包异常 */
    ERR_PUBLISH_CDN_STREAM_SERVER_FAILED: -3323,
    /** 云端混流回包异常 */
    ERR_CLOUD_MIX_TRANSCODING_SERVER_FAILED: -3324,
    /** 开始向腾讯云的直播 CDN 推流信令超时 */
    ERR_ROOM_REQUEST_START_PUBLISHING_TIMEOUT: -3333,
    /** 开始向腾讯云的直播 CDN 推流信令异常 */
    ERR_ROOM_REQUEST_START_PUBLISHING_ERROR: -3334,
    /** 停止向腾讯云的直播 CDN 推流信令超时 */
    ERR_ROOM_REQUEST_STOP_PUBLISHING_TIMEOUT: -3335,
    /** 停止向腾讯云的直播 CDN 推流信令异常 */
    ERR_ROOM_REQUEST_STOP_PUBLISHING_ERROR: -3336,
    /** 请求连麦超时 */
    ERR_ROOM_REQUEST_CONN_ROOM_TIMEOUT: -3326,
    /** 请求退出连麦超时 */
    ERR_ROOM_REQUEST_DISCONN_ROOM_TIMEOUT: -3327,
    /** 无效参数 */
    ERR_ROOM_REQUEST_CONN_ROOM_INVALID_PARAM: -3328,
    /** 当前是观众角色，不能请求或断开跨房连麦，需要先 switchRole() 到主播 */
    ERR_CONNECT_OTHER_ROOM_AS_AUDIENCE: -3330,
    /** 不支持跨房间连麦 */
    ERR_SERVER_CENTER_CONN_ROOM_NOT_SUPPORT: -102031,
    /** 达到跨房间连麦上限 */
    ERR_SERVER_CENTER_CONN_ROOM_REACH_MAX_NUM: -102032,
    /** 跨房间连麦重试次数耗尽 */
    ERR_SERVER_CENTER_CONN_ROOM_REACH_MAX_RETRY_TIMES: -102033,
    /** 跨房间连麦请求超时 */
    ERR_SERVER_CENTER_CONN_ROOM_REQ_TIMEOUT: -102034,
    /** 跨房间连麦请求格式错误 */
    ERR_SERVER_CENTER_CONN_ROOM_REQ: -102035,
    /** 跨房间连麦无签名 */
    ERR_SERVER_CENTER_CONN_ROOM_NO_SIG: -102036,
    /** 跨房间连麦签名解密失败 */
    ERR_SERVER_CENTER_CONN_ROOM_DECRYPT_SIG: -102037,
    /** 未找到跨房间连麦签名解密密钥 */
    ERR_SERVER_CENTER_CONN_ROOM_NO_KEY: -102038,
    /** 跨房间连麦签名解析错误 */
    ERR_SERVER_CENTER_CONN_ROOM_PARSE_SIG: -102039,
    /** 跨房间连麦签名时间戳错误 */
    ERR_SERVER_CENTER_CONN_ROOM_INVALID_SIG_TIME: -102040,
    /** 跨房间连麦签名不匹配 */
    ERR_SERVER_CENTER_CONN_ROOM_SIG_GROUPID: -102041,
    /** 本房间无连麦 */
    ERR_SERVER_CENTER_CONN_ROOM_NOT_CONNED: -102042,
    /** 本用户未发起连麦 */
    ERR_SERVER_CENTER_CONN_ROOM_USER_NOT_CONNED: -102043,
    /** 跨房间连麦失败 */
    ERR_SERVER_CENTER_CONN_ROOM_FAILED: -102044,
    /** 取消跨房间连麦失败 */
    ERR_SERVER_CENTER_CONN_ROOM_CANCEL_FAILED: -102045,
    /** 被连麦房间不存在 */
    ERR_SERVER_CENTER_CONN_ROOM_CONNED_ROOM_NOT_EXIST: -102046,
    /** 被连麦房间达到连麦上限 */
    ERR_SERVER_CENTER_CONN_ROOM_CONNED_REACH_MAX_ROOM: -102047,
    /** 被连麦用户不存在 */
    ERR_SERVER_CENTER_CONN_ROOM_CONNED_USER_NOT_EXIST: -102048,
    /** 被连麦用户已被删除 */
    ERR_SERVER_CENTER_CONN_ROOM_CONNED_USER_DELETED: -102049,
    /** 被连麦用户达到资源上限 */
    ERR_SERVER_CENTER_CONN_ROOM_CONNED_USER_FULL: -102050,
    /** 连麦请求序号错乱 */
    ERR_SERVER_CENTER_CONN_ROOM_INVALID_SEQ: -102051,
    /** 直播，推流出现网络断开，且经过多次重试无法恢复 */
    ERR_RTMP_PUSH_NET_DISCONNECT: -1307,
    /** 直播，推流地址非法，例如不是 RTMP 协议的地址 */
    ERR_RTMP_PUSH_INVALID_ADDRESS: -1313,
    /** 直播，连接推流服务器失败（若支持智能选路，IP 全部失败） */
    ERR_RTMP_PUSH_NET_ALLADDRESS_FAIL: -1324,
    /** 直播，网络不可用，请确认 WiFi、移动数据或者有线网络是否正常 */
    ERR_RTMP_PUSH_NO_NETWORK: -1325,
    /** 直播，服务器拒绝连接请求，可能是该推流地址已经被占用，或者 TXSecret 校验失败，或者是过期了，或者是欠费了 */
    ERR_RTMP_PUSH_SERVER_REFUSE: -1326,
    /** 直播，网络断连，且经多次重连抢救无效，可以放弃治疗，更多重试请自行重启播放 */
    ERR_PLAY_LIVE_STREAM_NET_DISCONNECT: -2301,
    /** 直播，获取加速拉流的地址失败 */
    ERR_GET_RTMP_ACC_URL_FAIL: -2302,
    /** 播放的文件不存在 */
    ERR_FILE_NOT_FOUND: -2303,
    /** H265 解码失败 */
    ERR_HEVC_DECODE_FAIL: -2304,
    /** 点播，音视频流解密失败 */
    ERR_VOD_DECRYPT_FAIL: -2305,
    /** 点播，获取点播文件信息失败 */
    ERR_GET_VODFILE_MEDIAINFO_FAIL: -2306,
    /** 直播，切流失败（切流可以播放不同画面大小的视频） */
    ERR_PLAY_LIVE_STREAM_SWITCH_FAIL: -2307,
    /** 直播，服务器拒绝连接请求 */
    ERR_PLAY_LIVE_STREAM_SERVER_REFUSE: -2308,
    /** 直播，RTMPACC 低延时拉流失败，且经过多次重试无法恢复 */
    ERR_RTMP_ACC_FETCH_STREAM_FAIL: -2309,
    /** 心跳失败，客户端定时向服务器发送数据包，告诉服务器自己活着，这个错误通常是发包超时 */
    ERR_ROOM_HEARTBEAT_FAIL: -3302,
    /** 拉取接口机服务器地址失败 */
    ERR_ROOM_REQUEST_IP_FAIL: -3303,
    /** 连接接口机服务器失败 */
    ERR_ROOM_CONNECT_FAIL: -3304,
    /** 请求视频位失败 */
    ERR_ROOM_REQUEST_AVSEAT_FAIL: -3305,
    /** 请求 token https 超时，请检查网络是否正常，或网络防火墙是否放行 https 访问 official.opensso.tencent-cloud.com:443 */
    ERR_ROOM_REQUEST_TOKEN_HTTPS_TIMEOUT: -3306,
    /** 请求 IP 和 sig 超时，请检查网络是否正常，或网络防火墙是否放行 UDP 访问下列 IP 和域名 query.tencent-cloud.com:8000 162.14.23.140:8000 162.14.7.49:8000 */
    ERR_ROOM_REQUEST_IP_TIMEOUT: -3307,
    /** 请求视频位超时 */
    ERR_ROOM_REQUEST_VIDEO_FLAG_TIMEOUT: -3309,
    /** 请求视频数据超时 */
    ERR_ROOM_REQUEST_VIDEO_DATA_ROOM_TIMEOUT: -3310,
    /** 请求修改视频能力项超时 */
    ERR_ROOM_REQUEST_CHANGE_ABILITY_TIMEOUT: -3311,
    /** 请求状态上报超时 */
    ERR_ROOM_REQUEST_STATUS_REPORT_TIMEOUT: -3312,
    /** 请求关闭视频超时 */
    ERR_ROOM_REQUEST_CLOSE_VIDEO_TIMEOUT: -3313,
    /** 请求接收视频项超时 */
    ERR_ROOM_REQUEST_SET_RECEIVE_TIMEOUT: -3314,
    /** 请求 token 无效参数，请检查 TRTCParams.userSig 是否填写正确 */
    ERR_ROOM_REQUEST_TOKEN_INVALID_PARAMETER: -3315,
    /** 请求 AES TOKEN 时，server 返回的内容是空的 */
    ERR_ROOM_REQUEST_AES_TOKEN_RETURN_ERROR: -3329,
    /** 请求接口机 IP 返回的列表为空的 */
    ERR_ACCIP_LIST_EMPTY: -3331,
    /** 请求发送 Json 信令超时 */
    ERR_ROOM_REQUEST_SEND_JSON_CMD_TIMEOUT: -3332,
    // Info 服务器（查询接口机 IP）, 服务器错误码，数值范围[-100000, -110000]
    /** server 解包错误，可能请求数据被篡改 */
    ERR_SERVER_INFO_UNPACKING_ERROR: -100000,
    /** TOKEN 错误 */
    ERR_SERVER_INFO_TOKEN_ERROR: -100001,
    /** 分配接口机错误 */
    ERR_SERVER_INFO_ALLOCATE_ACCESS_FAILED: -100002,
    /** 生成签名错误 */
    ERR_SERVER_INFO_GENERATE_SIGN_FAILED: -100003,
    /** https token 超时 */
    ERR_SERVER_INFO_TOKEN_TIMEOUT: -100004,
    /** 无效的命令字 */
    ERR_SERVER_INFO_INVALID_COMMAND: -100005,
    /** 权限位校验失败 */
    ERR_SERVER_INFO_PRIVILEGE_FLAG_ERROR: -100006,
    /** https 请求时，生成加密 key 错误 */
    ERR_SERVER_INFO_GENERATE_KEN_ERROR: -100007,
    /** https 请求时，生成 token 错误 */
    ERR_SERVER_INFO_GENERATE_TOKEN_ERROR: -100008,
    /** 数据库查询失败（房间相关存储信息） */
    ERR_SERVER_INFO_DATABASE: -100009,
    /** 房间号错误 */
    ERR_SERVER_INFO_BAD_ROOMID: -100010,
    /** 场景或角色错误 */
    ERR_SERVER_INFO_BAD_SCENE_OR_ROLE: -100011,
    /** 房间号转换出错 */
    ERR_SERVER_INFO_ROOMID_EXCHANGE_FAILED: -100012,
    /** 房间号非法 */
    ERR_SERVER_INFO_STRGROUP_HAS_INVALID_CHARS: -100014,
    /** 非法SDKAppid */
    ERR_SERVER_INFO_LACK_SDKAPPID: -100015,
    /** 无效请求, 旧版 0x1 要求带 Token; ECDH 要求带 ECDH Publich Key; 两个都没有就按报错 */
    ERR_SERVER_INFO_INVALID: -100016,
    /** 生成公钥失败 */
    ERR_SERVER_INFO_ECDH_GET_KEY: -100017,
    /** 获取tinyid失败 */
    ERR_SERVER_INFO_ECDH_GET_TINYID: -100018,
    // Access 接口机
    /** token 过期 */
    ERR_SERVER_ACC_TOKEN_TIMEOUT: -101000,
    /** 签名错误 */
    ERR_SERVER_ACC_SIGN_ERROR: -101001,
    /** 签名超时 */
    ERR_SERVER_ACC_SIGN_TIMEOUT: -101002,
    /** 房间不存在 */
    ERR_SERVER_ACC_ROOM_NOT_EXIST: -101003,
    /** 后台房间标识 roomId 错误 */
    ERR_SERVER_ACC_ROOMID: -101004,
    /** 后台用户位置标识 locationId 错误 */
    ERR_SERVER_ACC_LOCATIONID: -101005,
    // center 服务器（信令和流控处理等任务）
    /** 后台错误 */
    ERR_SERVER_CENTER_SYSTEM_ERROR: -102000,
    /** 无效的房间 Id */
    ERR_SERVER_CENTER_INVALID_ROOMID: -102001,
    /** 创建房间失败 */
    ERR_SERVER_CENTER_CREATE_ROOM_FAILED: -102002,
    /** 签名错误 */
    ERR_SERVER_CENTER_SIGN_ERROR: -102003,
    /** 签名过期 */
    ERR_SERVER_CENTER_SIGN_TIMEOUT: -102004,
    /** 房间不存在 */
    ERR_SERVER_CENTER_ROOM_NOT_EXIST: -102005,
    /** 房间添加用户失败 */
    ERR_SERVER_CENTER_ADD_USER_FAILED: -102006,
    /** 查找用户失败 */
    ERR_SERVER_CENTER_FIND_USER_FAILED: -102007,
    /** 频繁切换终端 */
    ERR_SERVER_CENTER_SWITCH_TERMINATION_FREQUENTLY: -102008,
    /** locationid 错误 */
    ERR_SERVER_CENTER_LOCATION_NOT_EXIST: -102009,
    /** 没有权限创建房间 */
    ERR_SERVER_CENTER_NO_PRIVILEDGE_CREATE_ROOM: -102010,
    /** 没有权限进入房间 */
    ERR_SERVER_CENTER_NO_PRIVILEDGE_ENTER_ROOM: -102011,
    /** 辅路抢视频位、申请辅路请求类型参数错误 */
    ERR_SERVER_CENTER_INVALID_PARAMETER_SUB_VIDEO: -102012,
    /** 没有权限上视频 */
    ERR_SERVER_CENTER_NO_PRIVILEDGE_PUSH_VIDEO: -102013,
    /** 没有空闲路由表 */
    ERR_SERVER_CENTER_ROUTE_TABLE_ERROR: -102014,
    /** 当前用户没有上行辅路 */
    ERR_SERVER_CENTER_NOT_PUSH_SUB_VIDEO: -102017,
    /** 用户被删除状态 */
    ERR_SERVER_CENTER_USER_WAS_DELETED: -102018,
    /** 没有权限请求视频 */
    ERR_SERVER_CENTER_NO_PRIVILEDGE_REQUEST_VIDEO: -102019,
    /** 进房参数 bussInfo 错误 */
    ERR_SERVER_CENTER_INVALID_PARAMETER: -102023,
    /** 请求 I 帧未知 opType */
    ERR_SERVER_CENTER_I_FRAME_UNKNOW_TYPE: -102024,
    /** 请求 I 帧包格式错误 */
    ERR_SERVER_CENTER_I_FRAME_INVALID_PACKET: -102025,
    /** 请求 I 帧目标用户不存在 */
    ERR_SERVER_CENTER_I_FRAME_DEST_USER_NOT_EXIST: -102026,
    /** 请求 I 帧房间用户太多 */
    ERR_SERVER_CENTER_I_FRAME_ROOM_TOO_BIG: -102027,
    /** 请求 I 帧参数错误 */
    ERR_SERVER_CENTER_I_FRAME_RPS_INVALID_PARAMETER: -102028,
    /** 房间号非法 */
    ERR_SERVER_CENTER_INVALID_ROOM_ID: -102029,
    /** 房间号超过限制 */
    ERR_SERVER_CENTER_ROOM_ID_TOO_LONG: -102030,
    /** 房间满员 */
    ERR_SERVER_CENTER_ROOM_FULL: -102052,
    /** json串解析失败 */
    ERR_SERVER_CENTER_DECODE_JSON_FAIL: -102053,
    /** 未定义命令字 */
    ERR_SERVER_CENTER_UNKNOWN_SUB_CMD: -102054,
    /** 未定义角色 */
    ERR_SERVER_CENTER_INVALID_ROLE: -102055,
    /** 代理机超出限制 */
    ERR_SERVER_CENTER_REACH_PROXY_MAX: -102056,
    //add by sunlitwang begin
    /** 无法保存用户自定义recordId */
    ERR_SERVER_CENTER_RECORDID_STORE: -102057,
    /** Protobuf序列化错误 */
    ERR_SERVER_CENTER_PB_SERIALIZE: -102058,
    // https://cloud.tencent.com/document/product/269/1671#.E5.B8.90.E5.8F.B7.E7.B3.BB.E7.BB.9F , 帐号系统, 主要是70000 - 79999之间.
    // 在请求 token 过程中，出现账号错误，SSO 返回的错误码，原为正数，现将其转换为负数。
    /** sig 过期，请尝试重新生成。如果是刚生成，就过期，请检查有效期填写的是否过小，或者填的 0 */
    ERR_SERVER_SSO_SIG_EXPIRED: -70001,
    /** sig 校验失败，请确认下 sig 内容是否被截断，如缓冲区长度不够导致的内容截断 */
    ERR_SERVER_SSO_SIG_VERIFICATION_FAILED_1: -70003,
    /** sig 校验失败，请确认下 sig 内容是否被截断，如缓冲区长度不够导致的内容截断 */
    ERR_SERVER_SSO_SIG_VERIFICATION_FAILED_2: -70004,
    /** sig 校验失败，可用工具自行验证生成的 sig 是否正确 */
    ERR_SERVER_SSO_SIG_VERIFICATION_FAILED_3: -70005,
    /** sig 校验失败，可用工具自行验证生成的 sig 是否正确 */
    ERR_SERVER_SSO_SIG_VERIFICATION_FAILED_4: -70006,
    /** sig 校验失败，可用工具自行验证生成的 sig 是否正确 */
    ERR_SERVER_SSO_SIG_VERIFICATION_FAILED_5: -70007,
    /** sig 校验失败，可用工具自行验证生成的 sig 是否正确 */
    ERR_SERVER_SSO_SIG_VERIFICATION_FAILED_6: -70008,
    /** 用业务公钥验证 sig 失败，请确认生成的 usersig 使用的私钥和 sdkAppId 是否对应 */
    ERR_SERVER_SSO_SIG_VERIFICATION_FAILED_7: -70009,
    /** sig 校验失败，可用工具自行验证生成的 sig 是否正确 */
    ERR_SERVER_SSO_SIG_VERIFICATION_FAILED_8: -70010,
    /** sig 中 identifier 与请求时的 identifier 不匹配，请检查登录时填写的 identifier 与 sig 中的是否一致 */
    ERR_SERVER_SSO_SIG_VERIFICATION_ID_NOT_MATCH: -70013,
    /** sig 中 sdkAppId 与请求时的 sdkAppId 不匹配，请检查登录时填写的 sdkAppId 与 sig 中的是否一致 */
    ERR_SERVER_SSO_APPID_NOT_MATCH: -70014,
    /** 内部第三方票据验证超时，请重试，如多次重试不成功，请@TLS 帐号支持，QQ 3268519604 */
    ERR_SERVER_SSO_VERIFICATION_EXPIRED: -70017,
    /** 内部第三方票据验证超时，请重试，如多次重试不成功，请@TLS 帐号支持，QQ 3268519604 */
    ERR_SERVER_SSO_VERIFICATION_FAILED: -70018,
    /** sdkAppId 未找到，请确认是否已经在腾讯云上配置 */
    ERR_SERVER_SSO_APPID_NOT_FOUND: -70020,
    /** 帐号已被拉入黑名单，请联系 TLS 帐号支持 QQ 3268519604 */
    ERR_SERVER_SSO_ACCOUNT_IN_BLACKLIST: -70051,
    /** usersig 已经失效，请重新生成，再次尝试 */
    ERR_SERVER_SSO_SIG_INVALID: -70052,
    /** 安全原因被限制 */
    ERR_SERVER_SSO_LIMITED_BY_SECURITY: -70114,
    /** 登录状态无效，请使用 usersig 重新鉴权 */
    ERR_SERVER_SSO_INVALID_LOGIN_STATUS: -70221,
    /** sdkAppId 填写错误 */
    ERR_SERVER_SSO_APPID_ERROR: -70252,
    /** 票据校验失败，请检查各项参数是否正确 */
    ERR_SERVER_SSO_TICKET_VERIFICATION_FAILED: -70346,
    /** 票据因过期原因校验失败 */
    ERR_SERVER_SSO_TICKET_EXPIRED: -70347,
    /** 创建账号数量超过已购买预付费数量限制 */
    ERR_SERVER_SSO_ACCOUNT_EXCEED_PURCHASES: -70398,
    /** 服务器内部错误，请重试 */
    ERR_SERVER_SSO_INTERNAL_ERROR: -70500,
};
/////////////////////////////////////////////////////////////////////////////////
//
//                     （二）错误码（警告）
//
/////////////////////////////////////////////////////////////////////////////////
/**
 * @memberof ErrorCode
 * @typedef 错误码（警告）
 * @description SDK 错误码（警告）对照表
 * | 符号 | 值 | 含义 |
 * |---|---|---|
 * |WARNING_HW_ENCODER_START_FAIL|1103|硬编码启动出现问题，自动切换到软编码|
 * |WARNING_VIDEO_ENCODER_SW_TO_HW|1107|当前 CPU 使用率太高，无法满足软件编码需求，自动切换到硬件编码|
 * |WARNING_INSUFFICIENT_CAPTURE_FPS|1108|摄像头采集帧率不足，部分自带美颜算法的 Android 手机上会出现|
 * |WARNING_SW_ENCODER_START_FAIL|1109|软编码启动失败|
 * |WARNING_REDUCE_CAPTURE_RESOLUTION|1110|摄像头采集分辨率被降低，以满足当前帧率和性能最优解。|
 * |WARNING_VIDEO_FRAME_DECODE_FAIL|2101|当前视频帧解码失败|
 * |WARNING_AUDIO_FRAME_DECODE_FAIL|2102|当前音频帧解码失败|
 * |WARNING_VIDEO_PLAY_LAG|2105|当前视频播放出现卡顿|
 * |WARNING_HW_DECODER_START_FAIL|2106|硬解启动失败，采用软解码|
 * |WARNING_VIDEO_DECODER_HW_TO_SW|2108|当前流硬解第一个 I 帧失败，SDK 自动切软解|
 * |WARNING_SW_DECODER_START_FAIL|2109|软解码器启动失败|
 * |WARNING_VIDEO_RENDER_FAIL|2110|视频渲染失败|
 * |WARNING_AUDIO_RECORDING_WRITE_FAIL|7001|音频录制写入文件失败|
 * |WARNING_ROOM_DISCONNECT|5101|网络断开连接|
 * |WARNING_IGNORE_UPSTREAM_FOR_AUDIENCE|6001|当前是观众角色，忽略上行音视频数据|
 */
export const TXLiteAVWarning = {
    /** 硬编码启动出现问题，自动切换到软编码 */
    WARNING_HW_ENCODER_START_FAIL: 1103,
    /** 当前 CPU 使用率太高，无法满足软件编码需求，自动切换到硬件编码 */
    WARNING_VIDEO_ENCODER_SW_TO_HW: 1107,
    /** 摄像头采集帧率不足，部分自带美颜算法的 Android 手机上会出现 */
    WARNING_INSUFFICIENT_CAPTURE_FPS: 1108,
    /** 软编码启动失败 */
    WARNING_SW_ENCODER_START_FAIL: 1109,
    /** 摄像头采集分辨率被降低，以满足当前帧率和性能最优解。 */
    WARNING_REDUCE_CAPTURE_RESOLUTION: 1110,
    /** 当前视频帧解码失败 */
    WARNING_VIDEO_FRAME_DECODE_FAIL: 2101,
    /** 当前音频帧解码失败 */
    WARNING_AUDIO_FRAME_DECODE_FAIL: 2102,
    /** 当前视频播放出现卡顿 */
    WARNING_VIDEO_PLAY_LAG: 2105,
    /** 硬解启动失败，采用软解码 */
    WARNING_HW_DECODER_START_FAIL: 2106,
    /** 当前流硬解第一个 I 帧失败，SDK 自动切软解 */
    WARNING_VIDEO_DECODER_HW_TO_SW: 2108,
    /** 软解码器启动失败 */
    WARNING_SW_DECODER_START_FAIL: 2109,
    /** 视频渲染失败 */
    WARNING_VIDEO_RENDER_FAIL: 2110,
    /** 音频录制写入文件失败 */
    WARNING_AUDIO_RECORDING_WRITE_FAIL: 7001,
    /** 网络断开连接 */
    WARNING_ROOM_DISCONNECT: 5101,
    /** 当前是观众角色，忽略上行音视频数据 */
    WARNING_IGNORE_UPSTREAM_FOR_AUDIENCE: 6001,
    /** 网络状况不佳：上行带宽太小，上传数据受阻 */
    WARNING_NET_BUSY: 1101,
    /** 直播，网络断连, 已启动自动重连（自动重连连续失败超过三次会放弃） */
    WARNING_RTMP_SERVER_RECONNECT: 1102,
    /** 直播，网络断连, 已启动自动重连（自动重连连续失败超过三次会放弃） */
    WARNING_LIVE_STREAM_SERVER_RECONNECT: 2103,
    /** 网络来包不稳：可能是下行带宽不足，或由于主播端出流不均匀 */
    WARNING_RECV_DATA_LAG: 2104,
    /** 直播，DNS 解析失败 */
    WARNING_RTMP_DNS_FAIL: 3001,
    /** 直播，服务器连接失败 */
    WARNING_RTMP_SEVER_CONN_FAIL: 3002,
    /** 直播，与 RTMP 服务器握手失败 */
    WARNING_RTMP_SHAKE_FAIL: 3003,
    /** 直播，服务器主动断开 */
    WARNING_RTMP_SERVER_BREAK_CONNECT: 3004,
    /** 直播，RTMP 读/写失败，将会断开连接 */
    WARNING_RTMP_READ_WRITE_FAIL: 3005,
    /** 直播，RTMP 写失败（SDK 内部错误码，不会对外抛出） */
    WARNING_RTMP_WRITE_FAIL: 3006,
    /** 直播，RTMP 读失败（SDK 内部错误码，不会对外抛出） */
    WARNING_RTMP_READ_FAIL: 3007,
    /** 直播，超过30s 没有数据发送，主动断开连接 */
    WARNING_RTMP_NO_DATA: 3008,
    /** 直播，connect 服务器调用失败（SDK 内部错误码，不会对外抛出） */
    WARNING_PLAY_LIVE_STREAM_INFO_CONNECT_FAIL: 3009,
    /** 直播，连接失败，该流地址无视频（SDK 内部错误码，不会对外抛出） */
    WARNING_NO_STEAM_SOURCE_FAIL: 3010,
    /** 网络断连，已启动自动重连 */
    WARNING_ROOM_RECONNECT: 5102,
    /** 网络状况不佳：上行带宽太小，上传数据受阻 */
    WARNING_ROOM_NET_BUSY: 5103,
};
/////////////////////////////////////////////////////////////////////////////////
//
//                     （三）JS 封装层抛出的异常（严重）
//
/////////////////////////////////////////////////////////////////////////////////
/**
 * @namespace ErrorCode
 * @description 错误码
 */
export const TXLiteJSError = {
    /**
     * 未知错误
     * @default 0xFFFF
     * @memberof module:ErrorCode
     */
    UNKNOWN: 0xffff,
    /**
     * 无效参数
     *
     * @default 0x1000
     * @memberof module:ErrorCode
     */
    INVALID_PARAMETER: 0x1000,
    /**
     * 非法操作
     *
     * @default 0x1001
     * @memberof module:ErrorCode
     */
    INVALID_OPERATION: 0x1001,
};
const getErrorName = function (code) {
    for (let key in TXLiteJSError) {
        if (TXLiteJSError[key] === code) {
            return key;
        }
    }
    return 'UNKNOWN';
};
/**
 * TrtcError 错误对象<br>
 * @extends Error
 * @namespace ErrorCode
 */
class TrtcError extends Error {
    constructor({ code = TXLiteJSError.UNKNOWN, message, extraInfo }) {
        if (extraInfo) {
            const tempError = {
                errCode: code,
                errMsg: message,
                extraInfo: Object.assign(Object.assign({}, extraInfo), { errCodeUrl: errorCodeUrl }),
            };
            super(JSON.stringify(tempError));
        }
        else {
            super(message +
                ` <${getErrorName(code)} 0x${code.toString(16)}>. Refer to: ${errorCodeUrl}`);
        }
        this.errCode = code;
        this.errMsg = message;
        this.extraInfo = Object.assign(Object.assign({}, extraInfo), { errCodeUrl: errorCodeUrl });
    }
    /**
     * 获取错误码<br>
     * 详细错误码列表参见 {@link module:ErrorCode ErrorCode}
     * @memberof TrtcError
     */
    getCode() {
        return this.errCode;
    }
}
export default TrtcError;
export function generateError_(error, code = TXLiteJSError.UNKNOWN, extraInfo) {
    return new TrtcError({
        code: error.code || code,
        message: `${NAME.LOG_PREFIX}${error.message}`,
        extraInfo,
    });
}
;

 src/utils/voiceCallByTX/TrtcCloud/lib/TrtcDefines.js

New file
@@ -0,0 +1,522 @@
/**
 * TRTC 关键类型定义<br>
 * @description 分辨率、质量等级等枚举和常量值的定义
 */
/////////////////////////////////////////////////////////////////////////////////
//
//                    【（一）视频相关枚举值定义】
//
/////////////////////////////////////////////////////////////////////////////////
/**
 * 视频分辨率<br>
 * 此处仅定义横屏分辨率（如 640 × 360），如需使用竖屏分辨率（如 360 × 640），需要同时指定 VideoResolutionMode 为 Portrait
 * @enum {Number}
 */
const TRTCVideoResolution_HACK_JSDOC = {
    /** 宽高比 1:1；分辨率 120x120；建议码率（VideoCall）80kbps; 建议码率（LIVE）120kbps */
    TRTCVideoResolution_120_120: 1,
    /** 宽高比 1:1 分辨率 160x160；建议码率（VideoCall）100kbps; 建议码率（LIVE）150kbps */
    TRTCVideoResolution_160_160: 3,
    /** 宽高比 1:1；分辨率 270x270；建议码率（VideoCall）200kbps; 建议码率（LIVE）300kbps */
    TRTCVideoResolution_270_270: 5,
    /** 宽高比 1:1；分辨率 480x480；建议码率（VideoCall）350kbps; 建议码率（LIVE）500kbps */
    TRTCVideoResolution_480_480: 7,
    /** 宽高比4:3；分辨率 160x120；建议码率（VideoCall）100kbps; 建议码率（LIVE）150kbps */
    TRTCVideoResolution_160_120: 50,
    /** 宽高比 4:3；分辨率 240x180；建议码率（VideoCall）150kbps; 建议码率（LIVE）250kbps */
    TRTCVideoResolution_240_180: 52,
    /** 宽高比 4:3；分辨率 280x210；建议码率（VideoCall）200kbps; 建议码率（LIVE）300kbps */
    TRTCVideoResolution_280_210: 54,
    /** 宽高比 4:3；分辨率 320x240；建议码率（VideoCall）250kbps; 建议码率（LIVE）375kbps */
    TRTCVideoResolution_320_240: 56,
    /** 宽高比 4:3；分辨率 400x300；建议码率（VideoCall）300kbps; 建议码率（LIVE）450kbps */
    TRTCVideoResolution_400_300: 58,
    /** 宽高比 4:3；分辨率 480x360；建议码率（VideoCall）400kbps; 建议码率（LIVE）600kbps */
    TRTCVideoResolution_480_360: 60,
    /** 宽高比 4:3；分辨率 640x480；建议码率（VideoCall）600kbps; 建议码率（LIVE）900kbps */
    TRTCVideoResolution_640_480: 62,
    /** 宽高比 4:3；分辨率 960x720；建议码率（VideoCall）1000kbps; 建议码率（LIVE）1500kbps */
    TRTCVideoResolution_960_720: 64,
    /** 宽高比 16:9；分辨率 160x90；建议码率（VideoCall）150kbps; 建议码率（LIVE）250kbps */
    TRTCVideoResolution_160_90: 100,
    /** 宽高比 16:9；分辨率 256x144；建议码率（VideoCall）200kbps; 建议码率（LIVE）300kbps */
    TRTCVideoResolution_256_144: 102,
    /** 宽高比 16:9；分辨率 320x180；建议码率（VideoCall）250kbps; 建议码率（LIVE）400kbps */
    TRTCVideoResolution_320_180: 104,
    /** 宽高比 16:9；分辨率 480x270；建议码率（VideoCall）350kbps; 建议码率（LIVE）550kbps */
    TRTCVideoResolution_480_270: 106,
    /** 宽高比 16:9；分辨率 640x360；建议码率（VideoCall）500kbps; 建议码率（LIVE）900kbps */
    TRTCVideoResolution_640_360: 108,
    /** 宽高比 16:9；分辨率 960x540；建议码率（VideoCall）850kbps; 建议码率（LIVE）1300kbps */
    TRTCVideoResolution_960_540: 110,
    /** 宽高比 16:9；分辨率 1280x720；建议码率（VideoCall）1200kbps; 建议码率（LIVE）1800kbps */
    TRTCVideoResolution_1280_720: 112,
    /** 宽高比 16:9；分辨率 1920x1080；建议码率（VideoCall）2000kbps; 建议码率（LIVE）3000kbps */
    TRTCVideoResolution_1920_1080: 114,
};
export var TRTCVideoResolution;
(function (TRTCVideoResolution) {
    TRTCVideoResolution[TRTCVideoResolution["TRTCVideoResolution_120_120"] = 1] = "TRTCVideoResolution_120_120";
    TRTCVideoResolution[TRTCVideoResolution["TRTCVideoResolution_160_160"] = 3] = "TRTCVideoResolution_160_160";
    TRTCVideoResolution[TRTCVideoResolution["TRTCVideoResolution_270_270"] = 5] = "TRTCVideoResolution_270_270";
    TRTCVideoResolution[TRTCVideoResolution["TRTCVideoResolution_480_480"] = 7] = "TRTCVideoResolution_480_480";
    TRTCVideoResolution[TRTCVideoResolution["TRTCVideoResolution_160_120"] = 50] = "TRTCVideoResolution_160_120";
    TRTCVideoResolution[TRTCVideoResolution["TRTCVideoResolution_240_180"] = 52] = "TRTCVideoResolution_240_180";
    TRTCVideoResolution[TRTCVideoResolution["TRTCVideoResolution_280_210"] = 54] = "TRTCVideoResolution_280_210";
    TRTCVideoResolution[TRTCVideoResolution["TRTCVideoResolution_320_240"] = 56] = "TRTCVideoResolution_320_240";
    TRTCVideoResolution[TRTCVideoResolution["TRTCVideoResolution_400_300"] = 58] = "TRTCVideoResolution_400_300";
    TRTCVideoResolution[TRTCVideoResolution["TRTCVideoResolution_480_360"] = 60] = "TRTCVideoResolution_480_360";
    TRTCVideoResolution[TRTCVideoResolution["TRTCVideoResolution_640_480"] = 62] = "TRTCVideoResolution_640_480";
    TRTCVideoResolution[TRTCVideoResolution["TRTCVideoResolution_960_720"] = 64] = "TRTCVideoResolution_960_720";
    TRTCVideoResolution[TRTCVideoResolution["TRTCVideoResolution_160_90"] = 100] = "TRTCVideoResolution_160_90";
    TRTCVideoResolution[TRTCVideoResolution["TRTCVideoResolution_256_144"] = 102] = "TRTCVideoResolution_256_144";
    TRTCVideoResolution[TRTCVideoResolution["TRTCVideoResolution_320_180"] = 104] = "TRTCVideoResolution_320_180";
    TRTCVideoResolution[TRTCVideoResolution["TRTCVideoResolution_480_270"] = 106] = "TRTCVideoResolution_480_270";
    TRTCVideoResolution[TRTCVideoResolution["TRTCVideoResolution_640_360"] = 108] = "TRTCVideoResolution_640_360";
    TRTCVideoResolution[TRTCVideoResolution["TRTCVideoResolution_960_540"] = 110] = "TRTCVideoResolution_960_540";
    TRTCVideoResolution[TRTCVideoResolution["TRTCVideoResolution_1280_720"] = 112] = "TRTCVideoResolution_1280_720";
    TRTCVideoResolution[TRTCVideoResolution["TRTCVideoResolution_1920_1080"] = 114] = "TRTCVideoResolution_1920_1080";
})(TRTCVideoResolution || (TRTCVideoResolution = {}));
/**
 * 视频分辨率模式<br>
 * TRTCVideoResolution 中仅定义了横屏分辨率（如 640 × 360），如需使用竖屏分辨率（如 360 × 640），需要同时指定 TRTCVideoResolutionMode 为 Portrait
 * @enum {Number}
 */
const TRTCVideoResolutionMode_HACK_JSDOC = {
    /** 横屏分辨率 */
    TRTCVideoResolutionModeLandscape: 0,
    /** 竖屏分辨率 */
    TRTCVideoResolutionModePortrait: 1,
};
export var TRTCVideoResolutionMode;
(function (TRTCVideoResolutionMode) {
    TRTCVideoResolutionMode[TRTCVideoResolutionMode["TRTCVideoResolutionModeLandscape"] = 0] = "TRTCVideoResolutionModeLandscape";
    TRTCVideoResolutionMode[TRTCVideoResolutionMode["TRTCVideoResolutionModePortrait"] = 1] = "TRTCVideoResolutionModePortrait";
})(TRTCVideoResolutionMode || (TRTCVideoResolutionMode = {}));
;
/**
 * 视频流类型<br>
 * TRTC 内部有三种不同的音视频流，分别是：
 * - 高清大画面：一般用来传输摄像头的视频数据
 * - 低清小画面：小画面和大画面的内容相互，但是分辨率和码率都比大画面低，因此清晰度也更低
 * - 辅流画面：一般用于屏幕分享，同一时间在同一个房间中只允许一个用户发布辅流视频，其他用户必须要等该用户关闭之后才能发布自己的辅流
 *
 * **Note:**
 * - 不支持单独开启低清小画面，小画面必须依附于大画面而存在，SDK 会自动设定低清小画面的分辨率和码率
 * @enum {Number}
 */
const TRTCVideoStreamType_HACK_JSDOC = {
    /** 大画面视频流 */
    TRTCVideoStreamTypeBig: 0,
    /** 小画面视频流 */
    TRTCVideoStreamTypeSmall: 1,
    /** 辅流（屏幕分享） */
    TRTCVideoStreamTypeSub: 2,
};
export var TRTCVideoStreamType;
(function (TRTCVideoStreamType) {
    TRTCVideoStreamType[TRTCVideoStreamType["TRTCVideoStreamTypeBig"] = 0] = "TRTCVideoStreamTypeBig";
    TRTCVideoStreamType[TRTCVideoStreamType["TRTCVideoStreamTypeSmall"] = 1] = "TRTCVideoStreamTypeSmall";
    TRTCVideoStreamType[TRTCVideoStreamType["TRTCVideoStreamTypeSub"] = 2] = "TRTCVideoStreamTypeSub";
})(TRTCVideoStreamType || (TRTCVideoStreamType = {}));
/**
 * 画面来源<br>
 * TRTC 内部有两种不同的画面来源，分别是：
 * - TRTCSnapshotSourceTypeStream: 视频流画面
 * - TRTCSnapshotSourceTypeView: 视频渲染画面
 *
 * **Note:**
 * - 截取视频流画面（TRTCSnapshotSourceTypeStream）一般更清晰。
 * @enum {Number}
 */
const TRTCSnapshotSourceType_HACK_JSDOC = {
    /** 视频流画面 */
    TRTCSnapshotSourceTypeStream: 0,
    /** 视频渲染画面 */
    TRTCSnapshotSourceTypeView: 1,
};
export var TRTCSnapshotSourceType;
(function (TRTCSnapshotSourceType) {
    TRTCSnapshotSourceType[TRTCSnapshotSourceType["TRTCSnapshotSourceTypeStream"] = 0] = "TRTCSnapshotSourceTypeStream";
    TRTCSnapshotSourceType[TRTCSnapshotSourceType["TRTCSnapshotSourceTypeView"] = 1] = "TRTCSnapshotSourceTypeView";
})(TRTCSnapshotSourceType || (TRTCSnapshotSourceType = {}));
/**
 * 视频画面填充模式<br>
 * 如果画面的显示分辨率不等于画面的原始分辨率，就需要您设置画面的填充模式:
 * - TRTCVideoFillMode_Fill，图像铺满屏幕，超出显示视窗的视频部分将被截掉，所以画面显示可能不完整。
 * - TRTCVideoFillMode_Fit，图像长边填满屏幕，短边区域会被填充黑色，但画面的内容肯定是完整的。
 * - TRTCVideoFillMode_ScaleFill，缩放填充模式，即无论画面的宽高比，都会被拉伸或压缩以完全填充显示区域，此模式下画面宽高比可能会被改变，导致渲染画面变形
 * @enum {Number}
 */
const TRTCVideoFillMode_HACK_JSDOC = {
    /** 图像铺满屏幕，超出显示视窗的视频部分将被截掉 */
    TRTCVideoFillMode_Fill: 0,
    /** 图像长边填满屏幕，短边区域会被填充黑色 */
    TRTCVideoFillMode_Fit: 1,
    /** 缩放填充模式，即无论画面的宽高比，都会被拉伸或压缩以完全填充显示区域 */
    TRTCVideoFillMode_ScaleFill: 2,
};
export var TRTCVideoFillMode;
(function (TRTCVideoFillMode) {
    TRTCVideoFillMode[TRTCVideoFillMode["TRTCVideoFillMode_Fill"] = 0] = "TRTCVideoFillMode_Fill";
    TRTCVideoFillMode[TRTCVideoFillMode["TRTCVideoFillMode_Fit"] = 1] = "TRTCVideoFillMode_Fit";
    TRTCVideoFillMode[TRTCVideoFillMode["TRTCVideoFillMode_ScaleFill"] = 2] = "TRTCVideoFillMode_ScaleFill";
})(TRTCVideoFillMode || (TRTCVideoFillMode = {}));
;
/**
 * 视频画面旋转方向<br>
 * TRTC SDK 提供了对本地和远程画面的旋转角度设置 API，如下的旋转角度都是指顺时针方向的。
 * @enum {Number}
 */
const TRTCVideoRotation_HACK_JSDOC = {
    /** 顺时针旋转0度 */
    TRTCVideoRotation_0: 0,
    /** 顺时针旋转90度 */
    TRTCVideoRotation_90: 1,
    /** 顺时针旋转180度 */
    TRTCVideoRotation_180: 2,
    /** 顺时针旋转270度 */
    TRTCVideoRotation_270: 3,
};
export var TRTCVideoRotation;
(function (TRTCVideoRotation) {
    TRTCVideoRotation[TRTCVideoRotation["TRTCVideoRotation_0"] = 0] = "TRTCVideoRotation_0";
    TRTCVideoRotation[TRTCVideoRotation["TRTCVideoRotation_90"] = 1] = "TRTCVideoRotation_90";
    TRTCVideoRotation[TRTCVideoRotation["TRTCVideoRotation_180"] = 2] = "TRTCVideoRotation_180";
    TRTCVideoRotation[TRTCVideoRotation["TRTCVideoRotation_270"] = 3] = "TRTCVideoRotation_270";
})(TRTCVideoRotation || (TRTCVideoRotation = {}));
/**
 * 画面渲染镜像类型<br>
 * TRTC 的画面镜像提供下列设置模式
 * @enum {Number}
 */
const TRTCVideoMirrorType_HACK_JSDOC = {
    /** 只适用于移动端， 本地预览时，前置摄像头镜像，后置摄像头不镜像 */
    TRTCVideoMirrorType_Auto: 0,
    /** 所有画面均镜像 */
    TRTCVideoMirrorType_Enable: 1,
    /** 所有画面均不镜像 */
    TRTCVideoMirrorType_Disable: 2
};
export var TRTCVideoMirrorType;
(function (TRTCVideoMirrorType) {
    TRTCVideoMirrorType[TRTCVideoMirrorType["TRTCVideoMirrorType_Auto"] = 0] = "TRTCVideoMirrorType_Auto";
    TRTCVideoMirrorType[TRTCVideoMirrorType["TRTCVideoMirrorType_Enable"] = 1] = "TRTCVideoMirrorType_Enable";
    TRTCVideoMirrorType[TRTCVideoMirrorType["TRTCVideoMirrorType_Disable"] = 2] = "TRTCVideoMirrorType_Disable";
})(TRTCVideoMirrorType || (TRTCVideoMirrorType = {}));
/**
 * 美颜（磨皮）算法<br>
 * TRTC SDK 内置了多种不同的磨皮算法，您可以选择最适合您产品定位的方案。
 * @enum {Number}
 */
const TRTCBeautyStyle_HACK_JSDOC = {
    /** 光滑，算法比较激进，磨皮效果比较明显，适用于秀场直播 */
    TRTCBeautyStyleSmooth: 0,
    /** 自然，算法更多地保留了面部细节，磨皮效果更加自然，适用于绝大多数直播场景 */
    TRTCBeautyStyleNature: 1,
    /** 优图，由优图实验室提供，磨皮效果介于光滑和自然之间，比光滑保留更多皮肤细节，比自然磨皮程度更高 */
    TRTCBeautyStylePitu: 2,
};
export var TRTCBeautyStyle;
(function (TRTCBeautyStyle) {
    TRTCBeautyStyle[TRTCBeautyStyle["TRTCBeautyStyleSmooth"] = 0] = "TRTCBeautyStyleSmooth";
    TRTCBeautyStyle[TRTCBeautyStyle["TRTCBeautyStyleNature"] = 1] = "TRTCBeautyStyleNature";
    TRTCBeautyStyle[TRTCBeautyStyle["TRTCBeautyStylePitu"] = 2] = "TRTCBeautyStylePitu";
})(TRTCBeautyStyle || (TRTCBeautyStyle = {}));
/**
 * 背景音效<br>
 * @enum {Number}
 */
export class AudioMusicParam {
    constructor(id, path, loopCount, publish, isShortFile, startTimeMS, endTimeMS) {
        this.id = id;
        this.path = path;
        this.loopCount = loopCount;
        this.publish = publish;
        this.isShortFile = isShortFile;
        this.startTimeMS = startTimeMS;
        this.endTimeMS = endTimeMS;
    }
}
/////////////////////////////////////////////////////////////////////////////////
//
//                    【（二）网络相关枚举值定义】
//
/////////////////////////////////////////////////////////////////////////////////
/**
 * 应用场景<br>
 * TRTC 可用于视频会议和在线直播等多种应用场景，针对不同的应用场景，TRTC SDK 的内部会进行不同的优化配置：
 * - TRTCAppSceneVideoCall    ：视频通话场景，适合[1对1视频通话]、[300人视频会议]、[在线问诊]、[视频聊天]、[远程面试]等。
 * - TRTCAppSceneLIVE         ：视频互动直播，适合[视频低延时直播]、[十万人互动课堂]、[视频直播 PK]、[视频相亲房]、[互动课堂]、[远程培训]、[超大型会议]等。
 * - TRTCAppSceneAudioCall    ：语音通话场景，适合[1对1语音通话]、[300人语音会议]、[语音聊天]、[语音会议]、[在线狼人杀]等。
 * - TRTCAppSceneVoiceChatRoom：语音互动直播，适合：[语音低延时直播]、[语音直播连麦]、[语聊房]、[K 歌房]、[FM 电台]等。
 * @enum {Number}
 */
const TRTCAppScene_HACK_JSDOC = {
    /**
     * 视频通话场景，支持720P、1080P高清画质，单个房间最多支持300人同时在线，最高支持50人同时发言。<br>
     * 适合：[视频低延时直播]、[十万人互动课堂]、[视频直播 PK]、[视频相亲房]、[互动课堂]、[远程培训]、[超大型会议]等。<br>
     * 注意：此场景下，您必须通过 TRTCParams 中的 role 字段指定当前用户的角色。
     */
    TRTCAppSceneVideoCall: 0,
    /**
     * 视频互动直播，支持平滑上下麦，切换过程无需等待，主播延时小于300ms；支持十万级别观众同时播放，播放延时低至1000ms。<br>
     * 在线直播场景，内部编码器和网络协议优化侧重性能和兼容性，性能和清晰度表现更佳。
     */
    TRTCAppSceneLIVE: 1,
    /**
     * 语音通话场景，支持 48kHz，支持双声道。单个房间最多支持300人同时在线，最高支持50人同时发言。<br>
     * 适合：[1对1语音通话]、[300人语音会议]、[语音聊天]、[语音会议]、[在线狼人杀]等。
     */
    TRTCAppSceneAudioCall: 2,
    /**
     * 语音互动直播，支持平滑上下麦，切换过程无需等待，主播延时小于300ms；支持十万级别观众同时播放，播放延时低至1000ms。<br>
     * 适合：[语音低延时直播]、[语音直播连麦]、[语聊房]、[K 歌房]、[FM 电台]等。<br>
     * 注意：此场景下，您必须通过 TRTCParams 中的 role 字段指定当前用户的角色。
     */
    TRTCAppSceneVoiceChatRoom: 3,
};
export var TRTCAppScene;
(function (TRTCAppScene) {
    TRTCAppScene[TRTCAppScene["TRTCAppSceneVideoCall"] = 0] = "TRTCAppSceneVideoCall";
    TRTCAppScene[TRTCAppScene["TRTCAppSceneLIVE"] = 1] = "TRTCAppSceneLIVE";
    TRTCAppScene[TRTCAppScene["TRTCAppSceneAudioCall"] = 2] = "TRTCAppSceneAudioCall";
    TRTCAppScene[TRTCAppScene["TRTCAppSceneVoiceChatRoom"] = 3] = "TRTCAppSceneVoiceChatRoom";
})(TRTCAppScene || (TRTCAppScene = {}));
/**
 * 角色，仅适用于直播场景（TRTCAppSceneLIVE 和 TRTCAppSceneVoiceChatRoom）<br>
 * 在直播场景中，多数用户只是观众，只有个别用户是主播，这种角色区分可以有利于 TRTC 进行更好的定向优化。
 * - Anchor：主播，可以上行视频和音频，一个房间里最多支持50个主播同时上行音视频。
 * - Audience：观众，只能观看，不能上行视频和音频，一个房间里的观众人数没有上限。
 *
 * @enum {Number}
 */
const TRTCRoleType_HACK_JSDOC = {
    /** 主播 */
    TRTCRoleAnchor: 20,
    /** 观众 */
    TRTCRoleAudience: 21,
};
export var TRTCRoleType;
(function (TRTCRoleType) {
    TRTCRoleType[TRTCRoleType["TRTCRoleAnchor"] = 20] = "TRTCRoleAnchor";
    TRTCRoleType[TRTCRoleType["TRTCRoleAudience"] = 21] = "TRTCRoleAudience";
})(TRTCRoleType || (TRTCRoleType = {}));
/////////////////////////////////////////////////////////////////////////////////
//
//                    【（三）音频相关枚举值定义】
//
/////////////////////////////////////////////////////////////////////////////////
/**
 * 音频质量<br>
 * @enum {Number}
 */
const TRTCAudioQuality_HACK_JSDOC = {
    /** 人声模式：适用于以人声沟通为主的应用场景，该模式下音频传输的抗性较强，TRTC 会通过各种人声处理技术保障在弱网络环境下的流畅度最佳 */
    TRTCAudioQualitySpeech: 1,
    /** 标准模式（或者默认模式）：介于 Speech 和 Music 之间的档位，对音乐的还原度比人声模式要好，但传输数据量比音乐模式要低很多，对各种场景均有不错的适应性，如无特殊需求推荐选择之。 */
    TRTCAudioQualityDefault: 2,
    /** 音乐模式：适用于对声乐要求很苛刻的场景，该模式下音频传输的数据量很大，TRTC 会通过各项技术确保音乐信号在各频段均能获得高保真的细节还原度 */
    TRTCAudioQualityMusic: 3
};
export var TRTCAudioQuality;
(function (TRTCAudioQuality) {
    TRTCAudioQuality[TRTCAudioQuality["TRTCAudioQualitySpeech"] = 1] = "TRTCAudioQualitySpeech";
    TRTCAudioQuality[TRTCAudioQuality["TRTCAudioQualityDefault"] = 2] = "TRTCAudioQualityDefault";
    TRTCAudioQuality[TRTCAudioQuality["TRTCAudioQualityMusic"] = 3] = "TRTCAudioQualityMusic";
})(TRTCAudioQuality || (TRTCAudioQuality = {}));
/////////////////////////////////////////////////////////////////////////////////
//
//                      【（四）TRTC 核心类型定义】
//
/////////////////////////////////////////////////////////////////////////////////
/**
 * 进房相关参数<br>
 * 只有该参数填写正确，才能顺利调用 enterRoom 进入 roomId 所指定的音视频房间。
 * @param {Number}       sdkAppId      - 【字段含义】应用标识（必填），腾讯视频云基于 sdkAppId 完成计费统计。<br>
 *                                       【推荐取值】在腾讯云 [TRTC 控制台](https://console.cloud.tencent.com/rav/) 中创建应用，之后可以在账号信息页面中得到该 ID。<br>
 * @param {String}       userId        - 【字段含义】用户标识（必填）。当前用户的 userId，相当于用户名，UTF-8编码。<br>
 *                                       【推荐取值】如果一个用户在您的账号系统中的 ID 为“abc”，则 userId 即可设置为“abc”。<br>
 * @param {String}       userSig       - 【字段含义】用户签名（必填），当前 userId 对应的验证签名，相当于登录密码。<br>
 *                                       【推荐取值】请参考 [如何计算UserSig](https://cloud.tencent.com/document/product/647/17275)。<br>
 * @param {Number}       roomId        - 【字段含义】房间号码（必填），指定房间号，在同一个房间里的用户（userId）可以彼此看到对方并进行视频通话, roomId 和 strRoomId 必须填一个, 若您选用 strRoomId，则 roomId 需要填写为0。<br>
 *                                       【推荐取值】您可以随意指定，但请不要重复，如果您的用户账号 ID 是数字类型的，可以直接用创建者的用户 ID 作为 roomId。<br>
 * @param {String}       strRoomId     - 【字段含义】字符串房间号码（选填），roomId 和 strRoomId 必须填一个。若两者都填，则优先选择 roomId。<br>
 *                                       【推荐取值】您可以随意指定，但请不要重复。<br>
 * @param {TRTCRoleType} role          - 【字段含义】直播场景下的角色，仅适用于直播场景（TRTCAppSceneLIVE 和 TRTCAppSceneVoiceChatRoom），视频通话场景下指定无效。<br>
 *                                       【推荐取值】默认值：主播（TRTCRoleAnchor）<br>
 * @param {String}       privateMapKey - 【字段含义】房间签名（非必填），如果您希望某个房间只能让特定的某些 userId 进入，就需要使用 privateMapKey 进行权限保护。<br>
 *                                       【推荐取值】仅建议有高级别安全需求的客户使用，参考文档：[进房权限保护](https://cloud.tencent.com/document/product/647/32240)<br>
 * @param {String}       businessInfo  - 【字段含义】业务数据（非必填），某些非常用的高级特性才需要用到此字段。<br>
 *                                       【推荐取值】不建议使用<br>
 * @param {String}       streamId      - 【字段含义】绑定腾讯云直播 CDN 流 ID[非必填]，设置之后，您就可以在腾讯云直播 CDN 上通过标准直播方案（FLV或HLS）播放该用户的音视频流。<br>
 *                                       【推荐取值】限制长度为64字节，可以不填写，一种推荐的方案是使用 “sdkappid_roomid_userid_main” 作为 streamid，这样比较好辨认且不会在您的多个应用中发生冲突。<br>
 *                                       【特殊说明】要使用腾讯云直播 CDN，您需要先在[控制台](https://console.cloud.tencent.com/trtc/) 中的功能配置页开启“启动自动旁路直播”开关。<br>
 *                                       【参考文档】[CDN 旁路直播](https://cloud.tencent.com/document/product/647/16826)。
 * @param {String}       userDefineRecordId - 【字段含义】设置云端录制完成后的回调消息中的 "userdefinerecordid"  字段内容，便于您更方便的识别录制回调。<br>
 *                                            【推荐取值】限制长度为64字节，只允许包含大小写英文字母（a-zA-Z）、数字（0-9）及下划线和连词符。<br>
 *                                            【参考文档】[云端录制](https://cloud.tencent.com/document/product/647/16823)。
 */
export class TRTCParams {
    constructor(sdkAppId, userId, roomId, userSig, strRoomId, privateMapKey, role, businessInfo, streamId, userDefineRecordId) {
        this.sdkAppId = sdkAppId;
        this.userId = userId;
        this.roomId = roomId;
        this.userSig = userSig;
        this.strRoomId = strRoomId;
        this.privateMapKey = privateMapKey;
        this.role = role;
        this.businessInfo = businessInfo;
        this.streamId = streamId;
        this.userDefineRecordId = userDefineRecordId;
    }
}
/**
 * 视频编码参数<br>
 * 该设置决定了远端用户看到的画面质量（同时也是云端录制出的视频文件的画面质量）。
 * @param {TRTCVideoResolution}     videoResolution - 【字段含义】 视频分辨率<br>
 *                                                    【推荐取值】 <br>
 *                                                     - 视频通话建议选择360 × 640及以下分辨率，resMode 选择 Portrait。<br>
 *                                                     - 手机直播建议选择 540 × 960，resMode 选择 Portrait。<br>
 *                                                     - Window 和 iMac 建议选择 640 × 360 及以上分辨率，resMode 选择 Landscape。
 *                                                    【特别说明】 TRTCVideoResolution 默认只能横屏模式的分辨率，例如640 × 360。<br>
 *                                                                如需使用竖屏分辨率，请指定 resMode 为 Portrait，例如640 × 360结合 Portrait 则为360 × 640。<br>
 * @param {TRTCVideoResolutionMode} resMode         - 【字段含义】分辨率模式（横屏分辨率 - 竖屏分辨率）<br>
 *                                                    【推荐取值】手机直播建议选择 Portrait，Window 和 Mac 建议选择 Landscape。<br>
 *                                                    【特别说明】如果 videoResolution 指定分辨率 640 × 360，resMode 指定模式为 Portrait，则最终编码出的分辨率为360 × 640。<br>
 * @param {Number}                  videoFps        - 【字段含义】视频采集帧率<br>
 *                                                    【推荐取值】15fps 或 20fps，10fps 以下会有轻微卡顿感，5fps 以下卡顿感明显，20fps 以上的帧率则过于浪费（电影的帧率也只有 24fps）。<br>
 *                                                    【特别说明】很多 Android 手机的前置摄像头并不支持15fps以上的采集帧率，部分过于突出美颜功能的 Android 手机前置摄像头的采集帧率可能低于10fps。<br>
 * @param {Number}                  videoBitrate    - 【字段含义】视频上行码率<br>
 *                                                    【推荐取值】推荐设置请参考本文件前半部分 TRTCVideoResolution 定义处的注释说明<br>
 *                                                    【特别说明】码率太低会导致视频中有很多的马赛克<br>
 * @param {Number}                  minVideoBitrate  -【字段含义】最低视频码率，SDK 会在网络不佳的情况下主动降低视频码率，最低会降至 minVideoBitrate 所设定的数值。
 *                                                    【推荐取值】<br>
 *                                                      - 如果您追求“允许卡顿但要保持清晰”的效果，可以设置 minVideoBitrate 为 videoBitrate 的 60%；
 *                                                      - 如果您追求“允许模糊但要保持流畅”的效果，可以设置 minVideoBitrate 为 200kbps；
 *                                                      - 如果您将 videoBitrate 和 minVideoBitrate 设置为同一个值，等价于关闭 SDK 的自适应调节能力；
 *                                                      - 默认值：0，此时最低码率由 SDK 根据分辨率情况，自动设置合适的数值。<br>
 *                                                    【特别说明】<br>
 *                                                     - 当您把分辨率设置的比较高时，minVideoBitrate 不适合设置的太低，否则会出现画面模糊和大范围的马赛克宏块。
 *                                                       比如把分辨率设置为 720p，把码率设置为 200kbps，那么编码出的画面将会出现大范围区域性马赛克。
 * @param {Boolean}                 enableAdjustRes - 【字段含义】是否允许调整分辨率<br>
 *                                                    【推荐取值】 <br>
 *                                                     - 手机直播建议选择 NO。<br>
 *                                                     - 视频通话模式，若更关注流畅性，建议选择 YES，此时若遇到带宽有限的弱网，SDK 会自动降低分辨率以保障更好的流畅度（仅针对 TRTCVideoStreamTypeBig 生效）。
 *                                                     - 默认值：NO。<br>
 *                                                    【特别说明】若有录制需求，选择 YES 时，请确保通话过程中，调整分辨率不会影响您的录制效果。<br>
 */
export class TRTCVideoEncParam {
    constructor(videoResolution = TRTCVideoResolution.TRTCVideoResolution_640_360, resMode = TRTCVideoResolutionMode.TRTCVideoResolutionModePortrait, videoFps = 15, videoBitrate = 550, minVideoBitrate = 0, enableAdjustRes = false) {
        this.videoResolution = videoResolution;
        this.videoResolutionMode = resMode;
        this.videoFps = videoFps;
        this.videoBitrate = videoBitrate;
        this.minVideoBitrate = minVideoBitrate;
        this.enableAdjustRes = enableAdjustRes;
    }
}
;
/**
 * 画面渲染参数<br>
 * 您可以通过设置此参数来控制画面的旋转、填充、镜像模式
 * @param {TRTCVideoRotation} rotation  - 【字段含义】视频画面旋转方向
 * @param {TRTCVideoFillMode} fillMode  - 【字段含义】视频画面填充模式
 * @param {TRTCVideoMirrorType} mirrorType  - 【字段含义】画面渲染镜像类型
 */
export class TRTCRenderParams {
    constructor(rotation = TRTCVideoRotation.TRTCVideoRotation_0, fillMode = TRTCVideoFillMode.TRTCVideoFillMode_Fit, mirrorType = TRTCVideoMirrorType.TRTCVideoMirrorType_Disable) {
        this.rotation = rotation;
        this.fillMode = fillMode;
        this.mirrorType = mirrorType;
    }
}
/**
 * 屏幕分享参数（仅适用于 Android 平台）<br>
 * 该设置决定了远端用户看到的画面质量（同时也是云端录制出的视频文件的画面质量）。
 * @param {Boolean} enableForegroundService - 是否同时启用 SDK 内置的前台服务，停止屏幕分享时会停止该服务。
 * 从 Android 10 开始，如果 APP 的 targetSdkVersion 大于等于 29 时，
 * 需要有 mediaProjection 类型的前台服务才能成功开始，否则会报 SecurityException。您可以自己启动一个前台服务，也可以使用 SDK 内置的前台服务。当使用内置的前台服务时 ** 您需要在 manifest.json 中添加以下内容：<uses-permission android:name="android.permission.FOREGROUND_SERVICE" />**
 * @param {String} appGroup 默认值为空，仅开启应用内屏幕分享；如需开启应用外屏幕分享，请填写 appGroup，同时在插件中配置相关信息，详见[功能接入/ios部分](https://cloud.tencent.com/document/product/647/113834)
 */
export class TRTCScreenShareParams {
    constructor(enableForegroundService, appGroup) {
        this.enableForegroundService = enableForegroundService;
        this.appGroup = appGroup;
    }
}
;
/**
 * 音频路由（即声音的播放模式）<br>
 * @enum {Number}
 */
const TRTCAudioRoute_HACK_JSDOC = {
    /** 使用扬声器播放（即“免提”），扬声器位于手机底部，声音偏大，适合外放音乐 */
    TRTCAudioRouteSpeaker: 0,
    /** 使用听筒播放，听筒位于手机顶部，声音偏小，适合需要保护隐私的通话场景 */
    TRTCAudioRouteEarpiece: 1,
};
export var TRTCAudioRoute;
(function (TRTCAudioRoute) {
    TRTCAudioRoute[TRTCAudioRoute["TRTCAudioRouteSpeaker"] = 0] = "TRTCAudioRouteSpeaker";
    TRTCAudioRoute[TRTCAudioRoute["TRTCAudioRouteEarpiece"] = 1] = "TRTCAudioRouteEarpiece";
})(TRTCAudioRoute || (TRTCAudioRoute = {}));
/////////////////////////////////////////////////////////////////////////////////
//
//                    【其它参数】
//
/////////////////////////////////////////////////////////////////////////////////
export var TRTCShareSource;
(function (TRTCShareSource) {
    TRTCShareSource["InApp"] = "InApp";
    TRTCShareSource["ByReplaykit"] = "ByReplaykit";
})(TRTCShareSource || (TRTCShareSource = {}));
/**
 * 重力感应开关（仅适用于移动端）<br>
 * @enum {Number}
 */
const TRTCGSensorMode_HACK_JSDOC = {
    /** 不适配重力感应，该模式是桌面平台上的默认值，该模式下，当前用户发布出去的视频画面不受重力感应方向变化的影响。 */
    TRTC_GSENSOR_MODE_DISABLE: 0,
    /** 适配重力感应，该模式是移动平台上的默认值，该模式下，当前用户发布出去的视频画面会跟随设备的重力感应方向进行相应的调整，同时本地预览画面保持方向不变。
      SDK 目前支持的一种适配模式是：当手机或 Pad 上下颠倒时，为了保证远端用户看到的画面方向正常，SDK 会自动将发布出去的画面上下旋转180度。如果您的 APP 的界面层开启了重力感应自适应，推荐使用 UIFixLayout 模式。
    */
    TRTC_GSENSOR_MODE_UIAUTOLAYOUT: 1,
};
export var TRTCGSensorMode;
(function (TRTCGSensorMode) {
    TRTCGSensorMode[TRTCGSensorMode["TRTC_GSENSOR_MODE_DISABLE"] = 0] = "TRTC_GSENSOR_MODE_DISABLE";
    TRTCGSensorMode[TRTCGSensorMode["TRTC_GSENSOR_MODE_UIAUTOLAYOUT"] = 1] = "TRTC_GSENSOR_MODE_UIAUTOLAYOUT";
})(TRTCGSensorMode || (TRTCGSensorMode = {}));
/**
 * 系统音量类型（仅适用于移动端）<br>
 * - 通话音量：手机专门为接打电话所设计的音量类型，自带回声抵消（AEC）功能，并且支持通过蓝牙耳机上的麦克风进行拾音，缺点是音质比较一般。当您通过手机侧面的音量按键下调手机音量时，如果无法将其调至零（也就是无法彻底静音），说明您的手机当前处于通话音量。
 * - 媒体音量：手机专门为音乐场景所设计的音量类型，无法使用系统的 AEC 功能，并且不支持通过蓝牙耳机的麦克风进行拾音，但具备更好的音乐播放效果。当您通过手机侧面的音量按键下调手机音量时，如果能够将手机音量调至彻底静音，说明您的手机当前处于媒体音量。
 * @enum {Number}
 */
const TXSystemVolumeType_HACK_JSDOC = {
    /**
     * 自动切换模式:
     * 也被称为“麦上通话，麦下媒体”，即主播上麦时使用通话音量，观众不上麦则使用媒体音量，适合在线直播场景。
     * 如果您在 enterRoom 时选择的场景为 TRTCAppSceneLIVE 或 TRTCAppSceneVoiceChatRoom，SDK 会自动使用该模式。
    */
    TXSystemVolumeTypeAuto: 0,
    /**
     * 全程媒体音量:
     * 通话全程使用媒体音量，并不是非常常用的音量类型，适用于对音质要求比较苛刻的音乐场景中。
     * 如果您的用户大都使用外接设备（比如外接声卡）为主，可以使用该模式，否则请慎用。
    */
    TXSystemVolumeTypeMedia: 1,
    /**
     * 全程通话音量:
     * 该方案的优势在于用户在上下麦时音频模块无需切换工作模式，可以做到无缝上下麦，适合于用户需要频繁上下麦的应用场景。
     * 如果您在 enterRoom 时选择的场景为 TRTCAppSceneVideoCall 或 TRTCAppSceneAudioCall，SDK 会自动使用该模式。
     */
    TXSystemVolumeTypeVOIP: 2,
};
export var TXSystemVolumeType;
(function (TXSystemVolumeType) {
    TXSystemVolumeType[TXSystemVolumeType["TXSystemVolumeTypeAuto"] = 0] = "TXSystemVolumeTypeAuto";
    TXSystemVolumeType[TXSystemVolumeType["TXSystemVolumeTypeMedia"] = 1] = "TXSystemVolumeTypeMedia";
    TXSystemVolumeType[TXSystemVolumeType["TXSystemVolumeTypeVOIP"] = 2] = "TXSystemVolumeTypeVOIP";
})(TXSystemVolumeType || (TXSystemVolumeType = {}));

 src/utils/voiceCallByTX/TrtcCloud/lib/constants.js

New file
@@ -0,0 +1,10 @@
export const NAME = {
    ANDROID: 'android',
    IOS: 'ios',
    STRING: 'string',
    FUNCTION: 'function',
    BOOLEAN: 'boolean',
    NUMBER: 'number',
    LOG_PREFIX: '【UniApp-JS】',
};
export const errorCodeUrl = 'https://web.sdk.qcloud.com/trtc/uniapp/doc/zh-cn/ErrorCode.html';

 src/utils/voiceCallByTX/TrtcCloud/lib/index.js

New file
@@ -0,0 +1,1086 @@
import TrtcCloudImpl from './TrtcCloudImpl.js';
import { TRTCVideoStreamType } from './TrtcDefines.js';
const version = '1.4.5';
export * from './TrtcDefines.js';
/**
 * TrtcCloud
 *
 * @class TrtcCloud
 */
export default class TrtcCloud {
    /**
     * 创建 TrtcCloud 单例
     *
     * @static
     * @memberof TrtcCloud
     * @example
     * TrtcCloud.createInstance();
     */
    static createInstance() {
        console.log('----------------------------------------------------------------');
        console.log(`                        SDK ${version}                    `);
        console.log('----------------------------------------------------------------');
        return TrtcCloudImpl._createInstance();
    }
    /**
     * 销毁 TrtcCloud 单例
     *
     * @static
     * @memberof TrtcCloud
     * @example
     * TrtcCloud.destroyInstance();
     */
    static destroyInstance() {
        return TrtcCloudImpl._destroyInstance();
    }
    /**
     * 设置 TrtcCloud 事件监听
     *
     * @param {String} event 事件名称
     * @param {Function} callback 事件回调
     * @memberof TrtcCloud
     *
     * @example
     * this.trtcCloud = TrtcCloud.createInstance(); // 创建 trtcCloud 实例
     * this.trtcCloud.on('onEnterRoom', (res) => {});
     */
    on(event, callback) {
        return TrtcCloudImpl._getInstance().on(event, callback);
    }
    /**
     * 取消事件绑定<br>
     *
     * @param {String} event 事件名称，传入通配符 '*' 会解除所有事件绑定。
     * @memberof TrtcCloud
     * @example
     * this.trtcCloud.off('onEnterRoom');
     *
     * this.trtcCloud.off('*'); // 取消所有绑定的事件
     */
    off(event) {
        return TrtcCloudImpl._getInstance().off(event);
    }
    /**
     * 进房<br>
     * 调用接口后，您会收到来自 TRTCCallback 中的 [onEnterRoom(result)]{@link TRTCCallback#onEnterRoom} 回调
     * 如果加入成功，result 会是一个正数（result > 0），表示加入房间所消耗的时间，单位是毫秒（ms）。<br>
     * 如果加入失败，result 会是一个负数（result < 0），表示进房失败的错误码。
     *
     * * 参数 scene 的枚举值如下：
     * - {@link TRTCAppSceneVideoCall}：<br>
     *          视频通话场景，支持720P、1080P高清画质，单个房间最多支持300人同时在线，最高支持50人同时发言。<br>
     *          适合：[1对1视频通话]、[300人视频会议]、[在线问诊]、[视频聊天]、[远程面试]等。<br>
     * - {@link TRTCAppSceneAudioCall}：<br>
     *          语音通话场景，支持 48kHz，支持双声道。单个房间最多支持300人同时在线，最高支持50人同时发言。<br>
     *          适合：[1对1语音通话]、[300人语音会议]、[语音聊天]、[语音会议]、[在线狼人杀]等。<br>
     * - {@link TRTCAppSceneLIVE}：<br>
     *          视频互动直播，支持平滑上下麦，切换过程无需等待，主播延时小于300ms；支持十万级别观众同时播放，播放延时低至1000ms。<br>
     *          适合：[视频低延时直播]、[十万人互动课堂]、[视频直播 PK]、[视频相亲房]、[互动课堂]、[远程培训]、[超大型会议]等。<br>
     * - {@link TRTCAppSceneVoiceChatRoom}：<br>
     *          语音互动直播，支持平滑上下麦，切换过程无需等待，主播延时小于300ms；支持十万级别观众同时播放，播放延时低至1000ms。<br>
     *          适合：[语音低延时直播]、[语音直播连麦]、[语聊房]、[K 歌房]、[FM 电台]等。<br>
     *
     * **Note:**
     * 1. 当 scene 选择为 TRTCAppSceneLIVE 或 TRTCAppSceneVoiceChatRoom 时，您必须通过 TRTCParams 中的 role 字段指定当前用户的角色。
     * 2. 不管进房是否成功，enterRoom 都必须与 exitRoom 配对使用，在调用 `exitRoom` 前再次调用 `enterRoom` 函数会导致不可预期的错误问题。
     *
     * @param {TRTCParams} params - 进房参数
     * @param {Number} params.sdkAppId      - 应用标识（必填）
     * @param {String} params.userId        - 用户标识（必填）
     * @param {String} params.userSig       - 用户签名（必填）
     * @param {Number} params.roomId        - 房间号码, roomId 和 strRoomId 必须填一个, 若您选用 strRoomId，则 roomId 需要填写为0。
     * @param {String} params.strRoomId     - 字符串房间号码 [选填]，在同一个房间内的用户可以看到彼此并进行视频通话, roomId 和 strRoomId 必须填一个。若两者都填，则优先选择 roomId
     * @param {TRTCRoleType} params.role    - 直播场景下的角色，默认值：主播
     * - TRTCRoleAnchor: 主播，可以上行视频和音频，一个房间里最多支持50个主播同时上行音视频。
     * - TRTCRoleAudience: 观众，只能观看，不能上行视频和音频，一个房间里的观众人数没有上限。
     * @param {String=} params.privateMapKey - 房间签名（非必填）
     * @param {String=} params.businessInfo  - 业务数据（非必填）
     * @param {String=} params.streamId      - 自定义 CDN 播放地址（非必填）
     * @param {String=} params.userDefineRecordId - 设置云端录制完成后的回调消息中的 "userdefinerecordid" 字段内容，便于您更方便的识别录制回调（非必填）
     * @param {TRTCAppScene} scene 应用场景，目前支持视频通话（TRTCAppSceneVideoCall）、语音通话（TRTCAppSceneAudioCall）、在线直播（TRTCAppSceneLIVE）、语音聊天室（VTRTCAppSceneVoiceChatRoom）四种场景，
     * 详见 [TrtcDefines] 中 TRTCAppScene 参数定义
     *
     * @memberof TrtcCloud
     * @example
     * import { TRTCAppScene } from '@/TrtcCloud/lib/TrtcDefines';
     * this.trtcCloud = TrtcCloud.createInstance(); // 创建实例，只需创建一次
     * const params = {
     *   sdkAppId: 0,
     *   userId: 'xxx',
     *   roomId: 12345,
     *   userSig: 'xxx'
     * };
     * this.trtcCloud.enterRoom(params, TRTCAppScene.TRTCAppSceneVideoCall);
     */
    enterRoom(params, scene) {
        return TrtcCloudImpl._getInstance().enterRoom(params, scene);
    }
    /**
     * 退房<br>
     * 执行退出房间的相关逻辑释放资源后，SDK 会通过 `onExitRoom()` 回调通知到您
     *
     * **Note:**
     * 1. 如果您要再次调用 `enterRoom()` 或者切换到其它的音视频 SDK，请等待 `onExitRoom()` 回调到来后再执行相关操作，否则可能会遇到如摄像头、麦克风设备被强占等各种异常问题。
     *
     * @memberof TrtcCloud
     * @example
     * this.trtcCloud.exitRoom();
     */
    exitRoom() {
        return TrtcCloudImpl._getInstance().exitRoom();
    }
    /**
     * 切换角色，仅适用于直播场景（TRTCAppSceneLIVE 和 TRTCAppSceneVoiceChatRoom）
     *
     * 在直播场景下，一个用户可能需要在“观众”和“主播”之间来回切换。
     * 您可以在进房前通过 TRTCParams 中的 role 字段确定角色，也可以通过 switchRole 在进房后切换角色。
     *
     * @param {TRTCRoleType} role - 目标角色，默认为主播
     * - TRTCRoleAnchor: 主播，可以上行视频和音频，一个房间里最多支持50个主播同时上行音视频。
     * - TRTCRoleAudience: 观众，只能观看，不能上行视频和音频，一个房间里的观众人数没有上限。
     *
     * @memberof TrtcCloud
     * @example
     * import { TRTCRoleType } from '@/TrtcCloud/lib/TrtcDefines';
     * this.trtcCloud.switchRole(TRTCRoleType.TRTCRoleAudience);
     */
    switchRole(role) {
        return TrtcCloudImpl._getInstance().switchRole(role);
    }
    /**
     * 请求跨房通话
     *
     * 默认情况下，只有同一个房间中的用户之间可以进行音视频通话，不同的房间之间的音视频流是相互隔离的。
     * 使用该接口让身处两个不同房间中的主播进行跨房间的音视频流分享，从而让每个房间中的观众都能观看到这两个主播的音视频。
     * 跨房通话的请求结果会通过监听 [onConnectOtherRoom](https://web.sdk.qcloud.com/trtc/uniapp/doc/zh-cn/TRTCCallback.html#event:onConnectOtherRoom) 事件通知给您。
     *
     * @param {Object} params - 跨房通话参数
     * - 如果对端的房间号为数字，那么传入的参数为 roomId。
     * - 如果对端的房间号为字符串，那么传入的参数为 strRoomId。
     * - 针对对端的房间号类型传递对应参数，不需要两个同时传递。具体请看 example 的使用。
     * @param {Number} params.roomId 跨房通话时对端的数字房间号 roomId(与 strRoomId 选填其中一个，不可同时传递)
     * @param {String} params.strRoomId 跨房通话时对端的字符串房间号 strRoomId(与 roomId 选填其中一个，不可同时传递)
     * @param {String} params.userId 跨房通话时对端的 userId(必填)
     *
     *
     * @memberof TrtcCloud
     * @example
     * this.trtcCloud.connectOtherRoom({"roomId": 1233, "userId": "user_11"});
     * this.trtcCloud.connectOtherRoom({"strRoomId": "1233", "userId": "user_22"});
     */
    connectOtherRoom(params) {
        return TrtcCloudImpl._getInstance().connectOtherRoom(params);
    }
    /**
     * 退出跨房通话
     *
     * 退出跨房通话的请求结果会通过监听 [onDisconnectOtherRoom](https://web.sdk.qcloud.com/trtc/uniapp/doc/zh-cn/TRTCCallback.html#event:onDisconnectOtherRoom) 事件通知给您。
     *
     * @memberof TrtcCloud
     * @example
     * this.trtcCloud.disconnectOtherRoom();
     */
    disconnectOtherRoom() {
        return TrtcCloudImpl._getInstance().disconnectOtherRoom();
    }
    /**
     * 开启本地视频的预览画面<br>
     * 当开始渲染首帧摄像头画面时，您会收到 `onFirstVideoFrame(null)` 回调
     *
     * @param {Boolean} isFrontCamera 前置、后置摄像头，true：前置摄像头；false：后置摄像头，**默认为 true**
     * @param {String=} viewId 用于承载视频画面的渲染控件，使用原生插件中的 TRTCCloudUniPlugin-TXLocalViewComponent component，需要提供 viewId 属性值，例如 viewId=userId
     * @memberof TrtcCloud
     * @example
     * // 预览本地画面
     * const viewId = this.userId;
     * this.trtcCloud.startLocalPreview(true, viewId);
     */
    startLocalPreview(isFrontCamera = true, viewId) {
        return TrtcCloudImpl._getInstance().startLocalPreview(isFrontCamera, viewId);
    }
    /**
     * 设置视频编码器的编码参数
     * - 该设置能够决定远端用户看到的画面质量，同时也能决定云端录制出的视频文件的画面质量。
     * @param {TRTCVideoEncParam} param 用于设置视频编码器的相关参数
     * @memberof TrtcCloud
     * @example
     *
     * import { TRTCVideoResolution, TRTCVideoResolutionMode, TRTCVideoEncParam } from '@/TrtcCloud/lib/TrtcDefines';
     * const videoResolution = TRTCVideoResolution.TRTCVideoResolution_480_360;
     * const videoResolutionMode = TRTCVideoResolutionMode.TRTCVideoResolutionModeLandscape; // 横屏采集
     * const videoFps = 15;
     * const videoBitrate = 900;
     * const minVideoBitrate = 200;
     * const enableAdjustRes = false;
     * // const param = new TRTCVideoEncParam(videoResolution, videoResolutionMode, videoFps, videoBitrate, minVideoBitrate, enableAdjustRes); // v1.1.0 方式
     *
     * const param = { // v1.2.0 以上版本支持的方式
     *  videoResolution,
     *  videoResolutionMode,
     *  videoFps,
     *  videoBitrate,
     *  minVideoBitrate,
     *  enableAdjustRes,
     * };
     *
     * this.trtcCloud.setVideoEncoderParam(param);
     */
    setVideoEncoderParam(param) {
        return TrtcCloudImpl._getInstance().setVideoEncoderParam(param);
    }
    /**
     * 切换前置或后置摄像头
     *
     * @param {Boolean} isFrontCamera 前置、后置摄像头，true：前置摄像头；false：后置摄像头
     * @memberof TrtcCloud
     * @example
     * // 切换前置或后置摄像头
     * const isFrontCamera = true;
     * this.trtcCloud.switchCamera(isFrontCamera);
     */
    switchCamera(isFrontCamera) {
        return TrtcCloudImpl._getInstance().switchCamera(isFrontCamera);
    }
    /**
     * 停止本地视频采集及预览
     *
     * @memberof TrtcCloud
     * @example
     * this.trtcCloud.stopLocalPreview();
     */
    stopLocalPreview() {
        return TrtcCloudImpl._getInstance().stopLocalPreview();
    }
    /**
     * 设置本地画面的渲染参数，可设置的参数包括有：画面的旋转角度、填充模式以及左右镜像等。
     * @param {TRTCRenderParams} params - 本地图像的参数
     * @param {TRTCVideoRotation} params.rotation - 图像的顺时针旋转角度，支持90、180以及270旋转角度，默认值：TRTCVideoRotation.TRTCVideoRotation_0
     * @param {TRTCVideoFillMode} params.fillMode - 视频画面填充模式，填充（画面可能会被拉伸裁剪）或适应（画面可能会有黑边），默认值：TRTCVideoFillMode.TRTCVideoFillMode_Fill
     * @param {TRTCVideoMirrorType} params.mirrorType - 画面镜像模式，默认值：TRTCVideoMirrorType.TRTCVideoMirrorType_Auto
     *
     * @memberof TrtcCloud
     * @example
     * import { TRTCVideoRotation, TRTCVideoFillMode, TRTCVideoMirrorType } from '@/TrtcCloud/lib/TrtcDefines';
     * const renderParams = {
     *  rotation: TRTCVideoRotation.TRTCVideoRotation_0,
     *  fillMode: TRTCVideoFillMode.TRTCVideoFillMode_Fill,
     *  mirrorType: TRTCVideoMirrorType.TRTCVideoMirrorType_Auto
     * };
     * this.trtcCloud.setLocalRenderParams(renderParams);
     */
    setLocalRenderParams(params) {
        return TrtcCloudImpl._getInstance().setLocalRenderParams(params);
    }
    /**
     * 暂停/恢复发布本地的视频流
     *
     * 该接口可以暂停（或恢复）发布本地的视频画面，暂停之后，同一房间中的其他用户将无法继续看到自己画面。 该接口在指定 TRTCVideoStreamTypeBig 时等效于 start/stopLocalPreview 这两个接口，但具有更好的响应速度。 因为 start/stopLocalPreview 需要打开和关闭摄像头，而打开和关闭摄像头都是硬件设备相关的操作，非常耗时。 相比之下，muteLocalVideo 只需要在软件层面对数据流进行暂停或者放行即可，因此效率更高，也更适合需要频繁打开关闭的场景。 当暂停/恢复发布指定 TRTCVideoStreamTypeBig 后，同一房间中的其他用户将会收到 onUserVideoAvailable 回调通知。 当暂停/恢复发布指定 TRTCVideoStreamTypeSub 后，同一房间中的其他用户将会收到 onUserSubStreamAvailable 回调通知。
     * @param {Number} streamType 要暂停/恢复的视频流类型（仅支持 TRTCVideoStreamTypeBig 和 TRTCVideoStreamTypeSub）
     * @param {Boolean} mute - true：屏蔽；false：开启，默认值：false
     *
     * @memberof TrtcCloud
     * @example
     * this.trtcCloud.muteLocalVideo(TRTCVideoStreamType.TRTCVideoStreamTypeBig, true);
     */
    muteLocalVideo(streamType, mute) {
        return TrtcCloudImpl._getInstance().muteLocalVideo(streamType, mute);
    }
    /**
     * 显示远端视频或辅流<br>
     *
     * @param {String} userId 指定远端用户的 userId
     * @param {Number} streamType 指定要观看 userId 的视频流类型
     * - 高清大画面：TRTCVideoStreamType.TRTCVideoStreamTypeBig
     * - 低清小画面：TRTCVideoStreamType.TRTCVideoStreamTypeSmall
     * - 辅流（屏幕分享）：TRTCVideoStreamType.TRTCVideoStreamTypeSub
     * @param {String} viewId 用于承载视频画面的渲染控件，使用原生插件中的 TRTCCloudUniPlugin-TXRemoteViewComponent component，需要提供 viewId 属性值，例如 viewId=userId
     * @memberof TrtcCloud
     * @example
     * import { TRTCVideoStreamType } from '@/TrtcCloud/lib/TrtcDefines';
     * const viewId = this.remoteUserId;
     * this.trtcCloud.startRemoteView(userId, TRTCVideoStreamType.TRTCVideoStreamTypeBig, viewId);
     */
    startRemoteView(userId, streamType, viewId) {
        return TrtcCloudImpl._getInstance().startRemoteView(userId, streamType, viewId);
    }
    /**
     * 停止显示远端视频画面，同时不再拉取该远端用户的视频数据流<br>
     * 指定要停止观看的 userId 的视频流类型
     *
     * @param {String} userId 指定的远端用户 ID
     * @param {Number} streamType
     * - 高清大画面：TRTCVideoStreamType.TRTCVideoStreamTypeBig
     * - 低清小画面：TRTCVideoStreamType.TRTCVideoStreamTypeSmall
     * - 辅流（屏幕分享）：TRTCVideoStreamType.TRTCVideoStreamTypeSub
     * @memberof TrtcCloud
     * @example
     * import { TRTCVideoStreamType } from '@/TrtcCloud/lib/TrtcDefines';
     * this.trtcCloud.stopRemoteView(remoteUserId, TRTCVideoStreamType.TRTCVideoStreamTypeBig);
     */
    stopRemoteView(userId, streamType) {
        return TrtcCloudImpl._getInstance().stopRemoteView(userId, streamType);
    }
    /**
     * 设置远端画面的渲染参数，可设置的参数包括有：画面的旋转角度、填充模式以及左右镜像等。
     * @param {String} userId 远端用户 ID
     * @param {Number} streamType 可以设置为主路画面（TRTCVideoStreamTypeBig）或辅路画面（TRTCVideoStreamTypeSub）
     * @param {TRTCRenderParams} params - 图像的参数
     * @param {TRTCVideoRotation} params.rotation - 图像的顺时针旋转角度，支持90、180以及270旋转角度，默认值：TRTCVideoRotation.TRTCVideoRotation_0
     * @param {TRTCVideoFillMode} params.fillMode - 视频画面填充模式，填充（画面可能会被拉伸裁剪）或适应（画面可能会有黑边），默认值：TRTCVideoFillMode.TRTCVideoFillMode_Fill
     * @param {TRTCVideoMirrorType} params.mirrorType - 画面镜像模式，默认值：TRTCVideoMirrorType.TRTCVideoMirrorType_Auto
     * @memberof TrtcCloud
     * @example
     * import { TRTCVideoRotation, TRTCVideoFillMode, TRTCVideoMirrorType } from '@/TrtcCloud/lib/TrtcDefines';
     * const renderParams = {
     *  rotation: TRTCVideoRotation.TRTCVideoRotation_0,
     *  fillMode: TRTCVideoFillMode.TRTCVideoFillMode_Fill,
     *  mirrorType: TRTCVideoMirrorType.TRTCVideoMirrorType_Auto
     * };
     * this.trtcCloud.setRemoteRenderParams(userId, TRTCVideoStreamType.TRTCVideoStreamTypeBig, renderParams);
     */
    setRemoteRenderParams(userId, streamType, params) { }
    /**
     * 设置视频编码器输出的画面方向<br>
     * 该设置不影响本地画面的预览方向，但会影响房间中其他用户所观看到（以及云端录制文件）的画面方向。
     * 当用户将手机或 Pad 上下颠倒时，由于摄像头的采集方向没有变，所以房间中其他用户所看到的画面会变成上下颠倒的，
     * 在这种情况下，您可以通过调用该接口将 SDK 编码出的画面方向旋转180度，如此一来，房间中其他用户所看到的画面可保持正常的方向。
     * 如果您希望实现上述这种友好的交互体验，我们更推荐您直接调用 setGSensorMode 实现更加智能的方向适配，无需您手动调用本接口。
     * @param {Number} rotation 目前支持 0、90、180、270 两个旋转角度，默认值：TRTCVideoRotation_0，即不旋转。
     * @memberof TrtcCloud
     * @example
     * import { TRTCVideoRotation } from '@/TrtcCloud/lib/TrtcDefines';
     * this.trtcCloud.setVideoEncoderRotation(TRTCVideoRotation.TRTCVideoRotation_90);
     */
    setVideoEncoderRotation(rotation) {
        return TrtcCloudImpl._getInstance().setVideoEncoderRotation(rotation);
    }
    /**
     * 设置编码器输出的画面镜像模式
     * @param {Boolean} mirror 是否开启远端镜像，true：开启远端画面镜像；false：关闭远端画面镜像，默认值：false。
     * @memberof TrtcCloud
     * @example
     * this.trtcCloud.setVideoEncoderMirror(true);
     */
    setVideoEncoderMirror(mirror) {
        return TrtcCloudImpl._getInstance().setVideoEncoderMirror(mirror);
    }
    /**
     * 设置重力感应的适配模式<br>
     * 您可以通过本接口实现如下这种友好的交互体验：
     * 当用户将手机或 Pad 上下颠倒时，由于摄像头的采集方向没有变，所以房间中其他用户所看到的画面会变成上下颠倒的，
     * 在这种情况下，您可以通过调用该接口让 SDK 根据设备陀螺仪的朝向自动调整本地画面和编码器输出画面的旋转方向，以使远端观众可以看到正常朝向的画面。
     * @param {Number} mode 重力感应模式，详情请参见 TRTCGSensorMode，默认值：TRTCGSensorMode_UIAutoLayout。。
     * @memberof TrtcCloud
     * @example
     * import { TRTCGSensorMode } from '@/TrtcCloud/lib/TrtcDefines';
     * this.trtcCloud.setGSensorMode(TRTCGSensorMode.TRTC_GSENSOR_MODE_DISABLE);
     */
    setGSensorMode(mode) {
        return TrtcCloudImpl._getInstance().setGSensorMode(mode);
    }
    /**
     * 视频画面截图
     *
     * 您可以通过本接口截取本地的视频画面，远端用户的主路画面以及远端用户的辅路（屏幕分享）画面。
     *
     * @param {String | null} userId 用户 ID，如指定 null 表示截取本地的视频画面
     * @param {Number} streamType 视频流类型，可选择截取主路画面（TRTCVideoStreamTypeBig，常用于摄像头）或辅路画面（TRTCVideoStreamTypeSub，常用于屏幕分享）
     * @param {TRTCSnapshotSourceType} sourceType 画面来源，可选择截取视频流画面（TRTCSnapshotSourceTypeStream）或视频渲染画面（TRTCSnapshotSourceTypeView），前者一般更清晰
     *
     * @memberof TrtcCloud
     * @example
     * import { TRTCVideoStreamType } from '@/TrtcCloud/lib/TrtcDefines';
     * this.trtcCloud.snapshotVideo(null, TRTCVideoStreamType.TRTCVideoStreamTypeBig, TRTCSnapshotSourceType.TRTCSnapshotSourceTypeStream); // 截取本地视频流画面
     * this.trtcCloud.snapshotVideo(this.remoteUserId, TRTCVideoStreamType.TRTCVideoStreamTypeBig, TRTCSnapshotSourceType.TRTCSnapshotSourceTypeView); // 截取远端指定用户视频渲染画面
     */
    snapshotVideo(userId, streamType, sourceType) {
        return TrtcCloudImpl._getInstance().snapshotVideo(userId, streamType, sourceType);
    }
    /**
     * 开启本地音频的采集和上行, 并设置音频质量<br>
     * 该函数会启动麦克风采集，并将音频数据传输给房间里的其他用户。 SDK 不会默认开启本地音频采集和上行，您需要调用该函数开启，否则房间里的其他用户将无法听到您的声音<br>
     * 主播端的音质越高，观众端的听感越好，但传输所依赖的带宽也就越高，在带宽有限的场景下也更容易出现卡顿
     *
     * @param {TRTCAudioQuality} quality 声音音质
     * - TRTCAudioQualitySpeech，流畅：采样率：16k；单声道；音频裸码率：16kbps；适合语音通话为主的场景，比如在线会议，语音通话。
     * - TRTCAudioQualityDefault，默认：采样率：48k；单声道；音频裸码率：50kbps；SDK 默认的音频质量，如无特殊需求推荐选择之。
     * - TRTCAudioQualityMusic，高音质：采样率：48k；双声道 + 全频带；音频裸码率：128kbps；适合需要高保真传输音乐的场景，比如在线K歌、音乐直播等
     * @memberof TrtcCloud
     * @example
     * import { TRTCAudioQuality } from '@/TrtcCloud/lib/TrtcDefines';
     * this.trtcCloud.startLocalAudio(TRTCAudioQuality.TRTCAudioQualityDefault);
     */
    startLocalAudio(quality) {
        return TrtcCloudImpl._getInstance().startLocalAudio(quality);
    }
    /**
     * 关闭本地音频的采集和上行<br>
     * 当关闭本地音频的采集和上行，房间里的其它成员会收到 `onUserAudioAvailable(false)` 回调通知
     *
     * @memberof TrtcCloud
     * @example
     * this.trtcCloud.stopLocalAudio();
     */
    stopLocalAudio() {
        return TrtcCloudImpl._getInstance().stopLocalAudio();
    }
    /**
     * 静音本地的音频
     *
     * 当静音本地音频后，房间里的其它成员会收到 onUserAudioAvailable(false) 回调通知。
     * 与 stopLocalAudio 不同之处在于，muteLocalAudio 并不会停止发送音视频数据，而是会继续发送码率极低的静音包。
     * 在对录制质量要求很高的场景中，选择 muteLocalAudio 是更好的选择，能录制出兼容性更好的 MP4 文件。
     * 这是由于 MP4 等视频文件格式，对于音频的连续性是要求很高的，简单粗暴地 stopLocalAudio 会导致录制出的 MP4 不易播放。
     *
     * @param {Boolean} mute - true：屏蔽；false：开启，默认值：false
     *
     * @memberof TrtcCloud
     * @example
     * this.trtcCloud.muteLocalAudio(true);
     */
    muteLocalAudio(mute) {
        return TrtcCloudImpl._getInstance().muteLocalAudio(mute);
    }
    /**
     * 静音掉某一个用户的声音，同时不再拉取该远端用户的音频数据流
     *
     * @param {String}  userId - 用户 ID
     * @param {Boolean} mute   - true：静音；false：非静音
     *
     * @memberof TrtcCloud
     * @example
     * this.trtcCloud.muteRemoteAudio('denny', true);
     */
    muteRemoteAudio(userId, mute) {
        return TrtcCloudImpl._getInstance().muteRemoteAudio(userId, mute);
    }
    /**
     * 静音掉所有用户的声音，同时不再拉取该远端用户的音频数据流
     *
     * @param {Boolean} mute - true：静音；false：非静音
     *
     * @memberof TrtcCloud
     * @example
     * this.trtcCloud.muteAllRemoteAudio(true);
     */
    muteAllRemoteAudio(mute) {
        return TrtcCloudImpl._getInstance().muteAllRemoteAudio(mute);
    }
    /**
     * 设置音频路由
     *
     * 设置“音频路由”，即设置声音是从手机的扬声器还是从听筒中播放出来，因此该接口仅适用于手机等移动端设备。 手机有两个扬声器：一个是位于手机顶部的听筒，一个是位于手机底部的立体声扬声器。
     * 设置音频路由为听筒时，声音比较小，只有将耳朵凑近才能听清楚，隐私性较好，适合用于接听电话。 设置音频路由为扬声器时，声音比较大，不用将手机贴脸也能听清，因此可以实现“免提”的功能。
     *
     * @param {TRTCAudioRoute} route 音频路由，即声音由哪里输出（扬声器、听筒）, 默认值：TRTCAudioRoute.TRTCAudioRouteSpeaker（扬声器）,
     * @memberof TrtcCloud
     * @example
     * import { TRTCAudioRoute } from '@/TrtcCloud/lib/TrtcDefines';
     * this.trtcCloud.setAudioRoute(TRTCAudioRoute.TRTCAudioRouteSpeaker); // TRTCAudioRoute.TRTCAudioRouteEarpiece (听筒)
     */
    setAudioRoute(route) {
        return TrtcCloudImpl._getInstance().setAudioRoute(route);
    }
    /**
     * 启用或关闭音量大小提示
     *
     * 开启此功能后，SDK 会在 onUserVoiceVolume() 中反馈对每一路声音音量大小值的评估。
     *
     * **Note:**
     * - 如需打开此功能，请在 startLocalAudio 之前调用才可以生效。
     *
     * @param {Number} interval - 设置 onUserVoiceVolume 回调的触发间隔，单位为ms，最小间隔为100ms，如果小于等于0则会关闭回调，建议设置为300ms
     * @memberof TrtcCloud
     * @example
     * this.trtcCloud.enableAudioVolumeEvaluation(300);
     */
    enableAudioVolumeEvaluation(interval) {
        return TrtcCloudImpl._getInstance().enableAudioVolumeEvaluation(interval);
    }
    /////////////////////////////////////////////////////////////////////////////////
    //
    //                      屏幕分享
    //
    /////////////////////////////////////////////////////////////////////////////////
    /**
     * 设置屏幕分享（即辅路）的视频编码参数
     *
     * 该接口可以设定远端用户所看到的屏幕分享（即辅路）的画面质量，同时也能决定云端录制出的视频文件中屏幕分享的画面质量。 请注意如下两个接口的差异：
     *  - setVideoEncoderParam 用于设置主路画面（TRTCVideoStreamTypeBig，一般用于摄像头）的视频编码参数。
     *  - setSubStreamEncoderParam 用于设置辅路画面（TRTCVideoStreamTypeSub，一般用于屏幕分享）的视频编码参数。
     *
     * **Note:**
     *  - 即使您使用主路传输屏幕分享（在调用 startScreenCapture 时设置 type=TRTCVideoStreamTypeBig），依然要使用 setSubStreamEncoderParam 设定屏幕分享的编码参数，而不要使用 setVideoEncoderParam
     * @param {TRTCVideoEncParam} param    辅流编码参数，详情请参考 TRTCVideoEncParam。
     * @memberof TrtcCloud
     * @example
     * const params = {
     *   videoResolution: TRTCVideoResolution.TRTCVideoResolution_640_360,
     *   videoResolutionMode: TRTCVideoResolutionMode.TRTCVideoResolutionModePortrait,
     *   videoFps: 15,
     *   videoBitrate: 900,
     *   minVideoBitrate: 200,
     *   enableAdjustRes: false,
     * };
     * this.trtcCloud.setSubStreamEncoderParam(params);
     */
    setSubStreamEncoderParam(param) {
        return TrtcCloudImpl._getInstance().setSubStreamEncoderParam(param);
    }
    /**
     * 启动屏幕分享
     *
     * **Note:**
     *  - 一个用户同时最多只能上传一条主路（TRTCVideoStreamTypeBig）画面和一条辅路（TRTCVideoStreamTypeSub）画面，
     * 默认情况下，屏幕分享使用辅路画面，如果使用主路画面，建议您提前停止摄像头采集（stopLocalPreview）避免相互冲突。
     *  - **仅支持 iOS 13.0 及以上系统，进行应用内的屏幕分享；若要应用外屏幕分享，需填写 shareParams.appGroup 字段。**
     *  - **Android: UniApp 使用 SDK 内置的前台服务时，只需要将接口参数 enableForegroundService 设置为 true。**
     *  - **Android: UniApp 自己启动前台，需要在 mediaProject 类型的前台服务成功后再启动屏幕分享。**
     *
     * @param {Number} streamType 屏幕分享使用的线路，可以设置为主路（TRTCVideoStreamTypeBig）或者辅路（TRTCVideoStreamTypeSub），推荐使用
     * @param {TRTCVideoEncParam} encParams 屏幕分享的画面编码参数，可以设置为 null，表示让 SDK 选择最佳的编码参数（分辨率、码率等）。即使在调用 startScreenCapture 时设置 type=TRTCVideoStreamTypeBig，依然可以使用此接口更新屏幕分享的编码参数。
     * @param {TRTCScreenShareParams} shareParams 您可以通过其中的 enableForegroundService 参数启用 SDK 内置的前台服务； 当 appGroup 正确填写时，会开启 iOS 系统屏幕分享；如果不填写 appGroup, 则默认使用应用内屏幕分享。
     * @memberof TrtcCloud
     * @example
     * import { TRTCVideoResolution, TRTCVideoResolutionMode, TRTCVideoStreamType} from '@/TrtcCloud/lib/TrtcDefines';
     * const encParams = {
     *   videoResolution: TRTCVideoResolution.TRTCVideoResolution_640_360,
     *   videoResolutionMode: TRTCVideoResolutionMode.TRTCVideoResolutionModePortrait,
     *   videoFps: 15,
     *   videoBitrate: 900,
     *   minVideoBitrate: 200,
     *   enableAdjustRes: false,
     * };
     * const shareParams = {
     *   enableForegroundService: true,
     *   appGroup: 'xxx',
     * };
     * this.trtcCloud.startScreenCapture(TRTCVideoStreamType.TRTCVideoStreamTypeSub, encParams, shareParams);
     */
    startScreenCapture(streamType = TRTCVideoStreamType.TRTCVideoStreamTypeSub, encParams = null, shareParams = {}) {
        return TrtcCloudImpl._getInstance().startScreenCapture(streamType, encParams, shareParams);
    }
    /**
     * 停止屏幕分享
     * @memberof TrtcCloud
     * @example
     * this.trtcCloud.stopScreenCapture();
     */
    stopScreenCapture() {
        return TrtcCloudImpl._getInstance().stopScreenCapture();
    }
    /**
     * 暂停屏幕分享
     * @memberof TrtcCloud
     * @example
     * this.trtcCloud.pauseScreenCapture();
     */
    pauseScreenCapture() {
        return TrtcCloudImpl._getInstance().pauseScreenCapture();
    }
    /**
     * 恢复屏幕分享
     * @memberof TrtcCloud
     * @example
     * this.trtcCloud.resumeScreenCapture();
     */
    resumeScreenCapture() {
        return TrtcCloudImpl._getInstance().resumeScreenCapture();
    }
    /**
     * 设置系统音量类型（仅适用于移动设备）
     *
     * @param {TXSystemVolumeType} type 系统音量类型
     *
     * @memberof TrtcCloud
     * @example
     * this.trtcCloud.setSystemVolumeType(TXSystemVolumeType.TXSystemVolumeTypeAuto)
     */
    setSystemVolumeType(type) {
        return TrtcCloudImpl._getInstance().setSystemVolumeType(type);
    }
    /**
    * 设置本地画面被暂停期间的替代图片
    *
    * 当您调用 muteLocaLVideo（true）暂停本地画面时，您可以通过调用本接口设置一张替代图片，设置后，房间中的其他用户会看到这张替代图片，而不是黑屏画面。
    *
    * @param {Number} fps 设置替代图片帧率，最小值为5，最大值为10，默认5。
    * @param {String} image 设置替代图片，空值代表在 muteLocalVideo 之后不再发送视频流数据，默认值为空。
    * @memberof TrtcCloud
    * @example
    * this.trtcCloud.setVideoMuteImage(6, 'xxxx');
    */
    setVideoMuteImage(fps, image) {
        return TrtcCloudImpl._getInstance().setVideoMuteImage(fps, image);
    }
    /**
    * 开启大小画面双路编码模式
    *
    * 开启双路编码模式后，当前用户的编码器会同时输出【高清大画面】和【低清小画面】两路视频流（但只有一路音频流）。
    * 如此以来，房间中的其他用户就可以根据自身的网络情况或屏幕大小选择订阅【高清大画面】或是【低清小画面】。

    * @param {Boolean} enable 是否开启小画面编码，默认值：false。
    * @param {TRTCVideoEncParam} smallVideoEncParam 小流的视频参数。
    *
    * @memberof TrtcCloud
    * @example
    * import { TRTCVideoEncParam, TRTCVideoResolution, TRTCVideoResolutionMode } from '@/TrtcCloud/lib/TrtcDefines';
    * this.trtcCloud.enableEncSmallVideoStream(true, {videoResolution: TRTCVideoResolution.TRTCVideoResolution_120_120, videoResolutionMode: TRTCVideoResolutionMode.TRTCVideoResolutionModeLandscape})
    */
    enableEncSmallVideoStream(enable, smallVideoEncParam) {
        return TrtcCloudImpl._getInstance().enableEncSmallVideoStream(enable, smallVideoEncParam);
    }
    /////////////////////////////////////////////////////////////////////////////////
    //
    //                      美颜 + 水印
    //
    /////////////////////////////////////////////////////////////////////////////////
    /**
     * 设置美颜（磨皮）算法
     * TRTC 内置多种不同的磨皮算法，您可以选择最适合您产品定位的方案
     *
     * **Note:**
     * - 设置美颜前，先调用 `setBeautyLevel` 设置美颜级别。否则美颜级别为 0 表示关闭美颜
     *
     * @param {TRTCBeautyStyle} beautyStyle 美颜风格，TRTCBeautyStyleSmooth：光滑；TRTCBeautyStyleNature：自然；TRTCBeautyStylePitu：优图
     * @memberof TrtcCloud
     * @example
     * import { TRTCBeautyStyle } from '@/TrtcCloud/lib/TrtcDefines';
     * const beautyLevel = 5; // 美颜级别，取值范围0 - 9； 0表示关闭，9表示效果最明显。
     * this.trtcCloud.setBeautyLevel(beautyLevel);
     * this.trtcCloud.setBeautyStyle(TRTCBeautyStyle.TRTCBeautyStyleSmooth);
     */
    setBeautyStyle(beautyStyle) {
        return TrtcCloudImpl._getInstance().setBeautyStyle(beautyStyle);
    }
    /**
     * 设置美颜级别
     * @param {Number} beautyLevel    美颜级别，取值范围0 - 9； 0表示关闭，9表示效果最明显。
     *
     * @memberof TrtcCloud
     * @example
     * const beautyLevel = 5; // 美颜级别，取值范围0 - 9； 0表示关闭，9表示效果最明显。
     * this.trtcCloud.setBeautyLevel(beautyLevel);
     */
    setBeautyLevel(beautyLevel) {
        return TrtcCloudImpl._getInstance().setBeautyLevel(beautyLevel);
    }
    /////////////////////////////////////////////////////////////////////////////////
    //
    //                      背景音效
    //
    /////////////////////////////////////////////////////////////////////////////////
    /**
     * 开始播放背景音乐
     * 每个音乐都需要您指定具体的 ID，您可以通过该 ID 对音乐的开始、停止、音量等进行设置。<br>
     * **Note:**
     * - 如果要多次播放同一首背景音乐，请不要每次播放都分配一个新的 ID，我们推荐使用相同的 ID。
     * - 若您希望同时播放多首不同的音乐，请为不同的音乐分配不同的 ID 进行播放。
     * - 如果使用同一个 ID 播放不同音乐，SDK 会先停止播放旧的音乐，再播放新的音乐。
     *
     * **Note:**<br>
     * 在 uni-app 中 path 如何获取。
     * - 使用 cdn 地址，例如：`path = https://web.sdk.qcloud.com/component/TUIKit/assets/uni-app/calling-bell-1.mp3;`
     * - 使用本地绝对路径。
     *     1. 通过 [uni.saveFile](https://zh.uniapp.dcloud.io/api/file/file.html#savefile) 获取保存后的相对路径（建议这种路径）。
     *     2. 将上一步的相对路径转成绝对路径，[plus.io.convertLocalFileSystemURL](https://www.html5plus.org/doc/zh_cn/io.html#plus.io.convertLocalFileSystemURL)。
     *
     * @param {AudioMusicParam} musicParam 音乐参数
     * @param {Number} musicParam.id 音乐 ID
     * @param {String} musicParam.path 音效文件的完整路径或 URL 地址。支持的音频格式包括 MP3、AAC、M4A、WAV
     * @param {Number} musicParam.loopCount 音乐循环播放的次数。取值范围为0 - 任意正整数，默认值：0。0表示播放音乐一次；1表示播放音乐两次；以此类推
     * @param {Boolean} musicParam.publish 是否将音乐传到远端。true：音乐在本地播放的同时，远端用户也能听到该音乐；false：主播只能在本地听到该音乐，远端观众听不到。默认值：false。
     * @param {Boolean} musicParam.isShortFile 播放的是否为短音乐文件。true：需要重复播放的短音乐文件；false：正常的音乐文件。默认值：false
     * @param {Number} musicParam.startTimeMS 音乐开始播放时间点，单位: 毫秒。
     * @param {Number} musicParam.endTimeMS 音乐结束播放时间点，单位: 毫秒，0 表示播放至文件结尾。
     * @memberof TrtcCloud
     * @example
     * import { AudioMusicParam } from '@/TrtcCloud/lib/TrtcDefines';
     * const musicParam = {
     *  id: 1,
     *  path: '',
     *  loopCount: 1,
     *  publish: true,
     *  isShortFile: false,
     *  startTimeMS: 0,
     *  endTimeMS: 0,
     * };
     * this.trtcCloud.startPlayMusic(musicParam);
     */
    startPlayMusic(musicParam) {
        return TrtcCloudImpl._getInstance().startPlayMusic(musicParam);
    }
    /**
     * 停止播放背景音乐
     * @param {Number} id    音乐 ID
     *
     * @memberof TrtcCloud
     * @example
     * const musicId = 5;
     * this.trtcCloud.stopPlayMusic(musicId);
     */
    stopPlayMusic(id) {
        return TrtcCloudImpl._getInstance().stopPlayMusic(id);
    }
    /**
     * 暂停播放背景音乐
     * @param {Number} id    音乐 ID
     * @memberof TrtcCloud
     * @example
     * const musicId = 5;
     * this.trtcCloud.pausePlayMusic(musicId);
     */
    pausePlayMusic(id) {
        return TrtcCloudImpl._getInstance().pausePlayMusic(id);
    }
    /**
     * 恢复播放背景音乐
     * @param {Number} id    音乐 ID
     * @memberof TrtcCloud
     * @example
     * const musicId = 5;
     * this.trtcCloud.resumePlayMusic(musicId);
     */
    resumePlayMusic(id) {
        return TrtcCloudImpl._getInstance().resumePlayMusic(id);
    }
    /**
     * 调用实验性接口
     * @param {any} params 实验性接口参数
     * @memberof TrtcCloud
     * @example
     * this.trtcCloud.callExperimentalAPI(params);
     */
    callExperimentalAPI(params) {
        return TrtcCloudImpl._getInstance().callExperimentalAPI(params);
    }
    /**
     * 使用 UDP 通道发送自定义消息给房间内所有用户<br>
     * 该接口可以让您借助 TRTC 的 UDP 通道，向当前房间里的其他用户广播自定义数据，以达到传输信令的目的。
     * 房间中的其他用户可以通过 onRecvCustomCmdMsg 事件接收消息。
     *
     * **Note:**
     * 1. 发送消息到房间内所有用户（暂时不支持 Web/小程序端），每秒最多能发送30条消息（与 {sendSEIMsg} 共享限制）。
     * 2. 每个包最大为 1KB，超过则很有可能会被中间路由器或者服务器丢弃。
     * 3. 每个客户端每秒最多能发送总计 16KB 数据（与 {sendSEIMsg} 共享限制）。
     * 4. 请将 `reliable` 和 `ordered` 同时设置为 true 或同时设置为 false，暂不支持交叉设置。
     * 5. 强烈建议您将不同类型的消息设定为不同的 cmdID，这样可以在要求有序的情况下减小消息时延。
     *
     * @param {any} params - 参数
     * @param {Number} params.cmdID     - 消息 ID，取值范围为 [1, 10]
     * @param {String} params.data      - 待发送的消息，单个消息的最大长度被限制为 1KB
     * @param {Boolean} params.reliable - 是否可靠发送，可靠发送可以获得更高的发送成功率，但可靠发送比不可靠发送会带来更大的接收延迟
     * @param {Number} params.ordered   - 是否要求有序，即是否要求接收端的数据包顺序和发送端的数据包顺序一致（这会带来一定的接收延时）
     * @return true：消息已经发出；false：消息发送失败。

     * @memberof TrtcCloud
     * @example
     * const params = {
     *  cmdID: 1,
     *  data: 'hello world',
     *  reliable: true,
     *  ordered: true,
     * };
     * this.trtcCloud.sendCustomCmdMsg(params);
     */
    sendCustomCmdMsg(params) {
        return TrtcCloudImpl._getInstance().sendCustomCmdMsg(params);
    }
    /////////////////////////////////////////////////////////////////////////////////
    //
    //                       设置 TRTCCallback 回调
    //
    /////////////////////////////////////////////////////////////////////////////////
    /**
     * 设置 TrtcCloud 回调
     *
     * @example
     * // 创建/使用/销毁 TrtcCloud 对象的示例代码：
     * import TrtcCloud from '@/TrtcCloud/lib/index';
     * this.trtcCloud = new TrtcCloud();
     *
     * // 添加事件监听的方法，事件关键字详见下方”通用事件回调“
     * this.trtcCloud.on('onEnterRoom', (result) => {
     *   if (result > 0) {
     *     console.log(`enter room success, spend ${result}ms`);
     *   } else {
     *     console.log(`enter room failed, error code = ${result}`);
     *   }
     * });
     *
     * @namespace TRTCCallback
     */
    /////////////////////////////////////////////////////////////////////////////////
    //
    //                      （一）事件回调
    //
    /////////////////////////////////////////////////////////////////////////////////
    /**
     * 错误回调，表示 SDK 不可恢复的错误，一定要监听并分情况给用户适当的界面提示<br>
     * @event TRTCCallback#onError
     * @param {Number} code 错误码，[详见](https://cloud.tencent.com/document/product/647/38308#.E9.94.99.E8.AF.AF.E7.A0.81.E8.A1.A8)
     * @param {String} message 错误信息
     * @param {Object} extraInfo 扩展信息字段，个别错误码可能会带额外的信息帮助定位问题
     */
    onError(code, message, extraInfo) { }
    /**
     * 警告回调，用于告知您一些非严重性问题，例如出现卡顿或者可恢复的解码失败<br>
     * @event TRTCCallback#onWarning
     * @param {Number} code 警告码，[详见](https://cloud.tencent.com/document/product/647/38308#.E8.AD.A6.E5.91.8A.E7.A0.81.E8.A1.A8)
     * @param {String} message 警告信息
     * @param {Object} extraInfo 扩展信息字段，个别警告码可能会带额外的信息帮助定位问题
     */
    onWarning(code, message, extraInfo) { }
    /**
     * 进房后的回调<br>
     * 调用 `enterRoom()` 接口执行进房操作后，会收到 `onEnterRoom(result)` 回调<br>
     * 如果加入成功，result 会是一个正数（result > 0），代表加入房间的时间消耗，单位是毫秒（ms）。<br>
     * 如果加入失败，result 会是一个负数（result < 0），代表进房失败的错误码。
     *
     * @event TRTCCallback#onEnterRoom
     * @param {Number} result 进房耗时
     */
    onEnterRoom(result) { }
    /**
     * 离开房间的事件回调<br>
     * 调用 `exitRoom()` 接口会执行退出房间的相关逻辑，例如释放音视频设备资源和编解码器资源等。待资源释放完毕，会通过 `onExitRoom()` 回调通知到您<br>
     *
     * **Note:**
     * - 如果您要再次调用 `enterRoom()` 或者切换到其他的音视频 SDK，请等待 `onExitRoom()` 回调到来之后再执行相关操作。 否则可能会遇到音频设备被占用等各种异常问题
     *
     * @event TRTCCallback#onExitRoom
     * @param {Number} reason 离开房间原因，0：主动调用 exitRoom 退房；1：被服务器踢出当前房间；2：当前房间整个被解散
     */
    onExitRoom(reason) { }
    /**
     * 跨房通话事件回调<br>
     * 调用 TRTCCloud 中的 [connectOtherRoom()](https://web.sdk.qcloud.com/trtc/uniapp/doc/zh-cn/TrtcCloud.html#connectOtherRoom) 接口会将两个不同房间中的主播拉通视频通话，也就是所谓的“主播PK”功能。
     * 调用者会收到 onConnectOtherRoom() 事件回调来获知跨房通话是否成功， 如果成功，两个房间中的所有用户都会收到来自另一个房间中的 PK 主播的 [onUserVideoAvailable()](http://127.0.0.1:5500/UniApp-TRTC-SDK/packages/TrtcCloud/docs/zh-cn/api/TRTCCallback.html#event:onUserVideoAvailable) 回调。
     *
     * @event TRTCCallback#onConnectOtherRoom
     * @param {Object} params 调用 [connectOtherRoom()](https://web.sdk.qcloud.com/trtc/uniapp/doc/zh-cn/TrtcCloud.html#connectOtherRoom) 接口返回值数据。
     * - userId：跨房通话时对端 userId
     * - errCode: [错误状态码](https://cloud.tencent.com/document/product/647/38308#.E8.AD.A6.E5.91.8A.E7.A0.81.E8.A1.A8),返回0表示跨房通话成功。
     * - errMsg: 状态信息，跨房通话成功返回 OK。
     */
    onConnectOtherRoom(params) { }
    /**
     * 结束跨房通话的结果回调<br>
     * 调用 TRTCCloud 中的 [disconnectOtherRoom()](https://web.sdk.qcloud.com/trtc/uniapp/doc/zh-cn/TrtcCloud.html#disconnectOtherRoom) 接口会将两个不同房间中的主播拉通视频通话，也就是所谓的“主播PK”功能。
     * 调用者会收到 onDisconnectOtherRoom() 事件回调来获知结束跨房通话是否成功。
     *
     * @event TRTCCallback#onDisconnectOtherRoom
     * @param {Object} params 调用 [disconnectOtherRoom()](https://web.sdk.qcloud.com/trtc/uniapp/doc/zh-cn/TrtcCloud.html#disconnectOtherRoom) 失败时返回的错误数据。
     * - errCode: [错误状态码](https://cloud.tencent.com/document/product/647/38308#.E8.AD.A6.E5.91.8A.E7.A0.81.E8.A1.A8)。
     * - errMsg: 错误信息。
     */
    onDisconnectOtherRoom(params) { }
    /**
     * 切换角色的事件回调<br>
     * 调用 TRTCCloud 中的 switchRole() 接口会切换主播和观众的角色，该操作会伴随一个线路切换的过程， 待 SDK 切换完成后，会抛出 onSwitchRole() 事件回调
     *
     * @event TRTCCallback#onSwitchRole
     * @param {Number} code 错误码，[详见](https://cloud.tencent.com/document/product/647/38308#.E8.AD.A6.E5.91.8A.E7.A0.81.E8.A1.A8)
     * @param {String} message 错误信息
     */
    onSwitchRole(code, message) { }
    /**
     * 开始渲染本地或远程用户的首帧画面<br>
     * 如果 userId 为 null，代表开始渲染本地采集的摄像头画面，需要您先调用 `startLocalPreview` 触发。 如果 userId 不为 null，代表开始渲染远程用户的首帧画面，需要您先调用 `startRemoteView` 触发<br>
     * 只有当您调用 `startLocalPreview()、startRemoteView() 或 startRemoteSubStreamView()` 之后，才会触发该回调
     *
     * @event TRTCCallback#onFirstVideoFrame
     * @param {String} userId 本地或远程用户 ID，如果 userId === null 代表本地，userId !== null 代表远程
     * @param {Number} streamType 视频流类型：摄像头或屏幕分享
     * @param {Number} width 画面宽度
     * @param {Number} height 画面高度
     */
    onFirstVideoFrame(userId, streamType, width, height) { }
    /**
     * 开始播放远程用户的首帧音频（本地声音暂不通知）<br>
     * 如果 userId 为 null，代表开始渲染本地采集的摄像头画面，需要您先调用 `startLocalPreview` 触发。 如果 userId 不为 null，代表开始渲染远程用户的首帧画面，需要您先调用 `startRemoteView` 触发<br>
     * 只有当您调用 `startLocalPreview()、startRemoteView() 或 startRemoteSubStreamView()` 之后，才会触发该回调
     *
     * @event TRTCCallback#onFirstAudioFrame
     * @param {String} userId 远程用户 ID
     */
    onFirstAudioFrame(userId) { }
    /**
     * 截图完成时回调<br>
     * @event TRTCCallback#onSnapshotComplete
     * @param {String} base64Data 截图对应的 base64 数据
     * @param {String} message 错误信息
     */
    onSnapshotComplete(base64Data, message) { }
    /**
     * 麦克风准备就绪
     */
    onMicDidReady() { }
    /**
     * 摄像头准备就绪
     */
    onCameraDidReady() { }
    /**
     * 网络质量：该回调每2秒触发一次，统计当前网络的上行和下行质量<br>
     * userId 为本地用户 ID 代表自己当前的视频质量
     *
     * @param {String} localQuality 上行网络质量
     * @param {String} remoteQuality 下行网络质量
     */
    onNetworkQuality(localQuality, remoteList) { }
    /**
     * 有用户加入当前房间<br>
     * 出于性能方面的考虑，在两种不同的应用场景下，该通知的行为会有差别：<br>
     * 通话场景（TRTCAppScene.TRTCAppSceneVideoCall 和 TRTCAppScene.TRTCAppSceneAudioCall）：该场景下用户没有角色的区别，任何用户进入房间都会触发该通知。<br>
     * 直播场景（TRTCAppScene.TRTCAppSceneLIVE 和 TRTCAppScene.TRTCAppSceneVoiceChatRoom ）：该场景不限制观众的数量，如果任何用户进出都抛出回调会引起很大的性能损耗，所以该场景下只有主播进入房间时才会触发该通知，观众进入房间不会触发该通知
     *
     * @event TRTCCallback#onRemoteUserEnterRoom
     * @param {String} userId 用户标识 ID
     */
    onRemoteUserEnterRoom(userId) { }
    /**
     * 有用户离开当前房间<br>
     * 与 onRemoteUserEnterRoom 相对应，在两种不同的应用场景下，该通知的行为会有差别：<br>
     * 通话场景（TRTCAppScene.TRTCAppSceneVideoCall 和 TRTCAppScene.TRTCAppSceneAudioCall）：该场景下用户没有角色的区别，任何用户进入房间都会触发该通知。<br>
     * 直播场景（TRTCAppScene.TRTCAppSceneLIVE 和 TRTCAppScene.TRTCAppSceneVoiceChatRoom ）：该场景不限制观众的数量，如果任何用户进出都抛出回调会引起很大的性能损耗，所以该场景下只有主播进入房间时才会触发该通知，观众进入房间不会触发该通知
     *
     * @event TRTCCallback#onRemoteUserLeaveRoom
     * @param {String} userId 用户标识 ID
     * @param {Number} reason 离开原因，0 表示用户主动退出房间，1 表示用户超时退出，2 表示被踢出房间
     */
    onRemoteUserLeaveRoom(userId, reason) { }
    /**
     * 首帧本地音频数据已经被送出<br>
     * 在 `enterRoom()` 并 `startLocalAudio()` 成功后开始麦克风采集，并将采集到的声音进行编码。 当 SDK 成功向云端送出第一帧音频数据后，会抛出这个回调事件
     *
     * @event TRTCCallback#onSendFirstLocalAudioFrame
     */
    onSendFirstLocalAudioFrame() { }
    /**
     * 首帧本地视频数据已经被送出<br>
     * SDK 会在 `enterRoom()` 并 `startLocalPreview()` 成功后开始摄像头采集，并将采集到的画面进行编码。 当 SDK 成功向云端送出第一帧视频数据后，会抛出这个回调事件
     *
     * @event TRTCCallback#onSendFirstLocalVideoFrame
     * @param {Number} streamType 视频流类型，大画面、小画面或辅流画面（屏幕分享）
     */
    onSendFirstLocalVideoFrame(streamType) { }
    /**
     * 技术指标统计回调<br>
     * 如果您是熟悉音视频领域相关术语，可以通过这个回调获取 SDK 的所有技术指标。 如果您是首次开发音视频相关项目，可以只关注 `onNetworkQuality` 回调
     *
     * **Note:**
     * - 每 2 秒回调一次
     *
     * @param {Object} statics 状态数据
     */
    onStatistics(statics) { }
    /**
     * 远端用户是否存在可播放的音频数据<br>
     * @event TRTCCallback#onUserAudioAvailable
     * @param {String} userId 用户标识 ID
     * @param {Boolean} available 声音是否开启
     */
    onUserAudioAvailable(userId, available) { }
    /**
     * 远端用户是否存在可播放的主路画面（一般用于摄像头）<br>
     * 当您收到 `onUserVideoAvailable(userId, true)` 通知时，表示该路画面已经有可用的视频数据帧到达。 此时，您需要调用 `startRemoteView(userId)` 接口加载该用户的远程画面。 然后，您会收到名为 onFirstVideoFrame(userid) 的首帧画面渲染回调。<br>
     * 当您收到 `onUserVideoAvailable(userId, false)` 通知时，表示该路远程画面已经被关闭，可能由于该用户调用了 `muteLocalVideo()` 或 `stopLocalPreview()`。
     *
     * @event TRTCCallback#onUserVideoAvailable
     * @param {String} userId 用户标识 ID
     * @param {Boolean} available 画面是否开启
     */
    onUserVideoAvailable(userId, available) { }
    /**
     * 用于提示音量大小的回调，包括每个 userId 的音量和远端总音量<br>
     * SDK 可以评估每一路音频的音量大小，并每隔一段时间抛出该事件回调，您可以根据音量大小在 UI 上做出相应的提示，比如“波形图”或“音量槽”。 要完成这个功能， 您需要先调用 enableAudioVolumeEvaluation 开启这个能力并设定事件抛出的时间间隔。 需要补充说明的是，无论当前房间中是否有人说话，SDK 都会按照您设定的时间间隔定时抛出此事件回调，只不过当没有人说话时，userVolumes 为空，totalVolume 为 0。
     *
     * **Note:**
     * - userVolumes 为一个数组，对于数组中的每一个元素，当 userId 为空时表示本地麦克风采集的音量大小，当 userId 不为空时代表远端用户的音量大小
     *
     * @event TRTCCallback#onUserVoiceVolume
     * @param {Array} userVolumes 是一个数组，用于承载所有正在说话的用户的音量大小，取值范围 0 - 100
     * @param {Number} totalVolume 所有远端用户的总音量大小, 取值范围 0 - 100
     */
    onUserVoiceVolume(userVolumes, totalVolume) { }
    /**
     * 屏幕分享开启的事件回调<br>
     * 当您通过 startScreenCapture 等相关接口启动屏幕分享时，SDK 便会抛出此事件回调
     * @event TRTCCallback#onScreenCaptureStarted
     */
    onScreenCaptureStarted() { }
    /**
     * 屏幕分享停止的事件回调<br>
     * 当您通过 stopScreenCapture 停止屏幕分享时，SDK 便会抛出此事件回调
     * @event TRTCCallback#onScreenCaptureStopped
     * @param {Number} reason 停止原因，0：用户主动停止；1：屏幕窗口关闭导致停止；2：表示屏幕分享的显示屏状态变更（如接口被拔出、投影模式变更等）
     */
    onScreenCaptureStopped(reason) { }
    /**
     * 屏幕分享停止的事件回调<br>
     * 当您通过 pauseScreenCapture 停止屏幕分享时，SDK 便会抛出此事件回调
     * @event TRTCCallback#onScreenCapturePaused
     * @param {Number} reason 停止原因，0：用户主动停止；1：屏幕窗口关闭导致停止；2：表示屏幕分享的显示屏状态变更（如接口被拔出、投影模式变更等）
     */
    onScreenCapturePaused(reason) { }
    /**
     * 屏幕分享恢复的事件回调<br>
     * 当您通过 resumeScreenCapture 恢复屏幕分享时，SDK 便会抛出此事件回调
     * @event TRTCCallback#onScreenCaptureResumed
     */
    onScreenCaptureResumed() { }
    /**
     * 某远端用户发布/取消了辅路视频画面<br>
     * “辅路画面”一般被用于承载屏幕分享的画面。当您收到 onUserSubStreamAvailable(userId, true) 通知时，表示该路画面已经有可播放的视频帧到达。 此时，您需要调用 startRemoteView 接口订阅该用户的远程画面，订阅成功后，您会继续收到该用户的首帧画面渲染回调 onFirstVideoFrame(userId)
     *
     * **Note:**
     * - 拉取 Web 端（用 [WebRTC](https://web.sdk.qcloud.com/trtc/webrtc/doc/zh-cn/index.html) 实现屏幕分享）的屏幕分享，收不到 onUserSubStreamAvailable 事件。因为 [WebRTC](https://web.sdk.qcloud.com/trtc/webrtc/doc/zh-cn/index.html) 推的屏幕分享也是主流
     * @param {String} userId 用户 ID
     * @param {Boolean} available 是否可用，true 表示辅流可用
     * @event TRTCCallback#onUserSubStreamAvailable
     */
    onUserSubStreamAvailable(userId, available) { }
    /**
     * 用户视频大小发生改变回调。<br>
     * 当您收到 onUserVideoSizeChanged(userId, streamtype, newWidth, newHeight) 通知时，表示该路画面大小发生了调整，调整的原因可能是该用户调用了 setVideoEncoderParam 或者 setSubStreamEncoderParam 重新设置了画面尺寸。
     * @param {String} userId 用户 ID
     * @param {Number} streamType 视频流类型，仅支持 TRTCVideoStreamTypeBig 和 TRTCVideoStreamTypeSub
     * @param {Number} newWidth 视频流的宽度（像素）
     * @param {Number} newHeight 视频流的高度（像素）
     * @event TRTCCallback#onUserVideoSizeChanged
     */
    onUserVideoSizeChanged(userId, streamType, newWidth, newHeight) { }
    /**
     * 背景音乐开始播放
     * @param {Number} id 播放的 id
     * @param {Number} errCode 播放的状态码
     * @event TRTCCallback#onStart
     */
    onStart(id, errCode) { }
    /**
     * 背景音乐的播放进度
     * @param {Number} id 播放的 id
     * @param {Number} curPtsMS 当前播放的位置
     * @param {Number} durationMS 当前音频总时长
     * @event TRTCCallback#onPlayProgress
     */
    onPlayProgress(id, curPtsMS, durationMS) { }
    /**
     * 背景音乐已经播放完毕
     * @param {Number} id 播放的 id
     * @param {Number} errCode 播放结束的状态码
     * @event TRTCCallback#onComplete
     */
    onComplete(id, errCode) { }
    /**
      * 收到自定义消息的事件回调。
      *
      * 当房间中的某个用户使用 {sendCustomCmdMsg} 发送自定义 UDP 消息时，房间中的其他用户可以通过 `onRecvCustomCmdMsg` 事件回调接收到该条消息。
      * @param {String} userId 用户标识。
      * @param {Number} cmdID 命令 ID。
      * @param {Number} seq   消息序号。
      * @param {String} message 消息数据。
      * @event TRTCCallback#onRecvCustomCmdMsg
      */
    onRecvCustomCmdMsg(userId, cmdID, seq, message) { }
}

 src/utils/voiceCallByTX/TrtcCloud/permission.js

New file
@@ -0,0 +1,279 @@
/**
 * 本模块封装了Android、iOS的应用权限判断、打开应用权限设置界面、以及位置系统服务是否开启
 */
 var isIos
 // #ifdef APP-PLUS
 isIos = (plus.os.name == "iOS");
 // #endif
 
 // 判断推送权限是否开启
 function judgeIosPermissionPush() {
   var result = false;
   var UIApplication = plus.ios.import("UIApplication");
   var app = UIApplication.sharedApplication();
   var enabledTypes = 0;
   if (app.currentUserNotificationSettings) {
     var settings = app.currentUserNotificationSettings();
     enabledTypes = settings.plusGetAttribute("types");
     console.log("enabledTypes1:" + enabledTypes);
     if (enabledTypes == 0) {
       console.log("推送权限没有开启");
     } else {
       result = true;
       console.log("已经开启推送功能!")
     }
     plus.ios.deleteObject(settings);
   } else {
     enabledTypes = app.enabledRemoteNotificationTypes();
     if (enabledTypes == 0) {
       console.log("推送权限没有开启!");
     } else {
       result = true;
       console.log("已经开启推送功能!")
     }
     console.log("enabledTypes2:" + enabledTypes);
   }
   plus.ios.deleteObject(app);
   plus.ios.deleteObject(UIApplication);
   return result;
 }
 
 // 判断定位权限是否开启
 function judgeIosPermissionLocation() {
   var result = false;
   var cllocationManger = plus.ios.import("CLLocationManager");
   var status = cllocationManger.authorizationStatus();
   result = (status != 2)
   console.log("定位权限开启：" + result);
   // 以下代码判断了手机设备的定位是否关闭，推荐另行使用方法 checkSystemEnableLocation
   /* var enable = cllocationManger.locationServicesEnabled();
   var status = cllocationManger.authorizationStatus();
   console.log("enable:" + enable);
   console.log("status:" + status);
   if (enable && status != 2) {
     result = true;
     console.log("手机定位服务已开启且已授予定位权限");
   } else {
     console.log("手机系统的定位没有打开或未给予定位权限");
   } */
   plus.ios.deleteObject(cllocationManger);
   return result;
 }
 // 判断麦克风权限是否开启
 function judgeIosPermissionRecord() {
   var result = false;
   var avaudiosession = plus.ios.import("AVAudioSession");
   var avaudio = avaudiosession.sharedInstance();
   var permissionStatus = avaudio.recordPermission();
   console.log("permissionStatus:" + permissionStatus);
   if (permissionStatus == 1684369017 || permissionStatus == 1970168948) {
     console.log("麦克风权限没有开启");
   } else {
     result = true;
     console.log("麦克风权限已经开启");
   }
   plus.ios.deleteObject(avaudiosession);
   return result;
 }
 
 // 判断相机权限是否开启
 function judgeIosPermissionCamera() {
   var result = false;
   var AVCaptureDevice = plus.ios.import("AVCaptureDevice");
   var authStatus = AVCaptureDevice.authorizationStatusForMediaType('vide');
   console.log("authStatus:" + authStatus);
   if (authStatus == 3) {
     result = true;
     console.log("相机权限已经开启");
   } else {
     console.log("相机权限没有开启");
   }
   plus.ios.deleteObject(AVCaptureDevice);
   return result;
 }
 
 // 判断相册权限是否开启
 function judgeIosPermissionPhotoLibrary() {
   var result = false;
   var PHPhotoLibrary = plus.ios.import("PHPhotoLibrary");
   var authStatus = PHPhotoLibrary.authorizationStatus();
   console.log("authStatus:" + authStatus);
   if (authStatus == 3) {
     result = true;
     console.log("相册权限已经开启");
   } else {
     console.log("相册权限没有开启");
   }
   plus.ios.deleteObject(PHPhotoLibrary);
   return result;
 }
 
 // 判断通讯录权限是否开启
 function judgeIosPermissionContact() {
   var result = false;
   var CNContactStore = plus.ios.import("CNContactStore");
   var cnAuthStatus = CNContactStore.authorizationStatusForEntityType(0);
   if (cnAuthStatus == 3) {
     result = true;
     console.log("通讯录权限已经开启");
   } else {
     console.log("通讯录权限没有开启");
   }
   plus.ios.deleteObject(CNContactStore);
   return result;
 }
 
 // 判断日历权限是否开启
 function judgeIosPermissionCalendar() {
   var result = false;
   var EKEventStore = plus.ios.import("EKEventStore");
   var ekAuthStatus = EKEventStore.authorizationStatusForEntityType(0);
   if (ekAuthStatus == 3) {
     result = true;
     console.log("日历权限已经开启");
   } else {
     console.log("日历权限没有开启");
   }
   plus.ios.deleteObject(EKEventStore);
   return result;
 }
 
 // 判断备忘录权限是否开启
 function judgeIosPermissionMemo() {
   var result = false;
   var EKEventStore = plus.ios.import("EKEventStore");
   var ekAuthStatus = EKEventStore.authorizationStatusForEntityType(1);
   if (ekAuthStatus == 3) {
     result = true;
     console.log("备忘录权限已经开启");
   } else {
     console.log("备忘录权限没有开启");
   }
   plus.ios.deleteObject(EKEventStore);
   return result;
 }
 
 // Android权限查询
 function requestAndroidPermission(permissionID) {
   return new Promise((resolve, reject) => {
     plus.android.requestPermissions(
       [permissionID], // 理论上支持多个权限同时查询，但实际上本函数封装只处理了一个权限的情况。有需要的可自行扩展封装
       function(resultObj) {
         var result = 0;
         for (var i = 0; i < resultObj.granted.length; i++) {
           var grantedPermission = resultObj.granted[i];
           console.log('已获取的权限：' + grantedPermission);
           result = 1
         }
         for (var i = 0; i < resultObj.deniedPresent.length; i++) {
           var deniedPresentPermission = resultObj.deniedPresent[i];
           console.log('拒绝本次申请的权限：' + deniedPresentPermission);
           result = 0
         }
         for (var i = 0; i < resultObj.deniedAlways.length; i++) {
           var deniedAlwaysPermission = resultObj.deniedAlways[i];
           console.log('永久拒绝申请的权限：' + deniedAlwaysPermission);
           result = -1
         }
         resolve(result);
         // 若所需权限被拒绝,则打开APP设置界面,可以在APP设置界面打开相应权限
         // if (result != 1) {
         // gotoAppPermissionSetting()
         // }
       },
       function(error) {
         console.log('申请权限错误：' + error.code + " = " + error.message);
         resolve({
           code: error.code,
           message: error.message
         });
       }
     );
   });
 }
 
 // 使用一个方法，根据参数判断权限
 function judgeIosPermission(permissionID) {
   if (permissionID == "location") {
     return judgeIosPermissionLocation()
   } else if (permissionID == "camera") {
     return judgeIosPermissionCamera()
   } else if (permissionID == "photoLibrary") {
     return judgeIosPermissionPhotoLibrary()
   } else if (permissionID == "record") {
     return judgeIosPermissionRecord()
   } else if (permissionID == "push") {
     return judgeIosPermissionPush()
   } else if (permissionID == "contact") {
     return judgeIosPermissionContact()
   } else if (permissionID == "calendar") {
     return judgeIosPermissionCalendar()
   } else if (permissionID == "memo") {
     return judgeIosPermissionMemo()
   }
   return false;
 }
 
 // 跳转到**应用**的权限页面
 function gotoAppPermissionSetting() {
   if (isIos) {
     var UIApplication = plus.ios.import("UIApplication");
     var application2 = UIApplication.sharedApplication();
     var NSURL2 = plus.ios.import("NSURL");
     // var setting2 = NSURL2.URLWithString("prefs:root=LOCATION_SERVICES");		
     var setting2 = NSURL2.URLWithString("app-settings:");
     application2.openURL(setting2);
 
     plus.ios.deleteObject(setting2);
     plus.ios.deleteObject(NSURL2);
     plus.ios.deleteObject(application2);
   } else {
     // console.log(plus.device.vendor);
     var Intent = plus.android.importClass("android.content.Intent");
     var Settings = plus.android.importClass("android.provider.Settings");
     var Uri = plus.android.importClass("android.net.Uri");
     var mainActivity = plus.android.runtimeMainActivity();
     var intent = new Intent();
     intent.setAction(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
     var uri = Uri.fromParts("package", mainActivity.getPackageName(), null);
     intent.setData(uri);
     mainActivity.startActivity(intent);
   }
 }
 
 // 检查系统的设备服务是否开启
 // var checkSystemEnableLocation = async function () {
 function checkSystemEnableLocation() {
   if (isIos) {
     var result = false;
     var cllocationManger = plus.ios.import("CLLocationManager");
     var result = cllocationManger.locationServicesEnabled();
     console.log("系统定位开启:" + result);
     plus.ios.deleteObject(cllocationManger);
     return result;
   } else {
     var context = plus.android.importClass("android.content.Context");
     var locationManager = plus.android.importClass("android.location.LocationManager");
     var main = plus.android.runtimeMainActivity();
     var mainSvr = main.getSystemService(context.LOCATION_SERVICE);
     var result = mainSvr.isProviderEnabled(locationManager.GPS_PROVIDER);
     console.log("系统定位开启:" + result);
     return result
   }
 }
 
//  module.exports = {
//    judgeIosPermission: judgeIosPermission,
//    requestAndroidPermission: requestAndroidPermission,
//    checkSystemEnableLocation: checkSystemEnableLocation,
//    gotoAppPermissionSetting: gotoAppPermissionSetting
//  }

// HBuilder 选择 vue3 时, 上面的打包无法通过 import 进行引入
export default {
  judgeIosPermission: judgeIosPermission,
  requestAndroidPermission: requestAndroidPermission,
  checkSystemEnableLocation: checkSystemEnableLocation,
  gotoAppPermissionSetting: gotoAppPermissionSetting
};
 

 src/utils/voiceCallByTX/TrtcCloud/view/TrtcLocalView.nvue

New file
@@ -0,0 +1,19 @@
<template>
    <TRTCCloudUniPlugin-TXLocalViewComponent :viewId="viewId"></TRTCCloudUniPlugin-TXLocalViewComponent>
</template>

<script>
    export default {
        name: 'TrtcLocalView',
        props: {
            viewId: {
                type: String,
                default: ''
            }
        },
    }
</script>

<style>

</style>

 src/utils/voiceCallByTX/TrtcCloud/view/TrtcRemoteView.nvue

New file
@@ -0,0 +1,23 @@
<template>
    <TRTCCloudUniPlugin-TXRemoteViewComponent :userId="userId" :viewId="viewId"></TRTCCloudUniPlugin-TXRemoteViewComponent>
</template>

<script>
    export default {
        name: 'TrtcRemoteView',
        props: {
            userId: {
                type: String,
                default: ''
            },
            viewId: {
                type: String,
                default: ''
            }
        },
    }
</script>

<style>

</style>

 src/utils/voiceCallByTX/index.js

New file
@@ -0,0 +1,36 @@
// #ifdef  APP-PLUS
import TrtcCloud from '@/utils/voiceCallByTX/TrtcCloud/lib/index';
import {TRTCAppScene} from '@/utils/voiceCallByTX/TrtcCloud/lib/TrtcDefines';

const trtcCloud = TrtcCloud.createInstance();
// #endif

// #ifdef  H5
import TRTC from 'trtc-sdk-v5';

const trtc = TRTC.create();
// #endif

import {genTestUserSig} from "@/utils/voiceCallByTX/GenerateTestUserSig.js";
import {sendVoiceCallApi} from "@/api/user/index.js";

export function enterRoom(payload, userId) {
  const data = JSON.parse(payload.data.data)
  const theOtherPartyId = payload.data.caller_id
  const {userSig, SDKAppID: sdkAppId} = genTestUserSig(userId);
  const params = {sdkAppId, userId, roomId: data.roomId, userSig};
// #ifdef APP-PLUS
  trtcCloud.enterRoom(params, TRTCAppScene.TRTCAppSceneVideoCall)
  trtcCloud.startLocalAudio();
// #endif
// #ifdef H5
  trtc.enterRoom(params)
  trtc.startLocalAudio()
// #endif
  // demo原因，直接接通来进行验证测试
  sendVoiceCallApi({
    caller_id: userId,
    receiver_id: theOtherPartyId,
    data: JSON.stringify({state: '接通', roomId: data.roomId}),
  })
}

 vite.config.js

@@ -12,15 +12,19 @@

  const { UNI_PLATFORM,UNI_CUSTOM_DEFINE } = process.env
  const ENV_NAME = UNI_CUSTOM_DEFINE && JSON.parse(UNI_CUSTOM_DEFINE)?.ENV_NAME
  console.log("平台 -> ", UNI_PLATFORM) // 得到 mp-weixin, h5, app 等
  console.log("环境 -> ", ENV_NAME || 'development') // 得到 development,test 等
  const __APP_ENV__ = {
    UNI_PLATFORM: UNI_PLATFORM,
    ENV_NAME: ENV_NAME || 'development'
  }
  console.log("平台 -> ", __APP_ENV__.UNI_PLATFORM) // 得到 mp-weixin, h5, app 等
  console.log("环境 -> ", __APP_ENV__.ENV_NAME) // 得到 development,test 等

  const env = loadEnv(mode, fileURLToPath(new URL("./env", import.meta.url)))
  // console.log("环境变量 env -> ", env)
  const isBuild = process.env.NODE_ENV === "production"
  return {
    define: {
      __APP_ENV__: process.env,
      __APP_ENV__,
    },
    // 自定义env目录
    envDir: "./env",
@@ -37,7 +41,7 @@
      hmr: true,
      host: true,
      open: true,
      proxy: createViteProxy(env,ENV_NAME)
      proxy: createViteProxy(env,__APP_ENV__.ENV_NAME)
    },
    // 设置scss的api类型为modern-compiler
    css: {