## VeLivePusher 类型：`class` 直播推流器。 ### destroy() 停止采集和推流，并销毁推流器。通常在调用 [stopPush](#velivepusher-stoppush) 结束推流后调用此方法进行清理。 **类型** ```ts () => void ``` ### setObserver() 设置推流器回调，通过设置回调，监听推流器的推流错误、状态、网络质量、设备、首帧等回调事件。 **注意** - 需要在创建推流引擎后，调用本方法； - 重复调用本方法，仅最后一次调用生效。 **类型** ```ts (observer: VeLivePusherObserver) => void ``` **参数** ```mixin-react const columns = [{ title: '名称', dataIndex: 'Name', width: 240, },{ title: '类型', dataIndex: 'Type', width: 240, render: (col, item, index) => { if(col.includes('')){ const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi; const new1 = regex.exec(col); return {new1?.[1]}{new1?.[4]}{new1?.[5]} } return col; } },{ title: '是否必选', dataIndex: 'Required', width: 120, },{ title: '默认值', dataIndex: 'Default', width: 120, render: (col, item, index) => { if(col.includes('')){ const regex = /(.*)
(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"observer","Type":"VeLivePusherObserver","Required":"是","Default":"无","Description":"推流器回调对象，详细信息请参见 VeLivePusherObserver。\n","children":[],"key":"observer"}]
      return ();
```
  

### setStatisticsObserver()  

设置推流器周期性回调，用于定期获取推流状态信息。

**注意**

  - 需要在创建推流引擎后，调用本方法；
  - 重复调用本方法，仅最后一次调用生效。

**类型**

  ```ts
  (observer: VeLivePusherStatisticsObserver, interval: number) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"observer","Type":"VeLivePusherStatisticsObserver","Required":"是","Default":"无","Description":"推流器周期性回调对象，详细信息请参见 VeLivePusherStatisticsObserver。
\n","children":[],"key":"observer"},{"Name":"interval","Type":"number","Required":"是","Default":"无","Description":"周期性回调的时间间隔，单位为 s，默认值为 5。\n","children":[],"key":"interval"}]
      return (
);
```
  

### setRenderView()  

设置本地摄像头预览视图。摄像头采集到的画面，经过美颜、脸形调整、滤镜等多种效果叠加之后，最终会显示到传入的 View 上。

**类型**

  ```ts
  (view: View) => Promise
  ```

**参数**


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

**返回值**

  Promise

### setRenderFillMode()  

设置本地预览画面的填充模式。

**类型**

  ```ts
  (mode: VeLivePusherRenderMode) => void
  ```

**参数**


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

### setVideoMirror()  

开启/关闭镜像。

**注意**

  用于配置视频镜像效果，影响采集、预览和推流画面。

**类型**

  ```ts
  (type: VeLiveVideoMirrorType, mirror: boolean) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"type","Type":"VeLiveVideoMirrorType","Required":"是","Default":"无","Description":"镜像类型，详细信息请参见 VeLiveVideoMirrorType。
\n","children":[],"key":"type"},{"Name":"mirror","Type":"boolean","Required":"是","Default":"无","Description":"是否开启镜像。\\
\ntrue：开启；
\nfalse：关闭。\n\n","children":[],"key":"mirror"}]
      return (
);
```
  

### startVideoCapture()  

开始视频采集。

**注意**

  调用该接口后，可以通过调用接口 [stopVideoCapture](#velivepusher-stopvideocapture) 停止视频采集。

**类型**

  ```ts
  (type: VeLiveVideoCaptureType) => void
  ```

**参数**


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

### stopVideoCapture()  

停止视频采集。

**注意**

  调用该接口后，可以通过调用接口 [startVideoCapture](#velivepusher-startvideocapture) 开始视频采集。

**类型**

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

### startAudioCapture()  

开始音频采集。

**注意**

  调用该接口后，可以通过调用接口 [stopAudioCapture](#velivepusher-stopaudiocapture) 停止音频采集。

**类型**

  ```ts
  (type: VeLiveAudioCaptureType) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"type","Type":"VeLiveAudioCaptureType","Required":"是","Default":"无","Description":"音频采集类型，详细信息请参见 VeLiveAudioCaptureType。\n","children":[],"key":"type"}]
      return (
);
```
  

### stopAudioCapture()  

停止音频采集。

**注意**

  调用该接口后，可以通过调用接口 [startAudioCapture](#velivepusher-startaudiocapture) 开始音频采集。

**类型**

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

### switchVideoCapture()  

切换视频采集类型。

**注意**

  该接口必须在调用接口 [startVideoCapture](#velivepusher-startvideocapture) 后调用才能生效。

**类型**

  ```ts
  (type: VeLiveVideoCaptureType) => void
  ```

**参数**


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

### switchAudioCapture()  

切换音频采集类型。

**注意**

  该接口必须在调用接口 [startVideoCapture](#velivepusher-startvideocapture) 后调用才能生效。

**类型**

  ```ts
  (type: VeLiveAudioCaptureType) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"type","Type":"VeLiveAudioCaptureType","Required":"是","Default":"无","Description":"音频采集类型，详细信息请参见 VeLiveAudioCaptureType。\n","children":[],"key":"type"}]
      return (
);
```
  

### getCurrentVideoCaptureType()  

获取当前视频采集类型。

**类型**

  ```ts
  () => VeLiveVideoCaptureType
  ```

**返回值**

  VeLiveVideoCaptureType  视频采集类型，详细信息请参见 [VeLiveVideoCaptureType](1317625#velivevideocapturetype)。

### getCurrentAudioCaptureType()  

获取当前音频采集类型。

**类型**

  ```ts
  () => VeLiveAudioCaptureType
  ```

**返回值**

  VeLiveAudioCaptureType  音频采集类型，详细信息请参见 [VeLiveAudioCaptureType](1317625#veliveaudiocapturetype)。

### updateCustomImage()  

自定义静态图，适用于静态图推流采集类型。

**注意**

  使用该接口时，需要将视频采集类型设置为 VeLiveVideoCaptureCustomImage，您可调用 [startVideoCapture](#velivepusher-startvideocapture) 方法，将 [VeLiveVideoCaptureType](1317625#velivevideocapturetype) 设置为 VeLiveVideoCaptureCustomImage。

**类型**

  ```ts
  (image: any) => Promise
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"image","Type":"any","Required":"是","Default":"无","Description":"静态图片，用于在静态图推流采集类型下设置静态图。\n","children":[],"key":"image"}]
      return (
);
```
  

**返回值**

  Promise

### getCameraDevice()  

获取相机设备管理对象 `VeLiveCameraDevice`。


**注意**

  该接口需要在 [startVideoCapture](#startvideocapture) 方法中设置 VeLiveVideoCaptureType 为 VeLiveVideoCaptureFrontCamera 或 VeLiveVideoCaptureBackCamera。

**类型**

  ```ts
  () => VeLiveCameraDevice
  ```

**返回值**

  VeLiveCameraDevice  相机设备管理对象 VeLiveCameraDevice。

### setVideoEncoderConfiguration()  

设置推流视频编码参数。

**注意**

  该接口可在推流开始前或开始后调用。

**类型**

  ```ts
  (config: VeLiveVideoEncoderConfiguration) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"config","Type":"VeLiveVideoEncoderConfiguration","Required":"是","Default":"无","Description":"推流视频参数，支持设置推流视频分辨率、编码格式、目标码率和视频 GOP 大小等信息。详情请参见 VeLiveVideoEncoderConfiguration。\n","children":[],"key":"config"}]
      return (
);
```
  

### setAudioEncoderConfiguration()  

设置推流音频编码参数。

**注意**

  该接口需要在 [startPush](#velivepusher-startpush) 或 [startPushWithUrls](#velivepusher-startpushwithurls) 方法之前调用。

**类型**

  ```ts
  (config: VeLiveAudioEncoderConfiguration) => void
  ```

**参数**


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

### startPush()  

开始推流。

**类型**

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

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"url","Type":"string","Required":"是","Default":"无","Description":"推流地址，用于将直播流推送到目标服务器。\n","children":[],"key":"url"}]
      return (
);
```
  

### startPushWithUrls()  

开始推流，支持备用推流地址。

**注意**

  当主推流地址不可用时，会自动切换到备用推流地址继续推流。

**类型**

  ```ts
  (urls: string[]) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"urls","Type":"string[]","Required":"是","Default":"无","Description":"推流地址列表，包含一个或多个推流地址。\n","children":[],"key":"urls"}]
      return (
);
```
  

### stopPush()  

停止推流。

**注意**

  停止推流后，可以通过调用 [startPush](#velivepusher-startpush) 或 [startPushWithUrls](#velivepusher-startpushwithurls) 方法重新开始推流。

**类型**

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

### isPushing()  

当前是否正在推流中，可用来查询推流器的当前状态。

**类型**

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

**返回值**

  boolean  是否正在推流。
  - true：正在推流中；
  - false：已经停止推流。

### setWatermark()  

设置推流水印。

**类型**

  ```ts
  (image: any, x: number, y: number, scale: number) => Promise
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"image","Type":"any","Required":"是","Default":"无","Description":"水印图片。取值为 null 时，表示禁用水印。
\n","children":[],"key":"image"},{"Name":"x","Type":"number","Required":"是","Default":"无","Description":"水印的水平偏移量，即水印图片相对视频流左上角的横向偏移与视频流宽度的比值，取值范围为 [0.0,1.0]。
\n","children":[],"key":"x"},{"Name":"y","Type":"number","Required":"是","Default":"无","Description":"水印的垂直偏移量，即水印图片相对视频流左上角的纵向偏移与视频流高度的比值，取值范围为 [0.0,1.0]。
\n","children":[],"key":"y"},{"Name":"scale","Type":"number","Required":"是","Default":"无","Description":"水印图片的缩放比例，取值范围为 [0.0,1.0]。\n","children":[],"key":"scale"}]
      return (
);
```
  

**返回值**

  Promise
  - 0：水印设置成功；
  - <0：水印设置失败。

### startFileRecording()  

开始本地文件录制。

**类型**

  ```ts
  (path: string, config: VeLiveFileRecorderConfiguration, listener: VeLiveFileRecordingListener) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"path","Type":"string","Required":"是","Default":"无","Description":"录制文件保存路径，不能为空。
\n","children":[],"key":"path"},{"Name":"config","Type":"VeLiveFileRecorderConfiguration","Required":"是","Default":"无","Description":"文件录制设置，详情请参见 VeLiveFileRecorderConfiguration。
\n","children":[],"key":"config"},{"Name":"listener","Type":"VeLiveFileRecordingListener","Required":"是","Default":"无","Description":"本地文件录制的监听，详情请参见 VeLiveFileRecordingListener。\n","children":[],"key":"listener"}]
      return (
);
```
  

### stopFileRecording()  

停止本地文件录制。

**注意**

  该接口需要在 [startFileRecording](#velivepusher-startfilerecording) 方法之后调用。

**类型**

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

### setProperty()  

高级配置。

**类型**

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

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"key","Type":"string","Required":"是","Default":"无","Description":"推流高级配置为 JSON 格式的字符串，此参数为 JSON 结构中的 Key。您可通过提交工单联系技术支持，了解配置方法。
\n","children":[],"key":"key"},{"Name":"value","Type":"object","Required":"是","Default":"无","Description":"推流高级配置为 JSON 格式的字符串，此参数为 JSON 结构中的 Value。您可通过提交工单联系技术支持，了解配置方法。\n","children":[],"key":"value"}]
      return (
);
```
  

**返回值**

  number
  - 0：成功；
  - -1：失败，参数错误。

### setOrientation()  

设置推流视频帧朝向。默认为竖屏推流。

**类型**

  ```ts
  (orientation: VeLiveOrientation) => void
  ```

**参数**


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

### sendSeiMessage()  

通过视频帧发送 SEI 消息。

**注意**

  该接口需要在调用 [startPush](#velivepusher-startpush) 或 [startPushWithUrls](#velivepusher-startpushwithurls) 方法之后调用。

**类型**

  ```ts
  (key: string, value: object, repeat: number, isKeyFrame: boolean, allowsCovered: boolean) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"key","Type":"string","Required":"是","Default":"无","Description":"SEI 消息为 JSON 格式的字符串。此参数为 JSON 结构中的 Key。
\n","children":[],"key":"key"},{"Name":"value","Type":"object","Required":"是","Default":"无","Description":"SEI 消息为 JSON 格式的字符串。此参数为 JSON 结构中的 Value。
\n","children":[],"key":"value"},{"Name":"repeat","Type":"number","Required":"是","Default":"无","Description":"消息发送重复的次数。例如，repeat 取值为 20，isKeyFrame 取值为 YES，则会在视频帧开始的连续 20 个关键帧中添加 SEI 消息。
\n","children":[],"key":"repeat"},{"Name":"isKeyFrame","Type":"boolean","Required":"是","Default":"无","Description":"是否仅在关键帧中包含 SEI 消息。\\
\ntrue：仅在关键帧中包含；
\nfalse：所有帧中均包含。
\n\n","children":[],"key":"isKeyFrame"},{"Name":"allowsCovered","Type":"boolean","Required":"是","Default":"无","Description":"是否允许覆盖。\\
\ntrue：允许；
\nfalse：不允许。\n\n","children":[],"key":"allowsCovered"}]
      return (
);
```
  

**返回值**

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

### setMute()  

设置静音。

**类型**

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

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"mute","Type":"boolean","Required":"是","Default":"无","Description":"是否设置为静音。默认为正常推流。\\
\ntrue：静音推流；
\nfalse：正常推流。\n\n","children":[],"key":"mute"}]
      return (
);
```
  

### isMute()  

当前是否是静音状态。

**类型**

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

**返回值**

  boolean
  - true：当前是静音状态；
  - false：当前非静音状态。

### getAudioDevice()  

获取音频模块管理对象。

**注意**

  该接口需要在 [startAudioCapture](#startaudiocapture) 方法中设置 [VeLiveAudioCaptureType](1317625#veliveaudiocapturetype) 为 VeLiveAudioCaptureMicrophone。

**类型**

  ```ts
  () => VeLiveAudioDevice
  ```

**返回值**

  [VeLiveAudioDevice](#veliveaudiodevice)  音频模块管理对象 [VeLiveAudioDevice](#veliveaudiodevice)。

### createPlayer()  

创建播放器。

**类型**

  ```ts
  () => VeLiveMediaPlayer
  ```

**返回值**

  [VeLiveMediaPlayer](#velivemediaplayer)  播放器管理对象 [VeLiveMediaPlayer](#velivemediaplayer)。

### `static` setLogLevel()  

设置输出到控制台的日志等级。

**类型**

  ```ts
  (logLevel: VeLivePusherLogLevel) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"logLevel","Type":"VeLivePusherLogLevel","Required":"是","Default":"无","Description":"输出的日志级别。级别详情请参见 VeLivePusherLogLevel。\n","children":[],"key":"logLevel"}]
      return (
);
```
  


## VeLiveAudioDevice 

类型：`class`

音频设备管理类。该类提供了用于管理和控制音频设备，包括设置音量、获取当前音量、检查硬件耳返支持情况、开启或关闭耳返的方法。

### setVoiceLoudness()  

设置音量响度。

**类型**

  ```ts
  (level: number) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"level","Type":"number","Required":"是","Default":"无","Description":"音量响度等级，取值范围为 [0.0,4.0]。\n","children":[],"key":"level"}]
      return (
);
```
  

### getVoiceLoudness()  

获取当前音量响度。

**类型**

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

**返回值**

  number  当前音量响度等级。

### isSupportHardwareEcho()  

查询是否支持硬件耳返。

**类型**

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

**返回值**

  boolean
  - true：支持；
  - false：不支持。

### enableEcho()  

是否开启耳返功能。

**类型**

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

**参数**


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

### isEnableEcho()  

获取当前耳返开启状态。

**类型**

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

**返回值**

  boolean
  - true：开启；
  - false：关闭。


## VeLiveMediaPlayer 

类型：`class`

媒体播放器对象。

### setListener()  

设置播放状态的监听。

**注意**

  重复调用本方法，仅最后一次调用生效。

**类型**

  ```ts
  (listener: VeLiveMediaPlayerListener) => void
  ```

**参数**


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

### prepare()  

设置文件路径。支持的文件格式包括 MP3、AAC、M4A、WAV。

**类型**

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

**参数**


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

**返回值**

  number
  - 0：成功；
  - ≠0：失败。

### start()  

暂停播放。

**注意**

  需要在调用 [start](#start) 开始播放后，调用本方法。

**类型**

  ```ts
  () => Promise
  ```

**返回值**

  Promise

### stop()  

停止播放。

**注意**

  需要在调用 [start](#velivemediaplayer-start) 开始播放后，调用本方法。

**类型**

  ```ts
  () => Promise
  ```

**返回值**

  Promise
  - 0：成功；
  - ≠0：失败。

### pause()  

暂停播放。

**注意**

  需要在调用 [start](#velivemediaplayer-start) 开始播放后，调用本方法。

**类型**

  ```ts
  () => Promise
  ```

**返回值**

  Promise

### resume()  

恢复播放。

**注意**

  需要在调用 [pause](#velivemediaplayer-pause) 暂停播放后，调用本方法。

**类型**

  ```ts
  () => Promise
  ```

**返回值**

  Promise

### getDuration()  

获取文件的总时长，单位为 ms。

**注意**

  需要在调用 [start](#velivemediaplayer-start) 开始播放后，调用本方法。

**类型**

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

**返回值**

  number
  - \>0：成功，音频文件时长；
  - ≤0：失败。

### seek()  

设置播放进度。

**类型**

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

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"posMs","Type":"number","Required":"是","Default":"无","Description":"播放时间，单位为 ms。\n","children":[],"key":"posMs"}]
      return (
);
```
  

**返回值**

  number
  - 0：成功；
  - ≠0：失败。

### enableMixer()  

开启/关闭音频是否混音到直播流。

**类型**

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

**参数**


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

### enableAutoEq()  

开启/关闭自动音量均衡。

**类型**

  ```ts
  (sourceLufs: number, targetLufs: number) => void
  ```

**参数**


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

### setRenderView()  

支持 MP4 格式的视频渲染。

**类型**

  ```ts
  (view: View) => void
  ```

**参数**


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

### setFrameListener()  

设置音视频帧回调的监听。

**注意**

  重复调用本方法，仅最后一次调用生效。

**类型**

  ```ts
  (listener: VeLiveMediaPlayerFrameListener) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"listener","Type":"VeLiveMediaPlayerFrameListener","Required":"是","Default":"无","Description":"音视频帧回调监听。详情请参见 VeLiveMediaPlayerFrameListener。\n","children":[],"key":"listener"}]
      return (
);
```
  

### setBGMVolume()  

设置播放音频的音量。

**类型**

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

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"volume","Type":"number","Required":"是","Default":"无","Description":"播放音频音量，取值范围为 [0.0,4.0]。\n","children":[],"key":"volume"}]
      return (
);
```
  

### setVoiceVolume()  

设置音频采集音量。

**注意**

  需要在调用 [start](#velivemediaplayer-start) 开始播放背景音乐后，调用本方法。

**类型**

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

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"volume","Type":"number","Required":"是","Default":"无","Description":"音频采集音量，取值范围为 [0.0,4.0]。\n","children":[],"key":"volume"}]
      return (
);
```
  

### enableBGMLoop()  

设置是否循环播放。

**类型**

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

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"loop","Type":"boolean","Required":"是","Default":"无","Description":"是否循环播放。默认为 false。\\
\ntrue：循环播放；
\nfalse：不循环播放。\n\n","children":[],"key":"loop"}]
      return (
);
```
  

### destroy()  

销毁播放器实例。

**类型**

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


## VeLivePusherConfiguration 

类型：`class`

推流引擎初始化配置。

### setReconnectIntervalSeconds()  

设置推流器推流失败后尝试重连的时间间隔。

**类型**

  ```ts
  (interval: number) => VeLivePusherConfiguration
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.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":"时间间隔，单位为 s，默认值为 5。\n","children":[],"key":"interval"}]
      return (
);
```
  

**返回值**

  VeLivePusherConfiguration

### getReconnectIntervalSeconds()  

获取推流器推流失败后尝试重连的时间间隔。

**类型**

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

**返回值**

  number  时间间隔，单位为 s。

### setReconnectCount()  

设置推流器推流失败后尝试重连的次数。

**类型**

  ```ts
  (maxCount: number) => VeLivePusherConfiguration
  ```

**参数**


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

**返回值**

  VeLivePusherConfiguration

### getReconnectCount()  

获取推流器推流失败后尝试重连的次数。

**类型**

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

**返回值**

  number  重连次数。

### setVideoCaptureConfig()  

设置视频采集参数，用于调整和设置视频采集相关的参数。

**类型**

  ```ts
  (config: VeLiveVideoCaptureConfiguration) => VeLivePusherConfiguration
  ```

**参数**


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

**返回值**

  VeLivePusherConfiguration  推流引擎初始化配置对象，详情请参见 [VeLivePusherConfiguration](#velivepusherconfiguration)。

### getVideoCaptureConfig()  

获取视频采集参数，用于调整和设置视频采集相关的参数。

**类型**

  ```ts
  () => VeLiveVideoCaptureConfiguration
  ```

**返回值**

  VeLiveVideoCaptureConfiguration  视频采集参数配置对象，详情请参见 [VeLiveVideoCaptureConfiguration](1317625#velivevideocaptureconfiguration)。

### setAudioCaptureConfig()  

设置音频采集参数，用于调整和设置音频采集相关的参数。

**类型**

  ```ts
  (config: VeLiveAudioCaptureConfiguration) => VeLivePusherConfiguration
  ```

**参数**


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

**返回值**

  VeLivePusherConfiguration  推流引擎初始化配置对象，详情请参见 [VeLivePusherConfiguration](#velivepusherconfiguration)。

### getAudioCaptureConfig()  

获取音频采集参数，用于调整和设置音频采集相关的参数。

**类型**

  ```ts
  () => VeLiveAudioCaptureConfiguration
  ```

**返回值**

  VeLiveAudioCaptureConfiguration  音频采集参数配置对象，详情请参见 [VeLiveAudioCaptureConfiguration](1317625#veliveaudiocaptureconfiguration)。

### android_setContext()  

设置应用上下文。

**类型**

  ```ts
  (context: $p_a.Context) => VeLivePusherConfiguration
  ```

**参数**


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

**返回值**

  VeLivePusherConfiguration  推流引擎初始化配置对象，详情请参见 [VeLivePusherConfiguration](#velivepusherconfiguration)。

### android_getContext()  

获取应用上下文。

**类型**

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

**返回值**

  $p_a.Context  应用上下文。

### setExtraParameters()  

设置扩展参数，默认不需要设置。如果需要使用，您可通过提交工单联系技术支持。

**类型**

  ```ts
  (params: string) => VeLivePusherConfiguration
  ```

**参数**


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

**返回值**

  VeLivePusherConfiguration  推流引擎初始化配置对象，详情请参见 [VeLivePusherConfiguration](#velivepusherconfiguration)。

### android_getExtraParams()  

获取扩展参数。

**类型**

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

**返回值**

  $p_a.LiveSdkSetting  扩展参数。

### android_build()  

构造推流引擎。

**类型**

  ```ts
  () => VeLivePusher
  ```

**返回值**

  [VeLivePusher](#velivepusher)  推流引擎，详情请参见 [VeLivePusher](#velivepusher)。
视频直播
