## RTCManager 类型：`class` RTC 核心类, 负责管理创建的引擎实例和房间实例 ### engine 类型：[IEngine](#iengine) | undefined RTC 引擎实例 ### room 类型：[IRoom](#iroom) | undefined RTC 房间实例 ### audioEffectPlayer 类型：[I_AudioEffectPlayer](#i_audioeffectplayer) | undefined RTC 音效播放器实例 ### mediaPlayer 类型：[I_MediaPlayer](#i_mediaplayer) | undefined RTC 音乐播放器实例 ### vodPlayer 类型：unknown 点播播放器实例 ### getSDKVersion() 获取当前 ReactNative SDK 版本 **类型** ```ts () => string | undefined ``` ### getBasicSDKVersion() 获取 ReactNative 依赖的 Android/iOS SDK 版本 **类型** ```ts () => string ``` ### createRTCEngine() 创建引擎对象如果当前进程中未创建引擎实例，那么你必须先使用此方法，以使用 RTC 提供的各种音视频能力。
如果当前进程中已创建了引擎实例，再次调用此方法时，会返回已创建的引擎实例。 **类型** ```ts (options: ICreateRTCEngineOptions) => Promise ``` **参数** ```mixin-react const columns = [{ title: '名称', dataIndex: 'Name', width: 240, },{ title: '类型', dataIndex: 'Type', width: 240, render: (col, item, index) => { if(col.includes('')){ const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi; const new1 = regex.exec(col); return {new1?.[1]}{new1?.[4]}{new1?.[5]} } return col; } },{ title: '必选', dataIndex: 'Required', width: 120, },{ title: '默认值', dataIndex: 'Default', width: 120, render: (col, item, index) => { if(col.includes('')){ const regex = /(.*)
(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"options","Type":"ICreateRTCEngineOptions","Required":"是","Default":"无","Description":"引擎初始化参数, 详情参考 ICreateRTCEngineOptions\n","children":[],"key":"options"}]
      return ();
```
  

**返回值**


  - engine: [IEngine](#iengine) 实例
  - null: ICreateRTCEngineOptions 无效。详见 [ICreateRTCEngineOptions](1390578#icreatertcengineoptions) ，so 文件加载失败。

### destroyRTCEngine()  

销毁所创建的引擎实例，并释放所有相关资源。

**类型**

  ```ts
  () => void
  ```

### setLogConfig()  

配置 SDK 本地日志参数，包括日志级别、存储路径、日志文件最大占用的总空间、日志文件名前缀。

**类型**

  ```ts
  (config: ILogConfigs) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"config","Type":"ILogConfigs","Required":"是","Default":"无","Description":"本地日志参数。\n","children":[],"key":"config"}]
      return (
);
```
  

**返回值**

  number
  + 0：成功。
  + –1：失败，本方法必须在创建引擎前调用。
  + –2：失败，参数填写错误。

### setVodPlayer()  

注入点播播放器实例

**类型**

  ```ts
  (vodPlayer: unknown) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"vodPlayer","Type":"unknown","Required":"是","Default":"无","Description":"-","children":[],"key":"vodPlayer"}]
      return (
);
```
  


## IEngine 

基于 Android/iOS SDK 的 [RTCVideo](#rtcvideo) 类封装的引擎类。

**类型**

  ```ts
  Omit<
    RTCVideo,
    | 'setLocalVideoCanvas'
    | 'createRTCRoom'
    | 'setCellularEnhancement'
    | 'enableAudioPropertiesReport'
    | 'setRemoteAudioPlaybackVolume'
    | 'getAudioEffectPlayer'
    | 'getMediaPlayer'
    | 'setScreenVideoEncoderConfig'
    | 'startScreenCapture'
    | 'setRemoteVideoCanvas'
    | 'requestRemoteVideoKeyFrame'
    | 'sendStreamSyncInfo'
  > & {
    setLocalVideoCanvas: (
      streamIndex: StreamIndex,
      videoCanvas: IVideoCanvas,
    ) => number | undefined;
    setRemoteVideoCanvas: (
      remoteInfo: IRemoteInfo,
      videoCanvas: IVideoCanvas,
    ) => ReturnStatus;
    createRTCRoom: (roomId: string) => IRoom;
    getAudioEffectPlayer: () => I_AudioEffectPlayer;
    getMediaPlayer: (playerId: number) => I_MediaPlayer;
    setCellularEnhancement: (config: IEnhanceMentConfig) => number;
    enableAudioPropertiesReport: (config: IAudioPropertiesConfig) => number;
    setRemoteAudioPlaybackVolume: (
      remoteStreamInfo: IRemoteStreamInfo,
      volume: number,
    ) => number;
    setScreenVideoEncoderConfig: (config: IScreenSolution) => number;
    startScreenCapture: (
      type: ScreenMediaType,
      bundleId?: string,
    ) => Promise;
    setRuntimeParameters: (params: Record) => number;
    feedback(options: ProblemFeedbackOption[], info: IFeedbackProblemInfo): number;
    requestRemoteVideoKeyFrame(remoteInfo: IRemoteInfo): number;
    sendStreamSyncInfo(data: ArrayBuffer, info: IStreamSyncInfoConfig): number;
  }
  ```

**成员**

  | 名称 | 类型 | 描述 |
  | :-- | :-- | :-- |
  | setLocalVideoCanvas | (streamIndex: [StreamIndex](1390578#streamindex), videoCanvas: [IVideoCanvas](1390578#ivideocanvas)) =\> number \| undefined | 设置本地视频渲染时使用的视图，并设置渲染模式。 |
  | setRemoteVideoCanvas | (remoteInfo: [IRemoteInfo](1390578#iremoteinfo), videoCanvas: [IVideoCanvas](1390578#ivideocanvas)) =\> [ReturnStatus](1390578#returnstatus) | 渲染来自指定远端用户的视频流时，设置使用的视图和渲染模式。
要解除绑定，将 `videoCanvas` 设置为空。 |
  | createRTCRoom | (roomId: string) =\> [IRoom](#iroom) | 创建房间实例。 
调用此方法仅返回一个房间实例，你仍需调用 joinRoom 才能真正地创建/加入房间。 |
  | getAudioEffectPlayer | () =\> [I_AudioEffectPlayer](#i_audioeffectplayer) | 创建音效播放器实例。 |
  | getMediaPlayer | (playerId: number) =\> [I_MediaPlayer](#i_mediaplayer) | 创建音乐播放器实例。 |
  | setCellularEnhancement | (config: [IEnhanceMentConfig](1390578#ienhancementconfig)) =\> number | 启用蜂窝网络辅助增强，改善通话质量。 |
  | enableAudioPropertiesReport | (config: [IAudioPropertiesConfig](1390578#iaudiopropertiesconfig)) =\> number | 启用音频信息提示。开启提示后，你可以收到 onLocalAudioPropertiesReportonRemoteAudioPropertiesReport 和 onActiveSpeaker。 |
  | setRemoteAudioPlaybackVolume | (remoteStreamInfo: [IRemoteStreamInfo](1390578#iremotestreaminfo), volume: number) =\> number | 调节来自指定远端用户的音频播放音量。 |
  | setScreenVideoEncoderConfig | (config: [IScreenSolution](1390578#iscreensolution)) =\> number | 为发布的屏幕共享视频流设置期望的编码参数，包括分辨率、帧率、码率、网络不佳时的回退策略等。 |
  | startScreenCapture | (type: [ScreenMediaType](1390578#screenmediatype), bundleId?: string) =\> Promise | 使用 RTC SDK 内部采集模块开始采集屏幕音频流和（或）视频流。 |
  | setRuntimeParameters | (params: Record) =\> number | 设置运行时的参数 |


## IRoom 

基于 Android/iOS SDK 的 [RTCRoom](#rtcroom) 类封装的房间类。

**类型**

  ```ts
  Omit & {
    joinRoom: (params: IJoinRoomProps) => number;
    setRemoteVideoConfig: (
      userId: string,
      remoteVideoConfig: IRemoteVideoConfig,
    ) => number;
  }
  ```

**成员**

  | 名称 | 类型 | 描述 |
  | :-- | :-- | :-- |
  | joinRoom | (params: [IJoinRoomProps](1390578#ijoinroomprops)) =\> number | 加入房间。
调用 createRTCRoom 创建房间后，调用此方法加入房间，同房间内其他用户进行音视频通话。 |
  | setRemoteVideoConfig | (userId: string, remoteVideoConfig: [IRemoteVideoConfig](1390578#iremotevideoconfig)) =\> number | 设置期望订阅的远端视频流的参数。 |


## I_AudioEffectPlayer 

基于 Android/iOS SDK 的 [IAudioEffectPlayer](#iaudioeffectplayer) 类封装的音效播放器类。

**类型**

  ```ts
  Omit & {
    start: (
      effectId: number,
      path: string,
      config: IAudioEffectPlayerConfig,
    ) => I_AudioEffectPlayer;
  }
  ```

**成员**

  | 名称 | 类型 | 描述 |
  | :-- | :-- | :-- |
  | start | (effectId: number, path: string, config: [IAudioEffectPlayerConfig](1390578#iaudioeffectplayerconfig)) =\> [I_AudioEffectPlayer](#i_audioeffectplayer) | 开始播放音效文件。
可以通过传入不同的 ID 和 filepath 多次调用本方法，以实现同时播放多个音效文件，实现音效叠加。 |


## I_MediaPlayer 

基于 Android/iOS SDK 的 [IMediaPlayer](#imediaplayer) 类封装的音乐播放器类

**类型**

  ```ts
  Omit & {
    open: (filePath: string, config: IMediaPlayerConfig) => number;
  }
  ```

**成员**

  | 名称 | 类型 | 描述 |
  | :-- | :-- | :-- |
  | open | (filePath: string, config: [IMediaPlayerConfig](1390578#imediaplayerconfig)) =\> number | 打开音乐文件。
一个播放器实例仅能够同时打开一个音乐文件。如果需要同时打开多个音乐文件，请创建多个音乐播放器实例。
要播放 PCM 格式的音频数据，参看 openWithCustomSource。`openWithCustomSource` 和此 API 互斥。 |


## ISpatialAudio 

类型：`class`

空间音频接口实例

### enableSpatialAudio()  

开启/关闭空间音频功能。

**注意**

  该方法仅开启空间音频功能，你须调用 updatePosition 设置自身位置坐标后方可收听空间音频效果。空间音频相关 API 和调用时序详见[空间音频](https://www.volcengine.com/docs/6348/93903)。

**类型**

  ```ts
  (enable: boolean) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"enable","Type":"boolean","Required":"是","Default":"无","Description":"是否开启空间音频功能：
\ntrue：开启
\nfalse：关闭（默认）\n\n","children":[],"key":"enable"}]
      return (
);
```
  

### disableRemoteOrientation()  

关闭本地用户朝向对本地用户发声效果的影响。
调用此接口后，房间内的其他用户收听本地发声时，声源都在收听者正面。

**注意**

  - 调用本接口关闭朝向功能后，在当前的空间音频实例的生命周期内无法再次开启。
  - 调用此接口不影响本地用户收听朝向的音频效果。要改变本地用户收听朝向，参看 updateSelfPosition 和 updateRemotePosition 。

**类型**

  ```ts
  () => void
  ```

### updateSelfPosition()  

设置本地用户在自建空间直角坐标系中的收听坐标和收听朝向，以实现本地用户预期的空间音频收听效果。

**注意**

  - 该方法需在进房后调用。
  - 调用该接口更新坐标前，你需调用 enableSpatialAudio 开启空间音频功能。空间音频相关 API 和调用时序详见[空间音频](https://www.volcengine.com/docs/6348/93903)。
  - 调用此接口在本地进行的设定对其他用户的空间音频收听效果不会产生任何影响。

**类型**

  ```ts
  (positionInfo: PositionInfo) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"positionInfo","Type":"PositionInfo","Required":"是","Default":"无","Description":"空间音频位置信息。参看 PositionInfo。\n","children":[],"key":"positionInfo"}]
      return (
);
```
  

**返回值**

  number
  - 0：成功。
  - <0：失败。
  - -2: 失败，原因是校验本地用户的三维朝向信息时，三个向量没有两两垂直。

### updateRemotePosition()  

设置房间内某一远端用户在本地用户自建的空间音频坐标系中的发声位置和发声朝向，以实现本地用户预期的空间音频收听效果。

**注意**

  - 该方法需在创建房间后调用。
  - 调用此接口在本地进行的设定对其他用户的空间音频收听效果不会产生任何影响。

**类型**

  ```ts
  (uid: string, positionInfo: PositionInfo) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"uid","Type":"string","Required":"是","Default":"无","Description":"用户 ID
\n","children":[],"key":"uid"},{"Name":"positionInfo","Type":"PositionInfo","Required":"是","Default":"无","Description":"远端用户的空间音频位置信息。参看 PositionInfo。\n","children":[],"key":"positionInfo"}]
      return (
);
```
  

**返回值**

  number
  - 0：成功。
  - <0：失败。
  - -2: 失败，原因是校验远端用户的三维朝向信息时，三个向量没有两两垂直。

### removeRemotePosition()  

移除调用 updateRemotePosition 为某一远端用户设置的空间音频效果。

**类型**

  ```ts
  (uid: string) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"uid","Type":"string","Required":"是","Default":"无","Description":"远端用户 ID。\n","children":[],"key":"uid"}]
      return (
);
```
  

**返回值**

  number
  - 0：成功。
  - <0：失败。

### removeAllRemotePosition()  

移除调用 updateRemotePosition 为所有远端用户设置的空间音频效果。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  - 0：成功。
  - <0：失败。


## IVideoDeviceManager 

类型：`class`

主要用于枚举、设置视频采集设备

### android_enumerateVideoCaptureDevices()  

获取当前系统内视频采集设备列表。

**类型**

  ```ts
  () => $p_a.List<$p_a.VideoDeviceInfo>
  ```

**返回值**

  $p_a.List<$p_a.VideoDeviceInfo\>  包含系统中所有视频采集设备的列表，参看 VideoDeviceInfo。

### setVideoCaptureDevice()  

设置当前视频采集设备

**类型**

  ```ts
  (deviceId: string) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"deviceId","Type":"string","Required":"是","Default":"无","Description":"视频设备 ID，可以通过 enumerateVideoCaptureDevices 获取\n","children":[],"key":"deviceId"}]
      return (
);
```
  

**返回值**

  number
  - 0：方法调用成功
  - !0：方法调用失败

### ios_getVideoCaptureDevice()  

获取当前 SDK 正在使用的视频采集设备信息

**类型**

  ```ts
  (deviceID: string) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"deviceID","Type":"string","Required":"是","Default":"无","Description":"视频设备 ID\n","children":[],"key":"deviceID"}]
      return (
);
```
  

**返回值**

  number
  - 0：方法调用成功
  - !0：方法调用失败


## IKTVPlayer 

类型：`class`

KTV 播放器接口。

### ios_delegate  

类型：$p_i.ByteRTCKTVPlayerDelegate

### android_setPlayerEventHandler()  

设置 KTV 播放器进度及状态回调接口。

**类型**

  ```ts
  (playerEventHandler: $p_a.IKTVPlayerEventHandler) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"playerEventHandler","Type":"$p_a.IKTVPlayerEventHandler","Required":"是","Default":"无","Description":"KTV 播放器回调类，参看 IKTVPlayerEventHandler。\n","children":[],"key":"playerEventHandler"}]
      return (
);
```
  

### playMusic()  

播放歌曲。

**注意**

  - 调用接口后，你会收到 onPlayStateChanged 回调歌曲播放状态。
  - 若音乐 ID 错误，会触发 onPlayStateChanged 回调，errorCode 为 –3023，playState 为 4。
  - 若未进房，会触发 onPlayStateChanged 回调，errorCode 为 –3022，playState 为 4。
  - 若音乐文件不存在，会触发 onPlayStateChanged 回调，errorCode 为 –3020，playState 为 4。

**类型**

  ```ts
  (musicId: string, trackType: AudioTrackType, playType: AudioPlayType) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"musicId","Type":"string","Required":"是","Default":"无","Description":"音乐 ID。
若同一 musicId 的歌曲正在播放，再次调用接口会从开始位置重新播放。若 musicId 对应的音频文件不存在会触发报错。
\n","children":[],"key":"musicId"},{"Name":"trackType","Type":"AudioTrackType","Required":"是","Default":"无","Description":"原唱伴唱类型，参看 AudioTrackType。
\n","children":[],"key":"trackType"},{"Name":"playType","Type":"AudioPlayType","Required":"是","Default":"无","Description":"音乐播放类型。参看 AudioPlayType。\n","children":[],"key":"playType"}]
      return (
);
```
  

### pauseMusic()  

暂停播放歌曲。

**注意**

  - 调用接口后，你会收到 onPlayStateChanged 回调歌曲播放状态。
  - 若音乐 ID 错误，会触发 onPlayStateChanged 回调，errorCode 为 –3023，playState 为 4。
  - 若未进房，会触发 onPlayStateChanged 回调，errorCode 为 –3022，playState 为 4。

**类型**

  ```ts
  (musicId: string) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"musicId","Type":"string","Required":"是","Default":"无","Description":"音乐 ID。\n","children":[],"key":"musicId"}]
      return (
);
```
  

### resumeMusic()  

继续播放歌曲。

**注意**

  - 调用接口后，你会收到 onPlayStateChanged 回调歌曲播放状态。
  - 若音乐 ID 错误，会触发 onPlayStateChanged 回调，errorCode 为 –3023，playState 为 4。
  - 若未进房，会触发 onPlayStateChanged 回调，errorCode 为 –3022，playState 为 4。

**类型**

  ```ts
  (musicId: string) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"musicId","Type":"string","Required":"是","Default":"无","Description":"音乐 ID。\n","children":[],"key":"musicId"}]
      return (
);
```
  

### stopMusic()  

停止播放歌曲。

**注意**

  - 调用接口后，你会收到 onPlayStateChanged 回调歌曲播放状态。
  - 若音乐 ID 错误，会触发 onPlayStateChanged 回调，errorCode 为 –3023，playState 为 4。
  - 若未进房，会触发 onPlayStateChanged 回调，errorCode 为 –3022，playState 为 4。

**类型**

  ```ts
  (musicId: string) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"musicId","Type":"string","Required":"是","Default":"无","Description":"音乐 ID。\n","children":[],"key":"musicId"}]
      return (
);
```
  

### seekMusic()  

设置音乐文件的起始播放位置。

**注意**

  - 调用本接口时音乐必须处于播放中状态。
  - 调用接口后，你会收到 onPlayStateChanged 回调歌曲播放状态。
  - 若音乐 ID 错误，会触发 onPlayStateChanged 回调，errorCode 为 –3023，playState 为 4。
  - 若未进房，会触发 onPlayStateChanged 回调，errorCode 为 –3022，playState 为 4。

**类型**

  ```ts
  (musicId: string, position: number) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"musicId","Type":"string","Required":"是","Default":"无","Description":"音乐 ID。
\n","children":[],"key":"musicId"},{"Name":"position","Type":"number","Required":"是","Default":"无","Description":"音乐起始位置，单位为毫秒，取值小于音乐文件总时长。\n","children":[],"key":"position"}]
      return (
);
```
  

### setMusicVolume()  

设置歌曲播放音量，只能在开始播放后进行设置。

**注意**

  - 调用本接口时音乐必须处于播放中状态。
  - 若设置的音量大于 400，则按最大值 400 进行调整；若设置的音量小于 0，则按最小值 0 进行调整。
  - 若音乐 ID 错误，会触发 onPlayStateChanged 回调，errorCode 为 –3023，playState 为 4。
  - 若未进房，会触发 onPlayStateChanged 回调，errorCode 为 –3022，playState 为 4。

**类型**

  ```ts
  (musicId: string, volume: number) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"musicId","Type":"string","Required":"是","Default":"无","Description":"音乐 ID。
\n","children":[],"key":"musicId"},{"Name":"volume","Type":"number","Required":"是","Default":"无","Description":"歌曲播放音量，调节范围：[0,400]。
\n0：静音。
\n100：原始音量。\n                - 400: 原始音量的 4 倍(自带溢出保护)。\n\n","children":[],"key":"volume"}]
      return (
);
```
  

### switchAudioTrackType()  

切换歌曲原唱伴唱。

**注意**

  调用本接口时音乐必须处于播放中状态。

**类型**

  ```ts
  (musicId: string) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"musicId","Type":"string","Required":"是","Default":"无","Description":"音乐 ID。\n","children":[],"key":"musicId"}]
      return (
);
```
  

### setMusicPitch()  

对播放中的音乐设置升降调信息。

**注意**

  - 调用本接口时音乐必须处于播放中状态。
  - 若设置的 pitch 大于 12，则按最大值 12 进行调整；若设置的 pitch 小于 –12，，则按最小值 –12 进行调整。
  - 若音乐 ID 错误，会触发 onPlayStateChanged 回调，errorCode 为 –3023，playState 为 4。
  - 若未进房，会触发 onPlayStateChanged 回调，errorCode 为 –3022，playState 为 4。

**类型**

  ```ts
  (musicId: string, pitch: number) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"musicId","Type":"string","Required":"是","Default":"无","Description":"音乐 ID。
\n","children":[],"key":"musicId"},{"Name":"pitch","Type":"number","Required":"是","Default":"无","Description":"相对于音乐文件原始音调的升高/降低值，取值范围 [-12，12]，默认值为 0，即不做调整。
取值范围内每相邻两个值的音高距离相差半音，正值表示升调，负值表示降调，设置的绝对值越大表示音调升高或降低越多。\n","children":[],"key":"pitch"}]
      return (
);
```
  


## IVideoEffect 

类型：`class`

高级视频特效，参看[集成指南](https://www.volcengine.com/docs/6348/114717)。

### initCVResource()  

检查视频特效证书，设置算法模型路径，并初始化特效模块。

**类型**

  ```ts
  (licenseFile: string, algoModelDir: string) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"licenseFile","Type":"string","Required":"是","Default":"无","Description":"证书文件的绝对路径，用于鉴权。
\n","children":[],"key":"licenseFile"},{"Name":"algoModelDir","Type":"string","Required":"是","Default":"无","Description":"算法模型绝对路径，即存放特效 SDK 所有算法模型的目录。\n","children":[],"key":"algoModelDir"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - –1000: 未集成特效 SDK。
  - –1002: 特效 SDK 版本不兼容。
  - < 0: 调用失败，错误码对应具体描述参看 [错误码表](https://www.volcengine.com/docs/6705/102042)。

### enableVideoEffect()  

开启高级美颜、滤镜等视频特效。

**注意**

  - 调用本方法前，必须先调用 initCVResource 进行初始化。
  - 调用该方法后，特效不直接生效，你还需调用 setEffectNodes 设置视频特效素材包或调用 setColorFilter 设置滤镜。
  - 调用 disableVideoEffect 关闭视频特效。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  - 0: 调用成功。
  - –1000: 未集成特效 SDK。
  - –1001: 特效 SDK 不支持该功能。
  - –1002: 特效 SDK 版本不兼容。
  - < 0: 调用失败，错误码对应具体描述参看 [错误码表](https://www.volcengine.com/docs/6705/102042)。

### disableVideoEffect()  

关闭视频特效。

**注意**

  调用 enableVideoEffect 开启视频特效。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  - 0: 调用成功。
  - –1000: 未集成特效 SDK。
  - –1001: 特效 SDK 不支持该功能。
  - –1002: 特效 SDK 版本不兼容。
  - < 0: 调用失败，错误码对应具体描述参看 [错误码表](https://www.volcengine.com/docs/6705/102042)。

### setEffectNodes()  

设置视频特效素材包。

**注意**

  调用本方法前，必须先调用 enableVideoEffect。

**类型**

  ```ts
  (effectNodes: Array) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"effectNodes","Type":"string[]","Required":"是","Default":"无","Description":"特效素材包绝对路径数组。
要取消当前视频特效，将此参数设置为 null。\n","children":[],"key":"effectNodes"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - –1000: 未集成特效 SDK。
  - –1001: 特效 SDK 不支持该功能。
  - –1002: 特效 SDK 版本不兼容。
  - < 0: 调用失败，错误码对应具体描述参看 [错误码表](https://www.volcengine.com/docs/6705/102042)。

### updateEffectNode()  

设置特效强度。

**类型**

  ```ts
  (effectNode: string, key: string, value: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"effectNode","Type":"string","Required":"是","Default":"无","Description":"特效素材包绝对路径，参考素材包结构说明。
\n","children":[],"key":"effectNode"},{"Name":"key","Type":"string","Required":"是","Default":"无","Description":"需要设置的素材 key 名称，参考素材 key 对应说明。
\n","children":[],"key":"key"},{"Name":"value","Type":"number","Required":"是","Default":"无","Description":"特效强度值，取值范围 [0,1]，超出范围时设置无效。\n","children":[],"key":"value"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - –1000: 未集成特效 SDK。
  - –1001: 特效 SDK 不支持该功能。
  - –1002: 特效 SDK 版本不兼容。
  - < 0: 调用失败，错误码对应具体描述参看 [错误码表](https://www.volcengine.com/docs/6705/102042)。

### setColorFilter()  

设置颜色滤镜。

**注意**

  调用 setColorFilterIntensity 设置已启用颜色滤镜的强度。设置强度为 0 时即关闭颜色滤镜。

**类型**

  ```ts
  (filterRes: string) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"filterRes","Type":"string","Required":"是","Default":"无","Description":"滤镜资源包绝对路径。\n","children":[],"key":"filterRes"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - –1000: 未集成特效 SDK。
  - –1001: 特效 SDK 不支持该功能。
  - –1002: 特效 SDK 版本不兼容。
  - < 0: 调用失败，错误码对应具体描述参看 [错误码表](https://www.volcengine.com/docs/6705/102042)。

### setColorFilterIntensity()  

设置已启用颜色滤镜的强度。

**类型**

  ```ts
  (intensity: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"intensity","Type":"number","Required":"是","Default":"无","Description":"滤镜强度。取值范围 [0,1]，超出范围时设置无效。
当设置滤镜强度为 0 时即关闭颜色滤镜。\n","children":[],"key":"intensity"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - –1000: 未集成特效 SDK。
  - –1001: 特效 SDK 不支持该功能。
  - –1002: 特效 SDK 版本不兼容。
  - < 0: 调用失败，错误码对应具体描述参看 [错误码表](https://www.volcengine.com/docs/6705/102042)。

### enableVirtualBackground()  

将摄像头采集画面中的人像背景替换为指定图片或纯色背景。

**注意**

  - 调用本方法前，必须先调用 initCVResource 进行初始化。
  - 调用 disableVirtualBackground 关闭虚拟背景。

**类型**

  ```ts
  (backgroundStickerRes: string, source: VirtualBackgroundSource) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"backgroundStickerRes","Type":"string","Required":"是","Default":"无","Description":"背景贴纸特效素材绝对路径。
\n","children":[],"key":"backgroundStickerRes"},{"Name":"source","Type":"VirtualBackgroundSource","Required":"是","Default":"无","Description":"背景贴纸对象，参看 VirtualBackgroundSource。\n","children":[],"key":"source"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - –1000: 未集成特效 SDK。
  - –1001: 特效 SDK 不支持该功能。
  - –1002: 特效 SDK 版本不兼容。
  - < 0: 调用失败，错误码对应具体描述参看 [错误码表](https://www.volcengine.com/docs/6705/102042)。

### disableVirtualBackground()  

关闭虚拟背景。

**注意**

  调用 enableVirtualBackground 开启虚拟背景后，可以调用此接口关闭虚拟背景。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  - 0: 调用成功。
  - –1000: 未集成特效 SDK。
  - –1001: 特效 SDK 不支持该功能。
  - –1002: 特效 SDK 版本不兼容。
  - < 0: 调用失败，错误码对应具体描述参看 [错误码表](https://www.volcengine.com/docs/6705/102042)。

### enableFaceDetection()  

开启人脸识别功能，并设置人脸检测结果回调观察者。
此观察者后，你会周期性收到 onFaceDetectResult 回调。

**类型**

  ```ts
  (observer: IFaceDetectionObserver, intervalMs: number, faceModelPath: string) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"observer","Type":"IFaceDetectionObserver","Required":"是","Default":"无","Description":"人脸检测结果回调观察者，参看 IFaceDetectionObserver。
\n","children":[],"key":"observer"},{"Name":"intervalMs","Type":"number","Required":"是","Default":"无","Description":"两次回调之间的最小时间间隔，必须大于 0，单位为毫秒。实际收到回调的时间间隔大于 interval_ms，小于 interval_ms+视频采集帧间隔。
\n","children":[],"key":"intervalMs"},{"Name":"faceModelPath","Type":"string","Required":"是","Default":"无","Description":"人脸检测算法模型文件路径，一般为 ttfacemodel 文件夹中 tt_face_vXXX.model 文件的绝对路径。\n","children":[],"key":"faceModelPath"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - –1000: 未集成特效 SDK。
  - –1001: 特效 SDK 不支持该功能。
  - –1002: 特效 SDK 版本不兼容。
  - -1004: 初始化中，初始化完成后启动此功能。
  - < 0: 调用失败，错误码对应具体描述参看 [错误码表](https://www.volcengine.com/docs/6705/102042)。

### disableFaceDetection()  

关闭人脸识别功能。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  - 0: 调用成功。
  - –1000: 未集成特效 SDK。
  - –1001: 特效 SDK 不支持该功能。
  - –1002: 特效 SDK 版本不兼容。
  - < 0: 调用失败，错误码对应具体描述参看 [错误码表](https://www.volcengine.com/docs/6705/102042)。


## RTCVideo 

类型：`class`

RTCVideo Class

### new RTCVideo()

**类型**

  ```ts
  constructor(...args: any[])
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"...args","Type":"any[]","Required":"是","Default":"无","Description":"-","children":[],"key":"...args"}]
      return (
);
```
  

### setRtcVideoEventHandler()  

设置引擎事件回调的接收类，必须继承自 IRTCVideoEventHandler 。

**注意**

  请勿直接在回调函数的实现中直接进行操作。
  - 调用方需要自行实现一个继承自 IRTCVideoEventHandler 的类，并重载其中需要关注的事件。
  - 该回调为异步回调
  - 所有的事件回调均会在独立的回调线程内触发，请接收回调事件时注意所有与线程运行环境有关的操作，如需要在 UI 线程内执行的操作等，

**类型**

  ```ts
  (engineEventHandler: RTCVideoEventHandler) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"engineEventHandler","Type":"RTCVideoEventHandler","Required":"是","Default":"无","Description":"事件处理器接口类，详见 IRTCVideoEventHandler 。\n","children":[],"key":"engineEventHandler"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### android_getAudioDeviceManager()  

获取音频设备管理接口

**类型**

  ```ts
  () => $p_a.IRTCAudioDeviceManager
  ```

**返回值**

  $p_a.IRTCAudioDeviceManager  音频设备管理接口 IRTCAudioDeviceManager

### startVideoCapture()  

立即开启内部视频采集。默认为关闭状态。
内部视频采集指：使用 RTC SDK 内置视频采集模块，进行采集。
调用该方法后，本地用户会收到 onVideoDeviceStateChanged 的回调。
本地用户在可见状态下调用该方法后，房间中的其他用户会收到 onUserStartVideoCapture 的回调。

**注意**

  - 自 v3.37.0 版本，使用本接口需要在 Gradle 里引入 Kotlin。
  - 调用 stopVideoCapture 可以停止内部视频采集。否则，只有当销毁引擎实例时，内部视频采集才会停止。
  - 创建引擎后，无论是否发布视频数据，你都可以调用该方法开启内部视频采集。只有当（内部或外部）视频采集开始以后视频流才会发布。
  - 如果需要从自定义视频采集切换为内部视频采集，你必须先停止发布流，关闭自定义采集，再调用此方法手动开启内部采集。
  - 内部视频采集使用的摄像头由 switchCamera 接口指定。
  - 你还可以联系技术支持人员，帮助你在服务端配置采集格式并下发到 Android 端。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### stopVideoCapture()  

立即关闭内部视频采集。默认为关闭状态。
内部视频采集指：使用 RTC SDK 内置视频采集模块，进行采集。
调用该方法，本地用户会收到 onVideoDeviceStateChanged 的回调。
可见用户进房后调用该方法，房间中的其他用户会收到 onUserStopVideoCapture 的回调。

**注意**

  - 调用 startVideoCapture 可以开启内部视频采集。
  - 如果不调用本方法停止内部视频采集，则只有当销毁引擎实例时，内部视频采集才会停止。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### startAudioCapture()  

开启内部音频采集。默认为关闭状态。
内部采集是指：使用 RTC SDK 内置的音频采集机制进行音频采集。
调用该方法开启后，本地用户会收到 [onAudioDeviceStateChanged](1390576#rtcvideoeventhandler-onaudiodevicestatechanged) 的回调。
可见用户进房后调用该方法，房间中的其他用户会收到 onUserStartAudioCapture 的回调。

**注意**

  - 若未取得当前设备的麦克风权限，调用该方法后会触发 [onAudioDeviceStateChanged](1390576#rtcvideoeventhandler-onaudiodevicestatechanged) 回调，对应的错误码为 `MediaDeviceError.MEDIA_DEVICE_ERROR_NOPERMISSION = 1`。
  - 调用 stopAudioCapture 可以关闭音频采集设备，否则，SDK 只会在销毁引擎的时候自动关闭设备。
  - 由于不同硬件设备初始化响应时间不同，频繁调用 stopAudioCapture 和本接口闭麦/开麦可能出现短暂无声问题，建议使用 [publishStream](#rtcroom-publishstream)/unpublishStream unpublishStream 实现临时闭麦和重新开麦。
  - 创建引擎后，无论是否发布音频数据，你都可以调用该方法开启音频采集，并且调用后方可发布音频。
  - 如果需要从自定义音频采集切换为内部音频采集，你必须先停止发布流，调用 setAudioSourceType 关闭自定义采集，再调用此方法手动开启内部采集。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### stopAudioCapture()  

立即关闭内部音频采集。默认为关闭状态。
内部采集是指：使用 RTC SDK 内置的音频采集机制进行音频采集。
调用该方法，本地用户会收到 [onAudioDeviceStateChanged](1390576#rtcvideoeventhandler-onaudiodevicestatechanged) 的回调。
可见用户进房后调用该方法，房间中的其他用户会收到 onUserStopAudioCapture 的回调。

**注意**

  - 调用 startAudioCapture 可以开启内部音频采集设备。
  - 如果不调用本方法停止内部音频采集，则只有当销毁引擎实例时，内部音频采集才会停止。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### setAudioScenario()  

设置音频场景类型。
你可以根据你的应用所在场景，选择合适的音频场景类型。
选择音频场景后，SDK 会自动根据客户端音频采集播放设备和状态，适用通话音量/媒体音量，并同步变更对应音频相关的算法配置和采集配置。

**注意**

  - 建议在加入房间和调用音频相关接口之前，调用此接口设置音频场景类型。如果在此之后调用此接口，可能会引入音频卡顿。
  - 通话音量更适合通话、会议等对信息准确度更高的场景。通话音量会激活系统硬件信号处理，使通话声音更清晰。同时，音量无法降低到 0。
  - 媒体音量更适合娱乐场景，因其声音的表现力会更强。媒体音量下，最低音量可以为 0。

**类型**

  ```ts
  (audioScenario: AudioScenarioType) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"audioScenario","Type":"AudioScenarioType","Required":"是","Default":"无","Description":"音频场景类型，参看 AudioScenarioType。\n","children":[],"key":"audioScenario"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### setAudioProfile()  

设置音质档位。
当所选的 [ChannelProfile](1390578#channelprofile) 中的音频参数无法满足你的场景需求时，调用本接口切换的音质档位。

**注意**

  - 该方法在进房前后均可调用；
  - 支持通话过程中动态切换音质档位。

**类型**

  ```ts
  (audioProfile: AudioProfileType) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"audioProfile","Type":"AudioProfileType","Required":"是","Default":"无","Description":"音质档位，参看 AudioProfileType\n","children":[],"key":"audioProfile"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### setAnsMode()  

支持根据业务场景，设置通话中的音频降噪模式。

**注意**

  - 该接口进房前后均可调用，可重复调用，仅最后一次调用生效。
  - 降噪算法包含传统降噪和 AI 降噪。传统降噪主要是抑制平稳噪声，比如空调声、风扇声等。而 AI 降噪主要是抑制非平稳噪声，比如键盘敲击声、桌椅碰撞声等。
  - 在 V3.57.1 之前的版本，只有以下 [ChannelProfile](1390578#channelprofile) 场景时，调用本接口可以开启 AI 降噪。其余场景的 AI 降噪不会生效。
           -  游戏语音模式： `CHANNEL_PROFILE_GAME(2)`
           -  高音质游戏模式： `CHANNEL_PROFILE_GAME_HD(8)`
           -  云游戏模式： `CHANNEL_PROFILE_CLOUD_GAME(3)`
           -  1 vs 1 音视频通话： `CHANNEL_PROFILE_CHAT(5)`
           -  多端同步播放音视频： `CHANNEL_PROFILE_LW_TOGETHER(7)`
           -  云端会议中的个人设备： `CHANNEL_PROFIEL_MEETING`
           -  课堂互动模式： `CHANNEL_PROFILE_MEETING_ROOM(17)`
           -  云端会议中的会议室终端： `CHANNEL_PROFILE_CLASSROOM(18)`

**类型**

  ```ts
  (ansMode: AnsMode) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"ansMode","Type":"AnsMode","Required":"是","Default":"无","Description":"降噪模式。具体参见 AnsMode。\n","children":[],"key":"ansMode"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### setVoiceChangerType()  

设置变声特效类型

**注意**

  - 如需使用该功能，需集成 SAMI 动态库，详情参看[按需集成插件](#1108726)文档。
  - 在进房前后都可设置。
  - 对 RTC SDK 内部采集的音频和自定义采集的音频都生效。
  - 只对单声道音频生效。
  - 与 setVoiceReverbType 互斥，后设置的特效会覆盖先设置的特效。

**类型**

  ```ts
  (voiceChanger: VoiceChangerType) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"voiceChanger","Type":"VoiceChangerType","Required":"是","Default":"无","Description":"变声特效类型，参看 VoiceChangerType\n","children":[],"key":"voiceChanger"}]
      return (
);
```
  

**返回值**

  number  方法调用结果：
  - 0：成功；
  - <0：失败。具体失败原因参看 [ReturnStatus](1390578#returnstatus)。

### setVoiceReverbType()  

设置混响特效类型

**注意**

  - 在进房前后都可设置。
  - 对 RTC SDK 内部采集的音频和自定义采集的音频都生效。
  - 只对单声道音频生效。
  - 与 setVoiceChangerType 互斥，后设置的特效会覆盖先设置的特效。

**类型**

  ```ts
  (voiceReverb: VoiceReverbType) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"voiceReverb","Type":"VoiceReverbType","Required":"是","Default":"无","Description":"混响特效类型，参看 VoiceReverbType\n","children":[],"key":"voiceReverb"}]
      return (
);
```
  

**返回值**

  number  方法调用结果：
  - 0：成功；
  - <0：失败。具体失败原因参看 [ReturnStatus](1390578#returnstatus)。

### setLocalVoiceEqualization()  

设置本地采集语音的均衡效果。包含内部采集和外部采集，但不包含混音音频文件。

**注意**

  根据奈奎斯特采样率，音频采样率必须大于等于设置的中心频率的两倍，否则，设置不生效。

**类型**

  ```ts
  (voiceEqualizationConfig: VoiceEqualizationConfig) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"voiceEqualizationConfig","Type":"VoiceEqualizationConfig","Required":"是","Default":"无","Description":"语音均衡效果，参看 VoiceEqualizationConfig\n","children":[],"key":"voiceEqualizationConfig"}]
      return (
);
```
  

**返回值**

  number
  - 0： 成功。
  - < 0： 失败。

### setLocalVoiceReverbParam()  

设置本地采集音频的混响效果。包含内部采集和外部采集，但不包含混音音频文件。

**注意**

  调用 enableLocalVoiceReverb 开启混响效果。

**类型**

  ```ts
  (config: VoiceReverbConfig) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"config","Type":"VoiceReverbConfig","Required":"是","Default":"无","Description":"混响效果，参看 VoiceReverbConfig\n","children":[],"key":"config"}]
      return (
);
```
  

**返回值**

  number
  - 0： 成功。
  - < 0： 失败。

### enableLocalVoiceReverb()  

开启本地音效混响效果

**注意**

  调用 setLocalVoiceReverbParam 设置混响效果。

**类型**

  ```ts
  (enable: boolean) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"enable","Type":"boolean","Required":"是","Default":"无","Description":"是否开启\n","children":[],"key":"enable"}]
      return (
);
```
  

**返回值**

  number
  - 0： 成功。
  - < 0： 失败。

### setLocalVideoCanvas()  

设置本地视频渲染时使用的视图，并设置渲染模式。

**注意**

  - 你应在加入房间前，绑定本地视图。退出房间后，此设置仍然有效。
  - 如果需要解除绑定，你可以调用本方法传入空视图。

**类型**

  ```ts
  (streamIndex: StreamIndex, videoCanvas: VideoCanvas) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"streamIndex","Type":"StreamIndex","Required":"是","Default":"无","Description":"视频流属性, 参看 StreamIndex
\n","children":[],"key":"streamIndex"},{"Name":"videoCanvas","Type":"VideoCanvas","Required":"是","Default":"无","Description":"视图信息和渲染模式, 参看 VideoCanvas\n","children":[],"key":"videoCanvas"}]
      return (
);
```
  

**返回值**

  number
  - 0: 成功
  - -1: videoCanvas 为空

### updateLocalVideoCanvas()  

修改本地视频渲染模式和背景色。

**注意**

  你可以在本地视频渲染过程中，调用此接口。调用结果会实时生效。

**类型**

  ```ts
  (streamIndex: StreamIndex, renderMode: RenderMode, backgroundColor: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"streamIndex","Type":"StreamIndex","Required":"是","Default":"无","Description":"视频流属性。参看 StreamIndex
\n","children":[],"key":"streamIndex"},{"Name":"renderMode","Type":"RenderMode","Required":"是","Default":"无","Description":"渲染模式。参看 VideoCanvas.renderMode
\n","children":[],"key":"renderMode"},{"Name":"backgroundColor","Type":"number","Required":"是","Default":"无","Description":"背景颜色。参看 VideoCanvas.backgroundColor\n","children":[],"key":"backgroundColor"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### updateRemoteStreamVideoCanvas()  

使用 SDK 内部渲染时，修改远端视频帧的渲染设置，包括渲染模式、背景颜色和旋转角度。

**注意**

  - 调用 setRemoteVideoCanvas 设置了远端视频渲染模式后，你可以调用此接口更新渲染模式、背景颜色、旋转角度的设置。
  - 该接口可以在远端视频渲染过程中调用，调用结果会实时生效。

**类型**

  ```ts
  (streamKey: RemoteStreamKey, remoteVideoRenderConfig: RemoteVideoRenderConfig) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"streamKey","Type":"RemoteStreamKey","Required":"是","Default":"无","Description":"远端流信息。参看 RemoteStreamKey。
\n","children":[],"key":"streamKey"},{"Name":"remoteVideoRenderConfig","Type":"RemoteVideoRenderConfig","Required":"是","Default":"无","Description":"视频帧渲染设置。具体参看 RemoteVideoRenderConfig。\n","children":[],"key":"remoteVideoRenderConfig"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### setRemoteVideoCanvas()  

渲染来自指定远端用户的视频流时，设置使用的视图和渲染模式。
要解除绑定，将 `videoCanvas` 设置为空。

**注意**

  本地用户离开房间时，会解除调用此 API 建立的绑定关系；远端用户离开房间则不会影响。

**类型**

  ```ts
  (streamKey: RemoteStreamKey, videoCanvas: VideoCanvas) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"streamKey","Type":"RemoteStreamKey","Required":"是","Default":"无","Description":"远端流信息。参看 RemoteStreamKey
\n","children":[],"key":"streamKey"},{"Name":"videoCanvas","Type":"VideoCanvas","Required":"是","Default":"无","Description":"视图信息和渲染模式，参看 VideoCanvas。3.56 版本起支持通过 renderRotation 设置远端视频渲染的旋转角度。\n","children":[],"key":"videoCanvas"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### setRemoteVideoSuperResolution()  

设置远端视频超分模式。

**注意**

  - 该功能仅 arm 架构支持。
  - 该方法须进房后调用。
  - 远端用户视频流的原始分辨率不能超过 640 × 360 px。
  - 支持对一路远端流开启超分，不支持对多路流开启超分。

**类型**

  ```ts
  (streamKey: RemoteStreamKey, mode: VideoSuperResolutionMode) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"streamKey","Type":"RemoteStreamKey","Required":"是","Default":"无","Description":"远端流信息，用于指定需要设置超分的视频流来源及属性，参看 RemoteStreamKey。
\n","children":[],"key":"streamKey"},{"Name":"mode","Type":"VideoSuperResolutionMode","Required":"是","Default":"无","Description":"超分模式，参看 VideoSuperResolutionMode。\n","children":[],"key":"mode"}]
      return (
);
```
  

**返回值**

  number
  - 0: RETURN_STATUS_SUCCESS，SDK 调用成功，并不代表超分模式实际状态，需要根据回调 onRemoteVideoSuperResolutionModeChanged 判断实际状态。
  - -1: RETURN_STATUS_NATIVE_IN_VALID，native library 未加载。
  - -2: RETURN_STATUS_PARAMETER_ERR，参数非法，指针为空或字符串为空。
  - -9: RETURN_STATUS_SCREEN_NOT_SUPPORT，不支持对屏幕流开启超分。

### android_setVideoDenoiser()  

设置视频降噪模式。

**注意**

  该功能仅 arm 架构支持。

**类型**

  ```ts
  (mode: $p_a.VideoDenoiseMode) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"mode","Type":"$p_a.VideoDenoiseMode","Required":"是","Default":"无","Description":"视频降噪模式。参看 VideoDenoiseMode。\n","children":[],"key":"mode"}]
      return (
);
```
  

**返回值**

  number
  - 0: API 调用成功。 用户可以根据回调函数 onVideoDenoiseModeChanged 判断视频降噪是否开启。
  - < 0: API 调用失败。

### setLocalVideoMirrorType()  

为采集到的视频流开启镜像

**注意**

  - 切换视频源不影响镜像设置。
  - 屏幕视频流始终不受镜像设置影响。
  - 使用外部渲染器时，`mirrorType` 支持设置为 `0`（无镜像）和 `3`（本地预览和编码传输镜像），不支持设置为 `1`（本地预览镜像）。
  - 该接口调用前，各视频源的初始状态如下：
  

  前置摄像头 后置摄像头 自定义采集视频源  桌面端摄像头  
  移动端 本地预览镜像，编码传输不镜像  本地预览不镜像，编码传输不镜像  本地预览不镜像，编码传输不镜像 /
  桌面端 / /  本地预览不镜像，编码传输不镜像  本地预览镜像，编码传输不镜像 
  


**类型**

  ```ts
  (mirrorType: MirrorType) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"mirrorType","Type":"MirrorType","Required":"是","Default":"无","Description":"镜像类型，参看 MirrorType\n","children":[],"key":"mirrorType"}]
      return ();
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### setRemoteVideoMirrorType()  

使用内部渲染时，为远端流开启镜像。

**类型**

  ```ts
  (remoteStreamKey: RemoteStreamKey, mirrorType: RemoteMirrorType) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"remoteStreamKey","Type":"RemoteStreamKey","Required":"是","Default":"无","Description":"远端流信息，用于指定需要镜像的视频流来源及属性，参看 RemoteStreamKey。
\n","children":[],"key":"remoteStreamKey"},{"Name":"mirrorType","Type":"RemoteMirrorType","Required":"是","Default":"无","Description":"远端流的镜像类型，参看 RemoteMirrorType。\n","children":[],"key":"mirrorType"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0: 调用失败，参看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明。

### setVideoRotationMode()  

设置采集视频的旋转模式。默认以 App 方向为旋转参考系。
接收端渲染视频时，将按照和发送端相同的方式进行旋转。

**注意**

  - 旋转仅对内部视频采集生效，不适用于外部视频源和屏幕源。
  - 调用该接口时已开启视频采集，将立即生效；调用该接口时未开启视频采集，则将在采集开启后生效。
  - 更多信息请参考[视频采集方向](https://www.volcengine.com/docs/6348/106458)。

**类型**

  ```ts
  (rotationMode: VideoRotationMode) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"rotationMode","Type":"VideoRotationMode","Required":"是","Default":"无","Description":"视频旋转参考系为 App 方向或重力方向，参看 VideoRotationMode。\n","children":[],"key":"rotationMode"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### switchCamera()  

切换视频内部采集时使用的前置/后置摄像头
调用此接口后，在本地会触发 onVideoDeviceStateChanged 回调。

**注意**

  - 默认使用前置摄像头。
  - 如果你正在使用相机进行视频采集，切换操作当即生效；如果相机未启动，后续开启内部采集时，会打开设定的摄像头。

**类型**

  ```ts
  (cameraId: CameraId) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"cameraId","Type":"CameraId","Required":"是","Default":"无","Description":"摄像头 ID，参看 CameraId\n","children":[],"key":"cameraId"}]
      return (
);
```
  

**返回值**

  number
  - 0：方法调用成功
  - < 0：方法调用失败

### setAudioRoute()  

强制切换当前的音频播放路由。默认使用 setDefaultAudioRoute 中设置的音频路由。
音频播放路由发生变化时，会收到 onAudioRouteChanged 回调。

**注意**

  - 对于绝大多数音频场景，使用 setDefaultAudioRoute 设置默认音频路由，并借助 RTC SDK 的音频路由自动切换逻辑即可完成。切换逻辑参见[移动端设置音频路由](https://www.volcengine.com/docs/6348/117836)。你应仅在例外的场景下，使用此接口，比如在接入外接音频设备时，手动切换音频路由。
  - 本接口仅支持在 `AUDIO_SCENARIO_COMMUNICATION` 音频场景下使用。你可以通过调用 setAudioScenario 切换音频场景。
  - 不同音频场景中，音频路由和发布订阅状态到音量类型的映射关系详见 [AudioScenarioType](1390578#audioscenariotype) 。

**类型**

  ```ts
  (audioRoute: AudioRoute) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"audioRoute","Type":"AudioRoute","Required":"是","Default":"无","Description":"音频播放路由，参见 AudioRoute。
对 Android 设备，不同的音频设备连接状态下，可切换的音频设备情况不同。参见移动端设置音频路由。\n","children":[],"key":"audioRoute"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### getAudioRoute()  

获取当前使用的音频播放路由。

**注意**

  要设置音频路由，详见 setAudioRoute。

**类型**

  ```ts
  () => AudioRoute
  ```

**返回值**

  [AudioRoute](1390578#audioroute)  详见 [AudioRoute](1390578#audioroute)

### setDefaultAudioRoute()  

将默认的音频播放设备设置为听筒或扬声器。

**注意**

  对于音频路由切换逻辑，参见[移动端设置音频路由](https://www.volcengine.com/docs/6348/117836)。

**类型**

  ```ts
  (route: AudioRoute) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"route","Type":"AudioRoute","Required":"是","Default":"无","Description":"音频播放设备。参看 AudioRoute。仅支持听筒或扬声器。\n","children":[],"key":"route"}]
      return (
);
```
  

**返回值**

  number
  - 0: 方法调用成功。
  - < 0: 方法调用失败。

### enableExternalSoundCard()  

启用匹配外置声卡的音频处理模式

**注意**

  - 当采用外接声卡进行音频采集时，建议开启此模式，以获得更好的音质。
  - 开启此模式时，仅支持耳机播放。如果需要使用扬声器或者外置音箱播放，关闭此模式。

**类型**

  ```ts
  (enable: boolean) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"enable","Type":"boolean","Required":"是","Default":"无","Description":"true: 开启\n       - false: 不开启(默认)\n\n","children":[],"key":"enable"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### muteAudioCapture()  

设置是否将录音信号静音（不改变本端硬件）。

**注意**

  - 该方法支持选择静音或取消静音麦克风采集，而不影响 SDK 音频流发布状态。
   - 静音后通过 setCaptureVolume 调整音量不会取消静音状态，音量状态会保存至取消静音。
   - 调用 startAudioCapture 开启音频采集前后，都可以使用此接口设置采集音量。

**类型**

  ```ts
  (index: StreamIndex, mute: boolean) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"index","Type":"StreamIndex","Required":"是","Default":"无","Description":"流索引，指定调节主流/屏幕流音量，参看 StreamIndex。
\n","children":[],"key":"index"},{"Name":"mute","Type":"boolean","Required":"是","Default":"无","Description":"是否静音音频采集。
\nTrue：静音（关闭麦克风）
\nFalse：（默认）开启麦克风\n\n","children":[],"key":"mute"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。具体失败原因参看 [ReturnStatus](1390578#returnstatus)。

### setCaptureVolume()  

调节音频采集音量

**注意**

  在开启音频采集前后，你都可以使用此接口设定采集音量。

**类型**

  ```ts
  (index: StreamIndex, volume: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"index","Type":"StreamIndex","Required":"是","Default":"无","Description":"流索引，指定调节主流还是调节屏幕流的音量，参看 StreamIndex
\n","children":[],"key":"index"},{"Name":"volume","Type":"number","Required":"是","Default":"无","Description":"采集的音量值和原始音量的比值，范围是 [0, 400]，单位为 %，自带溢出保护。\n只改变音频数据的音量信息，不涉及本端硬件的音量调节。\n为保证更好的通话质量，建议将 volume 值设为 [0,100]。
\n0：静音
\n100：原始音量\n                - 400: 最大可为原始音量的 4 倍(自带溢出保护)\n\n","children":[],"key":"volume"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### setPlaybackVolume()  

调节本地播放的所有远端用户混音后的音量。
播放音频前或播放音频时，你都可以使用此接口设定播放音量。

**注意**

  假设某远端用户 A 始终在被调节的目标用户范围内，当该方法与 setRemoteAudioPlaybackVolume 或 setRemoteRoomAudioPlaybackVolume 共同使用时，本地收听用户 A 的音量将为两次设置的音量效果的叠加。

**类型**

  ```ts
  (volume: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"volume","Type":"number","Required":"是","Default":"无","Description":"音频播放音量值和原始音量的比值，范围是 [0, 400]，单位为 %，自带溢出保护。\n为保证更好的通话质量，建议将 volume 值设为 [0,100]。
\n0：静音
\n100：原始音量\n                - 400: 最大可为原始音量的 4 倍(自带溢出保护)\n\n","children":[],"key":"volume"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### setLocalVoicePitch()  

开启本地语音变调功能，多用于 K 歌场景。
使用该方法，你可以对本地语音的音调进行升调或降调等调整。

**类型**

  ```ts
  (pitch: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"pitch","Type":"number","Required":"是","Default":"无","Description":"相对于语音原始音调的升高/降低值，取值范围[-12，12]，默认值为 0，即不做调整。
取值范围内每相邻两个值的音高距离相差半音，正值表示升调，负值表示降调，设置的绝对值越大表示音调升高或降低越多。
超出取值范围则设置失败，并且会触发 onWarning 回调，提示 WarningCode 错误码为 WARNING_CODE_SET_SCREEN_STREAM_INVALID_VOICE_PITCH 设置语音音调不合法\n","children":[],"key":"pitch"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### enableVocalInstrumentBalance()  

开启/关闭音量均衡功能。
开启音量均衡功能后，人声的响度会调整为 -16lufs。如果已调用 setAudioMixingLoudness 传入了混音音乐的原始响度，此音乐播放时，响度会调整为 -20lufs。

**注意**

  该接口须在调用 startAudioMixing 开始播放音频文件之前调用。

**类型**

  ```ts
  (enable: boolean) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"enable","Type":"boolean","Required":"是","Default":"无","Description":"是否开启音量均衡功能：
\ntrue: 是
\nfalse: 否\n\n","children":[],"key":"enable"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### enablePlaybackDucking()  

打开/关闭音量闪避功能，适用于在 RTC 通话过程中会同时播放短视频或音乐的场景，如“一起看”、“在线 KTV”等。
开启该功能后，当检测到远端人声时，本地的媒体播放音量会自动减弱，从而保证远端人声的清晰可辨；当远端人声消失时，本地媒体音量会恢复到闪避前的音量水平。

**类型**

  ```ts
  (enable: boolean) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"enable","Type":"boolean","Required":"是","Default":"无","Description":"是否开启音量闪避：
\ntrue: 是
\nfalse: 否\n\n","children":[],"key":"enable"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### login()  

登陆 RTS 服务器。
必须先登录，才能调用 sendUserMessageOutsideRoom 和 sendServerMessage 发送房间外点对点消息和向应用服务器发送消息
在调用本接口登录后，如果想要登出，需要调用 logout。

**注意**

  本地用户调用此方法登录成功后，会收到 onLoginResult 回调通登录结果，远端用户不会收到通知。

**类型**

  ```ts
  (token: string, uid: string) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"token","Type":"string","Required":"是","Default":"无","Description":"用户登录必须携带的 Token，用于鉴权验证。
测试时可使用控制台生成临时 Token，roomId 填任意值。
正式上线需要使用密钥 SDK 在你的服务端生成并下发 Token，roomId 置空，Token 有效期及生成方式参看使用 Token 完成鉴权。
\n","children":[],"key":"token"},{"Name":"uid","Type":"string","Required":"是","Default":"无","Description":"用户 ID
用户 ID 在 appid 的维度下是唯一的。\n","children":[],"key":"uid"}]
      return (
);
```
  

**返回值**

  number
  - 0：成功；
  - <0：失败。具体失败原因参看 [ReturnStatus](1390578#returnstatus)。

### logout()  

登出 RTS 服务器。
调用本接口登出后，无法调用房间外消息以及端到服务器消息相关的方法或收到相关回调。

**注意**

  - 调用本接口登出后，必须先调用 login 登录。
  - 本地用户调用此方法登出后，会收到 onLogout 回调通知结果，远端用户不会收到通知。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### updateLoginToken()  

更新用户用于登录的 Token
Token 有一定的有效期，当 Token 过期时，需调用此方法更新登录的 Token 信息。
调用 login 方法登录时，如果使用了过期的 Token 将导致登录失败，并会收到 onLoginResult 回调通知，错误码为 `LOGIN_ERROR_CODE_INVALID_TOKEN`。此时需要重新获取 Token，并调用此方法更新 Token。

**注意**

  - 如果 Token 无效导致登录失败，则调用此方法更新 Token 后，SDK 会自动重新登录，而用户不需要自己调用 login 方法。
  - Token 过期时，如果已经成功登录，则不会受到影响。Token 过期的错误会在下一次使用过期 Token 登录时，或因本地网络状况不佳导致断网重新登录时通知给用户。

**类型**

  ```ts
  (token: string) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"token","Type":"string","Required":"是","Default":"无","Description":"更新的动态密钥\n","children":[],"key":"token"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### setServerParams()  

设置应用服务器参数
客户端调用 sendServerMessage 或 sendServerBinaryMessage 发送消息给应用服务器之前，必须需要设置有效签名和应用服务器地址。

**注意**

  - 用户必须调用 login 登录后，才能调用本接口。
  - 调用本接口后，SDK 会使用 onServerParamsSetResult 返回相应结果。

**类型**

  ```ts
  (signature: string, url: string) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"signature","Type":"string","Required":"是","Default":"无","Description":"动态签名，应用服务器可使用该签名验证消息来源。
签名需自行定义，可传入任意非空字符串，建议将 uid 等信息编码为签名。
设置的签名会以 post 形式发送至通过本方法中 url 参数设置的应用服务器地址。
\n","children":[],"key":"signature"},{"Name":"url","Type":"string","Required":"是","Default":"无","Description":"应用服务器的地址\n","children":[],"key":"url"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### getPeerOnlineStatus()  

查询对端用户或本端用户的登录状态

**注意**

  - 必须调用 login 登录后，才能调用本接口。
  - 调用本接口后，SDK 会使用 onGetPeerOnlineStatus 回调通知查询结果。
  - 在发送房间外消息之前，用户可以通过本接口了解对端用户是否登录，从而决定是否发送消息。也可以通过本接口查询自己查看自己的登录状态。

**类型**

  ```ts
  (peerUserID: string) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"peerUserID","Type":"string","Required":"是","Default":"无","Description":"需要查询的用户 ID\n","children":[],"key":"peerUserID"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### sendUserMessageOutsideRoom()  

给房间外指定的用户发送文本消息（P2P）

**注意**

  - 在发送房间外文本消息前，必须先调用 login 完成登录。
  - 用户调用本接口发送文本信息后，会收到一次 onUserMessageSendResultOutsideRoom 回调，得知消息是否成功发送。
  - 若文本消息发送成功，则 uid 所指定的用户会通过 onUserMessageReceivedOutsideRoom 回调收到该消息。

**类型**

  ```ts
  (uid: string, message: string, config: MessageConfig) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"uid","Type":"string","Required":"是","Default":"无","Description":"消息接收用户的 ID
\n","children":[],"key":"uid"},{"Name":"message","Type":"string","Required":"是","Default":"无","Description":"发送的文本消息内容。
消息不超过 64 KB。
\n","children":[],"key":"message"},{"Name":"config","Type":"MessageConfig","Required":"是","Default":"无","Description":"消息类型，参看 MessageConfig。\n","children":[],"key":"config"}]
      return (
);
```
  

**返回值**

  number
  - \>0：发送成功，返回这次发送消息的编号，从 1 开始递增
  - -1：发送失败，RTCVideo 实例未创建
  - -2：发送失败，uid 为空

### sendUserBinaryMessageOutsideRoom()  

给房间外指定的用户发送二进制消息（P2P）

**注意**

  - 在发送房间外二进制消息前，必须先调用 login 完成登录。
  - 用户调用本接口发送二进制消息后，会收到一次 onUserMessageSendResultOutsideRoom 回调，通知消息是否发送成功；
  - 若二进制消息发送成功，则 uid 所指定的用户会通过 onUserBinaryMessageReceivedOutsideRoom 回调收到该条消息。

**类型**

  ```ts
  (uid: string, buffer: ArrayBuffer, config: MessageConfig) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"uid","Type":"string","Required":"是","Default":"无","Description":"消息接收用户的 ID
\n","children":[],"key":"uid"},{"Name":"buffer","Type":"ArrayBuffer","Required":"是","Default":"无","Description":"发送的二进制消息内容
消息不超过 46KB。
\n","children":[],"key":"buffer"},{"Name":"config","Type":"MessageConfig","Required":"是","Default":"无","Description":"消息类型，参看 MessageConfig。\n","children":[],"key":"config"}]
      return (
);
```
  

**返回值**

  number
  - \>0：发送成功，返回这次发送消息的编号，从 1 开始递增
  - -1：发送失败，RTCVideo 实例未创建
  - -2：发送失败，uid 为空

### sendServerMessage()  

客户端给应用服务器发送文本消息（P2Server）

**注意**

  - 在向应用服务器发送文本消息前，必须先调用 login 完成登录，随后调用 setServerParams 设置应用服务器。
  - 调用本接口后会收到一次 onServerMessageSendResult 回调，通知消息发送方是否发送成功。
  - 若文本消息发送成功，则之前调用 setServerParams 设置的应用服务器会收到该条消息。

**类型**

  ```ts
  (message: string) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"message","Type":"string","Required":"是","Default":"无","Description":"发送的文本消息内容
消息不超过 64 KB。\n","children":[],"key":"message"}]
      return (
);
```
  

**返回值**

  number
  - \>0：发送成功，返回这次发送消息的编号，从 1 开始递增
  - -1：发送失败，RTCVideo 实例未创建

### sendServerBinaryMessage()  

客户端给应用服务器发送二进制消息（P2Server）

**注意**

  - 在向应用服务器发送二进制消息前，必须先调用 login 完成登录，随后调用 setServerParams 设置应用服务器。
  - 调用本接口后，会收到一次 onServerMessageSendResult 回调，通知消息发送方发送成功或失败；
  - 若二进制消息发送成功，则之前调用 setServerParams 设置的应用服务器会收到该条消息。

**类型**

  ```ts
  (buffer: ArrayBuffer) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"buffer","Type":"ArrayBuffer","Required":"是","Default":"无","Description":"发送的二进制消息内容
消息不超过 46KB。\n","children":[],"key":"buffer"}]
      return (
);
```
  

**返回值**

  number
  - \>0：发送成功，返回这次发送消息的编号，从 1 开始递增
  - -1：发送失败，RTCVideo 实例未创建

### startNetworkDetection()  

开启通话前网络探测

**注意**

  - 成功调用本接口后，会在 3s 内收到一次 onNetworkDetectionResult 回调，此后每 2s 收到一次该回调，通知探测结果；
  - 若探测停止，则会收到一次 onNetworkDetectionStopped 通知探测停止。

**类型**

  ```ts
  (isTestUplink: boolean, expectedUplinkBitrate: number, isTestDownlink: boolean, expectedDownlinkBitrate: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"isTestUplink","Type":"boolean","Required":"是","Default":"无","Description":"是否探测上行带宽
\n","children":[],"key":"isTestUplink"},{"Name":"expectedUplinkBitrate","Type":"number","Required":"是","Default":"无","Description":"期望上行带宽，单位：kbps
范围为 {0, [100-10000]}，其中， 0 表示由 SDK 指定最高码率。
\n","children":[],"key":"expectedUplinkBitrate"},{"Name":"isTestDownlink","Type":"boolean","Required":"是","Default":"无","Description":"是否探测下行带宽
\n","children":[],"key":"isTestDownlink"},{"Name":"expectedDownlinkBitrate","Type":"number","Required":"是","Default":"无","Description":"期望下行带宽，单位：kbps
范围为 {0, [100-10000]}，其中， 0 表示由 SDK 指定最高码率。\n","children":[],"key":"expectedDownlinkBitrate"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### stopNetworkDetection()  

停止通话前网络探测

**注意**

  - 调用本接口后，会收到一次 onNetworkDetectionStopped 回调通知探测停止。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### enableAudioFrameCallback()  

设置并开启指定的音频数据帧回调

**注意**

  开启音频回调并调用 registerAudioFrameObserver 后 会收到对应的音频回调。两者调用顺序没有限制且相互独立。

**类型**

  ```ts
  (method: AudioFrameCallbackMethod, format: AudioFormat) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"method","Type":"AudioFrameCallbackMethod","Required":"是","Default":"无","Description":"音频回调方法，参看 AudioFrameCallbackMethod。
当音频回调方法设置为 AUDIO_FRAME_CALLBACK_RECORD(0)、AUDIO_FRAME_CALLBACK_PLAYBACK(1)、AUDIO_FRAME_CALLBACK_MIXED(2)时，你需要在参数 format 中指定准确的采样率和声道，暂不支持设置为自动。
当音频回调方法设置为 AUDIO_FRAME_CALLBACK_REMOTE_USER(3)时，将 format 中的各个字段设置为默认值。
\n","children":[],"key":"method"},{"Name":"format","Type":"AudioFormat","Required":"是","Default":"无","Description":"音频参数格式，参看 AudioFormat。\n","children":[],"key":"format"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### disableAudioFrameCallback()  

关闭音频回调

**注意**

  该方法需要在调用 enableAudioFrameCallback 之后调用。

**类型**

  ```ts
  (method: AudioFrameCallbackMethod) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"method","Type":"AudioFrameCallbackMethod","Required":"是","Default":"无","Description":"音频回调方法，参看 AudioFrameCallbackMethod。\n","children":[],"key":"method"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### registerAudioFrameObserver()  

注册音频数据回调观察者。

**注意**

  注册音频数据回调观察者并调用 enableAudioFrameCallback 后 会收到对应的音频回调。对回调中收到的音频数据进行处理，不会影响 RTC 的编码发送或渲染。

**类型**

  ```ts
  (observer: IAudioFrameObserver) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"observer","Type":"IAudioFrameObserver","Required":"是","Default":"无","Description":"音频数据观察者，参看 IAudioFrameObserver。如果传入 null，则取消注册。\n","children":[],"key":"observer"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### registerAudioProcessor()  

注册自定义音频处理器。
注册完成后，你可以调用 enableAudioProcessor，对本地采集到的音频进行处理，RTC SDK 将对处理后的音频进行编码和发送。也可以对接收到的远端音频进行自定义处理，RTC SDK 将对处理后的音频进行渲染。

**注意**

  - 重复调用此接口时，仅最后一次调用生效。
  - 更多相关信息，详见[音频自定义处理](https://www.volcengine.com/docs/6348/80635)。

**类型**

  ```ts
  (processor: IAudioFrameProcessor) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"processor","Type":"IAudioFrameProcessor","Required":"是","Default":"无","Description":"自定义音频处理器，详见 IAudioFrameProcessor。
SDK 只持有 processor 的弱引用，你应保证其生命周期。需要取消注册时，设置此参数为 nullptr。\n","children":[],"key":"processor"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### setVideoDigitalZoomConfig()  

设置本地摄像头数码变焦参数，包括缩放倍数，移动步长。

**注意**

  - 每次调用本接口只能设置一种参数。如果缩放系数和移动步长都需要设置，分别调用本接口传入相应参数。
  - 由于移动步长的默认值为 `0` ，在调用 setVideoDigitalZoomControl 或 startVideoDigitalZoomControl 进行数码变焦操作前，应先调用本接口。

**类型**

  ```ts
  (type: ZoomConfigType, size: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"type","Type":"ZoomConfigType","Required":"是","Default":"无","Description":"数码变焦参数类型，缩放系数或移动步长。参看 ZoomConfigType。必填。
\n","children":[],"key":"type"},{"Name":"size","Type":"number","Required":"是","Default":"无","Description":"缩放系数或移动步长，保留到小数点后三位。默认值为 0。必填。\n选择不同 type 时有不同的取值范围。当计算后的结果超过缩放和移动边界时，取临界值。\n     ZOOM_FOCUS_OFFSET(0)：缩放系数增量，范围为 [0, 7]。例如，设置为 0.5 时，如果调用 setVideoDigitalZoomControl 选择 Zoom in，则缩放系数增加 0.5。缩放系数范围 [1，8]，默认为 1，原始大小。\n     - ZOOM_MOVE_OFFSET(1)：移动百分比，范围为 [0, 0.5]，默认为 0，不移动。如果调用 setVideoDigitalZoomControl 选择的是左右移动，则移动距离为 size x 原始视频宽度；如果选择的是上下移动，则移动距离为 size x 原始视频高度。例如，视频帧边长为 1080 px，设置为 0.5 时，实际移动距离为 0.5 x 1080 px = 540 px。","children":[],"key":"size"}]
      return (
);
```
  

**返回值**

  number
  - 0：成功。
  - !0：失败。

### setVideoDigitalZoomControl()  

控制本地摄像头数码变焦，缩放或移动一次。设置对本地预览画面和发布到远端的视频都生效。

**注意**

  - 由于默认步长为 `0`，调用该方法前需通过 setVideoDigitalZoomConfig 设置参数。
  - 调用该方法进行移动前，应先使用本方法或 startVideoDigitalZoomControl 进行放大，否则无法移动。
  - 当数码变焦操作超出范围时，将置为临界值。例如，移动到了图片边界、放大到了 8 倍、缩小到原图大小。
  - 如果你希望实现持续数码变焦操作，调用 startVideoDigitalZoomControl。
  - 如果你需要对摄像头进行光学变焦控制，参看 setCameraZoomRatio。

**类型**

  ```ts
  (direction: ZoomDirectionType) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"direction","Type":"ZoomDirectionType","Required":"是","Default":"无","Description":"数码变焦操作类型，参看 ZoomDirectionType。\n","children":[],"key":"direction"}]
      return (
);
```
  

**返回值**

  number
  - 0：成功。
  - !0：失败。

### startVideoDigitalZoomControl()  

开启本地摄像头持续数码变焦，缩放或移动。设置对本地预览画面和发布到远端的视频都生效。

**注意**

  - 由于默认步长为 `0`，调用该方法前需通过 setVideoDigitalZoomConfig 设置参数。
  - 调用该方法进行移动前，应先使用本方法或 setVideoDigitalZoomControl 进行放大，否则无法移动。
  - 当数码变焦操作超出范围时，将置为临界值并停止操作。例如，移动到了图片边界、放大到了 8 倍、缩小到原图大小。
  - 你也可以调用 stopVideoDigitalZoomControl 手动停止控制。
  - 如果你希望实现单次数码变焦操作，调用 setVideoDigitalZoomControl。
  - 如果你需要对摄像头进行光学变焦控制，参看 setCameraZoomRatio。

**类型**

  ```ts
  (direction: ZoomDirectionType) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"direction","Type":"ZoomDirectionType","Required":"是","Default":"无","Description":"数码变焦操作类型，参看 ZoomDirectionType。\n","children":[],"key":"direction"}]
      return (
);
```
  

**返回值**

  number
  - 0：成功。
  - !0：失败。

### stopVideoDigitalZoomControl()  

停止本地摄像头持续数码变焦。

**注意**

  关于开始数码变焦，参看 startVideoDigitalZoomControl。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  - 0：成功。
  - !0：失败。

### registerLocalEncodedVideoFrameObserver()  

注册本地视频帧监测器。
无论使用内部采集还是自定义采集，调用该方法后，SDK 每监测到一帧本地视频帧时，都会将视频帧信息通过 onLocalEncodedVideoFrame 回调给用户。

**注意**

  该方法可在进房前后的任意时间调用，在进房前调用可保证尽可能早地监测视频帧并触发回调

**类型**

  ```ts
  (observer: ILocalEncodedVideoFrameObserver) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"observer","Type":"ILocalEncodedVideoFrameObserver","Required":"是","Default":"无","Description":"本地频帧监测器，参看 ILocalEncodedVideoFrameObserver 。将参数设置为 null 则取消注册。\n","children":[],"key":"observer"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### registerRemoteEncodedVideoFrameObserver()  

注册远端编码后视频数据回调。
完成注册后，当 SDK 监测到远端编码后视频帧时，会触发 onRemoteEncodedVideoFrame 回调

**注意**

  - 更多自定义解码功能说明参看 [自定义视频编解码](https://www.volcengine.com/docs/6348/82921#\%E8\%87\%AA\%E5\%AE\%9A\%E4\%B9\%89\%E8\%A7\%86\%E9\%A2\%91\%E8\%A7\%A3\%E7\%A0\%81)。
  - 该方法适用于手动订阅，并且进房前后均可调用，建议在进房前调用。
  - 引擎销毁前需取消注册，调用该方法将参数设置为 "null" 即可。

**类型**

  ```ts
  (observer: IRemoteEncodedVideoFrameObserver) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"observer","Type":"IRemoteEncodedVideoFrameObserver","Required":"是","Default":"无","Description":"远端编码后视频数据监测器，参看 IRemoteEncodedVideoFrameObserver\n","children":[],"key":"observer"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### setVideoSourceType()  

设置向 SDK 输入的视频源，包括屏幕流
默认使用内部采集。内部采集指：使用 RTC SDK 内置的视频采集机制进行视频采集。

**注意**

  - 该方法进房前后均可调用。
  - 当你已调用 startVideoCapture 开启内部采集后，再调用此方法切换至自定义采集时，SDK 会自动关闭内部采集。
  - 当你调用此方法开启自定义采集后，想要切换至内部采集，你必须先调用此方法关闭自定义采集，然后调用 startVideoCapture 手动开启内部采集。
  - 当你需要向 SDK 推送自定义编码后的视频帧，你需调用该方法将视频源切换至自定义编码视频源。

**类型**

  ```ts
  (index: StreamIndex, type: VideoSourceType) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"index","Type":"StreamIndex","Required":"是","Default":"无","Description":"视频流的属性，参看 StreamIndex
\n","children":[],"key":"index"},{"Name":"type","Type":"VideoSourceType","Required":"是","Default":"无","Description":"视频输入源类型，参看 VideoSourceType\n","children":[],"key":"type"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### startPushMixedStreamToCDN()  

新增合流转推直播任务，并设置合流的图片、视频视图布局和音频属性。
同一个任务中转推多路直播流时，SDK 会先将多路流合成一路流，然后再进行转推。

**注意**

  - 在调用该接口前，你需要在[控制台](https://console.volcengine.com/rtc/cloudRTC?tab=live&from=doc)开启转推直播功能。
  - 调用该方法后，关于启动结果和推流过程中的错误，会收到 onMixingEvent 回调。
  - 如果已在[控制台](https://console.volcengine.com/rtc/cloudRTC?tab=callback&from=doc)配置了转推直播的服务端回调，调用本接口会收到 [TranscodeStarted](https://www.volcengine.com/docs/6348/75125#transcodestarted)。重复调用该接口时，第二次调用会同时触发 [TranscodeStarted](https://www.volcengine.com/docs/6348/75125#transcodestarted) 和 [TranscodeUpdated](https://www.volcengine.com/docs/6348/75125#transcodeupdated)。
  - 调用 stopPushStreamToCDN 停止转推直播。

**类型**

  ```ts
  (taskId: string, mixedConfig: MixedStreamConfig, observer: IMixedStreamObserver) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"taskId","Type":"string","Required":"是","Default":"无","Description":"转推直播任务 ID，长度不超过 126 字节。
你可以在同一房间内发起多个转推直播任务，并用不同的任务 ID 加以区分。当你需要发起多个转推直播任务时，应使用多个 ID；当你仅需发起一个转推直播任务时，建议使用空字符串。
\n","children":[],"key":"taskId"},{"Name":"mixedConfig","Type":"MixedStreamConfig","Required":"是","Default":"无","Description":"转推直播配置参数。详见 MixedStreamConfig。
\n","children":[],"key":"mixedConfig"},{"Name":"observer","Type":"IMixedStreamObserver","Required":"是","Default":"无","Description":"无效参数。请忽略。\n","children":[],"key":"observer"}]
      return (
);
```
  

**返回值**

  number  方法调用结果：
  - 0：成功；
  - !0：失败。

### updatePushMixedStreamToCDN()  

更新合流转推直播参数，会收到 onMixingEvent 回调。
使用 startPushMixedStreamToCDN 启用转推直播功能后，使用此方法更新功能配置参数。

**类型**

  ```ts
  (taskId: string, mixedConfig: MixedStreamConfig) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"taskId","Type":"string","Required":"是","Default":"无","Description":"转推直播任务 ID。指定想要更新参数设置的转推直播任务。
\n","children":[],"key":"taskId"},{"Name":"mixedConfig","Type":"MixedStreamConfig","Required":"是","Default":"无","Description":"转推直播配置参数，详见 MixedStreamConfig。除特殊说明外，均支持过程中更新。
调用时，结构体中没有传入值的属性，会被更新为默认值。\n","children":[],"key":"mixedConfig"}]
      return (
);
```
  

**返回值**

  number  方法调用结果：
  - 0：成功；
  - !0：失败。

### startPushSingleStreamToCDN()  

新增单流转推直播任务。

**注意**

  - 在调用该接口前，你需要在[控制台](https://console.volcengine.com/rtc/cloudRTC?tab=live&from=doc)开启转推直播功能。
  - 调用该方法后，关于启动结果和推流过程中的错误，会收到 onStreamPushEvent 回调。
  - 调用 stopPushStreamToCDN 停止任务。
  - 由于本功能不进行编解码，所以推到 RTMP 的视频流会根据推流端的分辨率、编码方式、关闭摄像头等变化而变化。

**类型**

  ```ts
  (taskId: string, param: PushSingleStreamParam, observer: IPushSingleStreamToCDNObserver) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"taskId","Type":"string","Required":"是","Default":"无","Description":"任务 ID。
你可以发起多个转推直播任务，并用不同的任务 ID 加以区分。当你需要发起多个转推直播任务时，应使用多个 ID；当你仅需发起一个转推直播任务时，建议使用空字符串。
\n","children":[],"key":"taskId"},{"Name":"param","Type":"PushSingleStreamParam","Required":"是","Default":"无","Description":"转推直播配置参数。详见 PushSingleStreamParam。
\n","children":[],"key":"param"},{"Name":"observer","Type":"IPushSingleStreamToCDNObserver","Required":"是","Default":"无","Description":"单流转推直播观察者。详见 IPushSingleStreamToCDNObserver。
通过注册 observer 接收单流转推直播相关的回调。\n","children":[],"key":"observer"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### stopPushStreamToCDN()  

停止转推直播。
该方法可用于停止单流转推直播或停止合流转推直播，通过 taskId 区分需要停止的任务。

**注意**

  - 关于启动单流转推直播，参看 startPushSingleStreamToCDN。
  - 关于启动合流转推直播，参看 startPushMixedStreamToCDN。

**类型**

  ```ts
  (taskId: string) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"taskId","Type":"string","Required":"是","Default":"无","Description":"任务 ID。可以指定想要停止的单流转推直播或合流转推直播任务。\n","children":[],"key":"taskId"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### setVideoCaptureConfig()  

设置 RTC SDK 内部采集时的视频采集参数。
如果你的项目使用了 SDK 内部采集模块，可以通过本接口指定视频采集参数包括模式、分辨率、帧率。

**注意**

  - 本接口在引擎创建后即可调用，建议在调用 startVideoCapture 前调用本接口。
  - 建议同一设备上的不同引擎使用相同的视频采集参数。
  - 如果调用本接口前使用内部模块开始视频采集，采集参数默认为 Auto 模式。

**类型**

  ```ts
  (videoCaptureConfig: VideoCaptureConfig) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"videoCaptureConfig","Type":"VideoCaptureConfig","Required":"是","Default":"无","Description":"视频采集参数。参看: VideoCaptureConfig。\n","children":[],"key":"videoCaptureConfig"}]
      return (
);
```
  

**返回值**

  number
  - 0: 成功
  - < 0: 失败

### enableSimulcastMode()  

该方法设置视频流发布端是否开启发布多路编码参数不同的视频流的模式。

**注意**

  - 你应在进房前或进房后但未发布流时，调用此方法。
  - 开启推送多路流后，不能动态关闭，也不能更新多路流的路数和编码参数。
  - 开启推送多路视频流模式后，你可以在发布流前调用 [setVideoEncoderConfig](#rtcvideo-setvideoencoderconfig-1) 为多路视频流分别设置编码参数。
  - 该功能关闭时，或该功能开启但未设置多路流参数时，默认只发一路视频流，该流的编码参数为：分辨率 640px × 360px，帧率 15fps。

**类型**

  ```ts
  (enabled: boolean) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"enabled","Type":"boolean","Required":"是","Default":"无","Description":"是否开启推送多路视频流模式：
\ntrue：开启
\nfalse：关闭（默认）\n\n","children":[],"key":"enabled"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### setVideoEncoderConfig()  

视频发布端设置推送多路流时各路流的参数，包括分辨率、帧率、码率、网络不佳时的回退策略等。

**注意**

  - 该方法设置的多路参数是否均生效，取决于是否同时调用了 enableSimulcastMode 开启发布多路参数不同的视频流模式。若未开启推送多路流模式，但调用本方法设置了多个分辨率，SDK 则默认发布设置的第一条流，多个分辨率的设置将会在开启推送多路流模式之后生效。
  - 若期望推送多路不同分辨率的流，你需要在发布流之前调用本方法以及 enableSimulcastMode 方法。
  - 开启推送多路流后，不能动态关闭，也不能更新多路流的路数和编码参数。
  - 调用该方法设置多路视频流参数前，SDK 默认仅发布一条分辨率为 640px × 360px，帧率为 15fps 的视频流。
  - 调用该方法设置分辨率不同的多条流后，SDK 会根据订阅端设置的期望订阅参数自动匹配发送的流，具体规则参看[推送多路流](https://www.volcengine.com/docs/6348/70139)文档。
  - 该方法适用于摄像头采集的视频流，设置屏幕共享视频流参数参看 setScreenVideoEncoderConfig。

**类型**

  ```ts
  (channelSolutions: Array) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"channelSolutions","Type":"VideoEncoderConfig[]","Required":"是","Default":"无","Description":"要推送的多路视频流的参数，最多支持设置 3 路参数，超过 3 路时默认取前 3 路的值。
当设置了多路参数时，分辨率和帧率必须是从大到小排列。需注意，所设置的分辨率是各路流的最大分辨率。参看 VideoEncoderConfig。\n","children":[],"key":"channelSolutions"}]
      return (
);
```
  

**返回值**

  number  方法调用结果：
  - 0：成功
  - !0：失败

### setScreenVideoEncoderConfig()  

为发布的屏幕共享视频流设置期望的编码参数，包括分辨率、帧率、码率、网络不佳时的回退策略等。

**注意**

  建议在采集视频前设置编码参数。若采集前未设置编码参数，则使用默认编码参数: 分辨率 1920px × 1080px，帧率 15fps。

**类型**

  ```ts
  (screenSolution: ScreenVideoEncoderConfig) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"screenSolution","Type":"ScreenVideoEncoderConfig","Required":"是","Default":"无","Description":"屏幕共享视频流参数。参看 ScreenVideoEncoderConfig。\n","children":[],"key":"screenSolution"}]
      return (
);
```
  

**返回值**

  number
  - 0：成功。
  - !0：失败。

### enableAlphaChannelVideoEncode()  

开启自定义采集视频帧的 Alpha 通道编码功能。
适用于需要分离推流端视频主体与背景，且在拉流端可自定义渲染背景的场景。

**注意**

  - 该接口仅作用于自定义采集的、并且使用 RGBA 色彩模型的视频帧，包括 VideoPixelFormat.TEXTURE_2D、VideoPixelFormat.TEXTURE_OES、VideoPixelFormat.RGBA。
  - 该接口须在发布视频流之前调用。
  - 调用本接口开启 Alpha 通道编码后，你需调用 pushExternalVideoFrame 把自定义采集的视频帧推送至 RTC SDK。若推送了不支持的视频帧格式，则调用 pushExternalVideoFrame 时会返回错误码 ReturnStatus.RETURN_STATUS_PARAMETER_ERR。

**类型**

  ```ts
  (streamIndex: StreamIndex, alphaLayout: AlphaLayout) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"streamIndex","Type":"StreamIndex","Required":"是","Default":"无","Description":"需开启该功能的视频流类型，当前仅支持对 StreamIndex.STREAM_INDEX_MAIN 即主流开启。
\n","children":[],"key":"streamIndex"},{"Name":"alphaLayout","Type":"AlphaLayout","Required":"是","Default":"无","Description":"分离后的 Alpha 通道相对于 RGB 通道信息的排列位置。当前仅支持 AlphaLayout.TOP，即置于 RGB 通道信息上方。\n","children":[],"key":"alphaLayout"}]
      return (
);
```
  

**返回值**

  number  方法调用结果：
  - 0：成功；
  - !0：失败。

### disableAlphaChannelVideoEncode()  

关闭外部采集视频帧的 Alpha 通道编码功能。

**注意**

  该接口须在停止发布视频流之后调用。

**类型**

  ```ts
  (streamIndex: StreamIndex) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"streamIndex","Type":"StreamIndex","Required":"是","Default":"无","Description":"需关闭该功能的视频流类型，当前仅支持设置为 StreamIndex.STREAM_INDEX_MAIN 即主流。\n","children":[],"key":"streamIndex"}]
      return (
);
```
  

**返回值**

  number  方法调用结果：
  - 0：成功；
  - !0：失败。

### setAudioSourceType()  

切换音频采集方式

**注意**

  - 进房前后调用此方法均有效。
  - 如果你调用此方法由内部采集切换至自定义采集，SDK 会自动关闭内部采集。然后，调用 pushExternalAudioFrame 推送自定义采集的音频数据到 RTC SDK 用于传输。
  - 如果你调用此方法由自定义采集切换至内部采集，你必须再调用 startAudioCapture 手动开启内部采集。

**类型**

  ```ts
  (type: AudioSourceType) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"type","Type":"AudioSourceType","Required":"是","Default":"无","Description":"音频数据源，详见 AudioSourceType。
默认使用内部音频采集。音频采集和渲染方式无需对应。\n","children":[],"key":"type"}]
      return (
);
```
  

**返回值**

  number  方法调用结果：
  - \>0: 切换成功。
  - -1：切换失败。

### setAudioRenderType()  

切换音频渲染方式

**注意**

  - 进房前后调用此方法均有效。
  - 如果你调用此方法切换至自定义渲染，调用 pullExternalAudioFrame 获取音频数据。

**类型**

  ```ts
  (type: AudioRenderType) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"type","Type":"AudioRenderType","Required":"是","Default":"无","Description":"音频输出类型，详见 AudioRenderType默认使用内部音频渲染。音频采集和渲染方式无需对应。\n","children":[],"key":"type"}]
      return (
);
```
  

**返回值**

  number  方法调用结果：
  - \>0: 切换成功。
  - -1：切换失败。

### pullExternalAudioFrame()  

拉取下行音频数据用于自定义音频渲染。
调用该方法后，SDK 会主动拉取待播放的音频数据，包括远端已解码和混音后的音频数据，用于外部播放。

**注意**

  - 拉取外部音频数据前，必须先调用 setAudioRenderType 启用自定义音频渲染。
  - 由于 RTC SDK 的帧长为 10 毫秒，你应当每隔 10 毫秒拉取一次音频数据。确保音频采样点数（sample）x 拉取频率等于 audioFrame 的采样率 （sampleRate）。如设置采样率为 48000 时，每 10 毫秒调用本接口拉取数据，每次应拉取 480 个采样点。
  - 音频采样格式为 S16。音频缓冲区内的数据格式为 PCM 数据，其容量大小为 audioFrame.samples × audioFrame.channel × 2。

**类型**

  ```ts
  (audioFrame: AudioFrame) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"audioFrame","Type":"AudioFrame","Required":"是","Default":"无","Description":"音频数据帧，详见 AudioFrame\n","children":[],"key":"audioFrame"}]
      return (
);
```
  

**返回值**

  number  方法调用结果
   - 0: 设置成功
   - < 0: 设置失败

### createRTCRoom()  

创建房间实例。
调用此方法仅返回一个房间实例，你仍需调用 [joinRoom](#iroom-joinroom) 才能真正地创建/加入房间。
多次调用此方法以创建多个 [RTCRoom](#rtcroom) 实例。分别调用各 RTCRoom 实例中的 [joinRoom](#iroom-joinroom) 方法，同时加入多个房间。
多房间模式下，用户可以同时订阅各房间的音视频流。

**注意**

  - 如果需要加入的房间已存在，你仍需先调用本方法来获取 RTCRoom 实例，再调用 [joinRoom](#iroom-joinroom) 加入房间。
  - 请勿使用同样的 roomId 创建多个房间，否则后创建的房间实例会替换先创建的房间实例。
  - 如果你需要在多个房间发布音视频流，无须创建多房间，直接调用 startForwardStreamToRooms 开始跨房间转发媒体流。

**类型**

  ```ts
  (roomId: string) => RTCRoom
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"roomId","Type":"string","Required":"是","Default":"无","Description":"标识通话房间的房间 ID。该字符串符合正则表达式：[a-zA-Z0-9_@\\-\\.]{1,128}。\n","children":[],"key":"roomId"}]
      return (
);
```
  

**返回值**

  [RTCRoom](#rtcroom)  创建的 [RTCRoom](#rtcroom) 房间实例。

### setPublishFallbackOption()  

设置发布的音视频流的回退选项。
你可以调用该接口设置网络不佳或设备性能不足时从大流起进行降级处理，以保证通话质量。

**注意**

  - 该方法仅在调用 enableSimulcastMode 开启了发送多路视频流的情况下生效。
  - 该方法必须在进房前设置，进房后设置或更改设置无效。
  - 调用该方法后，如因性能或网络不佳产生发布性能回退或恢复，本端会提前收到 onPerformanceAlarms 回调发出的告警，以便采集设备配合调整。
  - 设置回退后，本地发布的音视频流发生回退或从回退中恢复时，远端会收到 onSimulcastSubscribeFallback 回调，通知该情况。
  - 你可以调用客户端 API 或者在服务端下发策略设置回退。当使用服务端下发配置实现时，下发配置优先级高于在客户端使用 API 设定的配置。

**类型**

  ```ts
  (option: PublishFallbackOption) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"option","Type":"PublishFallbackOption","Required":"是","Default":"无","Description":"本地发布的音视频流回退选项，参看 PublishFallbackOption。\n","children":[],"key":"option"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### setRemoteUserPriority()  

设置用户优先级。

**注意**

  - 该方法与 setSubscribeFallbackOption 搭配使用。
  - 如果开启了订阅流回退选项，弱网或性能不足时会优先保证收到的高优先级用户的流的质量。
  - 该方法在进房前后都可以使用，可以修改远端用户的优先级。

**类型**

  ```ts
  (roomid: RemoteUserPriority, uid: string, priority: RemoteUserPriority) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"roomid","Type":"RemoteUserPriority","Required":"是","Default":"无","Description":"房间 ID
\n","children":[],"key":"roomid"},{"Name":"uid","Type":"string","Required":"是","Default":"无","Description":"远端用户的 ID 。
\n","children":[],"key":"uid"},{"Name":"priority","Type":"RemoteUserPriority","Required":"是","Default":"无","Description":"远端用户的优先级，详见枚举类型 RemoteUserPriority 。\n","children":[],"key":"priority"}]
      return (
);
```
  

**返回值**

  number
  - 0： 成功。
  - < 0： 失败。

### sendSEIMessage()  

通过视频帧发送 SEI 数据。
在视频通话场景下，SEI 数据会随视频帧发送；在语音通话场景下，SDK 会自动生成一路 16px × 16px 的黑帧视频流用来发送 SEI 数据。

**注意**

  - 每秒发送的 SEI 消息数量建议不超过当前的视频帧率。在语音通话场景下，黑帧帧率为 15 fps。
  - 语音通话场景中，仅支持在内部采集模式下调用该接口发送 SEI 数据。
  - 视频通话场景中，使用自定义采集并通过 pushExternalVideoFrame 推送至 SDK 的视频帧，若本身未携带 SEI 数据，也可通过本接口发送 SEI 数据；若原视频帧中已添加了 SEI 数据，则调用此方法不生效。
  - 视频帧仅携带前后 2s 内收到的 SEI 数据；语音通话场景下，若调用此接口后 1min 内未有 SEI 数据发送，则 SDK 会自动取消发布视频黑帧。
  - 消息发送成功后，远端会收到 onSEIMessageReceived 回调。
  - 语音通话切换至视频通话时，会停止使用黑帧发送 SEI 数据，自动转为用采集到的正常视频帧发送 SEI 数据。

**类型**

  ```ts
  (streamIndex: StreamIndex, message: ArrayBuffer, repeatCount: number, mode: SEICountPerFrame) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"streamIndex","Type":"StreamIndex","Required":"是","Default":"无","Description":"指定携带 SEI 数据的媒体流类型，参看 StreamIndex。
语音通话场景下，该值需设为 STREAM_INDEX_MAIN，否则 SEI 数据会被丢弃从而无法送达远端。
\n","children":[],"key":"streamIndex"},{"Name":"message","Type":"ArrayBuffer","Required":"是","Default":"无","Description":"SEI 消息，建议每帧 SEI 数据总长度不超过 4 KB。超过长度限制的消息会被丢弃。
\n","children":[],"key":"message"},{"Name":"repeatCount","Type":"number","Required":"是","Default":"无","Description":"消息发送重复次数。取值范围是 [0, max{29, %{视频帧率}-1}]。推荐范围 [2,4]。
调用此接口后，这些 SEI 数据会添加到从当前视频帧开始的连续 %{repeatCount}+1 个视频帧中。
\n","children":[],"key":"repeatCount"},{"Name":"mode","Type":"SEICountPerFrame","Required":"是","Default":"无","Description":"SEI 发送模式，参看 SEICountPerFrame。\n","children":[],"key":"mode"}]
      return (
);
```
  

**返回值**

  number
  - \>= 0: 将被添加到视频帧中的 SEI 的数量。
  - < 0: 发送失败。

### setBusinessId()  

设置业务标识参数
可通过 businessId 区分不同的业务场景。businessId 由客户自定义，相当于一个“标签”，可以分担和细化现在 AppId 的逻辑划分的功能，但不需要鉴权。

**注意**

  - 需要在进房前调用，进房后调用该方法无效。

**类型**

  ```ts
  (businessId: string) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"businessId","Type":"string","Required":"是","Default":"无","Description":"用户设置的自己的 businessId 值
businessId 只是一个标签，颗粒度需要用户自定义。\n","children":[],"key":"businessId"}]
      return (
);
```
  

**返回值**

  number
  - 0： 成功
  - < 0： 失败
  - -6001： 用户已经在房间中。
  - -6002： 输入非法，合法字符包括所有小写字母、大写字母和数字，除此外还包括四个独立字符，分别是：英文句号，短横线，下划线和 \@ 。

### getVideoEffectInterface()  

获取视频特效接口。

**类型**

  ```ts
  () => IVideoEffect
  ```

**返回值**

  [IVideoEffect](#ivideoeffect)  视频特效接口，参看 [IVideoEffect](#ivideoeffect)。

### enableEffectBeauty()  

开启/关闭基础美颜。

**注意**

  - 本方法不能与高级视频特效接口共用。如已购买高级视频特效，建议参看[集成指南](https://www.volcengine.com/docs/6348/114717)使用高级美颜、特效、贴纸功能等。
  - 使用此功能需要集成特效 SDK，建议使用特效 SDK v4.4.2+ 版本。更多信息参看 [Native 端基础美颜](https://www.volcengine.com/docs/6348/372605)。
  - 调用 setBeautyIntensity 设置基础美颜强度。若在调用本方法前没有设置美颜强度，则使用默认强度。各基础美颜模式的强度默认值分别为：美白 0.7，磨皮 0.8，锐化 0.5，清晰 0.7。
  - 本方法仅适用于视频源，不适用于屏幕源。

**类型**

  ```ts
  (enable: boolean) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"enable","Type":"boolean","Required":"是","Default":"无","Description":"基础美颜开关
\ntrue: 开启基础美颜
\nfalse: 关闭基础美颜（默认）\n\n","children":[],"key":"enable"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - –1000: 未集成特效 SDK。
  - –1001: RTC SDK 版本不支持此功能。
  - –1002: 特效 SDK 当前版本不支持此功能，建议使用特效 SDK v4.4.2+ 版本。
  - –1003: 联系技术支持人员。
  - –1004: 正在下载相关资源，下载完成后生效。
  - <0: 调用失败，特效 SDK 内部错误，具体错误码请参考[错误码表](https://www.volcengine.com/docs/6705/102042)。

### setBeautyIntensity()  

调整基础美颜强度

**注意**

  - 若在调用 enableEffectBeauty 前设置美颜强度，则对应美颜功能的强度初始值会根据设置更新。
  - 销毁引擎后，美颜功能强度恢复默认值。

**类型**

  ```ts
  (beautyMode: EffectBeautyMode, intensity: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"beautyMode","Type":"EffectBeautyMode","Required":"是","Default":"无","Description":"基础美颜模式，参看 EffectBeautyMode。
\n","children":[],"key":"beautyMode"},{"Name":"intensity","Type":"number","Required":"是","Default":"无","Description":"美颜强度，取值范围为 [0,1]。强度为 0 表示关闭。
各基础美颜模式的强度默认值分别为：美白 0.7，磨皮 0.8，锐化 0.5，清晰 0.7。\n","children":[],"key":"intensity"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - –1000: 未集成特效 SDK。
  - –1001: RTC SDK 版本不支持此功能。
  - <0: 调用失败，特效 SDK 内部错误，具体错误码请参考[错误码表](https://www.volcengine.com/docs/6705/102042)。

### setVideoOrientation()  

在自定义视频前处理及编码前，设置 RTC 链路中的视频帧朝向，默认为 Adaptive 模式。
移动端开启视频特效贴纸，或使用自定义视频前处理时，建议固定视频帧朝向为 Portrait 模式。单流转推场景下，建议根据业务需要固定视频帧朝向为 Portrait 或 Landscape 模式。不同模式的具体显示效果参看[视频帧朝向](https://www.volcengine.com/docs/6348/128787)。

**注意**

  - 视频帧朝向设置仅适用于内部采集视频源。对于自定义采集视频源，设置视频帧朝向可能会导致错误，例如宽高对调。屏幕源不支持设置视频帧朝向。
  - 编码分辨率的更新与视频帧处理是异步操作，进房后切换视频帧朝向可能导致画面出现短暂的裁切异常，因此建议在进房前设置视频帧朝向，且不在进房后进行切换。

**类型**

  ```ts
  (orientation: VideoOrientation) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"orientation","Type":"VideoOrientation","Required":"是","Default":"无","Description":"视频帧朝向，参看 VideoOrientation。\n","children":[],"key":"orientation"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### setRuntimeParameters()  

设置运行时的参数

**注意**

  该接口需在 [joinRoom](#iroom-joinroom) 和 startAudioCapture 之前调用。

**类型**

  ```ts
  { (params: JSONObject): number; (params: Record): number; }
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"params","Type":"JSONObject","Required":"是","Default":"无","Description":"保留参数\n","children":[],"key":"params"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### getNativeHandle()  

获取 C++ 层 [IRTCVideo 句柄](https://www.volcengine.com/docs/6348/70095#irtcvideo)。

**注意**

  在一些场景下，获取 C++ 层 `IRTCVideo`，并通过其完成操作，相较于通过 Java 封装层完成有显著更高的执行效率。典型的场景有：视频/音频帧自定义处理，音视频通话加密等。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  - \>0：方法调用成功, 返回 C++ 层 `IRTCVideo` 的地址。
  - -1：方法调用失败

### stopASR()  

关闭语音识别服务

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### startFileRecording()  

该方法将通话过程中的音视频数据录制到本地的文件中。

**注意**

  - 调用该方法后，你会收到 onRecordingStateUpdate 回调。
  - 如果录制正常，系统每秒钟会通过 onRecordingProgressUpdate 回调通知录制进度。

**类型**

  ```ts
  (type: StreamIndex, config: RecordingConfig, recordingType: RecordingType) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"type","Type":"StreamIndex","Required":"是","Default":"无","Description":"流属性，指定录制主流还是屏幕流，参看 StreamIndex
\n","children":[],"key":"type"},{"Name":"config","Type":"RecordingConfig","Required":"是","Default":"无","Description":"本地录制参数配置，参看 RecordingConfig
\n","children":[],"key":"config"},{"Name":"recordingType","Type":"RecordingType","Required":"是","Default":"无","Description":"本地录制的媒体类型，参看 RecordingType\n","children":[],"key":"recordingType"}]
      return (
);
```
  

**返回值**

  number  0: 正常
  -1: 参数设置异常
  -2: 当前版本 SDK 不支持该特性，请联系技术支持人员

### stopFileRecording()  

停止本地录制

**注意**

  - 调用 startFileRecording 开启本地录制后，你必须调用该方法停止录制。
  - 调用该方法后，你会收到 onRecordingStateUpdate 回调提示录制结果。

**类型**

  ```ts
  (type: StreamIndex) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"type","Type":"StreamIndex","Required":"是","Default":"无","Description":"流属性，指定停止主流或者屏幕流录制，参看 StreamIndex\n","children":[],"key":"type"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### startAudioRecording()  

开启录制语音通话，生成本地文件。
在进房前后开启录制，如果未打开麦克风采集，录制任务正常进行，只是不会将数据写入生成的本地文件；只有调用 startAudioCapture 接口打开麦克风采集后，才会将录制数据写入本地文件。

**注意**

  - 录制包含各种音频效果。但不包含混音的背景音乐。
  - 调用 stopAudioRecording 关闭录制。
  - 加入房间前后均可调用。在进房前调用该方法，退房之后，录制任务不会自动停止，需调用 stopAudioRecording 关闭录制。在进房后调用该方法，退房之后，录制任务会自动被停止。如果加入了多个房间，录制的文件中会包含各个房间的音频。
  - 调用该方法后，你会收到 onAudioRecordingStateUpdate 回调。

**类型**

  ```ts
  (config: AudioRecordingConfig) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"config","Type":"AudioRecordingConfig","Required":"是","Default":"无","Description":"参看 AudioRecordingConfig\n","children":[],"key":"config"}]
      return (
);
```
  

**返回值**

  number
  - 0: 正常
  - -2: 参数设置异常
  - -3: 当前版本 SDK 不支持该特性，请联系技术支持人员

### stopAudioRecording()  

停止音频文件录制

**注意**

  调用 startAudioRecording 开启本地录制后，你必须调用该方法停止录制。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  - 0: 正常
  - -3: 当前版本 SDK 不支持该特性，请联系技术支持人员

### getAudioEffectPlayer()  

创建音效播放器实例。

**类型**

  ```ts
  () => IAudioEffectPlayer
  ```

**返回值**

  [IAudioEffectPlayer](#iaudioeffectplayer)  音效播放器。详见 [IAudioEffectPlayer](#iaudioeffectplayer)。

### getMediaPlayer()  

创建音乐播放器实例。

**类型**

  ```ts
  (playerId: number) => IMediaPlayer
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"playerId","Type":"number","Required":"是","Default":"无","Description":"音乐播放器实例 id。取值范围为 [0, 3]。最多同时存在 4 个实例，超出取值范围时返回 nullptr。\n","children":[],"key":"playerId"}]
      return (
);
```
  

**返回值**

  [IMediaPlayer](#imediaplayer)  音乐播放器实例，详见 [IMediaPlayer](#imediaplayer)

### setScreenAudioSourceType()  

在屏幕共享时，设置屏幕音频的采集方式（内部采集/自定义采集）

**注意**

  - 默认采集方式是 RTC SDK 内部采集。
  - 你应该在 publishScreen 前，调用此方法。否则，你将收到 onWarning 的报错：`WARNING_CODE_SET_SCREEN_AUDIO_SOURCE_TYPE_FAILED`。
  - 如果设定为内部采集，你必须再调用 startScreenCapture 开始采集。开启后，可以再次本接口切换为外部采集，此时内部采集将自动停止。
  - 如果设定为自定义采集，你必须再调用 pushScreenAudioFrame 将自定义采集到的屏幕音频帧推送到 RTC SDK。
  - 无论是内部采集还是自定义采集，你都必须调用 publishScreen 发布采集到的屏幕音频流。

**类型**

  ```ts
  (sourceType: AudioSourceType) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"sourceType","Type":"AudioSourceType","Required":"是","Default":"无","Description":"屏幕音频输入源类型, 参看 AudioSourceType。\n","children":[],"key":"sourceType"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### setScreenAudioStreamIndex()  

在屏幕共享时，设置屏幕音频流和麦克风采集到的音频流的混流方式

**注意**

  你应该在 publishScreen 之前，调用此方法。否则，你将收到 onWarning 的报错：`WARNING_CODE_SET_SCREEN_STREAM_INDEX_FAILED`

**类型**

  ```ts
  (index: StreamIndex) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"index","Type":"StreamIndex","Required":"是","Default":"无","Description":"混流方式，参看 StreamIndex
\nSTREAM_INDEX_MAIN: 将屏幕音频流和麦克风采集到的音频流混流
\nSTREAM_INDEX_SCREEN: 默认值，将屏幕音频流和麦克风采集到的音频流分为两路音频流\n\n","children":[],"key":"index"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### startScreenCapture()  

使用 RTC SDK 内部采集模块开始采集屏幕音频流和（或）视频流。

**注意**

  - 调用本接口时，采集模式应为内部模式。在外部采集模式下调用无效，并将触发 onVideoDeviceWarning 或 onAudioDeviceWarning 回调。
  - 采集后，你还需要调用 publishScreen 发布采集到的屏幕音视频。
  - 开启屏幕音频/视频采集成功后，本地用户会收到 onVideoDeviceStateChanged 和 [onAudioDeviceStateChanged](1390576#rtcvideoeventhandler-onaudiodevicestatechanged) 的回调。
  - 要关闭屏幕音视频内部采集，调用 stopScreenCapture。

**类型**

  ```ts
  (type: ScreenMediaType, mediaProjectionResultData: Intent) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"type","Type":"ScreenMediaType","Required":"是","Default":"无","Description":"媒体类型，参看 ScreenMediaType。
\n","children":[],"key":"type"},{"Name":"mediaProjectionResultData","Type":"unknown","Required":"是","Default":"无","Description":"向 Android 设备申请屏幕共享权限后，拿到的 Intent 数据，参看 getMediaProjection。\n","children":[],"key":"mediaProjectionResultData"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### updateScreenCapture()  

使用 RTC SDK 内部屏幕采集后，更新采集的媒体类型。

**注意**

  在 startScreenCapture 后调用该方法。

**类型**

  ```ts
  (type: ScreenMediaType) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"type","Type":"ScreenMediaType","Required":"是","Default":"无","Description":"媒体类型，指定屏幕采集媒体类型，参看 ScreenMediaType。\n","children":[],"key":"type"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### stopScreenCapture()  

在屏幕共享时，停止使用 RTC SDK 内部采集方式采集屏幕音视频。

**注意**

  - 调用本接口时，采集模式应为内部模式。在外部采集模式下调用无效，并将触发 onVideoDeviceWarning 或 onAudioDeviceWarning 回调。
  - 要开始屏幕音视频内部采集，调用 startScreenCapture。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### setExternalVideoEncoderEventHandler()  

注册自定义编码帧推送事件回调

**注意**

  - 该方法需在进房前调用。
  - 引擎销毁前需取消注册，调用该方法将参数设置为 "null" 即可。

**类型**

  ```ts
  (handler: IExternalVideoEncoderEventHandler) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"handler","Type":"IExternalVideoEncoderEventHandler","Required":"是","Default":"无","Description":"自定义编码帧回调类，参看 IExternalVideoEncoderEventHandler\n","children":[],"key":"handler"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### setVideoDecoderConfig()  

在订阅远端视频流之前，设置远端视频数据解码方式

**注意**

  - 当你想要对远端流进行自定义解码时，你需要先调用 registerRemoteEncodedVideoFrameObserver 注册远端视频流监测器，然后再调用该接口将解码方式设置为自定义解码。监测到的视频数据会通过 onRemoteEncodedVideoFrame 回调出来。
  - 自 3.56 起，要用于自动订阅场景下，你可以设置 `key` 中的 `RoomId` 和 `UserId` 为 `nullptr`，此时，通过此接口设置的解码方式根据 `key` 中的 `StreamIndex` 值，适用于所有的远端主流或屏幕流的解码方式。

**类型**

  ```ts
  (key: RemoteStreamKey, config: VideoDecoderConfig) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"key","Type":"RemoteStreamKey","Required":"是","Default":"无","Description":"远端流信息，指定对哪一路视频流进行解码方式设置，参看 RemoteStreamKey。
\n","children":[],"key":"key"},{"Name":"config","Type":"VideoDecoderConfig","Required":"是","Default":"无","Description":"视频解码方式，参看 VideoDecoderConfig。\n","children":[],"key":"config"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### requestRemoteVideoKeyFrame()  

在订阅远端视频流之后，向远端请求关键帧

**注意**

  - 该方法仅适用于手动订阅模式，并且在成功订阅远端流之后使用。
  - 该方法适用于调用 setVideoDecoderConfig 开启自定义解码功能后，并且自定义解码失败的情况下使用

**类型**

  ```ts
  (streamKey: RemoteStreamKey) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"streamKey","Type":"RemoteStreamKey","Required":"是","Default":"无","Description":"远端流信息，参看 RemoteStreamKey。\n","children":[],"key":"streamKey"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### setEarMonitorMode()  

打开/关闭耳返功能。

**注意**

  - 耳返功能仅适用于由 RTC SDK 内部采集的音频。
  - 使用耳返功能必须佩戴耳机。为保证低延时耳返最佳体验，建议佩戴有线耳机。蓝牙耳机不支持硬件耳返。
  - RTC SDK 支持硬件耳返和软件耳返。一般来说，硬件耳返延时低且音质好。如果 App 在手机厂商的硬件耳返白名单内，且运行环境存在支持硬件耳返的 SDK，RTC SDK 默认启用硬件耳返。使用华为手机硬件耳返功能时，请添加[华为硬件耳返的依赖配置](https://www.volcengine.com/docs/6348/113523)。

**类型**

  ```ts
  (mode: EarMonitorMode) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"mode","Type":"EarMonitorMode","Required":"是","Default":"无","Description":"耳返功能是否开启，详见 EarMonitorMode。\n","children":[],"key":"mode"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### setEarMonitorVolume()  

设置耳返音量。

**注意**

  - 设置耳返音量前，你必须先调用 setEarMonitorMode 打开耳返功能。

**类型**

  ```ts
  (volume: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"volume","Type":"number","Required":"是","Default":"无","Description":"耳返音量，调节范围：[0,100]，单位：%\n","children":[],"key":"volume"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### enableAudioPropertiesReport()  

启用音频信息提示。开启提示后，你可以收到 onLocalAudioPropertiesReport，onRemoteAudioPropertiesReport onRemoteAudioPropertiesReport 和 onActiveSpeaker。

**类型**

  ```ts
  (config: AudioPropertiesConfig) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"config","Type":"AudioPropertiesConfig","Required":"是","Default":"无","Description":"详见 AudioPropertiesConfig\n","children":[],"key":"config"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### sendStreamSyncInfo()  

发送音频流同步信息。将消息通过音频流发送到远端，并实现与音频流同步，该接口调用成功后，远端用户会收到 onStreamSyncInfoReceived 回调。

**注意**

  - 调用本接口的频率建议不超过 50 次每秒。
  - 在 `CHANNEL_PROFILE_INTERACTIVE_PODCAST` 房间模式下，此消息一定会送达。在其他房间模式下，如果本地用户未说话，此消息不一定会送达。

**类型**

  ```ts
  (data: ArrayBuffer, config: StreamSycnInfoConfig) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"data","Type":"ArrayBuffer","Required":"是","Default":"无","Description":"消息内容。
\n","children":[],"key":"data"},{"Name":"config","Type":"StreamSycnInfoConfig","Required":"是","Default":"无","Description":"音频流同步信息的相关配置。详见 StreamSycnInfoConfig 。\n","children":[],"key":"config"}]
      return (
);
```
  

**返回值**

  number
  - \>=0: 消息发送成功。返回成功发送的次数。
  - -1: 消息发送失败。消息长度大于 255 字节。
  - -2: 消息发送失败。传入的消息内容为空。
  - -3: 消息发送失败。通过屏幕流进行消息同步时，此屏幕流还未发布。
  - -4: 消息发送失败。通过用麦克风或自定义设备采集到的音频流进行消息同步时，此音频流还未发布，详见错误码 [ErrorCode](1390577#errorcode)。

### isCameraTorchSupported()  

检测当前使用的摄像头（前置/后置），是否支持闪光灯。

**注意**

  必须已调用 startVideoCapture 使用 SDK 内部采集模块进行视频采集时，才能检测闪光能力。

**类型**

  ```ts
  () => boolean
  ```

**返回值**

  boolean
  - true: 支持
  - false: 不支持

### isCameraZoomSupported()  

检测当前使用的摄像头（前置/后置），是否支持变焦（数码/光学变焦）。

**注意**

  必须已调用 startVideoCapture 使用 SDK 内部采集模块进行视频采集时，才能检测摄像头变焦能力。

**类型**

  ```ts
  () => boolean
  ```

**返回值**

  boolean
  - true: 支持
  - false: 不支持

### setCameraZoomRatio()  

设置当前使用的摄像头（前置/后置）的光学变焦倍数

**注意**

  - 必须已调用 startVideoCapture 使用 SDK 内部采集模块进行视频采集时，才能设置摄像头变焦倍数。
  - 设置结果在调用 stopVideoCapture 关闭内部采集后失效。
  - 你可以调用 setVideoDigitalZoomConfig 设置数码变焦参数， 调用 setVideoDigitalZoomControl 进行数码变焦。

**类型**

  ```ts
  (zoom: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"zoom","Type":"number","Required":"是","Default":"无","Description":"变焦倍数。取值范围是 [1, <最大变焦倍数>]。
最大变焦倍数可以通过调用 getCameraZoomMaxRatio 获取。\n","children":[],"key":"zoom"}]
      return (
);
```
  

**返回值**

  number
  - 0： 成功。
  - < 0： 失败。

### getCameraZoomMaxRatio()  

获取当前使用的摄像头（前置/后置）的最大变焦倍数

**注意**

  必须已调用 startVideoCapture 使用 SDK 内部采集模块进行视频采集时，才能检测摄像头最大变焦倍数。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number  最大变焦倍数

### setCameraTorch()  

打开/关闭当前使用的摄像头（前置/后置）的闪光灯

**注意**

  - 必须已调用 startVideoCapture 使用 SDK 内部采集模块进行视频采集时，才能设置闪光灯。
  - 设置结果在调用 stopVideoCapture 关闭内部采集后失效。

**类型**

  ```ts
  (torchState: TorchState) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"torchState","Type":"TorchState","Required":"是","Default":"无","Description":"闪光灯状态。参考 TorchState\n","children":[],"key":"torchState"}]
      return (
);
```
  

**返回值**

  number
  - 0： 成功。
  - < 0： 失败。

### isCameraFocusPositionSupported()  

检查当前使用的摄像头是否支持手动对焦。

**注意**

  必须已调用 startVideoCapture 使用 SDK 内部采集模块进行视频采集，才能检查摄像头是否支持手动对焦。

**类型**

  ```ts
  () => boolean
  ```

**返回值**

  boolean
  - true: 支持。
  - false: 不支持。

### setCameraFocusPosition()  

设置当前使用的摄像头的对焦点。

**注意**

  - 必须已调用 startVideoCapture 使用 SDK 内部采集模块进行视频采集，并且使用 SDK 内部渲染时，才能设置对焦点。
  - 移动设备时，自动取消对焦点设置。
  - 调用 stopVideoCapture 关闭内部采集后，设置的对焦点失效。

**类型**

  ```ts
  (x: number, y: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"x","Type":"number","Required":"是","Default":"无","Description":"对焦点水平方向归一化坐标。以本地预览画布的左上为原点，取值范围为 [0, 1]，0 表示最左边，1 表示最右边。
\n","children":[],"key":"x"},{"Name":"y","Type":"number","Required":"是","Default":"无","Description":"对焦点垂直方向归一化坐标。以本地预览画布的左上为原点，取值范围为 [0, 1]，0 表示最上边，1 表示最下边。\n","children":[],"key":"y"}]
      return (
);
```
  

**返回值**

  number
  - 0: 成功。
  - < 0: 失败。

### isCameraExposurePositionSupported()  

检查当前使用的摄像头是否支持手动设置曝光点。

**注意**

  必须已调用 startVideoCapture 使用 SDK 内部采集模块进行视频采集时，才能检查曝光点设置能力。

**类型**

  ```ts
  () => boolean
  ```

**返回值**

  boolean
  - true: 支持。
  - false: 不支持。

### setCameraExposurePosition()  

设置当前使用的摄像头的曝光点

**注意**

  - 必须已调用 startVideoCapture 使用 SDK 内部采集模块进行视频采集，并且使用 SDK 内部渲染时，才能设置曝光点。
  - 移动设备时，自动取消曝光点设置。
  - 调用 stopVideoCapture 关闭内部采集后，设置的曝光点失效。

**类型**

  ```ts
  (x: number, y: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"x","Type":"number","Required":"是","Default":"无","Description":"曝光点水平方向归一化坐标。以本地预览画布的左上为原点，取值范围为 [0, 1]，0 表示最左边，1 表示最右边。
\n","children":[],"key":"x"},{"Name":"y","Type":"number","Required":"是","Default":"无","Description":"曝光点垂直方向归一化坐标。以本地预览画布的左上为原点，取值范围为 [0, 1]，0 表示最上边，1 表示最下边。\n","children":[],"key":"y"}]
      return (
);
```
  

**返回值**

  number
  - 0: 成功。
  - < 0: 失败。

### setCameraExposureCompensation()  

设置当前使用的摄像头的曝光补偿。

**注意**

  - 必须已调用 startVideoCapture 使用 SDK 内部采集模块进行视频采集时，才能设置曝光补偿。
  - 调用 stopVideoCapture 关闭内部采集后，设置的曝光补偿失效。

**类型**

  ```ts
  (val: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"val","Type":"number","Required":"是","Default":"无","Description":"曝光补偿值，取值范围 [-1, 1]，0 为系统默认值(没有曝光补偿)。\n","children":[],"key":"val"}]
      return (
);
```
  

**返回值**

  number
  - 0: 成功。
  - < 0: 失败。

### enableCameraAutoExposureFaceMode()  

启用或禁用内部采集时人脸自动曝光模式。此模式会改善强逆光下，脸部过暗的问题；但也会导致 ROI 以外区域过亮/过暗的问题。

**注意**

  你必须在调用 startVideoCapture 开启内部采集前，调用此接口方可生效。

**类型**

  ```ts
  (enable: boolean) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"enable","Type":"boolean","Required":"是","Default":"无","Description":"是否启用。默认开启。\n","children":[],"key":"enable"}]
      return (
);
```
  

**返回值**

  number
  - 0: 成功。
  - < 0: 失败。

### startPushPublicStream()  

发布一路公共流
用户可以指定房间内多个用户发布的媒体流合成一路公共流。使用同一 `appID` 的用户，可以调用 startPlayPublicStream 获取和播放指定的公共流。

**注意**

  - 同一用户使用同一公共流 ID 多次调用本接口无效。如果你希望更新公共流参数，调用 updatePublicStreamParam 接口。
  - 不同用户使用同一公共流 ID 多次调用本接口时，RTC 将使用最后一次调用时传入的参数更新公共流。
  - 使用不同的 ID 多次调用本接口可以发布多路公共流。
  - 调用 stopPushPublicStream 停止推公共流。
  - 关于公共流功能的介绍，详见[发布和订阅公共流](https://www.volcengine.com/docs/6348/108930)

**类型**

  ```ts
  (publicStreamId: string, publicStream: PublicStreaming) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"publicStreamId","Type":"string","Required":"是","Default":"无","Description":"公共流 ID
\n","children":[],"key":"publicStreamId"},{"Name":"publicStream","Type":"PublicStreaming","Required":"是","Default":"无","Description":"公共流参数。详见 PublicStreaming。
一路公共流可以包含多路房间内的媒体流，按照指定的布局方式进行聚合。
如果指定的媒体流还未发布，则公共流将在指定流开始发布后实时更新。\n","children":[],"key":"publicStream"}]
      return (
);
```
  

**返回值**

  number  0: 成功。同时将收到 onPushPublicStreamResult 回调。
  - !0: 失败。当参数不合法或参数为空，调用失败。

### stopPushPublicStream()  

停止发布当前用户发布的公共流
关于发布公共流，查看 startPushPublicStream

**类型**

  ```ts
  (publicStreamId: string) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"publicStreamId","Type":"string","Required":"是","Default":"无","Description":"公共流 ID
指定的流必须为当前用户所发布。\n","children":[],"key":"publicStreamId"}]
      return (
);
```
  

**返回值**

  number
  - 0: 成功
  - !0: 失败

### updatePublicStreamParam()  

更新公共流参数
关于发布公共流，查看 startPushPublicStream。

**注意**

  调用本接口前需要通过 onPushPublicStreamResult 确认公共流是否已经成功启动。

**类型**

  ```ts
  (publicStreamId: string, transcoding: PublicStreaming) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"publicStreamId","Type":"string","Required":"是","Default":"无","Description":"公共流 ID
指定的流必须为当前用户所发布。
\n","children":[],"key":"publicStreamId"},{"Name":"transcoding","Type":"PublicStreaming","Required":"是","Default":"无","Description":"配置参数，详见 PublicStreaming。\n","children":[],"key":"transcoding"}]
      return (
);
```
  

**返回值**

  number
  - 0: 成功
  - !0: 失败

### startPlayPublicStream()  

订阅指定公共流
无论用户是否在房间内，都可以调用本接口获取和播放指定的公共流。

**注意**

  - 在调用本接口之前，建议先绑定渲染视图。
        - 调用 setPublicStreamVideoCanvas 绑定内部渲染视图：
        - 调用 setPublicStreamVideoSink 绑定自定义渲染视图：
  - 调用本接口后，可以通过 onFirstPublicStreamVideoFrameDecoded 和 onFirstPublicStreamAudioFrame 回调公共流的视频和音频首帧解码情况。
  - 调用本接口后，可以通过 onPublicStreamSEIMessageReceived 回调公共流中包含的 SEI 信息。
  - 调用 stopPlayPublicStream 取消订阅公共流。

**类型**

  ```ts
  (publicStreamId: string) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"publicStreamId","Type":"string","Required":"是","Default":"无","Description":"公共流 ID，如果指定流暂未发布，则本地客户端将在其开始发布后接收到流数据。\n","children":[],"key":"publicStreamId"}]
      return (
);
```
  

**返回值**

  number
  - 0: 成功。同时将收到 onPlayPublicStreamResult 回调。
  - !0: 失败。当参数不合法或参数为空，调用失败。

### stopPlayPublicStream()  

取消订阅指定公共流
关于订阅公共流，查看 startPlayPublicStream。

**类型**

  ```ts
  (publicStreamId: string) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"publicStreamId","Type":"string","Required":"是","Default":"无","Description":"公共流 ID\n","children":[],"key":"publicStreamId"}]
      return (
);
```
  

**返回值**

  number
  - 0：成功
  - !0：失败

### setPublicStreamVideoCanvas()  

为指定公共流绑定内部渲染视图。

**类型**

  ```ts
  (publicStreamId: string, canvas: VideoCanvas) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"publicStreamId","Type":"string","Required":"是","Default":"无","Description":"公共流 ID
\n","children":[],"key":"publicStreamId"},{"Name":"canvas","Type":"VideoCanvas","Required":"是","Default":"无","Description":"内部渲染视图，如果需要解除视频的绑定视图，把 videoCanvas 设置为空。详见 VideoCanvas\n","children":[],"key":"canvas"}]
      return (
);
```
  

**返回值**

  number
  - 0：成功
  - <0：失败

### setPublicStreamAudioPlaybackVolume()  

调节公共流的音频播放音量。

**类型**

  ```ts
  (publicStreamId: string, volume: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"publicStreamId","Type":"string","Required":"是","Default":"无","Description":"公共流 ID
\n","children":[],"key":"publicStreamId"},{"Name":"volume","Type":"number","Required":"是","Default":"无","Description":"音频播放音量值和原始音量值的比值，该比值的范围是 [0, 400]，单位为 %，且自带溢出保护。为保证更好的音频质量，建议设定在 [0, 100] 之间，其中 100 为系统默认值。\n","children":[],"key":"volume"}]
      return (
);
```
  

**返回值**

  number
  - 0: 成功调用。
  - -2: 参数错误。

### startEchoTest()  

开启音视频回路测试。
在进房前，用户可调用该接口对音视频通话全链路进行检测，包括对音视频设备以及用户上下行网络的检测，从而帮助用户判断是否可以正常发布和接收音视频流。
开始检测后，SDK 会录制你声音或视频。如果你在设置的延时范围内收到了回放，则视为音视频回路测试正常。

**注意**

  - 调用该方法开始音视频回路检测后，你可以调用 stopEchoTest 立即结束测试，也可等待测试 60s 后自动结束，以更换设备进行下一次测试，或进房。
  - 在该方法之前调用的所有跟设备控制、流控制相关的方法均在开始检测时失效，在结束检测后恢复生效。
  - 在调用 startEchoTest 和 stopEchoTest 之间调用的所有跟设备采集、流控制、进房相关的方法均不生效，并会收到 onWarning 回调，提示警告码为 `WARNING_CODE_IN_ECHO_TEST_MODE`。
  - 音视频回路检测的结果会通过 onEchoTestResult 回调通知。

**类型**

  ```ts
  (config: EchoTestConfig, delayTime: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"config","Type":"EchoTestConfig","Required":"是","Default":"无","Description":"回路测试参数设置，参看 EchoTestConfig。
\n","children":[],"key":"config"},{"Name":"delayTime","Type":"number","Required":"是","Default":"无","Description":"音视频延迟播放的时间间隔，用于指定在开始检测多长时间后期望收到回放。取值范围为 [2,10]，单位为秒，默认为 2 秒。\n","children":[],"key":"delayTime"}]
      return (
);
```
  

**返回值**

  number  方法调用结果：
  - 0：成功
  - -1：失败，当前用户已经在检测中
  - -2：失败，用户已进房
  - -3：失败，音视频均未采集
  - -4：失败，参数异常
  - -5：失败，已经存在相同 roomId 的房间

### stopEchoTest()  

停止音视频回路测试。
调用 startEchoTest 开启音视频回路检测后，你必须调用该方法停止检测。

**注意**

  音视频回路检测结束后，所有对系统设备及音视频流的控制均会恢复到开始检测前的状态。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number  方法调用结果：
  - 0：成功
  - -1：失败，未开启回路检测

### clearVideoWatermark()  

移除指定视频流的水印。

**类型**

  ```ts
  (streamIndex: StreamIndex) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"streamIndex","Type":"StreamIndex","Required":"是","Default":"无","Description":"需要移除水印的视频流属性，参看 StreamIndex。\n","children":[],"key":"streamIndex"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### setDummyCaptureImagePath()  

摄像头处于关闭状态时，使用静态图片填充本地推送的视频流。
调用 `stopVideoCapture` 接口时，会开始推静态图片。若要停止发送图片，可传入空字符串或启用内部摄像头采集。
可重复调用该接口来更新图片。

**注意**

  - 该接口只适用于 SDK 内部摄像头采集，不适用于自定义视频采集。
  - 本地预览无法看到静态图片。
  - 进入房间前后均可调用此方法。在多房间场景中，静态图片仅在发布的房间中生效。
  - 针对该静态图片，滤镜和镜像效果不生效，水印效果生效。
  - 只有主流能设置静态图片，屏幕流不支持设置。
  - 开启大小流后，静态图片对大小流均生效，且针对小流进行等比例缩小。

**类型**

  ```ts
  (filePath: string) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"filePath","Type":"string","Required":"是","Default":"无","Description":"设置静态图片的路径。
支持本地文件绝对路径和 Asset 资源路径(/assets/xx.png)，不支持网络链接，长度限制为 512 字节。
静态图片支持类型为 JPEG/JPG、PNG、BMP。
若图片宽高比与设置的编码宽高比不一致，图片会被等比缩放，黑边填充空白区域。推流帧率与码率与设置的编码参数一致。\n","children":[],"key":"filePath"}]
      return (
);
```
  

**返回值**

  number
  - 0: 成功。
  - -1: 失败。

### startCloudProxy()  

开启云代理

**注意**

  - 在加入房间前调用此接口
  - 在开启云代理后，进行通话前网络探测
  - 开启云代理后，并成功链接云代理服务器后，会收到 onCloudProxyConnected。
  - 要关闭云代理，调用 stopCloudProxy。

**类型**

  ```ts
  (cloudProxiesInfo: Array) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"cloudProxiesInfo","Type":"CloudProxyInfo[]","Required":"是","Default":"无","Description":"云代理服务器信息列表。参看 CloudProxyInfo。\n","children":[],"key":"cloudProxiesInfo"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### stopCloudProxy()  

关闭云代理

**注意**

  要开启云代理，调用 startCloudProxy。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### getSingScoringManager()  

创建 K 歌评分管理接口。

**注意**

  如需使用 K 歌评分功能，即调用该方法以及 `ISingScoringManager` 类下全部方法，需集成 SAMI 动态库，详情参看[按需集成插件](#1108726)文档。

**类型**

  ```ts
  () => ISingScoringManager
  ```

**返回值**

  [ISingScoringManager](#isingscoringmanager)  K 歌评分管理接口，参看 [ISingScoringManager](#isingscoringmanager)。

### getNetworkTimeInfo()  

通过 NTP 协议，获取网络时间。

**注意**

  - 第一次调用此接口会启动网络时间同步功能，并返回 `0`。同步完成后，会收到 onNetworkTimeSynchronized，此后，再次调用此 API，即可获取准确的网络时间。
  - 在合唱场景下，合唱参与者应在相同的网络时间播放背景音乐。

**类型**

  ```ts
  () => NetworkTimeInfo
  ```

**返回值**

  [NetworkTimeInfo](1390578#networktimeinfo)  网络时间。参看 [NetworkTimeInfo](1390578#networktimeinfo)。

### getKTVManager()  

创建 KTV 管理接口。

**类型**

  ```ts
  () => IKTVManager
  ```

**返回值**

  [IKTVManager](#iktvmanager)  KTV 管理接口，参看 [IKTVManager](#iktvmanager)。

### startHardwareEchoDetection()  

开启通话前回声检测

**注意**

  - 只有当 [ChannelProfile](1390578#channelprofile) 为 `CHANNEL_PROFIEL_MEETING` 和 `CHANNEL_PROFILE_MEETING_ROOM` 时支持开启本功能。
  - 开启检测前，你需要向用户获取音频设备的使用权限。
  - 开启检测前，请确保音频设备没有被静音，采集和播放音量正常。
  - 调用本接口后监听 onHardwareEchoDetectionResult 获取检测结果。
  - 检测期间，进程将独占音频设备，无法使用其他音频设备测试接口： startEchoTest、startAudioDeviceRecordTest startAudioDeviceRecordTest 或 startAudioPlaybackDeviceTest。
  - 调用 stopHardwareEchoDetection 停止检测，释放对音频设备的占用。

**类型**

  ```ts
  (testAudioFilePath: string) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"testAudioFilePath","Type":"string","Required":"是","Default":"无","Description":"用于回声检测的音频文件的绝对路径，路径字符串使用 UTF-8 编码格式，支持以下音频格式: mp3，aac，m4a，3gp，wav。
音频文件不为静音文件，推荐时长为 10 ～ 20 秒。\n","children":[],"key":"testAudioFilePath"}]
      return (
);
```
  

**返回值**

  number  方法调用结果：
  - 0: 成功。
  - -1：失败。上一次检测未结束，请先调用 stopHardwareEchoDetection 停止检测 后重新调用本接口。
  - -2：失败。路径不合法或音频文件格式不支持。

### stopHardwareEchoDetection()  

停止通话前回声检测

**注意**

  - 关于开启通话前回声检测，参看 startHardwareEchoDetection 。
  - 建议在收到 onHardwareEchoDetectionResult 通知的检测结果后，调用本接口停止检测。
  - 在用户进入房间前结束回声检测，释放对音频设备的占用，以免影响正常通话。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number  方法调用结果：
  - 0: 成功。
  - -1：失败。

### setCellularEnhancement()  

启用蜂窝网络辅助增强，改善通话质量。

**注意**

  此功能默认不开启。

**类型**

  ```ts
  (config: MediaTypeEnhancementConfig) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"config","Type":"MediaTypeEnhancementConfig","Required":"是","Default":"无","Description":"参看 MediaTypeEnhancementConfig。\n","children":[],"key":"config"}]
      return (
);
```
  

**返回值**

  number  方法调用结果：
  - 0: 成功。
  - -1：失败，内部错误。
  - -2: 失败，输入参数错误。

### android_getVideoDeviceManager()  

创建视频设备管理实例

**类型**

  ```ts
  () => $p_a.IVideoDeviceManager
  ```

**返回值**

  $p_a.[IVideoDeviceManager](#ivideodevicemanager)  视频设备管理实例，详见 [IVideoDeviceManager](#ivideodevicemanager)

### setVideoCaptureRotation()  

设置本端采集的视频帧的旋转角度。
当摄像头倒置或者倾斜安装时，可调用本接口进行调整。对于手机等普通设备，可调用 setVideoRotationMode 实现旋转。

**注意**

  - 对于内部采集的视频画面，如果已调用 setVideoRotationMode 设置了旋转方向，会在此基础上叠加旋转角度。
  - 调用本接口也将对自定义采集视频画面生效，在原有的旋转角度基础上叠加本次设置。
  - 视频贴纸特效或通过 enableVirtualBackground 增加的虚拟背景，也会跟随本接口的设置进行旋转。
  - 本地渲染视频和发送到远端的视频都会相应旋转，但不会应用到单流转推中。如果希望在单流转推的视频中应用旋转，调用 setVideoOrientation。

**类型**

  ```ts
  (rotation: VideoRotation) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"rotation","Type":"VideoRotation","Required":"是","Default":"无","Description":"相机朝向角度，默认为 VIDEO_ROTATION_0(0)，无旋转角度。详见 VideoRotation。\n","children":[],"key":"rotation"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### ios_setMaxVideoEncoderConfig()  

视频发布端设置期望发布的最大分辨率视频流参数，包括分辨率、帧率、码率、网络不佳时的回退策略等。
该接口支持设置一路视频流参数，设置多路参数请使用 [setVideoEncoderConfig](#rtcvideo-setvideoencoderconfig)。

**注意**

  - 你可以同时使用 enableSimulcastMode 方法来发布多路分辨率不同的流。具体而言，若期望发布多路不同分辨率的流，你需要在发布流之前调用本方法以及 enableSimulcastMode 方法开启多路流模式，SDK 会根据订阅端的设置智能调整发布的流数（最多发布 4 条）以及各路流的参数。其中，调用本方法设置的分辨率为各路流中的最大分辨率。具体规则参看[推送多路流](https://www.volcengine.com/docs/6348/70139)文档。
  - 调用该方法前，SDK 默认仅发布一条分辨率为 640px × 360px，帧率为 15fps 的视频流。
  - 自定义采集的场景下，务必调用该接口设置分辨率，以保证远端收到画面的完整性。
  - 该方法适用于摄像头采集的视频流，设置屏幕共享视频流参数参看 setScreenVideoEncoderConfig。

**类型**

  ```ts
  (encoderConfig: $p_i.ByteRTCVideoEncoderConfig) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"encoderConfig","Type":"$p_i.ByteRTCVideoEncoderConfig","Required":"是","Default":"无","Description":"期望发布的最大分辨率视频流参数。参看 ByteRTCVideoEncoderConfig。\n","children":[],"key":"encoderConfig"}]
      return (
);
```
  

**返回值**

  number  方法调用结果：
  - 0：成功
  - !0：失败

### ios_setCustomizeEncryptHandler()  

设置自定义加密和解密方式。

**注意**

  - 该方法与 setEncryptInfokey 为互斥关系，即按照调用顺序，最后一个调用的方法为最终生效的版本。
  - 该方法必须在调用 [:roomConfig: joinRoom:userInfo:roomConfig](#iroom-:roomconfig: joinroom:userinfo:roomconfig) 之前调用，可重复调用，以最后调用的参数作为生效参数。
  - 无论加密或者解密，其对原始数据的长度修改，需要控制在 180\% 之间，即如果输入数据为 100 字节，则处理完成后的数据必须不超过 180 字节，如果加密或解密结果超出该长度限制，则该音视频帧可能会被丢弃。
  - 数据加密/解密为串行执行，因而视实现方式不同，可能会影响到最终渲染效率，是否使用该方法，需要由使用方谨慎评估。

**类型**

  ```ts
  (handler: $p_i.id<$p_i.ByteRTCEncryptHandler>) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"handler","Type":"$p_i.ByteRTCEncryptHandler","Required":"是","Default":"无","Description":"自定义加密 handler，需要实现里面的加密和解密方法。参看 ByteRTCEncryptHandler。\n","children":[],"key":"handler"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 ByteRTCReturnStatus 获得更多错误说明

### `static` android_createRTCVideo_context$appId$handler$eglContext$parameters()  

创建引擎对象
如果当前进程中未创建引擎实例，那么你必须先使用此方法，以使用 RTC 提供的各种音视频能力。
如果当前进程中已创建了引擎实例，再次调用此方法时，会返回已创建的引擎实例。

**注意**

  你应注意保持 handler 的生命周期必须大于 [RTCVideo](#rtcvideo) 的生命周期，即 handler 必须在调用 destroyRTCVideo 之后销毁。

**类型**

  ```ts
  (context: $p_a.Context, appId: string, handler: $p_a.IRTCVideoEventHandler, eglContext: Object, parameters: $p_a.JSONObject) => $p_a.RTCVideo
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"context","Type":"unknown","Required":"是","Default":"无","Description":"Android Application Context
\n","children":[],"key":"context"},{"Name":"appId","Type":"string","Required":"是","Default":"无","Description":"每个应用的唯一标识符，由 RTC 控制台随机生成的。不同的 AppId 生成的实例在 RTC 中进行音视频通话完全独立，无法互通。
\n","children":[],"key":"appId"},{"Name":"handler","Type":"$p_a.IRTCVideoEventHandler","Required":"是","Default":"无","Description":"SDK 回调给应用层的 Handler，详见 IRTCVideoEventHandler
\n","children":[],"key":"handler"},{"Name":"eglContext","Type":"Object","Required":"是","Default":"无","Description":"如果需要支持外部纹理硬编码，则需要以 JObject 方式传入 eglContext。
\n","children":[],"key":"eglContext"},{"Name":"parameters","Type":"$p_a.JSONObject","Required":"是","Default":"无","Description":"私有参数。如需使用请联系技术支持人员。\n","children":[],"key":"parameters"}]
      return (
);
```
  

**返回值**

  $p_a.[RTCVideo](#rtcvideo)
  - RTCVideo：创建成功。返回一个可用的 [RTCVideo](#rtcvideo) 实例
  - Null：appId 或者 context 参数为空，.so 文件加载失败。

### `static` destroyRTCVideo()  

销毁由 createRTCVideo 所创建的引擎实例，并释放所有相关资源。

**注意**

  - 请确保和需要销毁的 [RTCVideo](#rtcvideo) 实例相关的业务场景全部结束后，才调用此方法
  - 该方法在调用之后，会销毁所有和此 [RTCVideo](#rtcvideo) 实例相关的内存，并且停止与媒体服务器的任何交互
  - 调用本方法会启动 SDK 退出逻辑。引擎线程会保留，直到退出逻辑完成。因此，不要在回调线程中直接调用此 API，会导致死锁。同时此方法是耗时操作，不建议在主线程调用本方法，避免主线程阻塞。

**类型**

  ```ts
  () => void
  ```

### `static` getSDKVersion()  

获取 SDK 当前的版本号。

**类型**

  ```ts
  () => string
  ```

**返回值**

  string  SDK 当前的版本号。

### `static` setLogConfig()  

配置 SDK 本地日志参数，包括日志级别、存储路径、日志文件最大占用的总空间、日志文件名前缀。

**注意**

  本方法必须在调用 createRTCVideo 之前调用。

**类型**

  ```ts
  (logConfig: RTCLogConfig) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"logConfig","Type":"RTCLogConfig","Required":"是","Default":"无","Description":"本地日志参数，参看 RTCLogConfig。\n","children":[],"key":"logConfig"}]
      return (
);
```
  

**返回值**

  number
  - 0：成功。
  - –1：失败，本方法必须在创建引擎前调用。
  - –2：失败，参数填写错误。

### `static` getErrorDescription()  

获取 SDK 内各种错误码、警告码的描述文字。

**类型**

  ```ts
  (code: number) => string
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"code","Type":"number","Required":"是","Default":"无","Description":"通过 onWarning 和 onError 回调获得的值，
具体可以参考 ErrorCode 和 WarningCode\n","children":[],"key":"code"}]
      return (
);
```
  

**返回值**

  string  String 描述文字


## RTCRoom 

类型：`class`

RTC 房间类

### ios_delegate  

类型：$p_i.ByteRTCRoomDelegate

### setRTCRoomEventHandler()  

通过设置 [RTCRoom](#rtcroom) 对象的事件句柄，监听此对象对应的回调事件。

**类型**

  ```ts
  (rtcRoomEventHandler: RTCRoomEventHandler) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"rtcRoomEventHandler","Type":"RTCRoomEventHandler","Required":"是","Default":"无","Description":"参看 IRTCRoomEventHandler\n","children":[],"key":"rtcRoomEventHandler"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### subscribeAllStreams()  

订阅房间内所有通过摄像头/麦克风采集的媒体流，或更新订阅选项。

**注意**

  - 多次调用订阅接口时，将根据末次调用接口和传入的参数，更新订阅配置。
  - 开启音频选路后，如果房间内的媒体流超过上限，建议通过调用 subscribeStream 逐一指定需要订阅的媒体流。
  - 调用该方法后，你会收到 onStreamSubscribed 通知方法调用结果。
  - 成功订阅远端用户的媒体流后，订阅关系将持续到调用 unsubscribeStream 取消订阅或本端用户退房。
  - 关于其他调用异常，你会收到 onStreamStateChanged 回调通知，具体异常原因参看 [ErrorCode](1390577#errorcode)。

**类型**

  ```ts
  (type: MediaStreamType) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"type","Type":"MediaStreamType","Required":"是","Default":"无","Description":"媒体流类型，用于指定订阅音频/视频。参看 MediaStreamType。\n","children":[],"key":"type"}]
      return (
);
```
  

**返回值**

  number
  - 0: 方法调用成功
  - !0: 方法调用失败

### unsubscribeAllStreams()  

取消订阅房间内所有的通过摄像头/麦克风采集的媒体流。
自动订阅和手动订阅的流都可以通过本方法取消订阅。

**注意**

  - 调用该方法后，你会收到 onStreamSubscribed 通知方法调用结果。
  - 关于其他调用异常，你会收到 onStreamStateChanged 回调通知，具体失败原因参看 [ErrorCode](1390577#errorcode)。

**类型**

  ```ts
  (type: MediaStreamType) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"type","Type":"MediaStreamType","Required":"是","Default":"无","Description":"媒体流类型，用于指定取消订阅音频/视频。参看 MediaStreamType。\n","children":[],"key":"type"}]
      return (
);
```
  

**返回值**

  number  方法调用结果：
  - 0：成功
  - !0：失败

### destroy()  

退出并销毁调用 createRTCRoom 所创建的房间实例。

**类型**

  ```ts
  () => void
  ```

### joinRoom()  

加入房间。
调用 createRTCRoom 创建房间后，调用此方法加入房间，同房间内其他用户进行音视频通话。

**注意**

  - 同一个 App ID 的同一个房间内，每个用户的用户 ID 必须是唯一的。如果两个用户的用户 ID 相同，则后进房的用户会将先进房的用户踢出房间，并且先进房的用户会收到 onRoomStateChanged 回调通知，错误类型详见 ERROR_CODE_DUPLICATE_LOGIN。
  - 本地用户调用此方法加入房间成功后，会收到 onRoomStateChanged 回调通知。若本地用户同时为可见用户，加入房间时远端用户会收到 onUserJoined 回调通知。
  - 房间内不可见用户的容量远远大于可见用户，而且用户默认可见，因此对于不参与互动的用户，你需要调用 setUserVisibility 更改为不可见用户。从而避免因房间内用户达到数量上限所导致的进房失败。默认情况下，一个 RTC 房间最多同时容纳 50 名可见用户，其中最多 30 人可同时上麦，更多信息参看[用户和媒体流上限](https://www.volcengine.com/docs/6348/257549)。
  - 用户加入房间成功后，在本地网络状况不佳的情况下，SDK 可能会与服务器失去连接，并触发 onConnectionStateChanged 回调。此时 SDK 会自动重试，直到成功重连。重连成功后，本地会收到 onRoomStateChanged 回调通知；如果加入房间的用户是可见用户，远端用户会收到 onUserJoined 回调通知。

**类型**

  ```ts
  (token: string, userInfo: UserInfo, roomConfig: RTCRoomConfig) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"token","Type":"string","Required":"是","Default":"无","Description":"动态密钥。用于对进房用户进行鉴权验证。
进入房间需要携带 Token。测试时可使用控制台生成临时 Token，正式上线需要使用密钥 SDK 在你的服务端生成并下发 Token。Token 有效期及生成方式参看使用 Token 完成鉴权。
使用不同 AppID 的 App 是不能互通的。
请务必保证生成 Token 使用的 AppID 和创建引擎时使用的 AppID 相同，否则会导致加入房间失败。
\n","children":[],"key":"token"},{"Name":"userInfo","Type":"UserInfo","Required":"是","Default":"无","Description":"用户信息。参看 UserInfo。
\n","children":[],"key":"userInfo"},{"Name":"roomConfig","Type":"RTCRoomConfig","Required":"是","Default":"无","Description":"房间参数配置，设置房间模式以及是否自动发布或订阅流。具体配置模式参看 RTCRoomConfig。\n","children":[],"key":"roomConfig"}]
      return (
);
```
  

**返回值**

  number
  - 0：方法调用成功。
  - -1：roomID / userInfo.uid 包含了无效的参数。
  - -2：已经在房间内。接口调用成功后，只要收到返回值为 0 ，且未调用 leaveRoom 成功，则再次调用进房接口时，无论填写的房间 ID 和用户 ID 是否重复，均触发此返回值。
  调用失败时，具体失败原因会通过 onRoomStateChanged 回调告知。

### leaveRoom()  

离开房间。
用户调用此方法离开房间，结束通话过程，释放所有通话相关的资源。
此方法是异步操作，调用返回时并没有真正退出房间。真正退出房间后，本地会收到 onLeaveRoom 回调通知。

**注意**

  - 调用 setUserVisibility 将自身设为可见的用户离开房间后，房间内其他用户会收到 onUserLeave 回调通知。
  - 如果调用此方法后立即销毁引擎，SDK 将无法触发 onLeaveRoom 回调。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### setUserVisibility()  

设置用户可见性。未调用该接口前，本地用户默认对他人可见。
默认情况下，一个 RTC 房间最多同时容纳 50 名可见用户，最多 30 人可同时上麦。更多信息参看[用户和媒体流上限](https://www.volcengine.com/docs/6348/257549)。

**注意**

  - 在加入房间前后，用户均可调用此方法设置用户可见性。
  - 设置用户可见性，会收到设置成功/失败回调 onUserVisibilityChanged。（v3.54 新增）
     • 在加入房间前设置用户可见性，若设置的可见性与默认值不同，将在加入房间时触发本回调。
     • 在加入房间后设置用户可见性，若可见性前后不同，会触发本回调。
     • 在断网重连后，若可见性发生改变，会触发本回调。
  - 在房间内，调用此方法成功切换用户可见性后，房间内其他用户会收到相应的回调。
     • 从可见换至不可见时，房间内其他用户会收到 onUserLeave。
     • 从不可见切换至可见时，房间内其他用户会收到 onUserJoined。
     • 若调用该方法将可见性设为 `false`，此时尝试发布流会收到 `WARNING_CODE_PUBLISH_STREAM_FORBIDEN` 警告。

**类型**

  ```ts
  (enable: boolean) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"enable","Type":"boolean","Required":"是","Default":"无","Description":"设置用户是否对房间内其他用户可见：
\ntrue: 可见，用户可以在房间内发布音视频流，房间中的其他用户将收到用户的行为通知，例如进房、开启视频采集和退房。
\nfalse: 不可见，用户不可以在房间内发布音视频流，房间中的其他用户不会收到用户的行为通知，例如进房、开启视频采集和退房。\n\n","children":[],"key":"enable"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0: 调用失败。参看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明。

### updateToken()  

更新 Token。
收到 onTokenWillExpire，onPublishPrivilegeTokenWillExpire onPublishPrivilegeTokenWillExpire， 或 onSubscribePrivilegeTokenWillExpire 时，你必须重新获取 Token，并调用此方法更新 Token，以保证通话的正常进行。

**注意**

  - 3.50（不含）以前的版本中，Token 中的发布和订阅权限为保留参数，无实际控制权限；3.50 及以后版本开放 Token 发布订阅控制权限，如需通过 Token 控制连麦权限，请联系技术支持团队开通白名单后支持。
  - 请勿同时调用 updateToken 和 [joinRoom](#iroom-joinroom) 方法更新 Token。若因 Token 过期或无效导致加入房间失败或已被移出房间，你应该在获取新的有效 Token 后调用 [joinRoom](#iroom-joinroom) 重新加入房间。

**类型**

  ```ts
  (token: string) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"token","Type":"string","Required":"是","Default":"无","Description":"重新获取的有效 Token。
如果 Token 无效，你会收到 onRoomStateChanged，错误码是 -1010。\n","children":[],"key":"token"}]
      return (
);
```
  

**返回值**

  number  方法调用结果：
  - 0：成功；
  - <0：失败。具体失败原因参看 [ReturnStatus](1390578#returnstatus)。

### sendUserMessage()  

给房间内指定的用户发送点对点文本消息（P2P）。

**注意**

  - 在发送房间内文本消息前，必须先调用 [joinRoom](#iroom-joinroom) 加入房间。
  - 调用后，会收到 onUserMessageSendResult 回调，通知消息发送成功或失败；
  - 若消息发送成功，则 userId 所指定的用户会收到 onUserMessageReceived 回调。

**类型**

  ```ts
  (userId: string, messageStr: string, config: MessageConfig) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"userId","Type":"string","Required":"是","Default":"无","Description":"消息接收用户的 ID
\n","children":[],"key":"userId"},{"Name":"messageStr","Type":"string","Required":"是","Default":"无","Description":"发送的文本消息内容。消息不超过 64 KB。
\n","children":[],"key":"messageStr"},{"Name":"config","Type":"MessageConfig","Required":"是","Default":"无","Description":"消息发送的可靠/有序类型，参看 MessageConfig\n","children":[],"key":"config"}]
      return (
);
```
  

**返回值**

  number
  - \>0：发送成功，返回这次发送消息的编号，从 1 开始递增
  - -1：发送失败，RTCRoom 实例未创建
  - -2：发送失败，uid 为空

### sendUserBinaryMessage()  

给房间内指定的用户发送点对点二进制消息（P2P）。

**注意**

  - 在发送房间内二进制消息前，必须先调用 [joinRoom](#iroom-joinroom) 加入房间。
  - 调用后，会收到 onUserMessageSendResult 回调，通知消息发送成功或失败；
  - 若消息发送成功，则 userId 所指定的用户会收到 onUserBinaryMessageReceived 回调。

**类型**

  ```ts
  (userId: string, buffer: ArrayBuffer, config: MessageConfig) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"userId","Type":"string","Required":"是","Default":"无","Description":"消息接收用户的 ID
\n","children":[],"key":"userId"},{"Name":"buffer","Type":"ArrayBuffer","Required":"是","Default":"无","Description":"发送的二进制消息内容。消息不超过 46KB。
\n","children":[],"key":"buffer"},{"Name":"config","Type":"MessageConfig","Required":"是","Default":"无","Description":"消息发送的可靠/有序类型，参看 MessageConfig。\n","children":[],"key":"config"}]
      return (
);
```
  

**返回值**

  number

### sendRoomMessage()  

给房间内的所有其他用户群发文本消息。

**注意**

  - 在房间内广播文本消息前，必须先调用 [joinRoom](#iroom-joinroom) 加入房间。
  - 调用后，会收到 onRoomMessageSendResult 回调；
  - 同一房间内的其他用户会收到 onRoomMessageReceived 回调。

**类型**

  ```ts
  (messageStr: string) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"messageStr","Type":"string","Required":"是","Default":"无","Description":"发送的文本消息内容，消息不超过 64 KB。\n","children":[],"key":"messageStr"}]
      return (
);
```
  

**返回值**

  number

### sendRoomBinaryMessage()  

给房间内的所有其他用户群发二进制消息。

**注意**

  - 在房间内广播二进制消息前，必须先调用 [joinRoom](#iroom-joinroom) 加入房间。
  - 调用后，会收到 onRoomMessageSendResult 回调；
  - 同一房间内的其他用户会收到 onRoomBinaryMessageReceived 回调。

**类型**

  ```ts
  (buffer: ArrayBuffer) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"buffer","Type":"ArrayBuffer","Required":"是","Default":"无","Description":"发送的二进制消息内容，消息不超过 46KB。\n","children":[],"key":"buffer"}]
      return (
);
```
  

**返回值**

  number

### setMultiDeviceAVSync()  

设置发流端音画同步。
当同一用户同时使用两个通话设备分别采集发送音频和视频时，有可能会因两个设备所处的网络环境不一致而导致发布的流不同步，此时你可以在视频发送端调用该接口，SDK 会根据音频流的时间戳自动校准视频流，以保证接收端听到音频和看到视频在时间上的同步性。

**注意**

  - 该方法在进房前后均可调用。
  - 进行音画同步的音频发布用户 ID 和视频发布用户 ID 须在同一个 RTC 房间内。
  - 调用该接口后音画同步状态发生改变时，你会收到 onAVSyncStateChange 回调。
  - 同一 RTC 房间内允许存在多个音视频同步关系，但需注意单个音频源不支持与多个视频源同时同步。
  - 如需更换同步音频源，再次调用该接口传入新的 `audioUserId` 即可；如需更换同步视频源，需先解除当前的同步关系，后在新视频源端开启同步。

**类型**

  ```ts
  (audioUserId: string) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"audioUserId","Type":"string","Required":"是","Default":"无","Description":"音频发送端的用户 ID，将该参数设为空则可解除当前音视频的同步关系。\n","children":[],"key":"audioUserId"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### setRemoteVideoConfig()  

设置期望订阅的远端视频流的参数。

**注意**

  - 若使用 342 及以前版本的 SDK，调用该方法前请联系技术支持人员开启按需订阅功能。
  - 该方法仅在发布端调用 enableSimulcastMode 开启了发送多路视频流的情况下生效，此时订阅端将收到来自发布端与期望设置的参数最相近的一路流；否则订阅端只会收到一路参数为分辨率 640px × 360px、帧率 15fps 的视频流。
  - 若发布端开启了推送多路流功能，但订阅端不对流参数进行设置，则默认接受发送端设置的分辨率最大的一路视频流。
  - 该方法需在进房后调用，若想进房前设置，你需调用 [joinRoom](#iroom-joinroom)，并对 `roomConfig` 中的 `remoteVideoConfig` 进行设置。
  - SDK 会根据发布端和所有订阅端的设置灵活调整视频流的参数，具体调整策略详见[推送多路流](https://www.volcengine.com/docs/6348/70139)文档。

**类型**

  ```ts
  (userId: string, remoteVideoConfig: RemoteVideoConfig) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"userId","Type":"string","Required":"是","Default":"无","Description":"期望配置订阅参数的远端视频流发布用户的 ID。
\n","children":[],"key":"userId"},{"Name":"remoteVideoConfig","Type":"RemoteVideoConfig","Required":"是","Default":"无","Description":"期望配置的远端视频流参数，参看 RemoteVideoConfig。\n","children":[],"key":"remoteVideoConfig"}]
      return (
);
```
  

**返回值**

  number  方法调用结果：
  - 0：成功；
  - <0：失败。具体失败原因参看 [ReturnStatus](1390578#returnstatus)。

### publishStream()  

在当前所在房间内发布本地通过摄像头/麦克风采集的媒体流

**注意**

  - 如果你已经在用户进房时通过调用 [joinRoom](#iroom-joinroom) 成功选择了自动发布，则无需再调用本接口。
  - 调用 setUserVisibility 方法将自身设置为不可见后无法调用该方法，需将自身切换至可见后方可调用该方法发布摄像头音视频流。
  - 如果你需要发布屏幕共享流，调用 publishScreen。
  - 如果你需要向多个房间发布流，调用 startForwardStreamToRooms。
  - 调用此方法后，房间中的所有远端用户会收到 onUserPublishStream 回调通知，其中成功收到了音频流的远端用户会收到 onFirstRemoteAudioFrame 回调，订阅了视频流的远端用户会收到 onFirstRemoteVideoFrameDecoded 回调。
  - 调用 unpublishStream 取消发布。

**类型**

  ```ts
  (type: MediaStreamType) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"type","Type":"MediaStreamType","Required":"是","Default":"无","Description":"媒体流类型，用于指定发布音频/视频，参看 MediaStreamType\n","children":[],"key":"type"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### unpublishStream()  

停止将本地摄像头/麦克风采集的媒体流发布到当前所在房间中

**注意**

  - 调用 [publishStream](#rtcroom-publishstream) 手动发布摄像头音视频流后，你需调用此接口停止发布。
  - 调用此方法停止发布音视频流后，房间中的其他用户将会收到 [onUserUnpublishStream](1390576#rtcroomeventhandler-onuserunpublishstream) 回调通知。

**类型**

  ```ts
  (type: MediaStreamType) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"type","Type":"MediaStreamType","Required":"是","Default":"无","Description":"媒体流类型，用于指定停止发布音频/视频，参看 MediaStreamType\n","children":[],"key":"type"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### publishScreen()  

在当前所在房间内发布本地屏幕共享音视频流

**注意**

  - 即使你已经在用户进房时通过调用 [joinRoom](#iroom-joinroom) 成功选择了自动发布，也需要调用本接口发布屏幕流。
  - 调用 setUserVisibility 方法将自身设置为不可见后无法调用该方法，需将自身切换至可见后方可调用该方法发布屏幕流。
  - 调用该方法后，房间中的所有远端用户会收到 onUserPublishScreen 回调，其中成功收到音频流的远端用户会收到 onFirstRemoteAudioFrame 回调，订阅了视频流的远端用户会收到 onFirstRemoteVideoFrameDecoded 回调。
  - 调用该方法后，本地用户会收到 onScreenVideoFrameSendStateChanged。
  - 如果你需要向多个房间发布流，调用 startForwardStreamToRooms。
  - 调用 unpublishScreen 取消发布。
  - 查看 [Android 端屏幕共享](https://www.volcengine.com/docs/6348/124176)，获取更多信息。

**类型**

  ```ts
  (type: MediaStreamType) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"type","Type":"MediaStreamType","Required":"是","Default":"无","Description":"媒体流类型，用于指定发布屏幕音频/视频，参看 MediaStreamType。\n","children":[],"key":"type"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### unpublishScreen()  

停止将本地屏幕共享音视频流发布到当前所在房间中

**注意**

  - 调用 publishScreen 发布屏幕流后，你需调用此接口停止发布。
  - 调用此方法停止发布屏幕音视频流后，房间中的其他用户将会收到 onUserUnpublishScreen 回调。

**类型**

  ```ts
  (type: MediaStreamType) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"type","Type":"MediaStreamType","Required":"是","Default":"无","Description":"媒体流类型，用于指定停止发布屏幕音频/视频，参看 MediaStreamType\n","children":[],"key":"type"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### subscribeStream()  

订阅房间内指定的通过摄像头/麦克风采集的媒体流，或更新对指定远端用户的订阅选项

**注意**

  - 若当前用户在调用本接口时已经订阅该远端用户（手动订阅或自动订阅），则将根据本次传入的参数，更新订阅配置。
  - 你必须先通过 onUserPublishStream 回调获取当前房间里的远端摄像头音视频流信息，然后调用本方法按需订阅。
  - 调用该方法后，你会收到 onStreamSubscribed 通知方法调用结果。
  - 成功订阅远端用户的媒体流后，订阅关系将持续到调用 unsubscribeStream 取消订阅或本端用户退房。
  - 关于其他调用异常，你会收到 onStreamStateChanged 回调通知，具体异常原因参看 [ErrorCode](1390577#errorcode)。

**类型**

  ```ts
  (uid: string, type: MediaStreamType) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"uid","Type":"string","Required":"是","Default":"无","Description":"指定订阅的远端发布音视频流的用户 ID。
\n","children":[],"key":"uid"},{"Name":"type","Type":"MediaStreamType","Required":"是","Default":"无","Description":"媒体流类型，用于指定订阅音频/视频。参看 MediaStreamType。\n","children":[],"key":"type"}]
      return (
);
```
  

**返回值**

  number  方法调用结果：
  - 0：成功；
  - <0：失败。具体失败原因参看 [ReturnStatus](1390578#returnstatus)。

### unsubscribeStream()  

取消订阅房间内指定的通过摄像头/麦克风采集的媒体流。
该方法对自动订阅和手动订阅模式均适用。

**注意**

  - 调用该方法后，你会收到 onStreamSubscribed 通知方法调用结果。
  - 关于其他调用异常，你会收到 onStreamStateChanged 回调通知，具体失败原因参看 [ErrorCode](1390577#errorcode)。

**类型**

  ```ts
  (uid: string, type: MediaStreamType) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"uid","Type":"string","Required":"是","Default":"无","Description":"指定取消订阅的远端发布音视频流的用户 ID。
\n","children":[],"key":"uid"},{"Name":"type","Type":"MediaStreamType","Required":"是","Default":"无","Description":"媒体流类型，用于指定取消订阅音频/视频。参看 MediaStreamType。\n","children":[],"key":"type"}]
      return (
);
```
  

**返回值**

  number  方法调用结果：
  - 0：成功；
  - <0：失败。具体失败原因参看 [ReturnStatus](1390578#returnstatus)。

### subscribeScreen()  

订阅房间内指定的远端屏幕共享音视频流，或更新对指定远端用户的订阅选项

**注意**

  - 若当前用户在调用本接口时已经订阅该远端用户（手动订阅或自动订阅），则将根据本次传入的参数，更新订阅配置。
  - 你必须先通过 onUserPublishScreen 回调获取当前房间里的远端屏幕流信息，然后调用本方法按需订阅。
  - 调用该方法后，你会收到 onStreamSubscribed 通知方法调用结果。
  - 成功订阅远端用户的媒体流后，订阅关系将持续到调用 unsubscribeScreen 取消订阅或本端用户退房。
  - 关于其他调用异常，你会收到 onStreamStateChanged 回调通知，具体异常原因参看 [ErrorCode](1390577#errorcode)。

**类型**

  ```ts
  (uid: string, type: MediaStreamType) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"uid","Type":"string","Required":"是","Default":"无","Description":"指定订阅的远端发布屏幕流的用户 ID。
\n","children":[],"key":"uid"},{"Name":"type","Type":"MediaStreamType","Required":"是","Default":"无","Description":"媒体流类型，用于指定订阅音频/视频。参看 MediaStreamType。\n","children":[],"key":"type"}]
      return (
);
```
  

**返回值**

  number  方法调用结果：
  - 0：成功；
  - <0：失败。具体失败原因参看 [ReturnStatus](1390578#returnstatus)。

### unsubscribeScreen()  

取消订阅房间内指定的远端屏幕共享音视频流。
该方法对自动订阅和手动订阅模式均适用。

**注意**

  - 调用该方法后，你会收到 onStreamSubscribed 通知流的退订结果。
  - 关于其他调用异常，你会收到 onStreamStateChanged 回调通知，具体失败原因参看 [ErrorCode](1390577#errorcode)。

**类型**

  ```ts
  (uid: string, type: MediaStreamType) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"uid","Type":"string","Required":"是","Default":"无","Description":"指定取消订阅的远端发布屏幕流的用户 ID。
\n","children":[],"key":"uid"},{"Name":"type","Type":"MediaStreamType","Required":"是","Default":"无","Description":"媒体流类型，用于指定取消订阅音频/视频。参看 MediaStreamType。\n","children":[],"key":"type"}]
      return (
);
```
  

**返回值**

  number  方法调用结果：
  - 0：成功；
  - <0：失败。具体失败原因参看 [ReturnStatus](1390578#returnstatus)。

### pauseAllSubscribedStream()  

暂停接收来自远端的媒体流。

**注意**

  - 该方法仅暂停远端流的接收，并不影响远端流的采集和发送；
  - 该方法不改变用户的订阅状态以及订阅流的属性。
  - 若想恢复接收远端流，需调用 resumeAllSubscribedStream。
  - 多房间场景下，仅暂停接收发布在当前所在房间的流。

**类型**

  ```ts
  (mediaType: PauseResumeControlMediaType) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"mediaType","Type":"PauseResumeControlMediaType","Required":"是","Default":"无","Description":"媒体流类型，指定需要暂停接收音频还是视频流，参看 PauseResumeControlMediaType。\n","children":[],"key":"mediaType"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### resumeAllSubscribedStream()  

恢复接收来自远端的媒体流

**注意**

  - 该方法仅恢复远端流的接收，并不影响远端流的采集和发送；
  - 该方法不改变用户的订阅状态以及订阅流的属性。

**类型**

  ```ts
  (mediaType: PauseResumeControlMediaType) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"mediaType","Type":"PauseResumeControlMediaType","Required":"是","Default":"无","Description":"媒体流类型，指定需要暂停接收音频还是视频流，参看 PauseResumeControlMediaType\n","children":[],"key":"mediaType"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### stopForwardStreamToRooms()  

停止跨房间媒体流转发。
通过 startForwardStreamToRooms 发起媒体流转发后，可调用本方法停止向所有目标房间转发媒体流。

**注意**

  - 调用本方法后，将在本端触发 onForwardStreamStateChanged 回调。
  - 调用本方法后，原目标房间中的用户将接收到本地用户停止发布 [onUserUnpublishStream](1390576#rtcroomeventhandler-onuserunpublishstream)/onUserUnpublishScreen onUserUnpublishScreen 和退房 onUserLeave 的回调。
  - 如果需要停止向指定的房间转发媒体流，请调用 updateForwardStreamToRooms 更新房间信息。
  - 如果需要暂停转发，请调用 pauseForwardStreamToAllRooms，并在之后随时调用 [resumeForwardStreamToAllRooms](#rtcroom-resumeforwardstreamtoallrooms) 快速恢复转发。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### pauseForwardStreamToAllRooms()  

暂停跨房间媒体流转发。
通过 startForwardStreamToRooms 发起媒体流转发后，可调用本方法暂停向所有目标房间转发媒体流。
调用本方法暂停向所有目标房间转发后，你可以随时调用 [resumeForwardStreamToAllRooms](#rtcroom-resumeforwardstreamtoallrooms) 快速恢复转发。

**注意**

  调用本方法后，目标房间中的用户将接收到本地用户停止发布 [onUserUnpublishStream](1390576#rtcroomeventhandler-onuserunpublishstream)/onUserUnpublishScreen onUserUnpublishScreen 和退房 onUserLeave 的回调。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### resumeForwardStreamToAllRooms()  

恢复跨房间媒体流转发。
调用 pauseForwardStreamToAllRooms 暂停转发之后，调用本方法恢复向所有目标房间转发媒体流。

**注意**

  目标房间中的用户将接收到本地用户进房 onUserJoined 和发布 onUserPublishStream/onUserPublishScreen onUserPublishScreen 的回调。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### getRangeAudio()  

获取范围语音接口实例。

**注意**

  首次调用该方法须在创建房间后、加入房间前。范围语音相关 API 和调用时序详见[范围语音](https://www.volcengine.com/docs/6348/114727)。

**类型**

  ```ts
  () => IRangeAudio
  ```

**返回值**

  [IRangeAudio](#irangeaudio)  方法调用结果：
  - IRangeAudio：成功，返回一个 [IRangeAudio](#irangeaudio) 实例。
  - null：失败，当前 SDK 不支持范围语音功能。

### getSpatialAudio()  

获取空间音频接口实例。

**注意**

  - 首次调用该方法须在创建房间后、加入房间前。空间音频相关 API 和调用时序详见[空间音频](https://www.volcengine.com/docs/6348/93903)。
  - 只有在使用支持真双声道播放的设备时，才能开启空间音频效果；
  - 在网络状况不佳的情况下，即使开启了这一功能，也不会产生空间音频效果；
  - 机型性能不足可能会导致音频卡顿，使用低端机时，不建议开启空间音频效果；
  - 空间音频效果在启用服务端选路功能时，不生效。

**类型**

  ```ts
  () => ISpatialAudio
  ```

**返回值**

  [ISpatialAudio](#ispatialaudio)  空间音频管理接口实例。如果返回 NULL，则表示不支持空间音频，详见 [ISpatialAudio](#ispatialaudio) 。

### setRemoteRoomAudioPlaybackVolume()  

调节某个房间内所有远端用户的音频播放音量。

**注意**

  假设某远端用户 A 始终在被调节的目标用户范围内，
  - 当该方法与 setRemoteAudioPlaybackVolume 共同使用时，本地收听用户 A 的音量为后调用的方法设置的音量；
  - 当该方法与 setPlaybackVolume 方法共同使用时，本地收听用户 A 的音量将为两次设置的音量效果的叠加。

**类型**

  ```ts
  (volume: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"volume","Type":"number","Required":"是","Default":"无","Description":"音频播放音量和原始音量的比值，范围是 [0, 400]，单位为 %，自带溢出保护。\n为保证更好的通话质量，建议将 volume 值设为 [0,100]。
\n0: 静音
\n100: 原始音量，默认值\n                - 400: 最大可为原始音量的 4 倍(自带溢出保护)\n\n","children":[],"key":"volume"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### setAudioSelectionConfig()  

设置本端发布流在音频选路中的优先级。

**注意**

  在控制台上为本 appId 开启音频选路后，调用本接口才会生效。进房前后调用均可生效。更多信息参见[音频选路](https://www.volcengine.com/docs/6348/113547)。
  如果本端用户同时加入不同房间，使用本接口进行的设置相互独立。

**类型**

  ```ts
  (audioSelectionPriority: AudioSelectionPriority) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"audioSelectionPriority","Type":"AudioSelectionPriority","Required":"是","Default":"无","Description":"本端发布流在音频选路中的优先级，默认正常参与音频选路。参见 AudioSelectionPriority。\n","children":[],"key":"audioSelectionPriority"}]
      return (
);
```
  

**返回值**

  number

### setRoomExtraInfo()  

设置/更新房间附加信息，可用于标识房间状态或属性，或灵活实现各种业务逻辑。

**注意**

  - 在设置房间附加信息前，必须先调用 [joinRoom](#iroom-joinroom) 加入房间。
  - 调用该方法后，会收到一次 onSetRoomExtraInfoResult 回调，提示设置结果。
  - 调用该方法成功设置附加信息后，同一房间内的其他用户会收到关于该信息的回调 onRoomExtraInfoUpdate。
  - 新进房的用户会收到进房前房间内已有的全部附加信息通知。

**类型**

  ```ts
  (key: string, value: string) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"key","Type":"string","Required":"是","Default":"无","Description":"房间附加信息键值，长度小于 10 字节。
同一房间内最多可存在 5 个 key，超出则会从第一个 key 起进行替换。
\n","children":[],"key":"key"},{"Name":"value","Type":"string","Required":"是","Default":"无","Description":"房间附加信息内容，长度小于 128 字节。\n","children":[],"key":"value"}]
      return (
);
```
  

**返回值**

  number
  - 0: 方法调用成功，返回本次调用的任务编号；
  - <0: 方法调用失败，具体原因详见 [SetRoomExtraInfoResult](1390578#setroomextrainforesult)。

### startSubtitle()  

识别或翻译房间内所有用户的语音，形成字幕。
调用该方法时，可以在 [SubtitleMode](1390578#subtitlemode) 中选择语音识别或翻译模式。如果选择识别模式，语音识别文本会通过 onSubtitleMessageReceived 事件回调给你；
如果选择翻译模式，你会同时收到两个 onSubtitleMessageReceived 回调，分别包含字幕原文及字幕译文。
调用该方法后，你会收到 onSubtitleStateChanged 回调，通知字幕是否开启。

**注意**

  - 使用字幕功能前，你需要在 [RTC 控制台](https://console.volcengine.com/rtc/cloudRTC?tab=subtitle&from=doc) 开启实时字幕功能。
  - 如果你需要使用流式语音识别模式，你应在 [语音技术控制台](https://console.volcengine.com/speech/service/16) 创建流式语音识别应用。创建时，服务类型应选择 `流式语音识别`，而非 `音视频字幕生成`。创建后，在 [RTC 控制台](https://console.volcengine.com/rtc/cloudRTC?tab=subtitle&from=doc) 上启动流式语音识别，并填写创建语音技术应用时获取的相关信息，包括：APP ID，Access Token，和 Cluster ID。
  - 如果你需要使用实时语音翻译模式，你应开通机器翻译服务，参考 [开通服务](https://www.volcengine.com/docs/4640/130262)。完成开通后，在 [RTC 控制台](https://console.volcengine.com/rtc/cloudRTC?tab=subtitle&from=doc) 上启用实时语音翻译模式。
  - 此方法需要在进房后调用。
  - 如需指定源语言，你需要在调用 `joinRoom` 接口进房时，通过 extraInfo 参数传入格式为`"语种英文名": "语种代号"` JSON 字符串，例如设置源语言为英文时，传入 `"source_language": "en"`。如未指定源语言，SDK 会将系统语种设定为源语言。如果你的系统语种不是中文、英文和日文，此时 SDK 会自动将中文设为源语言。
    - 识别模式下，你可以传入 [RTC 控制台](https://console.volcengine.com/rtc/cloudRTC?tab=subtitle&from=doc)上预设或自定义的语种英文名和语种代号。识别模式下支持的语言参看[识别模式语种支持](https://www.volcengine.com/docs/6561/109880#\%E8\%AF\%AD\%E7\%A7\%8D\%E6\%94\%AF\%E6\%8C\%81)。
    - 翻译模式下，你需要传入机器翻译规定的语种英文名和语种代号。翻译模式下支持的语言及对应的代号参看[翻译模式语言支持](https://www.volcengine.com/docs/4640/35107)。

**类型**

  ```ts
  (subtitleConfig: SubtitleConfig) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"subtitleConfig","Type":"SubtitleConfig","Required":"是","Default":"无","Description":"字幕配置信息。参看 SubtitleConfig。\n","children":[],"key":"subtitleConfig"}]
      return (
);
```
  

**返回值**

  number
  -  0: 调用成功。
  - !0: 调用失败。

### stopSubtitle()  

关闭字幕。
调用该方法后，用户会收到 onSubtitleStateChanged 回调，通知字幕是否关闭。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  -  0: 调用成功。
  - !0: 调用失败。

### getRoomId()  

获取房间 ID。

**类型**

  ```ts
  () => string
  ```

**返回值**

  string  房间 ID。


## IRangeAudio 

类型：`class`

范围语音接口实例

### enableRangeAudio()  

开启/关闭范围语音功能。
范围语音是指，在同一 RTC 房间中设定的音频接收距离范围内，本地用户收听到的远端用户音频音量会随着远端用户的靠近/远离而放大/衰减；若远端用户在房间内的位置超出设定范围，则本地用户无法接收其音频。音频接收范围设置参看 updateReceiveRange。

**注意**

  该方法进房前后都可调用，为保证进房后范围语音效果的平滑切换，你需在该方法前先调用 updatePosition 设置自身位置坐标，然后开启该方法收听范围语音效果。

**类型**

  ```ts
  (enable: boolean) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"enable","Type":"boolean","Required":"是","Default":"无","Description":"是否开启范围语音功能：
\ntrue: 开启
\nfalse: 关闭（默认）\n\n","children":[],"key":"enable"}]
      return (
);
```
  

### updatePosition()  

更新本地用户在房间内空间直角坐标系中的位置坐标。

**注意**

  - 调用该接口更新坐标后，你需调用 enableRangeAudio 开启范围语音功能以收听范围语音效果。

**类型**

  ```ts
  (pos: Position) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"pos","Type":"Position","Required":"是","Default":"无","Description":"三维坐标的值，默认为 [0, 0, 0]，参看 Position。\n","children":[],"key":"pos"}]
      return (
);
```
  

**返回值**

  number  方法调用结果：
  - 0：成功；
  - !0：失败。

### updateReceiveRange()  

更新本地用户的音频收听范围。

**类型**

  ```ts
  (range: ReceiveRange) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"range","Type":"ReceiveRange","Required":"是","Default":"无","Description":"音频收听范围，参看 ReceiveRange。\n","children":[],"key":"range"}]
      return (
);
```
  

**返回值**

  number  方法调用结果：
  - 0：成功；
  - !0: 失败。

### setAttenuationModel()  

设置范围语音的音量衰减模式。

**注意**

  音量衰减范围通过 updateReceiveRange 进行设置。

**类型**

  ```ts
  (type: AttenuationType, coefficient: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"type","Type":"AttenuationType","Required":"是","Default":"无","Description":"音量衰减模式。默认为线性衰减。详见 AttenuationType。
\n","children":[],"key":"type"},{"Name":"coefficient","Type":"number","Required":"是","Default":"无","Description":"指数衰减模式下的音量衰减系数，默认值为 1。范围 [0.1,100]，推荐设置为 50。数值越大，音量的衰减速度越快。\n","children":[],"key":"coefficient"}]
      return (
);
```
  

**返回值**

  number  调用是否成功
  - `0`:调用成功
  - `-1`:调用失败。原因为在调用 enableRangeAudio 开启范围语音前或进房前调用本接口

### setNoAttenuationFlags()  

添加标签组，用于标记相互之间通话不衰减的用户组。
在同一个 RTC 房间中，如果多个用户的标签组之间有交集，那么，他们之间互相通话时，通话不衰减。
比如，用户身处多个队伍，队伍成员间通话不衰减。那么，可以为每个队伍绑定专属标签，每个用户的标签组包含用户所属各个队伍的标签。

**类型**

  ```ts
  (flags: Array) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"flags","Type":"string[]","Required":"是","Default":"无","Description":"标签组\n","children":[],"key":"flags"}]
      return (
);
```
  


## IAudioEffectPlayer 

类型：`class`

音效播放器
调用 setEventHandler 设置回调句柄以获取相关回调。

### start()  

开始播放音效文件。
可以通过传入不同的 ID 和 filepath 多次调用本方法，以实现同时播放多个音效文件，实现音效叠加。

**注意**

  - 如果已经通过 preload 将文件加载至内存，确保此处的 ID 与 preload 设置的 ID 相同。
  - 开始播放音效文件后，可以调用 stop 方法停止播放音效文件。

**类型**

  ```ts
  (effectId: number, filePath: string, config: AudioEffectPlayerConfig) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"effectId","Type":"number","Required":"是","Default":"无","Description":"音效 ID。用于标识音效，请保证音效 ID 唯一性。
如果使用相同的 ID 重复调用本方法后，上一个音效会停止，下一个音效开始，并收到 onAudioEffectPlayerStateChanged。
\n","children":[],"key":"effectId"},{"Name":"filePath","Type":"string","Required":"是","Default":"无","Description":"音效文件路径。
支持在线文件的 URL、本地文件的 URI、本地文件的绝对路径或以 /assets/ 开头的本地文件路径。对于在线文件的 URL，仅支持 https 协议。
推荐的音效文件采样率：8KHz、16KHz、22.05KHz、44.1KHz、48KHz。
不同平台支持的本地音效文件格式:
mp3 mp4 aac m4a 3gp wav ogg ts wma
Android Y Y Y Y Y Y Y 
iOS/macOS Y Y Y Y Y Y 
Windows Y Y Y Y Y Y Y Y

不同平台支持的在线音效文件格式: mp3 mp4 aac m4a 3gp wav ogg ts wma
Android Y Y Y Y Y 
iOS/macOS Y Y Y Y 
Windows Y Y Y Y Y Y Y
\n","children":[],"key":"filePath"},{"Name":"config","Type":"AudioEffectPlayerConfig","Required":"是","Default":"无","Description":"音效配置，详见 AudioEffectPlayerConfig。\n","children":[],"key":"config"}]
      return ();
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### stop()  

停止播放音效文件。

**注意**

  - 调用 start 方法开始播放音效文件后，可以调用本方法停止播放音效文件。
  - 调用本方法停止播放音效文件后，该音效文件会被自动卸载。

**类型**

  ```ts
  (effectId: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"effectId","Type":"number","Required":"是","Default":"无","Description":"音效 ID\n","children":[],"key":"effectId"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### stopAll()  

停止播放所有音效文件。

**注意**

  - 调用 start 方法开始播放音效文件后，可以调用本方法停止播放所有音效文件。
  - 调用本方法停止播放所有音效文件后，该音效文件会被自动卸载。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### preload()  

预加载指定音乐文件到内存中，以避免频繁播放同一文件时的重复加载，减少 CPU 占用。

**注意**

  - 本方法只是预加载指定音效文件，只有调用 start 方法才开始播放指定音效文件。
  - 调用本方法预加载的指定音效文件可以通过 unload 卸载。

**类型**

  ```ts
  (effectId: number, filePath: string) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"effectId","Type":"number","Required":"是","Default":"无","Description":"音效 ID。用于标识音效，请保证音效 ID 唯一性。
如果使用相同的 ID 重复调用本方法，后一次会覆盖前一次。
如果先调用 start，再使用相同的 ID 调用本方法 ，会收到回调 onAudioEffectPlayerStateChanged ，通知前一个音效停止，然后加载下一个音效。
调用本方法预加载 A.mp3 后，如果需要使用相同的 ID 调用 start 播放 B.mp3，请先调用 unload 卸载 A.mp3 ，否则会报错 AUDIO_MIXING_ERROR_LOAD_CONFLICT。
\n","children":[],"key":"effectId"},{"Name":"filePath","Type":"string","Required":"是","Default":"无","Description":"音效文件路径。支持本地文件的 URI、本地文件的绝对路径或以 /assets/ 开头的本地文件路径。
预加载的文件长度不得超过 20s。
不同平台支持的音效文件格式和 start 一致。\n","children":[],"key":"filePath"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### unload()  

卸载指定音效文件。

**注意**

  仅在调用 start 或 preload 后调用此接口。

**类型**

  ```ts
  (effectId: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"effectId","Type":"number","Required":"是","Default":"无","Description":"音效 ID\n","children":[],"key":"effectId"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### unloadAll()  

卸载所有音效文件。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### pause()  

暂停播放音效文件。

**注意**

  - 调用 start 方法开始播放音效文件后，可以通过调用本方法暂停播放音效文件。
  - 调用本方法暂停播放音效文件后，可调用 resume 方法恢复播放。

**类型**

  ```ts
  (effectId: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"effectId","Type":"number","Required":"是","Default":"无","Description":"音效 ID\n","children":[],"key":"effectId"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### pauseAll()  

暂停播放所有音效文件。

**注意**

  - 调用 start 方法开始播放音效文件后，可以通过调用本方法暂停播放所有音效文件。
  - 调用本方法暂停播放所有音效文件后，可调用 resumeAll 方法恢复所有播放。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### resume()  

恢复播放音效文件。

**注意**

  调用 pause 方法暂停播放音效文件后，可以通过调用本方法恢复播放。

**类型**

  ```ts
  (effectId: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"effectId","Type":"number","Required":"是","Default":"无","Description":"音效 ID\n","children":[],"key":"effectId"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### resumeAll()  

恢复播放所有音效文件。

**注意**

  调用 pauseAll 方法暂停所有正在播放音效文件后，可以通过调用本方法恢复播放。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### setPosition()  

设置音效文件的起始播放位置。

**注意**

  - 在播放在线文件时，调用此接口可能造成播放延迟的现象。
  - 仅在调用 start 后调用此接口。

**类型**

  ```ts
  (effectId: number, position: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"effectId","Type":"number","Required":"是","Default":"无","Description":"音效 ID
\n","children":[],"key":"effectId"},{"Name":"position","Type":"number","Required":"是","Default":"无","Description":"音效文件起始播放位置，单位为毫秒。
你可以通过 getDuration 获取音效文件总时长，position 的值应小于音效文件总时长。\n","children":[],"key":"position"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### getPosition()  

获取音效文件播放进度。

**注意**

  - 在播放在线文件时，调用此接口可能造成播放延迟的现象。
  - 仅在调用 start 后调用此接口。

**类型**

  ```ts
  (effectId: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"effectId","Type":"number","Required":"是","Default":"无","Description":"音效 ID\n","children":[],"key":"effectId"}]
      return (
);
```
  

**返回值**

  number
  - \>0: 成功, 音效文件播放进度，单位为毫秒。
  - < 0: 失败

### setVolume()  

调节指定音效的音量大小，包括音效文件和 PCM 音频。

**注意**

  仅在调用 start 后调用此接口。

**类型**

  ```ts
  (effectId: number, volume: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"effectId","Type":"number","Required":"是","Default":"无","Description":"音效 ID
\n","children":[],"key":"effectId"},{"Name":"volume","Type":"number","Required":"是","Default":"无","Description":"播放音量相对原音量的比值。单位为 %。范围为 [0, 400]，建议范围是 [0, 100]。带溢出保护。\n","children":[],"key":"volume"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### setVolumeAll()  

设置所有音效的音量大小，包括音效文件和 PCM 音效。

**注意**

  该接口的优先级低于 setVolume，即通过 setVolume 单独设置了音量的音效 ID，不受该接口设置的影响。

**类型**

  ```ts
  (volume: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"volume","Type":"number","Required":"是","Default":"无","Description":"播放音量相对原音量的比值。单位为 %。范围为 [0, 400]，建议范围是 [0, 100]。带溢出保护。\n","children":[],"key":"volume"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### getVolume()  

获取当前音量。

**注意**

  仅在调用 start 后调用此接口。

**类型**

  ```ts
  (effectId: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"effectId","Type":"number","Required":"是","Default":"无","Description":"音效 ID\n","children":[],"key":"effectId"}]
      return (
);
```
  

**返回值**

  number
  - \>0: 成功, 当前音量值。
  - < 0: 失败

### getDuration()  

获取音效文件时长。

**注意**

  仅在调用 start 后调用此接口。

**类型**

  ```ts
  (effectId: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"effectId","Type":"number","Required":"是","Default":"无","Description":"音效 ID\n","children":[],"key":"effectId"}]
      return (
);
```
  

**返回值**

  number
  - \>0: 成功, 音效文件时长，单位为毫秒。
  - < 0: 失败

### setEventHandler()  

设置回调句柄。

**类型**

  ```ts
  (handler: IAudioEffectPlayerEventHandler) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"handler","Type":"IAudioEffectPlayerEventHandler","Required":"是","Default":"无","Description":"参看 IAudioEffectPlayerEventHandler。\n","children":[],"key":"handler"}]
      return (
);
```
  

**返回值**

  number
  - 0: 成功。
  - < 0: 失败。


## IMediaPlayer 

类型：`class`

音乐播放器
调用 setEventHandler 设置回调句柄以获取相关回调。

### open()  

打开音乐文件。
一个播放器实例仅能够同时打开一个音乐文件。如果需要同时打开多个音乐文件，请创建多个音乐播放器实例。
要播放 PCM 格式的音频数据，参看 openWithCustomSource。`openWithCustomSource` 和此 API 互斥。

**类型**

  ```ts
  (filePath: string, config: MediaPlayerConfig) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"filePath","Type":"string","Required":"是","Default":"无","Description":"音乐文件路径。
支持在线文件的 URL、本地文件的 URI、本地文件的绝对路径或以 /assets/ 开头的本地文件路径。对于在线文件的 URL，仅支持 https 协议。
推荐的采样率：8KHz、16KHz、22.05KHz、44.1KHz、48KHz。
不同平台支持的本地文件格式:
mp3 mp4 aac m4a 3gp wav ogg ts wma
Android Y Y Y Y Y Y Y 
iOS/macOS Y Y Y Y Y Y 
Windows Y Y Y Y Y Y Y Y

不同平台支持的在线文件格式: mp3 mp4 aac m4a 3gp wav ogg ts wma
Android Y Y Y Y Y 
iOS/macOS Y Y Y Y 
Windows Y Y Y Y Y Y Y
\n","children":[],"key":"filePath"},{"Name":"config","Type":"MediaPlayerConfig","Required":"是","Default":"无","Description":"详见 MediaPlayerConfig。\n","children":[],"key":"config"}]
      return ();
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### start()  

播放音乐。你仅需要在调用 open，且未开启自动播放时，调用此方法。

**注意**

  - 要播放 PCM 格式的音频数据，参看 openWithCustomSource。`openWithCustomSource` 和此 API 互斥。
  - 调用本方法播放音频文件后，可调用 stop 方法暂停播放。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### openWithCustomSource()  

启动音频裸数据混音。
要播放音乐文件，参看 open。`open` 与此 API 互斥。

**注意**

  - 调用本方法启动后，再调用 pushExternalAudioFrame 推送音频数据，才会开始混音。
  - 如要结束 PCM 音频数据混音，调用 stop。

**类型**

  ```ts
  (source: MediaPlayerCustomSource, config: MediaPlayerConfig) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"source","Type":"MediaPlayerCustomSource","Required":"是","Default":"无","Description":"数据源，详见 MediaPlayerCustomSource
\n","children":[],"key":"source"},{"Name":"config","Type":"MediaPlayerConfig","Required":"是","Default":"无","Description":"详见 MediaPlayerConfig\n","children":[],"key":"config"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### stop()  

调用 open, start, 或 openWithCustomSource 开始播放后，可以调用本方法停止。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### pause()  

调用 open，或 start 开始播放音频文件后，调用本方法暂停播放。

**注意**

  - 调用本方法暂停播放后，可调用 resume 恢复播放。
  - 此接口仅支持音频文件，不支持 PCM 数据。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### resume()  

调用 pause 暂停音频播放后，调用本方法恢复播放。

**注意**

  此接口仅支持音频文件，不支持 PCM 数据。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### setVolume()  

调节指定混音的音量大小，包括音乐文件混音和 PCM 混音。

**注意**

  仅在音频播放进行状态时，调用此方法。

**类型**

  ```ts
  (volume: number, type: AudioMixingType) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"volume","Type":"number","Required":"是","Default":"无","Description":"播放音量相对原音量的比值。单位为 %。范围为 [0, 400]，建议范围是 [0, 100]。带溢出保护。
\n","children":[],"key":"volume"},{"Name":"type","Type":"AudioMixingType","Required":"是","Default":"无","Description":"详见 AudioMixingType。\n","children":[],"key":"type"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### getVolume()  

获取当前音量

**注意**

  仅在音频播放进行状态时，调用此方法。包括音乐文件混音和 PCM 混音。

**类型**

  ```ts
  (type: AudioMixingType) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"type","Type":"AudioMixingType","Required":"是","Default":"无","Description":"详见 AudioMixingType。\n","children":[],"key":"type"}]
      return (
);
```
  

**返回值**

  number
  - \>0: 成功, 当前音量值。
  - < 0: 失败

### getTotalDuration()  

获取音乐文件时长。

**注意**

  - 仅在音频播放进行状态时，调用此方法。
  - 此接口仅支持音频文件，不支持 PCM 数据。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  - \>0: 成功, 音乐文件时长，单位为毫秒。
  - < 0: 失败

### getPlaybackDuration()  

获取混音音乐文件的实际播放时长，单位为毫秒。

**注意**

  - 实际播放时长指的是歌曲不受停止、跳转、倍速、卡顿影响的播放时长。例如，若歌曲正常播放到 1:30 时停止播放 30s 或跳转进度到 2:00, 随后继续正常播放 2 分钟，则实际播放时长为 3 分 30 秒。
  - 仅在音频播放进行状态，且 setProgressInterval 设置间隔大于 `0` 时，调用此方法。
  - 此接口仅支持音频文件，不支持 PCM 数据。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  - \>0: 实际播放时长。
  - < 0: 失败。

### getPosition()  

获取音乐文件播放进度。

**注意**

  - 仅在音频播放进行状态时，调用此方法。
  - 此接口仅支持音频文件，不支持 PCM 数据。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  - \>0: 成功, 音乐文件播放进度，单位为毫秒。
  - < 0: 失败

### setAudioPitch()  

开启变调功能，多用于 K 歌场景。

**注意**

  - 仅在音频播放进行状态时，调用此方法。
  - 仅支持音乐文件混音，不支持 PCM 数据。

**类型**

  ```ts
  (pitch: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"pitch","Type":"number","Required":"是","Default":"无","Description":"与音乐文件原始音调相比的升高/降低值，取值范围为 [-12，12]，默认值为 0。每相邻两个值的音高距离相差半音，正值表示升调，负值表示降调。\n","children":[],"key":"pitch"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### setPosition()  

设置音乐文件的起始播放位置。

**注意**

  - 此接口仅支持音频文件，不支持 PCM 数据。
  - 在播放在线文件时，调用此接口可能造成播放延迟的现象。

**类型**

  ```ts
  (position: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"position","Type":"number","Required":"是","Default":"无","Description":"音乐文件起始播放位置，单位为毫秒。
你可以通过 getTotalDuration 获取音乐文件总时长，position 的值应小于音乐文件总时长。\n","children":[],"key":"position"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### setAudioDualMonoMode()  

设置当前音乐文件的声道模式

**注意**

  - 仅在音频播放进行状态时，调用此方法。
  - 仅支持音频文件，不支持 PCM 数据。

**类型**

  ```ts
  (mode: AudioMixingDualMonoMode) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"mode","Type":"AudioMixingDualMonoMode","Required":"是","Default":"无","Description":"声道模式。默认的声道模式和源文件一致，详见 AudioMixingDualMonoMode。\n","children":[],"key":"mode"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### getAudioTrackCount()  

获取当前音乐文件的音轨数

**注意**

  - 仅在音频播放进行状态时，调用此方法。
  - 此方法仅支持音乐文件，不支持 PCM 数据。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  + >= 0：成功，返回当前音乐文件的音轨数
  - < 0：方法调用失败

### selectAudioTrack()  

指定当前音乐文件的播放音轨

**注意**

  - 仅在音频播放进行状态时，调用此方法。
  - 此方法仅支持音乐文件，不支持 PCM 数据。

**类型**

  ```ts
  (index: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"index","Type":"number","Required":"是","Default":"无","Description":"指定的播放音轨，从 0 开始，取值范围为 [0, getAudioTrackCount()-1]。
设置的参数值需要小于 getAudioTrackCount 的返回值\n","children":[],"key":"index"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### setPlaybackSpeed()  

设置播放速度

**注意**

  - 仅在音频播放进行状态时，调用此方法。
  - 此方法对音频文件可用，不支持 PCM 数据。

**类型**

  ```ts
  (speed: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"speed","Type":"number","Required":"是","Default":"无","Description":"播放速度与原始文件速度的比例，单位：%，取值范围为 [50,200]，默认值为 100。\n","children":[],"key":"speed"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### setProgressInterval()  

设置音频文件混音时，收到 onMediaPlayerPlayingProgress 的间隔。

**注意**

  - 仅在音频播放进行状态时，调用此方法。
  - 此方法仅支持音频文件，不支持 PCM 数据。

**类型**

  ```ts
  (interval: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"interval","Type":"number","Required":"是","Default":"无","Description":"时间间隔，单位毫秒。
\ninterval > 0 时，触发回调。实际间隔为 10 的倍数。如果输入数值不能被 10 整除，将自动向上取整。例如传入 52，实际间隔为 60 ms。
\ninterval <= 0 时，不会触发回调。\n\n","children":[],"key":"interval"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### setLoudness()  

如果你需要使用 enableVocalInstrumentBalance 对音频文件/PCM 音频数据设置音量均衡，你必须通过此接口传入其原始响度。

**注意**

  - 仅在音频播放进行状态时，调用此方法。
  - 此方法对音频文件和音频裸数据播放都可用。

**类型**

  ```ts
  (loudness: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"loudness","Type":"number","Required":"是","Default":"无","Description":"原始响度，单位：lufs，取值范围为 [-70.0, 0.0]。
当设置的值小于 -70.0lufs 时，则默认调整为 -70.0lufs，大于 0.0lufs 时，则不对该响度做音量均衡处理。默认值为 1.0lufs，即不做处理。\n","children":[],"key":"loudness"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### registerAudioFrameObserver()  

注册回调句柄以在本地音乐文件混音时，收到相关回调。

**注意**

  此接口仅支持音频文件，不支持 PCM 数据。

**类型**

  ```ts
  (observer: IMediaPlayerAudioFrameObserver) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"observer","Type":"IMediaPlayerAudioFrameObserver","Required":"是","Default":"无","Description":"参看 IMediaPlayerAudioFrameObserver。\n","children":[],"key":"observer"}]
      return (
);
```
  

**返回值**

  number
  - 0: 调用成功。
  - < 0 : 调用失败。查看 [ReturnStatus](1390578#returnstatus) 获得更多错误说明

### pushExternalAudioFrame()  

推送用于混音的 PCM 音频帧数据

**注意**

  - 调用该方法前，须通过 openWithCustomSource 启动外部音频流混音。
  - 使用参考建议：首次推送数据，请在应用侧先缓存一定数据（如 200 毫秒），然后一次性推送过去；此后的推送操作定时 10 毫秒一次，并且每次的音频数据量为 10 毫秒数据量。
  - 如果要暂停播放，暂停推送即可。

**类型**

  ```ts
  (audioFrame: AudioFrame) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"audioFrame","Type":"AudioFrame","Required":"是","Default":"无","Description":"音频帧，详见 AudioFrame。
\n音频采样格式必须为 S16。音频缓冲区内的数据格式必须为 PCM，其容量大小应该为 audioFrame.samples × audioFrame.channel × 2。
\n必须指定具体的采样率和声道数，不支持设置为自动。\n\n","children":[],"key":"audioFrame"}]
      return (
);
```
  

**返回值**

  number
  - 0: 成功
  - < 0: 失败

### setEventHandler()  

设置回调句柄。

**类型**

  ```ts
  (handler: IMediaPlayerEventHandler) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"handler","Type":"IMediaPlayerEventHandler","Required":"是","Default":"无","Description":"参看 IMediaPlayerEventHandler。\n","children":[],"key":"handler"}]
      return (
);
```
  

**返回值**

  number
  - 0: 成功。
  - < 0: 失败。


## ISingScoringManager 

类型：`class`

K 歌评分管理接口。

### setSingScoringConfig()  

设置 K 歌评分参数。

**类型**

  ```ts
  (config: SingScoringConfig) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"config","Type":"SingScoringConfig","Required":"是","Default":"无","Description":"K 歌评分的各项参数，详见 SingScoringConfig。\n","children":[],"key":"config"}]
      return (
);
```
  

**返回值**

  number
  - 0：配置成功。
  - -1：接口调用失败。
  - -2：未集成 K 歌评分模块。
  - \>0：其他错误，具体参看[错误码表](https://www.volcengine.com/docs/6489/148198)。

### startSingScoring()  

开始 K 歌评分。

**注意**

  - 在调用 initSingScoring 初始化 K 歌评分功能后调用该接口。
  - 调用该接口后，将会根据设置的回调时间间隔，收到评分结果 onCurrentScoringInfo 回调。
  - 如果调用 startAudioMixing 接口播放音频文件，请在收到 onAudioMixingStateChanged(AUDIO_MIXING_STATE_PLAYING(1)) 之后调用此接口。

**类型**

  ```ts
  (position: number, scoringInfoInterval: number) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"position","Type":"number","Required":"是","Default":"无","Description":"开始评分时，音乐的播放进度，单位：ms。
\n","children":[],"key":"position"},{"Name":"scoringInfoInterval","Type":"number","Required":"是","Default":"无","Description":"实时回调的时间间隔，单位：ms；默认 50 ms。最低间隔为 20 ms。\n","children":[],"key":"scoringInfoInterval"}]
      return (
);
```
  

**返回值**

  number
  - 0：配置成功。
  - -1：接口调用失败。
  - -2：未集成 K 歌评分模块。
  - \>0：其他错误，具体参看[错误码表](https://www.volcengine.com/docs/6489/148198)。

### stopSingScoring()  

停止 K 歌评分。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  - 0：成功。
  - <0：失败。

### getLastSentenceScore()  

获取上一句的演唱评分。调用 startSingScoring 开始评分后可以调用该接口。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  - <0：获取评分失败。
  - \>=0：上一句歌词的演唱评分。

### getTotalScore()  

获取当前演唱总分。调用 startSingScoring 开始评分后可以调用该接口。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  - <0：获取总分失败。
  - \>=0：当前演唱总分。

### getAverageScore()  

获取当前演唱歌曲的平均分。

**类型**

  ```ts
  () => number
  ```

**返回值**

  number
  - <0：获取平均分失败。
  - \>=0：当前演唱平均分。


## IKTVManager 

类型：`class`

KTV 管理接口。

### ios_delegate  

类型：$p_i.ByteRTCKTVManagerDelegate

### android_setKTVManagerEventHandler()  

设置 KTV 回调接口。

**类型**

  ```ts
  (ktvManagerEventHandler: $p_a.IKTVManagerEventHandler) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"ktvManagerEventHandler","Type":"$p_a.IKTVManagerEventHandler","Required":"是","Default":"无","Description":"KTV 回调类，参看 IKTVManagerEventHandler。\n","children":[],"key":"ktvManagerEventHandler"}]
      return (
);
```
  

### setMaxCacheSize()  

设置歌曲文件最大占用的本地缓存。

**类型**

  ```ts
  (maxCacheSizeMB: number) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"maxCacheSizeMB","Type":"number","Required":"是","Default":"无","Description":"本地缓存，单位 MB。
设置值小于等于 0 时，使用默认值 1024 MB。\n","children":[],"key":"maxCacheSizeMB"}]
      return (
);
```
  

### getMusicDetail()  

获取音乐详细信息。

**注意**

  调用接口后，你会收到 onMusicDetailResult 回调。

**类型**

  ```ts
  (musicId: string) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"musicId","Type":"string","Required":"是","Default":"无","Description":"音乐 ID。\n","children":[],"key":"musicId"}]
      return (
);
```
  

### downloadMusic()  

下载音乐。

**注意**

  - 若音乐下载成功，你会收到 onDownloadSuccess 回调。
  - 若音乐下载失败，你会收到 onDownloadFailed 回调。
  - 音乐下载进度更新时，你会收到 onDownloadMusicProgress 回调。

**类型**

  ```ts
  (musicId: string) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"musicId","Type":"string","Required":"是","Default":"无","Description":"音乐 ID。\n","children":[],"key":"musicId"}]
      return (
);
```
  

**返回值**

  number  下载任务 ID。

### downloadLyric()  

下载歌词。

**注意**

  - 若歌词下载成功，你会收到 onDownloadSuccess 回调。
  - 若歌词下载失败，你会收到 onDownloadFailed 回调。

**类型**

  ```ts
  (musicId: string, lyricType: DownloadLyricType) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"musicId","Type":"string","Required":"是","Default":"无","Description":"音乐 ID。
\n","children":[],"key":"musicId"},{"Name":"lyricType","Type":"DownloadLyricType","Required":"是","Default":"无","Description":"歌词文件类型，参看 DownloadLyricType。\n","children":[],"key":"lyricType"}]
      return (
);
```
  

**返回值**

  number  下载任务 ID。

### downloadMidi()  

下载 MIDI 文件。

**注意**

  - 若文件下载成功，你会收到 onDownloadSuccess 回调。
  - 若文件下载失败，你会收到 onDownloadFailed 回调。

**类型**

  ```ts
  (musicId: string) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"musicId","Type":"string","Required":"是","Default":"无","Description":"音乐 ID。\n","children":[],"key":"musicId"}]
      return (
);
```
  

**返回值**

  number  下载任务 ID。

### cancelDownload()  

取消下载任务。

**类型**

  ```ts
  (downloadId: number) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '描述',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"downloadId","Type":"number","Required":"是","Default":"无","Description":"下载任务 ID。\n","children":[],"key":"downloadId"}]
      return (
);
```
  

### clearCache()  

清除当前音乐缓存文件，包括音乐音频和歌词。

**类型**

  ```ts
  () => void
  ```

### getKTVPlayer()  

获取 KTV 播放器。

**类型**

  ```ts
  () => IKTVPlayer
  ```

**返回值**

  [IKTVPlayer](#iktvplayer)  KTV 播放器接口，参看 [IKTVPlayer](#iktvplayer)。


## IAudioMixingManager 

类型：`class`

混音管理类

:::warning 已弃用 
   since 353. Use [IAudioEffectPlayer](#iaudioeffectplayer) and [IMediaPlayer](#imediaplayer) instead.
:::
	前置摄像头	后置摄像头	自定义采集视频源	桌面端摄像头
移动端	本地预览镜像，编码传输不镜像	本地预览不镜像，编码传输不镜像	本地预览不镜像，编码传输不镜像	/
桌面端	/	/	本地预览不镜像，编码传输不镜像	本地预览镜像，编码传输不镜像
实时音视频
