## IFaceDetectionObserver 类型：`interface` 人脸检测结果回调观察者注意：回调函数是在 SDK 内部线程（非 UI 线程）同步抛出来的，请不要做耗时操作或直接操作 UI，否则可能导致 app 崩溃。 ### onFaceDetectResult 特效 SDK 进行人脸检测结果的回调。调用 enableFaceDetection 注册了 [IFaceDetectionObserver](#ifacedetectionobserver)，并使用 RTC SDK 中包含的特效 SDK 进行视频特效处理时，你会收到此回调。 **类型** ```ts ((result: FaceDetectionResult) => void) | undefined ``` **参数** ```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":"result","Type":"FaceDetectionResult","Required":"是","Default":"无","Description":"人脸检测结果, 参看 FaceDetectionResult。\n","children":[],"key":"result"}]
      return ();
```
  


## RTCVideoEventHandler 

类型：`interface`

音视频引擎事件回调接口
注意：回调函数是在 SDK 内部线程（非 UI 线程）同步抛出来的，请不要做耗时操作或直接操作 UI，否则可能导致 app 崩溃。

### onWarning  

发生警告回调。
SDK 运行时出现了警告。SDK 通常会自动恢复，警告信息可以忽略。

**类型**

  ```ts
  ((warn: WarningCode) => void) | undefined
  ```

**参数**


```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":"warn","Type":"WarningCode","Required":"是","Default":"无","Description":"警告代码，参见 WarningCode\n","children":[],"key":"warn"}]
      return (
);
```
  

### onError  

发生错误回调。
SDK 运行时出现了网络或媒体相关的错误，且无法自动恢复时触发此回调。
你可能需要干预.

**类型**

  ```ts
  ((err: ErrorCode) => void) | undefined
  ```

**参数**


```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":"err","Type":"ErrorCode","Required":"是","Default":"无","Description":"错误代码，详情定义见: ErrorCode\n","children":[],"key":"err"}]
      return (
);
```
  

### onExtensionAccessError  

当访问插件失败时，收到此回调。
RTC SDK 将一些功能封装成插件。当使用这些功能时，如果插件不存在，功能将无法使用。

**类型**

  ```ts
  ((extensionName: string, msg: string) => void) | undefined
  ```

**参数**


```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":"extensionName","Type":"string","Required":"是","Default":"无","Description":"插件名字
\n","children":[],"key":"extensionName"},{"Name":"msg","Type":"string","Required":"是","Default":"无","Description":"失败说明\n","children":[],"key":"msg"}]
      return (
);
```
  

### onSysStats  

每 2 秒发生回调，通知当前 cpu，内存使用的信息。

**类型**

  ```ts
  ((stats: SysStats) => void) | undefined
  ```

**参数**


```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":"stats","Type":"SysStats","Required":"是","Default":"无","Description":"cpu，内存信息。详见 SysStats 数据类型。\n","children":[],"key":"stats"}]
      return (
);
```
  

### onNetworkTypeChanged  

SDK 当前网络连接类型改变回调。当 SDK 的当前网络连接类型发生改变时回调该事件。

**类型**

  ```ts
  ((type: RTCNetworkType) => void) | undefined
  ```

**参数**


```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":"RTCNetworkType","Required":"是","Default":"无","Description":"网络类型。
\n-1： 网络连接类型未知。
\n0： 网络连接已断开。
\n1： LAN
\n2： Wi-Fi,包含热点
\n3： 2G 移动网络
\n4： 3G 移动网络
\n5： 4G 移动网络
\n6： 5G 移动网络\n\n","children":[],"key":"type"}]
      return (
);
```
  

### onUserStartVideoCapture  

房间内的可见用户调用 startVideoCapture 开启内部视频采集时，房间内其他用户会收到此回调。

**类型**

  ```ts
  ((roomId: string, uid: string) => void) | undefined
  ```

**参数**


```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
\n","children":[],"key":"roomId"},{"Name":"uid","Type":"string","Required":"是","Default":"无","Description":"开启视频采集的远端用户 ID\n","children":[],"key":"uid"}]
      return (
);
```
  

### onUserStopVideoCapture  

房间内的可见用户调用 stopVideoCapture 关闭内部视频采集时，房间内其他用户会收到此回调。
若发布视频数据前未开启采集，房间内所有可见用户会收到此回调。

**类型**

  ```ts
  ((roomId: string, uid: string) => void) | undefined
  ```

**参数**


```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
\n","children":[],"key":"roomId"},{"Name":"uid","Type":"string","Required":"是","Default":"无","Description":"关闭视频采集的远端用户 ID\n","children":[],"key":"uid"}]
      return (
);
```
  

### onCreateRoomStateChanged  

创建房间失败回调。

**类型**

  ```ts
  ((roomId: string, errorCode: number) => void) | undefined
  ```

**参数**


```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。
\n","children":[],"key":"roomId"},{"Name":"errorCode","Type":"number","Required":"是","Default":"无","Description":"创建房间错误码，具体原因参看 ErrorCode。\n","children":[],"key":"errorCode"}]
      return (
);
```
  

### onUserStartAudioCapture  

房间内的用户调用 startAudioCapture 开启音频采集时，房间内其他用户会收到此回调。

**类型**

  ```ts
  ((roomId: string, uid: string) => void) | undefined
  ```

**参数**


```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
\n","children":[],"key":"roomId"},{"Name":"uid","Type":"string","Required":"是","Default":"无","Description":"开启音频采集的远端用户 ID\n","children":[],"key":"uid"}]
      return (
);
```
  

### onUserStopAudioCapture  

房间内的用户调用 stopAudioCapture 关闭音频采集时，房间内其他用户会收到此回调。

**类型**

  ```ts
  ((roomId: string, uid: string) => void) | undefined
  ```

**参数**


```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
\n","children":[],"key":"roomId"},{"Name":"uid","Type":"string","Required":"是","Default":"无","Description":"关闭音频采集的远端用户 ID\n","children":[],"key":"uid"}]
      return (
);
```
  

### onLocalAudioStateChanged  

本地音频流的状态发生改变时，收到此回调。

**类型**

  ```ts
  ((state: LocalAudioStreamState, error: LocalAudioStreamError) => void) | undefined
  ```

**参数**


```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":"state","Type":"LocalAudioStreamState","Required":"是","Default":"无","Description":"本地音频设备的状态，详见 LocalAudioStreamState
\n","children":[],"key":"state"},{"Name":"error","Type":"LocalAudioStreamError","Required":"是","Default":"无","Description":"本地音频流状态改变时的错误码，详见 LocalAudioStreamError\n","children":[],"key":"error"}]
      return (
);
```
  

### onRemoteAudioStateChanged  

用户订阅来自远端的音频流状态发生改变时，会收到此回调，了解当前的远端音频流状态。

**类型**

  ```ts
  ((key: RemoteStreamKey, state: RemoteAudioState, reason: RemoteAudioStateChangeReason) => void) | undefined
  ```

**参数**


```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":"state","Type":"RemoteAudioState","Required":"是","Default":"无","Description":"远端音频流状态，详见 RemoteAudioState
\n","children":[],"key":"state"},{"Name":"reason","Type":"RemoteAudioStateChangeReason","Required":"是","Default":"无","Description":"远端音频流状态改变的原因，详见 RemoteAudioStateChangeReason\n","children":[],"key":"reason"}]
      return (
);
```
  

### onLocalVideoStateChanged  

本地视频流的状态发生改变时，收到该事件。

**类型**

  ```ts
  ((streamIndex: StreamIndex, state: LocalVideoStreamState, error: LocalVideoStreamError) => void) | undefined
  ```

**参数**


```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":"state","Type":"LocalVideoStreamState","Required":"是","Default":"无","Description":"本地视频流状态，参看 LocalVideoStreamState
\n","children":[],"key":"state"},{"Name":"error","Type":"LocalVideoStreamError","Required":"是","Default":"无","Description":"本地视频状态改变时的错误码，参看 LocalVideoStreamError\n","children":[],"key":"error"}]
      return (
);
```
  

### onRemoteVideoStateChanged  

远端视频流的状态发生改变时，房间内订阅此流的用户会收到该事件。

**类型**

  ```ts
  ((streamKey: RemoteStreamKey, videoState: RemoteVideoState, videoStateReason: RemoteVideoStateChangeReason) => void) | undefined
  ```

**参数**


```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":"远端视频流信息，房间、用户 ID、流属性等，参看 RemoteStreamKey
\n","children":[],"key":"streamKey"},{"Name":"videoState","Type":"RemoteVideoState","Required":"是","Default":"无","Description":"远端视频流状态，参看 RemoteVideoState
\n","children":[],"key":"videoState"},{"Name":"videoStateReason","Type":"RemoteVideoStateChangeReason","Required":"是","Default":"无","Description":"远端视频流状态改变原因，参看 RemoteVideoStateChangeReason\n","children":[],"key":"videoStateReason"}]
      return (
);
```
  

### onFirstRemoteVideoFrameRendered  

SDK 内部渲染成功远端视频流首帧后，收到此回调。

**类型**

  ```ts
  ((remoteStreamKey: RemoteStreamKey, frameInfo: VideoFrameInfo) => void) | undefined
  ```

**参数**


```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":"frameInfo","Type":"VideoFrameInfo","Required":"是","Default":"无","Description":"视频帧信息，参看 VideoFrameInfo\n","children":[],"key":"frameInfo"}]
      return (
);
```
  

### onFirstRemoteVideoFrameDecoded  

SDK 接收并解码远端视频流首帧后，收到此回调。

**类型**

  ```ts
  ((remoteStreamKey: RemoteStreamKey, frameInfo: VideoFrameInfo) => void) | undefined
  ```

**参数**


```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":"frameInfo","Type":"VideoFrameInfo","Required":"是","Default":"无","Description":"视频帧信息，参看 VideoFrameInfo\n","children":[],"key":"frameInfo"}]
      return (
);
```
  

### onFirstLocalVideoFrameCaptured  

RTC SDK 在本地完成第一帧视频帧或屏幕视频帧采集时，收到此回调。

**类型**

  ```ts
  ((streamIndex: StreamIndex, frameInfo: VideoFrameInfo) => void) | undefined
  ```

**参数**


```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":"frameInfo","Type":"VideoFrameInfo","Required":"是","Default":"无","Description":"视频信息，参看 VideoFrameInfo\n","children":[],"key":"frameInfo"}]
      return (
);
```
  

### onLocalVideoSizeChanged  

本地预览视频大小或旋转信息发生改变时，收到此回调。

**类型**

  ```ts
  ((streamIndex: StreamIndex, frameInfo: VideoFrameInfo) => void) | undefined
  ```

**参数**


```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":"frameInfo","Type":"VideoFrameInfo","Required":"是","Default":"无","Description":"视频帧信息，参看 VideoFrameInfo\n","children":[],"key":"frameInfo"}]
      return (
);
```
  

### onRemoteVideoSizeChanged  

远端视频大小或旋转信息发生改变时，房间内订阅此视频流的用户会收到此回调。

**类型**

  ```ts
  ((remoteStreamKey: RemoteStreamKey, frameInfo: VideoFrameInfo) => void) | undefined
  ```

**参数**


```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":"frameInfo","Type":"VideoFrameInfo","Required":"是","Default":"无","Description":"视频帧信息，参看 VideoFrameInfo\n","children":[],"key":"frameInfo"}]
      return (
);
```
  

### onConnectionStateChanged  

回调 SDK 与信令服务器连接状态相关事件。当 SDK 与信令服务器的网络连接状态改变时回调该事件。

**类型**

  ```ts
  ((state: ConnectionState) => void) | undefined
  ```

**参数**


```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":"state","Type":"ConnectionState","Required":"是","Default":"无","Description":"当前 SDK 与信令服务器连接状态。 详细定义参见 ConnectionState\n","children":[],"key":"state"}]
      return (
);
```
  

### onAudioRouteChanged  

音频播放路由变化时，收到该回调。

**类型**

  ```ts
  ((route: AudioRoute) => void) | undefined
  ```

**参数**


```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 (
);
```
  

### onFirstLocalAudioFrame  

发布音频流时，采集到第一帧音频帧，收到该回调。

**类型**

  ```ts
  ((streamIndex: StreamIndex) => void) | undefined
  ```

**参数**


```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 (
);
```
  

### onFirstRemoteAudioFrame  

接收到来自远端某音频流的第一帧时，收到该回调。

**类型**

  ```ts
  ((remoteStreamKey: RemoteStreamKey) => void) | undefined
  ```

**参数**


```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"}]
      return (
);
```
  

### onSEIMessageReceived  

收到通过调用 sendSEIMessage 发送带有 SEI 消息的视频帧时，收到此回调。

**类型**

  ```ts
  ((remoteStreamKey: RemoteStreamKey, message: ByteBuffer) => void) | undefined
  ```

**参数**


```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":"包含 SEI 发送者的用户名，所在的房间名和媒体流，详见 RemoteStreamKey
\n","children":[],"key":"remoteStreamKey"},{"Name":"message","Type":"ArrayBuffer","Required":"是","Default":"无","Description":"收到的 SEI 消息内容\n","children":[],"key":"message"}]
      return (
);
```
  

### onSEIStreamUpdate  

黑帧视频流发布状态回调。
在语音通话场景下，本地用户调用 sendSEIMessage 通过黑帧视频流发送 SEI 数据时，流的发送状态会通过该回调通知远端用户。
你可以通过此回调判断携带 SEI 数据的视频帧为黑帧，从而不对该视频帧进行渲染。

**类型**

  ```ts
  ((remoteStreamKey: RemoteStreamKey, event: SEIStreamUpdateEventType) => void) | undefined
  ```

**参数**


```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":"event","Type":"SEIStreamUpdateEventType","Required":"是","Default":"无","Description":"黑帧视频流状态，参看 SEIStreamUpdateEvent\n","children":[],"key":"event"}]
      return (
);
```
  

### onLoginResult  

登录结果回调

**类型**

  ```ts
  ((uid: string, errorCode: LoginErrorCode, elapsed: number) => void) | undefined
  ```

**参数**


```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":"errorCode","Type":"LoginErrorCode","Required":"是","Default":"无","Description":"登录结果
详见 LoginErrorCode。
\n","children":[],"key":"errorCode"},{"Name":"elapsed","Type":"number","Required":"是","Default":"无","Description":"从调用 login 接口开始到返回结果所用时长。
单位为 ms。\n","children":[],"key":"elapsed"}]
      return (
);
```
  

### onLogout  

登出结果回调

**类型**

  ```ts
  ((reason: LogoutReason) => void) | undefined
  ```

**参数**


```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":"reason","Type":"LogoutReason","Required":"是","Default":"无","Description":"用户登出的原因，参看 LogoutReason\n","children":[],"key":"reason"}]
      return (
);
```
  

### onServerParamsSetResult  

设置应用服务器参数的返回结果

**类型**

  ```ts
  ((error: number) => void) | undefined
  ```

**参数**


```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":"error","Type":"number","Required":"是","Default":"无","Description":"设置结果
\n返回 200，设置成功
\n返回其他，设置失败，详见 UserMessageSendResult\n\n","children":[],"key":"error"}]
      return (
);
```
  

### onGetPeerOnlineStatus  

查询对端或本端用户登录状态的返回结果

**类型**

  ```ts
  ((peerUserId: string, status: UserOnlineStatus) => void) | undefined
  ```

**参数**


```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"},{"Name":"status","Type":"UserOnlineStatus","Required":"是","Default":"无","Description":"查询的用户登录状态
详见 UserOnlineStatus.\n","children":[],"key":"status"}]
      return (
);
```
  

### onUserMessageReceivedOutsideRoom  

收到房间外用户调用 sendUserMessageOutsideRoom 发来的文本消息时，会收到此回调

**类型**

  ```ts
  ((uid: string, message: string) => void) | undefined
  ```

**参数**


```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":"收到的文本消息内容\n","children":[],"key":"message"}]
      return (
);
```
  

### onUserBinaryMessageReceivedOutsideRoom  

收到房间外用户调用 sendUserBinaryMessageOutsideRoom 发来的二进制消息时，会收到此回调

**类型**

  ```ts
  ((uid: string, message: ByteBuffer) => void) | undefined
  ```

**参数**


```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":"ArrayBuffer","Required":"是","Default":"无","Description":"收到的二进制消息内容\n","children":[],"key":"message"}]
      return (
);
```
  

### onUserMessageSendResultOutsideRoom  

给房间外指定的用户发送消息的回调

**类型**

  ```ts
  ((msgid: number, error: UserMessageSendResult) => void) | undefined
  ```

**参数**


```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":"msgid","Type":"number","Required":"是","Default":"无","Description":"本条消息的 ID
所有的 P2P 和 P2Server 消息共用一个 ID 序列。
\n","children":[],"key":"msgid"},{"Name":"error","Type":"UserMessageSendResult","Required":"是","Default":"无","Description":"消息发送结果
详见 UserMessageSendResult。\n","children":[],"key":"error"}]
      return (
);
```
  

### onServerMessageSendResult  

给应用服务器发送消息的回调。

**类型**

  ```ts
  ((msgid: number, error: UserMessageSendResult, message: ByteBuffer) => void) | undefined
  ```

**参数**


```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":"msgid","Type":"number","Required":"是","Default":"无","Description":"本条消息的 ID
所有的 P2P 和 P2Server 消息共用一个 ID 序列。
\n","children":[],"key":"msgid"},{"Name":"error","Type":"UserMessageSendResult","Required":"是","Default":"无","Description":"消息发送结果，详见 UserMessageSendResult。
\n","children":[],"key":"error"},{"Name":"message","Type":"ArrayBuffer","Required":"是","Default":"无","Description":"应用服务器收到 HTTP 请求后，在 ACK 中返回的信息。消息不超过 64 KB。\n","children":[],"key":"message"}]
      return (
);
```
  

### onNetworkDetectionResult  

通话前网络探测结果。
成功调用 startNetworkDetection 接口开始探测后，会在 3s 内首次收到该回调，之后每 2s 收到一次该回调。

**类型**

  ```ts
  ((type: NetworkDetectionLinkType, quality: NetworkQuality, rtt: number, lostRate: number, bitrate: number, jitter: number) => void) | undefined
  ```

**参数**


```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":"NetworkDetectionLinkType","Required":"是","Default":"无","Description":"探测网络类型为上行/下行
\n","children":[],"key":"type"},{"Name":"quality","Type":"NetworkQuality","Required":"是","Default":"无","Description":"探测网络的质量，参看 NetworkQuality。
\n","children":[],"key":"quality"},{"Name":"rtt","Type":"number","Required":"是","Default":"无","Description":"探测网络的 RTT，单位：ms
\n","children":[],"key":"rtt"},{"Name":"lostRate","Type":"number","Required":"是","Default":"无","Description":"探测网络的丢包率
\n","children":[],"key":"lostRate"},{"Name":"bitrate","Type":"number","Required":"是","Default":"无","Description":"探测网络的带宽，单位：kbps
\n","children":[],"key":"bitrate"},{"Name":"jitter","Type":"number","Required":"是","Default":"无","Description":"探测网络的抖动,单位：ms\n","children":[],"key":"jitter"}]
      return (
);
```
  

### onNetworkDetectionStopped  

通话前网络探测结束
以下情况将停止探测并收到本一次本回调：
1. 当调用 stopNetworkDetection 接口停止探测后，会收到一次该回调；
2. 当收到远端/本端音频首帧后，停止探测；
3. 当探测超过 3 分钟后，停止探测；
4. 当探测链路断开一定时间之后，停止探测。

**类型**

  ```ts
  ((reason: NetworkDetectionStopReason) => void) | undefined
  ```

**参数**


```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":"reason","Type":"NetworkDetectionStopReason","Required":"是","Default":"无","Description":"停止探测的原因类型,参考 NetworkDetectionStopReason\n","children":[],"key":"reason"}]
      return (
);
```
  

### onSimulcastSubscribeFallback  

音视频流因网络环境变化等原因发生回退，或从回退中恢复时，触发该回调。

**类型**

  ```ts
  ((event: RemoteStreamSwitchEvent) => void) | undefined
  ```

**参数**


```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":"event","Type":"RemoteStreamSwitchEvent","Required":"是","Default":"无","Description":"音视频流发生变化的信息。参看 RemoteStreamSwitch。\n","children":[],"key":"event"}]
      return (
);
```
  

### onPerformanceAlarms  

本地未通过 setPublishFallbackOption 开启发布性能回退，检测到设备性能不足时，收到此回调。
本地通过 setPublishFallbackOption 开启发布性能回退，因设备性能/网络原因，造成发布性能回退/恢复时，收到此回调。

**类型**

  ```ts
  ((mode: PerformanceAlarmMode, roomId: string, reason: PerformanceAlarmReason, data: SourceWantedData) => void) | undefined
  ```

**参数**


```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":"PerformanceAlarmMode","Required":"是","Default":"无","Description":"指示本地是否开启发布回退功能。参看 PerformanceAlarmMode
当发布端未开启发布性能回退时，mode 值为 NORMAL。
\n当发布端开启发布性能回退时，mode 值为 SIMULCAST。
\n\n","children":[],"key":"mode"},{"Name":"roomId","Type":"string","Required":"是","Default":"无","Description":"未开启发布性能回退时，roomId 为空
\n开启发布性能回退时，roomId 是告警影响的房间 ID。
\n\n","children":[],"key":"roomId"},{"Name":"reason","Type":"PerformanceAlarmReason","Required":"是","Default":"无","Description":"告警原因，参看 PerformanceAlarmReason
\n","children":[],"key":"reason"},{"Name":"data","Type":"SourceWantedData","Required":"是","Default":"无","Description":"性能回退相关数据，详见 SourceWantedData。\n","children":[],"key":"data"}]
      return (
);
```
  

### onAudioFrameSendStateChanged  

本地音频首帧发送状态发生改变时，收到此回调。

**类型**

  ```ts
  ((roomId: string, user: RTCUser, state: FirstFrameSendState) => void) | undefined
  ```

**参数**


```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
\n","children":[],"key":"roomId"},{"Name":"user","Type":"RTCUser","Required":"是","Default":"无","Description":"本地用户信息，详见 RtcUser
\n","children":[],"key":"user"},{"Name":"state","Type":"FirstFrameSendState","Required":"是","Default":"无","Description":"首帧发送状态，详见 FirstFrameSendState\n","children":[],"key":"state"}]
      return (
);
```
  

### onVideoFrameSendStateChanged  

本地视频首帧发送状态发生改变时，收到此回调。

**类型**

  ```ts
  ((roomId: string, user: RTCUser, state: FirstFrameSendState) => void) | undefined
  ```

**参数**


```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
\n","children":[],"key":"roomId"},{"Name":"user","Type":"RTCUser","Required":"是","Default":"无","Description":"本地用户信息，详见 RtcUser
\n","children":[],"key":"user"},{"Name":"state","Type":"FirstFrameSendState","Required":"是","Default":"无","Description":"首帧发送状态，详见 FirstFrameSendState\n","children":[],"key":"state"}]
      return (
);
```
  

### onScreenVideoFrameSendStateChanged  

屏幕共享流的视频首帧发送状态发生改变时，收到此回调。

**类型**

  ```ts
  ((roomId: string, user: RTCUser, state: FirstFrameSendState) => void) | undefined
  ```

**参数**


```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
\n","children":[],"key":"roomId"},{"Name":"user","Type":"RTCUser","Required":"是","Default":"无","Description":"本地用户信息，详见 RtcUser
\n","children":[],"key":"user"},{"Name":"state","Type":"FirstFrameSendState","Required":"是","Default":"无","Description":"首帧发送状态，详见 FirstFrameSendState\n","children":[],"key":"state"}]
      return (
);
```
  

### onAudioFramePlayStateChanged  

音频首帧播放状态发生改变时，收到此回调。

**类型**

  ```ts
  ((roomId: string, user: RTCUser, state: FirstFramePlayState) => void) | undefined
  ```

**参数**


```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
\n","children":[],"key":"roomId"},{"Name":"user","Type":"RTCUser","Required":"是","Default":"无","Description":"远端用户信息，详见 RtcUser
\n","children":[],"key":"user"},{"Name":"state","Type":"FirstFramePlayState","Required":"是","Default":"无","Description":"首帧播放状态，详见 FirstFramePlayState\n","children":[],"key":"state"}]
      return (
);
```
  

### onVideoFramePlayStateChanged  

视频首帧播放状态发生改变时，收到此回调。

**类型**

  ```ts
  ((roomId: string, user: RTCUser, state: FirstFramePlayState) => void) | undefined
  ```

**参数**


```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
\n","children":[],"key":"roomId"},{"Name":"user","Type":"RTCUser","Required":"是","Default":"无","Description":"远端用户信息，详见 RtcUser
\n","children":[],"key":"user"},{"Name":"state","Type":"FirstFramePlayState","Required":"是","Default":"无","Description":"首帧播放状态，详见 FirstFramePlayState\n","children":[],"key":"state"}]
      return (
);
```
  

### onScreenVideoFramePlayStateChanged  

屏幕共享流视频首帧播放状态发生改变时，收到此回调。

**类型**

  ```ts
  ((roomId: string, user: RTCUser, state: FirstFramePlayState) => void) | undefined
  ```

**参数**


```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
\n","children":[],"key":"roomId"},{"Name":"user","Type":"RTCUser","Required":"是","Default":"无","Description":"远端用户信息，详见 RtcUser
\n","children":[],"key":"user"},{"Name":"state","Type":"FirstFramePlayState","Required":"是","Default":"无","Description":"首帧播放状态，详见 FirstFramePlayState\n","children":[],"key":"state"}]
      return (
);
```
  

### onAudioDeviceStateChanged  

音频设备状态回调。提示音频采集、音频播放等媒体设备的状态。

**类型**

  ```ts
  ((deviceID: string, deviceType: AudioDeviceType, deviceState: MediaDeviceState, deviceError: MediaDeviceError) => void) | undefined
  ```

**参数**


```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"},{"Name":"deviceType","Type":"AudioDeviceType","Required":"是","Default":"无","Description":"设备类型，详见 AudioDeviceType。
\n","children":[],"key":"deviceType"},{"Name":"deviceState","Type":"MediaDeviceState","Required":"是","Default":"无","Description":"设备状态，详见 MediaDeviceState。
\n","children":[],"key":"deviceState"},{"Name":"deviceError","Type":"MediaDeviceError","Required":"是","Default":"无","Description":"设备错误类型，详见 MediaDeviceError。\n","children":[],"key":"deviceError"}]
      return (
);
```
  

### onVideoDeviceStateChanged  

视频设备状态回调。提示摄像头视频采集、屏幕视频采集等媒体设备的状态。

**类型**

  ```ts
  ((deviceID: string, deviceType: VideoDeviceType, deviceState: MediaDeviceState, deviceError: MediaDeviceError) => void) | undefined
  ```

**参数**


```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"},{"Name":"deviceType","Type":"VideoDeviceType","Required":"是","Default":"无","Description":"设备类型，详见 VideoDeviceType。
\n","children":[],"key":"deviceType"},{"Name":"deviceState","Type":"MediaDeviceState","Required":"是","Default":"无","Description":"设备状态，详见 MediaDeviceState。
\n","children":[],"key":"deviceState"},{"Name":"deviceError","Type":"MediaDeviceError","Required":"是","Default":"无","Description":"设备错误类型，详见 MediaDeviceError。\n","children":[],"key":"deviceError"}]
      return (
);
```
  

### onAudioDeviceWarning  

音频设备警告回调。音频设备包括音频采集设备、音频渲染设备等。

**类型**

  ```ts
  ((deviceID: string, deviceType: AudioDeviceType, deviceWarning: MediaDeviceWarning) => void) | undefined
  ```

**参数**


```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"},{"Name":"deviceType","Type":"AudioDeviceType","Required":"是","Default":"无","Description":"参看 AudioDeviceType
\n","children":[],"key":"deviceType"},{"Name":"deviceWarning","Type":"MediaDeviceWarning","Required":"是","Default":"无","Description":"参看 MediaDeviceWarning\n","children":[],"key":"deviceWarning"}]
      return (
);
```
  

### onVideoDeviceWarning  

视频设备警告回调，包括视频采集等设备。

**类型**

  ```ts
  ((deviceID: string, deviceType: VideoDeviceType, deviceWarning: MediaDeviceWarning) => void) | undefined
  ```

**参数**


```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"},{"Name":"deviceType","Type":"VideoDeviceType","Required":"是","Default":"无","Description":"参看 VideoDeviceType
\n","children":[],"key":"deviceType"},{"Name":"deviceWarning","Type":"MediaDeviceWarning","Required":"是","Default":"无","Description":"参看 MediaDeviceWarning\n","children":[],"key":"deviceWarning"}]
      return (
);
```
  

### onRecordingStateUpdate  

获取本地录制状态回调。
该回调由 startFileRecording 或 stopFileRecording 触发。

**类型**

  ```ts
  ((type: StreamIndex, state: RecordingState, errorCode: RecordingErrorCode, info: RecordingInfo) => void) | undefined
  ```

**参数**


```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":"state","Type":"RecordingState","Required":"是","Default":"无","Description":"录制状态，参看 RecordingState
\n","children":[],"key":"state"},{"Name":"errorCode","Type":"RecordingErrorCode","Required":"是","Default":"无","Description":"录制错误码，参看 RecordingErrorCode
\n","children":[],"key":"errorCode"},{"Name":"info","Type":"RecordingInfo","Required":"是","Default":"无","Description":"录制文件的详细信息，参看 RecordingInfo\n","children":[],"key":"info"}]
      return (
);
```
  

### onRecordingProgressUpdate  

本地录制进度回调。
该回调由 startFileRecording 触发，录制状态正常时，系统每秒钟都会通过该回调提示录制进度。

**类型**

  ```ts
  ((type: StreamIndex, progress: RecordingProgress, info: RecordingInfo) => void) | undefined
  ```

**参数**


```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":"progress","Type":"RecordingProgress","Required":"是","Default":"无","Description":"录制进度，参看 RecordingProgress
\n","children":[],"key":"progress"},{"Name":"info","Type":"RecordingInfo","Required":"是","Default":"无","Description":"录制文件的详细信息，参看 RecordingInfo\n","children":[],"key":"info"}]
      return (
);
```
  

### onAudioRecordingStateUpdate  

调用 startAudioRecording 或 stopAudioRecording 改变音频文件录制状态时，收到此回调。

**类型**

  ```ts
  ((state: AudioRecordingState, errorCode: AudioRecordingErrorCode) => void) | undefined
  ```

**参数**


```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":"state","Type":"AudioRecordingState","Required":"是","Default":"无","Description":"录制状态，参看 AudioRecordingState
\n","children":[],"key":"state"},{"Name":"errorCode","Type":"AudioRecordingErrorCode","Required":"是","Default":"无","Description":"录制错误码，参看 AudioRecordingErrorCode\n","children":[],"key":"errorCode"}]
      return (
);
```
  

### onAudioMixingPlayingProgress  

混音音频文件播放进度回调

**类型**

  ```ts
  ((mixId: number, progress: number) => void) | undefined
  ```

**参数**


```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":"mixId","Type":"number","Required":"是","Default":"无","Description":"混音 ID
\n","children":[],"key":"mixId"},{"Name":"progress","Type":"number","Required":"是","Default":"无","Description":"当前混音音频文件播放进度，单位毫秒\n","children":[],"key":"progress"}]
      return (
);
```
  

### onLocalAudioPropertiesReport  

调用 enableAudioPropertiesReport 后，你会周期性地收到此回调，了解本地音频的相关信息。
本地音频包括使用 RTC SDK 内部机制采集的麦克风音频，屏幕音频和本地混音音频信息。

**类型**

  ```ts
  ((audioPropertiesInfos: Array) => void) | undefined
  ```

**参数**


```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":"audioPropertiesInfos","Type":"LocalAudioPropertiesInfo[]","Required":"是","Default":"无","Description":"本地音频信息，详见 LocalAudioPropertiesInfo 。\n","children":[],"key":"audioPropertiesInfos"}]
      return (
);
```
  

### onRemoteAudioPropertiesReport  

远端用户进房后，本地调用 enableAudioPropertiesReport ，根据设置的 interval 值，本地会周期性地收到此回调，了解订阅的远端用户的音频信息。
远端用户的音频包括使用 RTC SDK 内部机制/自定义机制采集的麦克风音频和屏幕音频。

**类型**

  ```ts
  ((audioPropertiesInfos: Array, totalRemoteVolume: number) => void) | undefined
  ```

**参数**


```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":"audioPropertiesInfos","Type":"RemoteAudioPropertiesInfo[]","Required":"是","Default":"无","Description":"远端音频信息，其中包含音频流属性、房间 ID、用户 ID ，详见 RemoteAudioPropertiesInfo。
\n","children":[],"key":"audioPropertiesInfos"},{"Name":"totalRemoteVolume","Type":"number","Required":"是","Default":"无","Description":"订阅的所有远端流的总音量。\n","children":[],"key":"totalRemoteVolume"}]
      return (
);
```
  

### onActiveSpeaker  

调用 enableAudioPropertiesReport 后，根据设置的 `AudioPropertiesConfig.interval`，你会周期性地收到此回调，获取房间内的最活跃用户信息。

**类型**

  ```ts
  ((roomId: string, uid: string) => void) | undefined
  ```

**参数**


```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
\n","children":[],"key":"roomId"},{"Name":"uid","Type":"string","Required":"是","Default":"无","Description":"最活跃用户（ActiveSpeaker）的用户 ID\n","children":[],"key":"uid"}]
      return (
);
```
  

### onStreamSyncInfoReceived  

音频流同步信息回调。可以通过此回调，在远端用户调用 sendStreamSyncInfo 发送音频流同步消息后，收到远端发送的音频流同步信息。

**类型**

  ```ts
  ((streamKey: RemoteStreamKey, streamType: SyncInfoStreamType, data: ByteBuffer) => void) | undefined
  ```

**参数**


```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":"streamType","Type":"SyncInfoStreamType","Required":"是","Default":"无","Description":"媒体流类型，详见 SyncInfoStreamType 。
\n","children":[],"key":"streamType"},{"Name":"data","Type":"ArrayBuffer","Required":"是","Default":"无","Description":"消息内容。\n","children":[],"key":"data"}]
      return (
);
```
  

### onPushPublicStreamResult  

 WTN 流发布结果回调。
调用 startPushPublicStream 接口发布 WTN 流后，启动结果通过此回调方法通知用户。

**类型**

  ```ts
  ((roomId: string, publicStreamId: string, error: PublicStreamErrorCode) => void) | undefined
  ```

**参数**


```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":"发布 WTN 流的房间 ID
\n","children":[],"key":"roomId"},{"Name":"publicStreamId","Type":"string","Required":"是","Default":"无","Description":" WTN 流 ID
\n","children":[],"key":"publicStreamId"},{"Name":"error","Type":"PublicStreamErrorCode","Required":"是","Default":"无","Description":" WTN 流发布结果状态码。详见 PublicStreamErrorCode。\n","children":[],"key":"error"}]
      return (
);
```
  

### onPlayPublicStreamResult  

订阅 WTN 流的结果回调
调用 startPlayPublicStream 接口启动拉 WTN 流功能后，通过此回调收到启动结果和拉流过程中的错误。

**类型**

  ```ts
  ((publicStreamId: string, error: PublicStreamErrorCode) => void) | undefined
  ```

**参数**


```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":" WTN 流 ID。
\n","children":[],"key":"publicStreamId"},{"Name":"error","Type":"PublicStreamErrorCode","Required":"是","Default":"无","Description":" WTN 流订阅结果状态码。详见 PublicStreamErrorCode。\n","children":[],"key":"error"}]
      return (
);
```
  

### onPublicStreamSEIMessageReceived  

回调 WTN 流中包含的 SEI 信息。
调用 startPlayPublicStream 接口启动拉 WTN 流功能后，通过此回调收到 WTN 流中的 SEI 消息。

**类型**

  ```ts
  ((publicStreamId: string, message: ByteBuffer, sourceType: DataMessageSourceType) => void) | undefined
  ```

**参数**


```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":" WTN 流 ID。
\n","children":[],"key":"publicStreamId"},{"Name":"message","Type":"ArrayBuffer","Required":"是","Default":"无","Description":"收到的 SEI 消息内容。
通过调用客户端 sendSEIMessage 插入的 SEI 信息。
当 WTN 流中的多路视频流均包含有 SEI 信息：SEI 不互相冲突时，将通过多次回调分别发送；SEI 在同一帧有冲突时，则只有一条流中的 SEI 信息被透传并融合到 WTN 流中。
\n","children":[],"key":"message"},{"Name":"sourceType","Type":"DataMessageSourceType","Required":"是","Default":"无","Description":"SEI 消息类型，自 3.52.1 版本后固定为 0，自定义消息。参看 DataMessageSourceType。\n","children":[],"key":"sourceType"}]
      return (
);
```
  

### onPublicStreamDataMessageReceived  

回调 WTN 流中包含的数据信息。
调用 startPlayPublicStream 订阅 WTN 流后，通过监听本回调获取 WTN 流中的数据消息，包括调用 Open API 发送的 SEI 消息和音量回调。

**类型**

  ```ts
  ((publicStreamId: string, message: ByteBuffer, sourceType: DataMessageSourceType) => void) | undefined
  ```

**参数**


```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":" WTN 流 ID。
\n","children":[],"key":"publicStreamId"},{"Name":"message","Type":"ArrayBuffer","Required":"是","Default":"无","Description":"收到的数据消息内容，如下：
\n调用 WTN 流 OpenAPI 发送的自定义消息。
\n媒体流音量变化，需要通过 WTN 流 OpenAPI 开启回调。JSON 格式说明如下：
\n                { \n                \"Type\" : \"VolumeIndication\", //具体业务类型 \n                \"VolumeInfos\"[                 // 业务类型对应信息 \n                { \n                \"RoomId\":\"1000001\", // 房间 ID \n                \"UserId\":\"1000001\", // 用户 ID \n                \"StreamType\":0, // 0:摄像头流；1:屏幕流 \n                \"LinearVolume\":1 // 线性音量大小 \n                } \n                ] \n                }\n\n","children":[],"key":"message"},{"Name":"sourceType","Type":"DataMessageSourceType","Required":"是","Default":"无","Description":"数据消息来源，参看 DataMessageSourceType。\n","children":[],"key":"sourceType"}]
      return (
);
```
  

### onFirstPublicStreamVideoFrameDecoded  

 WTN 流的首帧视频解码成功
关于订阅 WTN 流，详见 startPlayPublicStream。

**类型**

  ```ts
  ((publicStreamId: string, videoFrameInfo: VideoFrameInfo) => void) | undefined
  ```

**参数**


```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":" WTN 流 ID
\n","children":[],"key":"publicStreamId"},{"Name":"videoFrameInfo","Type":"VideoFrameInfo","Required":"是","Default":"无","Description":"视频帧信息，参看 VideoFrameInfo\n","children":[],"key":"videoFrameInfo"}]
      return (
);
```
  

### onFirstPublicStreamAudioFrame  

 WTN 流的音频首帧解码成功
关于订阅 WTN 流，详见 startPlayPublicStream。

**类型**

  ```ts
  ((publicStreamId: string) => void) | undefined
  ```

**参数**


```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":" WTN 流 ID\n","children":[],"key":"publicStreamId"}]
      return (
);
```
  

### onEchoTestResult  

关于音视频回路测试结果的回调。

**类型**

  ```ts
  ((result: EchoTestResult) => void) | undefined
  ```

**参数**


```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":"result","Type":"EchoTestResult","Required":"是","Default":"无","Description":"测试结果，参看 EchoTestResult\n","children":[],"key":"result"}]
      return (
);
```
  

### onCloudProxyConnected  

调用 startCloudProxy 开启云代理，SDK 首次成功连接云代理服务器时，回调此事件。

**类型**

  ```ts
  ((interval: number) => void) | undefined
  ```

**参数**


```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":"从开启云代理到连接成功经过的时间，单位为 ms\n","children":[],"key":"interval"}]
      return (
);
```
  

### onHardwareEchoDetectionResult  

通话前回声检测结果回调。

**类型**

  ```ts
  ((hardwareEchoDetectionResult: HardwareEchoDetectionResult) => void) | undefined
  ```

**参数**


```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":"hardwareEchoDetectionResult","Type":"HardwareEchoDetectionResult","Required":"是","Default":"无","Description":"参见 HardwareEchoDetectionResult\n","children":[],"key":"hardwareEchoDetectionResult"}]
      return (
);
```
  

### onLocalProxyStateChanged  

本地代理状态发生改变回调。调用 setLocalProxy 设置本地代理后，SDK 会触发此回调，通知代理连接的状态。

**类型**

  ```ts
  ((localProxyType: LocalProxyType, localProxyState: LocalProxyState, localProxyError: LocalProxyError) => void) | undefined
  ```

**参数**


```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":"localProxyType","Type":"LocalProxyType","Required":"是","Default":"无","Description":"本地代理类型。参看 LocalProxyType 。
\n","children":[],"key":"localProxyType"},{"Name":"localProxyState","Type":"LocalProxyState","Required":"是","Default":"无","Description":"本地代理状态。参看 LocalProxyState。
\n","children":[],"key":"localProxyState"},{"Name":"localProxyError","Type":"LocalProxyError","Required":"是","Default":"无","Description":"本地代理错误。参看 LocalProxyError。\n","children":[],"key":"localProxyError"}]
      return (
);
```
  

### onUserMuteAudio  

房间内用户暂停/恢复发送音频流时，房间内其他用户会收到此回调。

:::warning 已弃用 
   since 3.36 and will be deleted in 3.51, use onUserPublishStream, onUserPublishScreen, onUserUnpublishStream and onUserUnpublishScreen instead.
:::

**类型**

  ```ts
  ((roomId: string, uid: string, muteState: MuteState) => void) | undefined
  ```

**参数**


```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
\n","children":[],"key":"roomId"},{"Name":"uid","Type":"string","Required":"是","Default":"无","Description":"改变本地音频发送状态的用户 ID
\n","children":[],"key":"uid"},{"Name":"muteState","Type":"MuteState","Required":"是","Default":"无","Description":"发送状态，参看 MuteState\n","children":[],"key":"muteState"}]
      return (
);
```
  

### onUserMuteVideo  

房间内用户暂停/恢复发送视频流时，房间内其他用户会收到此回调。

:::warning 已弃用 
   since 3.36 and will be deleted in 3.51, use onUserPublishStream, onUserPublishScreen, onUserUnpublishStream and onUserUnpublishScreen instead.
:::

**类型**

  ```ts
  ((roomId: string, uid: string, muteState: MuteState) => void) | undefined
  ```

**参数**


```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
\n","children":[],"key":"roomId"},{"Name":"uid","Type":"string","Required":"是","Default":"无","Description":"暂停/恢复发送视频流的用户 ID。
\n","children":[],"key":"uid"},{"Name":"muteState","Type":"MuteState","Required":"是","Default":"无","Description":"视频流的发送状态。参看 MuteState。\n","children":[],"key":"muteState"}]
      return (
);
```
  

### onAudioPlaybackDeviceChanged  

音频播放设备变化时，收到该回调。

:::warning 已弃用 
   since 3.38 and will be deleted in 3.51, use onAudioRouteChanged instead.
:::

**类型**

  ```ts
  ((device: AudioPlaybackDevice) => void) | undefined
  ```

**参数**


```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":"device","Type":"AudioPlaybackDevice","Required":"是","Default":"无","Description":"新的音频设备，详见 AudioPlaybackDevice\n","children":[],"key":"device"}]
      return (
);
```
  

### onMediaDeviceStateChanged  

媒体设备状态回调。提示音频采集、音频播放、摄像头视频采集、屏幕视频采集四种媒体设备的状态。

:::warning 已弃用 
   since 3.37 and will be deleted in 3.51, using onAudioDeviceStateChanged and onVideoDeviceStateChanged instead.
:::

**类型**

  ```ts
  ((deviceID: string, deviceType: MediaDeviceType, deviceState: MediaDeviceState, deviceError: MediaDeviceError) => void) | undefined
  ```

**参数**


```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"},{"Name":"deviceType","Type":"MediaDeviceType","Required":"是","Default":"无","Description":"设备类型，详见 MediaDeviceType。
\n","children":[],"key":"deviceType"},{"Name":"deviceState","Type":"MediaDeviceState","Required":"是","Default":"无","Description":"设备状态，详见 MediaDeviceState。
\n","children":[],"key":"deviceState"},{"Name":"deviceError","Type":"MediaDeviceError","Required":"是","Default":"无","Description":"设备错误类型，详见 MediaDeviceError。\n","children":[],"key":"deviceError"}]
      return (
);
```
  

### onMediaDeviceWarning  

媒体设备警告回调。媒体设备包括：音频采集设备、音频渲染设备、和视频采集设备。

:::warning 已弃用 
   since 3.37 and will be deleted in 3.51, using onAudioDeviceWarning and onVideoDeviceWarning instead.
:::

**类型**

  ```ts
  ((deviceID: string, deviceType: MediaDeviceType, deviceWarning: MediaDeviceWarning) => void) | undefined
  ```

**参数**


```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"},{"Name":"deviceType","Type":"MediaDeviceType","Required":"是","Default":"无","Description":"参看 MediaDeviceType
\n","children":[],"key":"deviceType"},{"Name":"deviceWarning","Type":"MediaDeviceWarning","Required":"是","Default":"无","Description":"参看 MediaDeviceWarning\n","children":[],"key":"deviceWarning"}]
      return (
);
```
  

### onHttpProxyState  

HTTP 代理连接状态改变时，收到该回调。

:::warning 已弃用 
   since 3.52, will be deleted at 3.57, use onLocalProxyStateChanged instead
:::

**类型**

  ```ts
  ((state: number) => void) | undefined
  ```

**参数**


```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":"state","Type":"number","Required":"是","Default":"无","Description":"当前 HTTP 代理连接状态\n","children":[],"key":"state"}]
      return (
);
```
  

### onHttpsProxyState  

HTTPS 代理连接状态改变时，收到该回调。

:::warning 已弃用 
   since 3.52, will be deleted at 3.57, use onLocalProxyStateChanged instead
:::

**类型**

  ```ts
  ((state: number) => void) | undefined
  ```

**参数**


```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":"state","Type":"number","Required":"是","Default":"无","Description":"当前 HTTPS 代理连接状态\n","children":[],"key":"state"}]
      return (
);
```
  

### onSocks5ProxyState  

SOCKS5 代理状态改变时，收到该回调。

:::warning 已弃用 
   since 3.52, will be deleted at 3.57, use onLocalProxyStateChanged instead
:::

**类型**

  ```ts
  ((state: number, cmd: string, proxyAddress: string, localAddress: string, remoteAddress: string) => void) | undefined
  ```

**参数**


```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":"state","Type":"number","Required":"是","Default":"无","Description":"SOCKS5 代理连接状态
\n","children":[],"key":"state"},{"Name":"cmd","Type":"string","Required":"是","Default":"无","Description":"代理连接的每一步操作命令
\n","children":[],"key":"cmd"},{"Name":"proxyAddress","Type":"string","Required":"是","Default":"无","Description":"代理地址信息
\n","children":[],"key":"proxyAddress"},{"Name":"localAddress","Type":"string","Required":"是","Default":"无","Description":"当前连接使用的本地地址
\n","children":[],"key":"localAddress"},{"Name":"remoteAddress","Type":"string","Required":"是","Default":"无","Description":"远端的连接地址\n","children":[],"key":"remoteAddress"}]
      return (
);
```
  

### onAudioMixingStateChanged  

音频混音文件播放状态改变时回调

:::warning 已弃用 
   since 353. Use [IMediaPlayerEventHandler](#imediaplayereventhandler) and [IAudioEffectPlayerEventHandler](#iaudioeffectplayereventhandler) instead.
:::

**类型**

  ```ts
  ((mixId: number, state: AudioMixingState, error: AudioMixingError) => void) | undefined
  ```

**参数**


```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":"mixId","Type":"number","Required":"是","Default":"无","Description":"混音 ID
使用 IAudioMixingManager 相关接口时传入的唯一 ID。
\n","children":[],"key":"mixId"},{"Name":"state","Type":"AudioMixingState","Required":"是","Default":"无","Description":"混音状态
其混音状态可参考。
\n","children":[],"key":"state"},{"Name":"error","Type":"AudioMixingError","Required":"是","Default":"无","Description":"错误码
详见 AudioMixingError。\n","children":[],"key":"error"}]
      return (
);
```
  


## IAudioFrameObserver 

类型：`interface`

音频数据回调观察者
注意：回调函数是在 SDK 内部线程（非 UI 线程）同步抛出来的，请不要做耗时操作或直接操作 UI，否则可能导致 app 崩溃。
本接口类中的回调周期均为 20 ms。

### onRecordAudioFrame  

返回麦克风录制的音频数据

**类型**

  ```ts
  ((audioFrame: IAudioFrame) => void) | undefined
  ```

**参数**


```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":"IAudioFrame","Required":"是","Default":"无","Description":"音频数据, 参看 IAudioFrame。\n","children":[],"key":"audioFrame"}]
      return (
);
```
  

### onPlaybackAudioFrame  

返回订阅的所有远端用户混音后的音频数据。

**类型**

  ```ts
  ((audioFrame: IAudioFrame) => void) | undefined
  ```

**参数**


```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":"IAudioFrame","Required":"是","Default":"无","Description":"音频数据, 参看 IAudioFrame。\n","children":[],"key":"audioFrame"}]
      return (
);
```
  

### onRemoteUserAudioFrame  

返回远端单个用户的音频数据

**类型**

  ```ts
  ((streamKey: RemoteStreamKey, audioFrame: IAudioFrame) => void) | undefined
  ```

**参数**


```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":"audioFrame","Type":"IAudioFrame","Required":"是","Default":"无","Description":"音频数据，参看 IAudioFrame。\n","children":[],"key":"audioFrame"}]
      return (
);
```
  

### onMixedAudioFrame  

返回本地麦克风录制和订阅的所有远端用户混音后的音频数据

**类型**

  ```ts
  ((audioFrame: IAudioFrame) => void) | undefined
  ```

**参数**


```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":"IAudioFrame","Required":"是","Default":"无","Description":"音频数据, 参看 IAudioFrame。\n","children":[],"key":"audioFrame"}]
      return (
);
```
  


## IAudioFrameProcessor 

类型：`interface`

自定义音频处理器。
注意：回调函数是在 SDK 内部线程（非 UI 线程）同步抛出来的，请不要做耗时操作或直接操作 UI，否则可能导致 app 崩溃。


## ILocalEncodedVideoFrameObserver 

类型：`interface`

本地视频帧监测器
注意：回调函数是在 SDK 内部线程（非 UI 线程）同步抛出来的，请不要做耗时操作或直接操作 UI，否则可能导致 app 崩溃。

### onLocalEncodedVideoFrame  

调用 registerLocalEncodedVideoFrameObserver 后，SDK 每次使用内部采集，采集到一帧视频帧，或收到一帧外部视频帧时，都会回调该事件。

**类型**

  ```ts
  ((streamIndex: StreamIndex, encodedVideoFrame: RTCEncodedVideoFrame) => void) | undefined
  ```

**参数**


```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":"encodedVideoFrame","Type":"RTCEncodedVideoFrame","Required":"是","Default":"无","Description":"本地视频帧信息，参看 RTCEncodedVideoFrame\n","children":[],"key":"encodedVideoFrame"}]
      return (
);
```
  


## IRemoteEncodedVideoFrameObserver 

类型：`interface`

远端编码后视频数据监测器
注意：回调函数是在 SDK 内部线程（非 UI 线程）同步抛出来的，请不要做耗时操作或直接操作 UI，否则可能导致 app 崩溃。

### onRemoteEncodedVideoFrame  

调用 registerRemoteEncodedVideoFrameObserver 后，SDK 监测到远端编码后视频数据时，触发该回调

**类型**

  ```ts
  ((streamKey: RemoteStreamKey, encodedVideoFrame: RTCEncodedVideoFrame) => void) | undefined
  ```

**参数**


```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":"encodedVideoFrame","Type":"RTCEncodedVideoFrame","Required":"是","Default":"无","Description":"收到的远端视频帧信息，参看 RTCEncodedVideoFrame\n","children":[],"key":"encodedVideoFrame"}]
      return (
);
```
  


## IMixedStreamObserver 

类型：`interface`

转推直播观察者。

### onMixingEvent  

转推直播状态回调

**类型**

  ```ts
  ((eventType: ByteRTCStreamMixingEvent, taskId: string, error: RTCStreamMixingErrorCode, mixType: MixedStreamType) => void) | undefined
  ```

**参数**


```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":"eventType","Type":"ByteRTCStreamMixingEvent","Required":"是","Default":"无","Description":"转推直播任务状态, 参看 ByteRTCStreamMixingEvent
\n","children":[],"key":"eventType"},{"Name":"taskId","Type":"string","Required":"是","Default":"无","Description":"转推直播任务 ID
\n","children":[],"key":"taskId"},{"Name":"error","Type":"RTCStreamMixingErrorCode","Required":"是","Default":"无","Description":"转推直播错误码，参看 ByteRTCTranscoderErrorCode
\n","children":[],"key":"error"},{"Name":"mixType","Type":"MixedStreamType","Required":"是","Default":"无","Description":"转推直播类型，参看 MixedStreamType\n","children":[],"key":"mixType"}]
      return (
);
```
  


## IPushSingleStreamToCDNObserver 

类型：`interface`

单流转推直播观察者。
注意：回调函数是在 SDK 内部线程（非 UI 线程）同步抛出来的，请不要做耗时操作或直接操作 UI，否则可能导致 app 崩溃。

### onStreamPushEvent  

单流转推直播状态回调

**类型**

  ```ts
  ((eventType: RTCStreamSinglePushEvent, taskId: string, error: number) => void) | undefined
  ```

**参数**


```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":"eventType","Type":"RTCStreamSinglePushEvent","Required":"是","Default":"无","Description":"任务状态, 参看 ByteRTCStreamSinglePushEvent
\n","children":[],"key":"eventType"},{"Name":"taskId","Type":"string","Required":"是","Default":"无","Description":"任务 ID
\n","children":[],"key":"taskId"},{"Name":"error","Type":"number","Required":"是","Default":"无","Description":"错误码，参看 ByteRTCTranscoderErrorCode\n","children":[],"key":"error"}]
      return (
);
```
  


## RTCRoomEventHandler 

类型：`interface`

房间事件回调接口
注意：回调函数是在 SDK 内部线程（非 UI 线程）同步抛出来的，请不要做耗时操作或直接操作 UI，否则可能导致 app 崩溃。

### onLeaveRoom  

离开房间成功回调。
用户调用 leaveRoom 方法后，SDK 会停止所有的发布订阅流，并在释放所有通话相关的音视频资源后，通过此回调通知用户离开房间成功。

**类型**

  ```ts
  ((stats: RTCRoomStats) => void) | undefined
  ```

**参数**


```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":"stats","Type":"RTCRoomStats","Required":"是","Default":"无","Description":"保留参数，目前为空。\n","children":[],"key":"stats"}]
      return (
);
```
  

### onRoomStateChanged  

房间状态改变回调，加入房间、异常退出房间、发生房间相关的警告或错误时会收到此回调。

**类型**

  ```ts
  ((roomId: string, uid: string, state: number, extraInfo: string) => void) | undefined
  ```

**参数**


```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。
\n","children":[],"key":"roomId"},{"Name":"uid","Type":"string","Required":"是","Default":"无","Description":"用户 ID。
\n","children":[],"key":"uid"},{"Name":"state","Type":"number","Required":"是","Default":"无","Description":"房间状态码。
\n0: 加入房间成功。
\n!0: 加入房间失败、异常退房、发生房间相关的警告或错误。具体原因参看 ErrorCode 及 WarningCode。
\n\n","children":[],"key":"state"},{"Name":"extraInfo","Type":"string","Required":"是","Default":"无","Description":"额外信息，如 {\"elapsed\":1187,\"join_type\":0}。
join_type 表示加入房间的类型，0为首次进房，1为重连进房。
elapsed 表示加入房间耗时，即本地用户从调用 joinRoom 到加入房间成功所经历的时间间隔，单位为 ms。\n","children":[],"key":"extraInfo"}]
      return (
);
```
  

### onStreamStateChanged  

流状态改变回调，发生流相关的警告或错误时会收到此回调。

**类型**

  ```ts
  ((roomId: string, uid: string, state: number, extraInfo: string) => void) | undefined
  ```

**参数**


```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。
\n","children":[],"key":"roomId"},{"Name":"uid","Type":"string","Required":"是","Default":"无","Description":"用户 ID。
\n","children":[],"key":"uid"},{"Name":"state","Type":"number","Required":"是","Default":"无","Description":"流状态码，参看 ErrorCode 及 WarningCode。
\n","children":[],"key":"state"},{"Name":"extraInfo","Type":"string","Required":"是","Default":"无","Description":"附加信息，目前为空。\n","children":[],"key":"extraInfo"}]
      return (
);
```
  

### onAVSyncStateChange  

发布端调用 setMultiDeviceAVSync 后音视频同步状态发生改变时，会收到此回调。

**类型**

  ```ts
  ((state: AVSyncState) => void) | undefined
  ```

**参数**


```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":"state","Type":"AVSyncState","Required":"是","Default":"无","Description":"音视频同步状态，参看 AVSyncState。\n","children":[],"key":"state"}]
      return (
);
```
  

### onRoomStats  

房间内通话统计信息回调。
用户进房开始通话后，每 2s 收到一次本回调。

**类型**

  ```ts
  ((stats: RTCRoomStats) => void) | undefined
  ```

**参数**


```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":"stats","Type":"RTCRoomStats","Required":"是","Default":"无","Description":"房间内的汇总统计数据。详见 RTCRoomStats。\n","children":[],"key":"stats"}]
      return (
);
```
  

### onUserJoined  

远端可见用户加入房间，或房内不可见用户切换为可见的回调。
1.远端用户调用 setUserVisibility 方法将自身设为可见后加入房间时，房间内其他用户将收到该事件。
2.远端可见用户断网后重新连入房间时，房间内其他用户将收到该事件。
3.房间内隐身远端用户调用 setUserVisibility 方法切换至可见时，房间内其他用户将收到该事件。
4.新进房用户也会收到进房前已在房内的可见用户的进房回调通知。

**类型**

  ```ts
  ((userInfo: UserInfo, elapsed: number) => void) | undefined
  ```

**参数**


```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":"userInfo","Type":"UserInfo","Required":"是","Default":"无","Description":"用户信息。参看 UserInfo。
\n","children":[],"key":"userInfo"},{"Name":"elapsed","Type":"number","Required":"是","Default":"无","Description":"保留字段，无意义。\n","children":[],"key":"elapsed"}]
      return (
);
```
  

### onUserLeave  

远端用户离开房间，或切至不可见时，房间内其他用户会收到此事件

**类型**

  ```ts
  ((uid: string, reason: RTCUserOfflineReason) => void) | undefined
  ```

**参数**


```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":"reason","Type":"RTCUserOfflineReason","Required":"是","Default":"无","Description":"用户离开房间的原因：
\n0: 远端用户调用 leaveRoom 主动退出房间。
\n                - 1: 远端用户因 Token 过期或网络原因等掉线。详细信息请参看[连接状态提示](https://www.volcengine.com/docs/6348/95376) \n2: 远端用户调用 setUserVisibility 切换至不可见状态。
\n3: 服务端调用 OpenAPI 将该远端用户踢出房间。\n\n","children":[],"key":"reason"}]
      return (
);
```
  

### onTokenWillExpire  

Token 进房权限过期前 30 秒将触发该回调。
收到该回调后，你需调用 updateToken 更新 Token 进房权限。

**类型**

  ```ts
  (() => void) | undefined
  ```

### onPublishPrivilegeTokenWillExpire  

Token 发布权限过期前 30 秒将触发该回调。
收到该回调后，你需调用 updateToken 更新 Token 发布权限。

**类型**

  ```ts
  (() => void) | undefined
  ```

### onSubscribePrivilegeTokenWillExpire  

Token 订阅权限过期前 30 秒将触发该回调。
收到该回调后，你需调用 updateToken 更新 Token 订阅权限有效期。

**类型**

  ```ts
  (() => void) | undefined
  ```

### onUserPublishStream  

房间内新增远端摄像头/麦克风采集的媒体流的回调。

**类型**

  ```ts
  ((uid: string, type: MediaStreamType) => void) | undefined
  ```

**参数**


```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 (
);
```
  

### onUserUnpublishStream  

房间内远端摄像头/麦克风采集的媒体流移除的回调。

**类型**

  ```ts
  ((uid: string, type: MediaStreamType, reason: StreamRemoveReason) => void) | undefined
  ```

**参数**


```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"},{"Name":"reason","Type":"StreamRemoveReason","Required":"是","Default":"无","Description":"远端流移除的原因，参看 StreamRemoveReason。\n","children":[],"key":"reason"}]
      return (
);
```
  

### onUserPublishScreen  

房间内新增远端屏幕共享音视频流的回调。

**类型**

  ```ts
  ((uid: string, type: MediaStreamType) => void) | undefined
  ```

**参数**


```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 (
);
```
  

### onUserUnpublishScreen  

房间内远端屏幕共享音视频流移除的回调。

**类型**

  ```ts
  ((uid: string, type: MediaStreamType, reason: StreamRemoveReason) => void) | undefined
  ```

**参数**


```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"},{"Name":"reason","Type":"StreamRemoveReason","Required":"是","Default":"无","Description":"远端流移除的原因，参看 StreamRemoveReason。\n","children":[],"key":"reason"}]
      return (
);
```
  

### onLocalStreamStats  

本地流数据统计以及网络质量回调。
本地用户发布流成功后，SDK 会周期性（2s）的通过此回调事件通知用户发布的流在此次统计周期内的质量统计信息。
统计信息通过 [LocalStreamStats](1390578#localstreamstats) 类型的回调参数传递给用户，其中包括发送音视频比特率、发送帧率、编码帧率，网络质量等。

**类型**

  ```ts
  ((stats: LocalStreamStats) => void) | undefined
  ```

**参数**


```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":"stats","Type":"LocalStreamStats","Required":"是","Default":"无","Description":"音视频流以及网络状况统计信息。参见 LocalStreamStats。\n","children":[],"key":"stats"}]
      return (
);
```
  

### onRemoteStreamStats  

本地订阅的远端音/视频流数据统计以及网络质量回调。
本地用户订阅流成功后，SDK 会周期性（2s）的通过此回调事件通知用户订阅的流在此次统计周期内的质量统计信息，包括：发送音视频比特率、发送帧率、编码帧率，网络质量等。

**类型**

  ```ts
  ((stats: RemoteStreamStats) => void) | undefined
  ```

**参数**


```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":"stats","Type":"RemoteStreamStats","Required":"是","Default":"无","Description":"音视频流以及网络状况统计信息。参见 RemoteStreamStats。\n","children":[],"key":"stats"}]
      return (
);
```
  

### onStreamSubscribed  

关于订阅媒体流状态改变的回调

**类型**

  ```ts
  ((stateCode: SubscribeState, userId: string, info: SubscribeConfig) => void) | undefined
  ```

**参数**


```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":"stateCode","Type":"SubscribeState","Required":"是","Default":"无","Description":"订阅媒体流状态，参看 SubscribeState
\n","children":[],"key":"stateCode"},{"Name":"userId","Type":"string","Required":"是","Default":"无","Description":"流发布用户的用户 ID
\n","children":[],"key":"userId"},{"Name":"info","Type":"SubscribeConfig","Required":"是","Default":"无","Description":"流的属性，参看 SubscribeConfig\n","children":[],"key":"info"}]
      return (
);
```
  

### onRoomMessageReceived  

接收到房间内广播消息的回调。
房间内其他用户调用 sendRoomMessage 发送广播消息时，收到此回调。

**类型**

  ```ts
  ((uid: string, message: string) => void) | undefined
  ```

**参数**


```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":"收到的消息内容\n","children":[],"key":"message"}]
      return (
);
```
  

### onRoomBinaryMessageReceived  

收到房间内广播二进制消息的回调。
房间内其他用户调用 sendRoomBinaryMessage 发送广播二进制消息时，收到此回调。

**类型**

  ```ts
  ((uid: string, message: ByteBuffer) => void) | undefined
  ```

**参数**


```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":"ArrayBuffer","Required":"是","Default":"无","Description":"收到的二进制消息内容\n","children":[],"key":"message"}]
      return (
);
```
  

### onUserMessageReceived  

收到来自房间中其他用户通过 sendUserMessage 发来的点对点文本消息时，会收到此回调。

**类型**

  ```ts
  ((uid: string, message: string) => void) | undefined
  ```

**参数**


```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":"收到的文本消息内容。\n","children":[],"key":"message"}]
      return (
);
```
  

### onUserBinaryMessageReceived  

收到来自房间中其他用户通过 sendUserBinaryMessage 发来的点对点二进制消息时，会收到此回调。

**类型**

  ```ts
  ((uid: string, message: ByteBuffer) => void) | undefined
  ```

**参数**


```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":"ArrayBuffer","Required":"是","Default":"无","Description":"收到的二进制消息内容。\n","children":[],"key":"message"}]
      return (
);
```
  

### onUserMessageSendResult  

向房间内单个用户发送文本或二进制消息后（P2P），消息发送方会收到该消息发送结果回调。

**类型**

  ```ts
  ((msgid: number, error: UserMessageSendResult) => void) | undefined
  ```

**参数**


```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":"msgid","Type":"number","Required":"是","Default":"无","Description":"本条消息的 ID。
\n","children":[],"key":"msgid"},{"Name":"error","Type":"UserMessageSendResult","Required":"是","Default":"无","Description":"文本或二进制消息发送结果，详见 UserMessageSendResult\n","children":[],"key":"error"}]
      return (
);
```
  

### onRoomMessageSendResult  

调用 sendRoomMessage 或 sendRoomBinaryMessage 向房间内群发文本或二进制消息后，消息发送方会收到该消息发送结果回调。

**类型**

  ```ts
  ((msgid: number, error: RoomMessageSendResult) => void) | undefined
  ```

**参数**


```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":"msgid","Type":"number","Required":"是","Default":"无","Description":"本条消息的 ID。
\n","children":[],"key":"msgid"},{"Name":"error","Type":"RoomMessageSendResult","Required":"是","Default":"无","Description":"消息发送结果，详见 RoomMessageSendResult\n","children":[],"key":"error"}]
      return (
);
```
  

### onVideoStreamBanned  

通过调用服务端 BanUserStream/UnbanUserStream 方法禁用/解禁指定房间内指定用户视频流的发送时，触发此回调。

**类型**

  ```ts
  ((uid: string, banned: boolean) => void) | undefined
  ```

**参数**


```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":"banned","Type":"boolean","Required":"是","Default":"无","Description":"视频流发送状态
\ntrue: 视频流发送被禁用
\nfalse: 视频流发送被解禁\n\n","children":[],"key":"banned"}]
      return (
);
```
  

### onAudioStreamBanned  

通过调用服务端 BanUserStream/UnbanUserStream 方法禁用/解禁指定房间内指定用户音频流的发送时，触发此回调。

**类型**

  ```ts
  ((uid: string, banned: boolean) => void) | undefined
  ```

**参数**


```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":"banned","Type":"boolean","Required":"是","Default":"无","Description":"音频流发送状态
\ntrue: 音频流发送被禁用
\nfalse: 音频流发送被解禁\n\n","children":[],"key":"banned"}]
      return (
);
```
  

### onForwardStreamStateChanged  

跨房间媒体流转发状态和错误回调

**类型**

  ```ts
  ((stateInfos: Array) => void) | undefined
  ```

**参数**


```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":"stateInfos","Type":"ForwardStreamStateInfo[]","Required":"是","Default":"无","Description":"跨房间媒体流转发目标房间信息数组，详见 ForwardStreamStateInfo\n","children":[],"key":"stateInfos"}]
      return (
);
```
  

### onForwardStreamEvent  

跨房间媒体流转发事件回调

**类型**

  ```ts
  ((eventInfos: Array) => void) | undefined
  ```

**参数**


```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":"eventInfos","Type":"ForwardStreamEventInfo[]","Required":"是","Default":"无","Description":"跨房间媒体流转发目标房间事件数组，详见 ForwardStreamEventInfo\n","children":[],"key":"eventInfos"}]
      return (
);
```
  

### onNetworkQuality  

加入房间并发布或订阅流后， 以每 2 秒一次的频率，报告本地用户和已订阅的远端用户的上下行网络质量信息。

**类型**

  ```ts
  ((localQuality: NetworkQualityStats, remoteQualities: Array) => void) | undefined
  ```

**参数**


```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":"localQuality","Type":"NetworkQualityStats","Required":"是","Default":"无","Description":"本地网络质量，详见 NetworkQualityStats。
\n","children":[],"key":"localQuality"},{"Name":"remoteQualities","Type":"NetworkQualityStats[]","Required":"是","Default":"无","Description":"已订阅用户的网络质量，详见 NetworkQualityStats。\n","children":[],"key":"remoteQualities"}]
      return (
);
```
  

### onSetRoomExtraInfoResult  

调用 setRoomExtraInfo 设置房间附加信息结果的回调。

**类型**

  ```ts
  ((taskId: number, error: SetRoomExtraInfoResult) => void) | undefined
  ```

**参数**


```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":"number","Required":"是","Default":"无","Description":"调用 setRoomExtraInfo 的任务编号。
\n","children":[],"key":"taskId"},{"Name":"error","Type":"SetRoomExtraInfoResult","Required":"是","Default":"无","Description":"设置房间附加信息的结果，详见 SetRoomExtraInfoResult\n","children":[],"key":"error"}]
      return (
);
```
  

### onRoomExtraInfoUpdate  

接收同一房间内，其他用户调用 setRoomExtraInfo 设置的房间附加信息的回调。

**类型**

  ```ts
  ((key: string, value: string, lastUpdateUserId: string, lastUpdateTimeMs: number) => void) | undefined
  ```

**参数**


```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":"房间附加信息的键值
\n","children":[],"key":"key"},{"Name":"value","Type":"string","Required":"是","Default":"无","Description":"房间附加信息的内容
\n","children":[],"key":"value"},{"Name":"lastUpdateUserId","Type":"string","Required":"是","Default":"无","Description":"最后更新本条信息的用户 ID。
\n","children":[],"key":"lastUpdateUserId"},{"Name":"lastUpdateTimeMs","Type":"number","Required":"是","Default":"无","Description":"最后更新本条信息的 Unix 时间，单位：毫秒。\n","children":[],"key":"lastUpdateTimeMs"}]
      return (
);
```
  

### onUserVisibilityChanged  

用户调用 setUserVisibility 设置用户可见性的回调。

**类型**

  ```ts
  ((currentUserVisibility: boolean, errorCode: UserVisibilityChangeError) => void) | undefined
  ```

**参数**


```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":"currentUserVisibility","Type":"boolean","Required":"是","Default":"无","Description":"当前用户的可见性。
\ntrue: 可见，用户可以在房间内发布音视频流，房间中的其他用户将收到用户的行为通知，例如进房、开启视频采集和退房。
\nfalse: 不可见，用户不可以在房间内发布音视频流，房间中的其他用户不会收到用户的行为通知，例如进房、开启视频采集和退房。
\n\n","children":[],"key":"currentUserVisibility"},{"Name":"errorCode","Type":"UserVisibilityChangeError","Required":"是","Default":"无","Description":"设置用户可见性错误码，参看 UserVisibilityChangeError。\n","children":[],"key":"errorCode"}]
      return (
);
```
  

### onSubtitleStateChanged  

字幕状态发生改变回调。
当用户调用 startSubtitle 和 stopSubtitle 使字幕状态发生改变或字幕任务出现错误时，触发该回调。

**类型**

  ```ts
  ((state: SubtitleState, errorCode: SubtitleErrorCode, errorMessage: string) => void) | undefined
  ```

**参数**


```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":"state","Type":"SubtitleState","Required":"是","Default":"无","Description":"字幕状态。参看 SubtitleState。
\n","children":[],"key":"state"},{"Name":"errorCode","Type":"SubtitleErrorCode","Required":"是","Default":"无","Description":"字幕任务错误码。参看 SubtitleErrorCode。
\n","children":[],"key":"errorCode"},{"Name":"errorMessage","Type":"string","Required":"是","Default":"无","Description":"与第三方服务有关的错误信息。\n","children":[],"key":"errorMessage"}]
      return (
);
```
  

### onSubtitleMessageReceived  

字幕相关内容回调。
当用户成功调用 startSubtitle 后会收到此回调，通知字幕的相关信息。

**类型**

  ```ts
  ((subtitles: Array) => void) | undefined
  ```

**参数**


```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":"subtitles","Type":"SubtitleMessage[]","Required":"是","Default":"无","Description":"字幕消息内容。参看 SubtitleMessage。\n","children":[],"key":"subtitles"}]
      return (
);
```
  

### onRoomWarning  

发生警告回调。

:::warning 已弃用 
   since 3.41 and will be deleted in 3.51, use onRoomStateChanged and onStreamStateChanged instead.
:::

**类型**

  ```ts
  ((warn: WarningCode) => void) | undefined
  ```

**参数**


```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":"warn","Type":"WarningCode","Required":"是","Default":"无","Description":"警告代码，参见 WarningCode\n","children":[],"key":"warn"}]
      return (
);
```
  

### onRoomError  

发生错误回调。

:::warning 已弃用 
   since 3.41 and will be deleted in 3.51, use onRoomStateChanged and onStreamStateChanged instead.
:::

**类型**

  ```ts
  ((err: ErrorCode) => void) | undefined
  ```

**参数**


```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":"err","Type":"ErrorCode","Required":"是","Default":"无","Description":"错误代码，详情定义见: ErrorCode\n","children":[],"key":"err"}]
      return (
);
```
  

### onStreamAdd  

房间内新流发布回调。
房间内的远端用户发布新的音视频流时，本地用户会收到此回调通知。

:::warning 已弃用 
   since 3.36 and will be deleted in 3.51, use onUserPublishStream and onUserPublishScreen instead.
:::

**类型**

  ```ts
  ((stream: RTCStream) => void) | undefined
  ```

**参数**


```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":"stream","Type":"RTCStream","Required":"是","Default":"无","Description":"流的属性，详见 RTCStream 数据类型。\n","children":[],"key":"stream"}]
      return (
);
```
  


## IAudioEffectPlayerEventHandler 

类型：`interface`

[IAudioEffectPlayer](1390575#iaudioeffectplayer) 对应的回调句柄。你必须调用 setEventHandler 完成设置后，才能收到对应回调。

### onAudioEffectPlayerStateChanged  

播放状态改变时回调。

**类型**

  ```ts
  ((effectId: number, state: PlayerState, error: PlayerError) => void) | undefined
  ```

**参数**


```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":"IAudioEffectPlayer 的 ID。通过 getAudioEffectPlayer 设置。
\n","children":[],"key":"effectId"},{"Name":"state","Type":"PlayerState","Required":"是","Default":"无","Description":"混音状态。参考 PlayerState。
\n","children":[],"key":"state"},{"Name":"error","Type":"PlayerError","Required":"是","Default":"无","Description":"错误码。参考 PlayerError。\n","children":[],"key":"error"}]
      return (
);
```
  


## IMediaPlayerAudioFrameObserver 

类型：`interface`

本地音频文件混音的音频帧观察者。

### onFrame  

当本地音频文件混音时，回调播放的音频帧。

**类型**

  ```ts
  ((playerId: number, frame: IAudioFrame) => void) | undefined
  ```

**参数**


```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":"-","children":[],"key":"playerId"},{"Name":"frame","Type":"IAudioFrame","Required":"是","Default":"无","Description":"参看 IAudioFrame。\n","children":[],"key":"frame"}]
      return (
);
```
  


## IMediaPlayerEventHandler 

类型：`interface`

[IMediaPlayer](1390575#imediaplayer) 对应的回调句柄。你必须调用 setEventHandler 完成设置后，才能收到对应回调。

### onMediaPlayerStateChanged  

播放状态改变时回调。

**类型**

  ```ts
  ((playerId: number, state: PlayerState, error: PlayerError) => void) | undefined
  ```

**参数**


```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":"IMediaPlayer 的 ID。通过 getMediaPlayer 设置。
\n","children":[],"key":"playerId"},{"Name":"state","Type":"PlayerState","Required":"是","Default":"无","Description":"混音状态。参考 PlayerState。
\n","children":[],"key":"state"},{"Name":"error","Type":"PlayerError","Required":"是","Default":"无","Description":"错误码。参考 PlayerError。\n","children":[],"key":"error"}]
      return (
);
```
  

### onMediaPlayerPlayingProgress  

播放进度周期性回调。回调周期通过 setProgressInterval 设置。

**类型**

  ```ts
  ((playerId: number, progress: number) => void) | undefined
  ```

**参数**


```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":"IMediaPlayer 的 ID。通过 getMediaPlayer 设置。
\n","children":[],"key":"playerId"},{"Name":"progress","Type":"number","Required":"是","Default":"无","Description":"进度。单位 ms。\n","children":[],"key":"progress"}]
      return (
);
```
  


## IExternalVideoEncoderEventHandler 

类型：`interface`

自定义编码帧回调类
注意：回调函数是在 SDK 内部线程（非 UI 线程）同步抛出来的，请不要做耗时操作或直接操作 UI，否则可能导致 app 崩溃。

### onStart  

提示自定义编码帧可以开始推送的回调。
收到该回调后，你即可调用 pushExternalEncodedVideoFrame 向 SDK 推送自定义编码视频帧

**类型**

  ```ts
  ((index: StreamIndex) => void) | undefined
  ```

**参数**


```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"}]
      return (
);
```
  

### onStop  

当收到该回调时，你需停止向 SDK 推送自定义编码视频帧

**类型**

  ```ts
  ((index: StreamIndex) => void) | undefined
  ```

**参数**


```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"}]
      return (
);
```
  

### onRateUpdate  

当自定义编码流的帧率或码率发生变化时，触发该回调

**类型**

  ```ts
  ((streamIndex: StreamIndex, videoIndex: number, fps: number, bitrateKbps: number) => void) | undefined
  ```

**参数**


```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":"videoIndex","Type":"number","Required":"是","Default":"无","Description":"对应编码流的下标
\n","children":[],"key":"videoIndex"},{"Name":"fps","Type":"number","Required":"是","Default":"无","Description":"变化后的帧率，单位：fps
\n","children":[],"key":"fps"},{"Name":"bitrateKbps","Type":"number","Required":"是","Default":"无","Description":"变化后的码率，单位：kbps\n","children":[],"key":"bitrateKbps"}]
      return (
);
```
  

### onRequestKeyFrame  

提示流发布端需重新生成关键帧的回调

**类型**

  ```ts
  ((streamIndex: StreamIndex, videoIndex: number) => void) | undefined
  ```

**参数**


```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":"videoIndex","Type":"number","Required":"是","Default":"无","Description":"对应编码流的下标\n","children":[],"key":"videoIndex"}]
      return (
);
```
  

### onActiveVideoLayer  

作为自定义编码视频流的发送端，你会在视频流可发送状态发生变化时，收到此回调。
你可以根据此回调的提示，仅对可发送的视频流进行编码，以降低本端视频编码性能消耗。此回调会根据多个因素综合判断触发，包括：本端设备性能和本端网络性能，以及按需订阅场景下，远端用户是否订阅。

**类型**

  ```ts
  ((streamIndex: StreamIndex, videoIndex: number, active: boolean) => void) | undefined
  ```

**参数**


```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":"videoIndex","Type":"number","Required":"是","Default":"无","Description":"对应编码流的下标
\n","children":[],"key":"videoIndex"},{"Name":"active","Type":"boolean","Required":"是","Default":"无","Description":"该路流可发送状态\n","children":[],"key":"active"}]
      return (
);
```
  


## IAudioFileFrameObserver 

类型：`interface`

本地音频文件混音的音频帧观察者。
注意：回调函数是在 SDK 内部线程（非 UI 线程）同步抛出来的，请不要做耗时操作或直接操作 UI，否则可能导致 app 崩溃。

### onAudioFileFrame  

当本地音频文件混音时，回调播放的音频帧。

**类型**

  ```ts
  ((mixID: number, audioFrame: IAudioFrame) => void) | undefined
  ```

**参数**


```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":"mixID","Type":"number","Required":"是","Default":"无","Description":"混音 ID。
\n","children":[],"key":"mixID"},{"Name":"audioFrame","Type":"IAudioFrame","Required":"是","Default":"无","Description":"参看 IAudioFrame。\n","children":[],"key":"audioFrame"}]
      return (
);
```
  


## IMediaPlayerCustomSourceProvider 

类型：`interface`

内存播放数据源回调
实时音视频
