## LivePusher 类型：`class` 推流 SDK 的核心类，用于管理音视频采集、合流、推流等。 ### 属性 | 属性 | 类型 | 说明 | | :-- | :-- | :-- | | observer | Observer | `只读` 推流器的观察者，用于接收推流状态、错误、警告等通知回调。 | | isEnableMixing | boolean | `只读` 当前是否为开启合流的状态，默认为 `false`。合流是将多个音视频流（如摄像头、麦克风、屏幕分享等）合并为一个流，便于推送到远端或录制。\ |||- `true`：启用合流，将所有输入流整合为单一流。 |\ |||- `false`：不启用合流，独立推送各流。 | | | pushMode | [PushMode](1438157#pushmode) | `只读` 当前推流模式。\ |||- `rtm`：使用 RTM 传输协议。 |\ |||- `WebTransport`：使用 WebTransport 传输协议。 | | ### new LivePusher() 创建一个新的 `LivePusher` 实例。 **类型** ```ts constructor(options?: ConfigOptions) ``` **参数** ```mixin-react const columns = [{ title: '名称', dataIndex: 'Name', width: 260, },{ title: '类型', dataIndex: 'Type', width: null, render: (col, item, index) => { if(col.includes('')){ return
; } return col; } },{ title: '是否必选', dataIndex: 'Required', width: undefined, },{ title: '默认值', dataIndex: 'Default', width: undefined, render: (col, item, index) => { if(col.includes('')){ const regex = /(.*)
(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"options","Type":"ConfigOptions | undefined","Required":"否","Default":"无","Description":"配置选项，定义推流相关的参数。\n","children":[],"key":"options"}]
      return ();
```
  

### getDevicesList()  

获取设备列表，包括音频输入设备和视频输入设备。

**类型**

  ```ts
  (kind?: 'audioinput' | 'videoinput') => Promise
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"kind","Type":"\"audioinput\" | \"videoinput\" | undefined","Required":"否","Default":"无","Description":"指定设备类型，不传时默认获取所有设备。
\naudioinput：音频输入设备。
\nvideoinput：视频输入设备。\n\n","children":[],"key":"kind"}]
      return (
);
```
  

**返回值**

  Promise
  - 成功：返回包含 [`MediaDeviceInfo`](https://developer.mozilla.org/en-US/docs/Web/API/MediaDeviceInfo) 对象的数组，每个对象表示一个音频输入设备或视频输入设备的详细信息。
  - 失败：返回错误信息。

### getCameras()  

获取摄像头设备列表。

**类型**

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

**返回值**

  Promise
  - 成功：返回包含 [`MediaDeviceInfo`](https://developer.mozilla.org/en-US/docs/Web/API/MediaDeviceInfo) 对象的数组，每个对象表示一个视频输入设备（摄像头）。
  - 失败：返回错误信息。

### getMicrophones()  

获取麦克风设备列表。

**类型**

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

**返回值**

  Promise
  - 成功：返回返回一个包含 [`MediaDeviceInfo`](https://developer.mozilla.org/en-US/docs/Web/API/MediaDeviceInfo) 对象的数组，每个对象表示一个音频输入设备（麦克风）。
  - 失败：返回错误信息。

### startCamera()  

启动摄像头视频采集。

**注意**

  如果主播未授权访问摄像头，会抛出权限错误。

**类型**

  ```ts
  (deviceId?: string) => Promise
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"deviceId","Type":"string | undefined","Required":"否","Default":"无","Description":"指定要启动采集的摄像头设备 ID，可以通过 getDevicesList 或 getCameras 获取。
\n移动端支持传入 user 和 environment。
\nuser：获取前置摄像头。
\nenvironment：获取后置摄像头。\n\n","children":[],"key":"deviceId"}]
      return (
);
```
  

**返回值**

  Promise  返回 `Promise` 对象。
  - 成功：返回采集的流 ID，流 ID 作为合流、停止采集的参数使用。
  - 失败：返回错误信息。

### stopCamera()  

停止摄像头视频采集。

**类型**

  ```ts
  (streamId?: string) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"streamId","Type":"string | undefined","Required":"否","Default":"无","Description":"指定需要停止采集的流 ID，在成功调用 startCamera 时返回。不传时默认停止所有摄像头采集。\n","children":[],"key":"streamId"}]
      return (
);
```
  

### startMicrophone()  

启动麦克风音频采集。

**注意**

  如果主播未授予麦克风权限，会抛出权限错误。

**类型**

  ```ts
  (deviceId?: string) => Promise
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"deviceId","Type":"string | undefined","Required":"否","Default":"无","Description":"指定需要启动采集的设备 ID，可以通过 getDevicesList 或 getMicrophones 获取。不传时默认启动所有麦克风采集。\n","children":[],"key":"deviceId"}]
      return (
);
```
  

**返回值**

  Promise  返回 `Promise` 对象。
  - 成功：返回采集的流 ID，流 ID 作为混音、停止采集的参数使用。
  - 失败：返回错误信息。

### stopMicrophone()  

停止麦克风音频采集。

**类型**

  ```ts
  (streamId?: string) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"streamId","Type":"string | undefined","Required":"否","Default":"无","Description":"指定需要停止采集的流 ID，在成功调用 startMicrophone 时返回。不传时默认停止所有麦克风采集。\n","children":[],"key":"streamId"}]
      return (
);
```
  

### startVideoFileCapture()  

启动视频文件采集。

**注意**

  暂时仅支持 Chrome 浏览器采集。

**类型**

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

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"url","Type":"string","Required":"是","Default":"无","Description":"视频文件的 URL，支持在线地址或 Blob URL。
\n在线地址：指互联网上公开可访问的视频文件 URL，例如，https://example.com/video.mp4。
\nBlob URL：指通过浏览器 Blob 对象动态生成的临时地址，例如，blob:http://example.com/abc1234。\n\n","children":[],"key":"url"}]
      return (
);
```
  

**返回值**

  Promise  返回 `Promise` 对象。
  - 成功：返回采集的流 ID，该流 ID 可用于合流或停止采集。
  - 失败：返回错误信息。

### stopVideoFileCapture()  

停止视频文件采集。

**类型**

  ```ts
  (streamId?: string) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"streamId","Type":"string | undefined","Required":"否","Default":"无","Description":"指定需要停止采集的流 ID，在成功调用 startVideoFileCapture 时返回。不传时默认停止所有视频文件采集。\n","children":[],"key":"streamId"}]
      return (
);
```
  

### startScreenCapture()  

启动屏幕采集。

**注意**

  - 屏幕声音采集功能仅在 Chrome 74+ 和 Edge 79+ 浏览器版本中可用。
  - 详细信息请参考 [`getDisplayMedia()`](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getDisplayMedia#browser_compatibility) 获取浏览器兼容性。

**类型**

  ```ts
  (audio?: boolean) => Promise
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"audio","Type":"boolean","Required":"是","Default":"false\n\n","Description":"是否采集系统声音或者标签⻚声音。
\ntrue：采集。
\nfalse：不采集。\n\n","children":[],"key":"audio"}]
      return (
);
```
  

**返回值**

  Promise  返回 `Promise` 对象。
  - 成功：返回采集的流 ID，流 ID 作为合流、停止采集的参数使用。
  - 失败：返回错误信息。

### stopScreenCapture()  

停止屏幕采集。

**类型**

  ```ts
  (streamId?: string) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"streamId","Type":"string | undefined","Required":"否","Default":"无","Description":"指定需要停止采集的流 ID，在成功调用 startScreenCapture 时返回。不传时默认停止所有屏幕采集。\n","children":[],"key":"streamId"}]
      return (
);
```
  

### startAudioFileCapture()  

启动音频文件采集。

**注意**

    暂时仅支持 Chrome 浏览器采集。

**类型**

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

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"url","Type":"string","Required":"是","Default":"无","Description":"音频文件的 URL。支持文件在线地址和 Blob URL。
\n在线地址：指互联网上公开可访问的音频文件 URL，例如，https://example.com/audio-file.mp3。
\nBlob URL：指通过浏览器 Blob 对象动态生成的临时地址，例如，blob:http://example.com/71d7a6d8。\n\n","children":[],"key":"url"}]
      return (
);
```
  

**返回值**

  Promise  返回 `Promise` 对象。
  - 成功：返回采集的流 ID，流 ID 可以作为混音、停止采集的参数使用。
  - 失败：返回错误信息。

### stopAudioFileCapture()  

停止音频文件采集。

**类型**

  ```ts
  (streamId?: string) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"streamId","Type":"string | undefined","Required":"否","Default":"无","Description":"指定需要停止采集的流 ID，在成功调用 startAudioFileCapture 时返回。不传时默认停止所有音频文件采集。\n","children":[],"key":"streamId"}]
      return (
);
```
  

### startImageCapture()  

启动图片采集。

**类型**

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

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"url","Type":"string","Required":"是","Default":"无","Description":"图片文件的 URL。支持文件在线地址和 Blob URL。
\n在线地址：指互联网上公开可访问的图片文件 URL，例如，https://example.com/image-file.png。
\nBlob URL：指通过浏览器 Blob 对象动态生成的临时地址，例如，blob:http://example.com/71d7a6d8。\n\n","children":[],"key":"url"}]
      return (
);
```
  

**返回值**

  Promise  返回 `Promise` 对象。
  - 成功：返回采集的流 ID，流 ID 可以作为合流、停止采集的参数使用。
  - 失败：返回错误信息。

### stopImageCapture()  

停止图片采集。

**类型**

  ```ts
  (streamId?: string) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"streamId","Type":"string | undefined","Required":"否","Default":"无","Description":"指定需要停止采集的流 ID，在成功调用 startImageCapture 时返回。不传时默认停止所有图片采集。\n","children":[],"key":"streamId"}]
      return (
);
```
  

### startCustomVideoCapture()  

启动自定义视频流采集。

**类型**

  ```ts
  (track: MediaStreamTrack) => string | undefined
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"track","Type":"MediaStreamTrack","Required":"是","Default":"无","Description":"需要采集的视频流。可以来自设备摄像头、屏幕共享或通过 Canvas 绘制生成的视频。例如，通过摄像头或屏幕共享获取的 VideoTrack。\n","children":[],"key":"track"}]
      return (
);
```
  

**返回值**

  string | undefined
  - 成功：返回采集的流 ID，流 ID 可以作为合流、停止采集的参数使用。
  - 失败：返回错误信息。

### stopCustomVideoCapture()  

停止自定义视频流采集。

**类型**

  ```ts
  (streamId?: string) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"streamId","Type":"string | undefined","Required":"否","Default":"无","Description":"指定需要停止采集的流 ID，在成功调用 startCustomVideoCapture 时返回。不传时默认停止所有自定义视频流的采集。\n","children":[],"key":"streamId"}]
      return (
);
```
  

### startCustomAudioCapture()  

启动自定义音频流采集。

**类型**

  ```ts
  (track: MediaStreamTrack) => string | undefined
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"track","Type":"MediaStreamTrack","Required":"是","Default":"无","Description":"需要采集的自定义音频流，可以来自麦克风、音频文件或其他音频源。例如，通过麦克风获取的 AudioTrack。\n","children":[],"key":"track"}]
      return (
);
```
  

**返回值**

  string | undefined
  - 成功：返回采集的流 ID，流 ID 可以作为混音、停止采集的参数使用。
  - 失败：返回错误信息。

### stopCustomAudioCapture()  

停止自定义音频流采集。

**类型**

  ```ts
  (streamId?: string) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"streamId","Type":"string | undefined","Required":"否","Default":"无","Description":"指定需要停止采集的流 ID，在成功调用 startCustomAudioCapture 时返回。不传时默认停止所有自定义音频流的采集。\n","children":[],"key":"streamId"}]
      return (
);
```
  

### startVolumeDetect()  

开始音量检测。用于监测指定音频流或最终合流输出的音量值。

**注意**

  - 确保音频流已启动并正常推流，调用前请检查音频轨道是否有效。
  - 启动音量检测后，可通过 [`getVolume()`](#livepusher-getvolume) 方法获取实时音量值。

**类型**

  ```ts
  (streamId?: string) => Promise
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"streamId","Type":"string | undefined","Required":"否","Default":"无","Description":"指定需要检测音量的流 ID。
\n当 streamId 为 undefined 时，检测最终合流输出的音量，包括所有参与合流的音频。
\n如果指定 streamId，仅检测该音频流的音量。\n\n","children":[],"key":"streamId"}]
      return (
);
```
  

**返回值**

  Promise  返回 `Promise` 对象。
  - 成功：无返回值。
  - 失败：返回错误信息。

### stopVolumeDetect()  

停止音量检测。

**注意**

  - 适用于需要停止对某一特定音频流或最终输出音频流进行音量检测的场景。
  - 停止音量检测后，您将无法再通过 [`getVolume()`](#livepusher-getvolume) 方法获取对应流的音量。

**类型**

  ```ts
  (streamId?: string) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"streamId","Type":"string | undefined","Required":"否","Default":"无","Description":"指定需要停止音量检测的流 ID。
\n当 streamId 为 undefined 时，停止最终合流输出的音量检测。
\n如果指定 streamId，仅停止该音频流的音量检测。\n\n","children":[],"key":"streamId"}]
      return (
);
```
  

### getVolume()  

获取音量。

**注意**

  在调用此方法之前，您需要先调用 [`startVolumeDetect()`](#livepusher-startvolumedetect) 方法启动音量检测。调用示例：
  ```js
  await livePusher.startVolumeDetect()
  const volume = livePusher.getVolume()
  console.log(volume)
  ```

**类型**

  ```ts
  (streamId?: string) => number
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"streamId","Type":"string | undefined","Required":"否","Default":"无","Description":"指定需要获取音量的流 ID。
\n当 streamId 为 undefined 时，返回最终合流输出的音量，包括所有参与合流的音频。
\n如果指定 streamId，仅输出该音频流的音量。\n\n","children":[],"key":"streamId"}]
      return (
);
```
  

**返回值**

  number  返回指定流 ID 的音量值，范围为 `[1,10]`，数值越大表示音量越高。

### enableMixing()  

启用或禁用合流功能。

**注意**

  - 合流必须在推流前设置，推流过程中无法切换该状态。
  - 启用合流前后，均可以调用 [`setMixingConfig()`](#livepusher-setmixingconfig) 配置合流画布参数（如宽度、高度、帧率等），以确保合流画面符合预期。

**类型**

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

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"enable","Type":"boolean","Required":"是","Default":"无","Description":"指定是否启用本地合流。
\ntrue：启用。
\nfalse：停用。\n\n","children":[],"key":"enable"}]
      return (
);
```
  

### setMixingConfig()  

配置合流参数，包括合流画布的宽度、高度、帧率等。

**类型**

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

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"config","Type":"IMixingViewConfig","Required":"是","Default":"无","Description":"合流画布的配置信息，例如宽、高、帧率等参数。\n","children":[],"key":"config"}]
      return (
);
```
  

### setRenderView()  

设置视频的预览区域。本地视频会在指定的容器内进行预览，同时预览内容与推流的画面和声音完全一致。

**类型**

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

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"containerId","Type":"string","Required":"是","Default":"无","Description":"用于指定预览区域的 HTML 容器元素 ID。\n","children":[],"key":"containerId"}]
      return (
);
```
  

### startPreview()  

开始本地视频预览。启用本地视频的预览功能，主播可以通过预览区域查看本地视频效果。

**类型**

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

### stopPreview()  

停止本地视频预览。

**注意**

  调用此接口停止本地视频的预览功能时，不会影响实际推流。

**类型**

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

### startPush()  

开始推流，支持 RTM 和 WebTransport 两种推流方式。

**类型**

  ```ts
  (rtmUrl: string) => Promise
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"rtmUrl","Type":"string","Required":"是","Default":"无","Description":"推流地址，可以登录视频直播控制台获取 RTM 或 WebTransport 推流地址。\n","children":[],"key":"rtmUrl"}]
      return (
);
```
  

**返回值**

  Promise  返回 `Promise` 对象。
  - 成功：无返回值。
  - 失败：返回错误信息。

### addVideoStream()  

将视频流添加到合流画布中，可以将多个视频流（例如主播的摄像头画面、屏幕共享画面）合成到同一个合流画布中，如果视频流中包含音频信息，音频也会被添加到混音模块中。

**注意**

  必须在已调用 [`enableMixing()`](#livepusher-enablemixing) 方法启用合流功能后使用。

**类型**

  ```ts
  (config: IVideoStreamLayoutParams | IVideoStreamLayoutParams[]) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"config","Type":"IVideoStreamLayoutParams | IVideoStreamLayoutParams[]","Required":"是","Default":"无","Description":"视频流布局参数，可以是单个对象或多个对象组成的数组。\n","children":[],"key":"config"}]
      return (
);
```
  

### removeVideoStream()  

从合流画布中移除指定的视频流。当需要从合流画布中删除某个视频画面时使用。

**类型**

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

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"streamId","Type":"string","Required":"是","Default":"无","Description":"要移除的视频流的 ID。\n","children":[],"key":"streamId"}]
      return (
);
```
  

### updateVideoStream()  

更新已添加的视频流的布局参数，例如位置、大小等，适用于动态布局调整等场景。

**类型**

  ```ts
  (config: IVideoStreamLayoutParams | IVideoStreamLayoutParams[]) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"config","Type":"IVideoStreamLayoutParams | IVideoStreamLayoutParams[]","Required":"是","Default":"无","Description":"视频流更新参数，可以是单个对象或多个对象组成的数组。\n","children":[],"key":"config"}]
      return (
);
```
  

### muteVideoStream()  

隐藏合流画布中的视频流。当需要暂时隐藏某个视频画面，但不想从合流画布中移除该视频流时使用。

**类型**

  ```ts
  (streamId?: string) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"streamId","Type":"string | undefined","Required":"否","Default":"无","Description":"要隐藏的视频流的 ID。如果不传，则隐藏所有视频流。\n","children":[],"key":"streamId"}]
      return (
);
```
  

### unmuteVideoStream()  

取消隐藏合流画布中的视频流，需要重新显示之前隐藏的视频流时使用。

**类型**

  ```ts
  (streamId?: string) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"streamId","Type":"string | undefined","Required":"否","Default":"无","Description":"要重新显示的视频流的 ID。如果不传，则重新显示所有视频流。\n","children":[],"key":"streamId"}]
      return (
);
```
  

### addAudioStream()  

将音频流添加到混音模块中（需要启用合流功能）。当需要在合流音频中加入额外的音频源时使用，例如，添加背景音乐。

**注意**

  必须在已调用 [`enableMixing()`](#livepusher-enablemixing) 方法启用合流功能后使用。

**类型**

  ```ts
  (config: IAudioStreamLayoutParams | IAudioStreamLayoutParams[]) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"config","Type":"IAudioStreamLayoutParams | IAudioStreamLayoutParams[]","Required":"是","Default":"无","Description":"音频流参数，可以是单个对象或多个对象组成的数组。\n","children":[],"key":"config"}]
      return (
);
```
  

### removeAudioStream()  

移除指定的音频流。如果目标是单独的音频流，则直接移除；如果目标是一个包含音频轨道的视频流，仅会影响该视频流中的音频部分，而不会对视频画面产生任何影响。

**类型**

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

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"streamId","Type":"string","Required":"是","Default":"无","Description":"要移除的流 ID。如果不传，则移除所有音频流。\n","children":[],"key":"streamId"}]
      return (
);
```
  

### updateAudioStream()  

更新音频流的音量大小。在混音场景中调整某个或多个音频流的音量，例如，主播语音、背景音乐和视频音频的平衡调整。

**注意**

  您可以按照如下顺序调用接口。
  - 调用 `enableMixing(true)` 开启合流功能。
  - 使用 `addAudioStream()` 添加音频流到混音模块。
  - 调用 `updateAudioStream()` 更新音频流的参数。

**类型**

  ```ts
  (config: IAudioStreamLayoutParams | IAudioStreamLayoutParams[]) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"config","Type":"IAudioStreamLayoutParams | IAudioStreamLayoutParams[]","Required":"是","Default":"无","Description":"要更新的音频流参数，支持单个对象或数组以更新多个音频流。\n","children":[],"key":"config"}]
      return (
);
```
  

### muteAudioStream()  

静音指定的音频流或包含音频轨道的视频流。在某个音频流内容不需要被输出时使用。

**注意**

  静音指定的音频流。如果目标是单独的音频流，则直接静音；如果目标是一个包含音频轨道的视频流，仅会影响该视频流中的音频部分，而不会对视频画面产生任何影响。

**类型**

  ```ts
  (streamId?: string) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"streamId","Type":"string | undefined","Required":"否","Default":"无","Description":"要静音的流 ID。如果不传，则静音所有音频流。\n","children":[],"key":"streamId"}]
      return (
);
```
  

### unmuteAudioStream()  

取消对指定音频流的静音操作，或取消所有音频流的静音状态。

**类型**

  ```ts
  (streamId?: string) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"streamId","Type":"string | undefined","Required":"否","Default":"无","Description":"要取消静音的流 ID，不传时取消所有流的静音。\n","children":[],"key":"streamId"}]
      return (
);
```
  

### setProperty()  

设置推流和采集相关的配置属性，包括视频分辨率、帧率、码率、音频采样率等。适用于需要调整某些关键配置的场景，例如，调整视频采集的清晰度、根据目标服务选择推流协议（如 RTM 或 WebTransport）等。

**注意**

  - 部分属性设置可能需要在推流前完成（如分辨率和帧率），请确保在推流启动前调用相关配置。
  - 属性 `setPushMode` 的设置应在初始化阶段完成，不支持动态切换。

**类型**

  ```ts
  (key: K, value: IProperty[K]) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"key","Type":"K","Required":"是","Default":"无","Description":"要设置的属性名称。
\n","children":[],"key":"key"},{"Name":"value","Type":"IProperty[K]","Required":"是","Default":"无","Description":"对应属性的值，根据 key 的类型填写。\n","children":[],"key":"value"}]
      return (
);
```
  

### setVideoQuality()  

设置推流和采集的视频质量。

**类型**

  ```ts
  (quality: keyof typeof VIDEO_DEFAULT_QUALITY) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"quality","Type":"\"120p\" | \"180p\" | \"240p\" | \"360p\" | \"480p\" | \"720p-1\" | \"720p-2\" | \"720p-3\" | \"1080p-1\" | \"1080p-2\" | \"1080p-3\"","Required":"是","Default":"无","Description":"视频质量，详情请参见 VIDEO_DEFAULT_QUALITY\n","children":[],"key":"quality"}]
      return (
);
```
  

### setAudioQuality()  

设置推流和采集音频的质量，包括采样率和码率：
- 采样率：仅影响麦克风的音频采集质量。
- 码率：决定最终推流音频的质量。

**类型**

  ```ts
  (quality: keyof typeof AUDIO_DEFAULT_QUALITY) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"quality","Type":"\"STANDARD\" | \"HIGHT\"","Required":"是","Default":"无","Description":"音频质量。
\nSTANDARD：标准音质（低码率），适合语音通话、网络差场景。
\nHIGHT：高音质（高码率），适合音乐直播、高质量场景。\n\n","children":[],"key":"quality"}]
      return (
);
```
  

### stopPush()  

停止推流。

**类型**

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

**返回值**

  Promise  返回 `Promise` 对象。
  - 成功：无返回值。
  - 失败：返回错误信息。

### isPushing()  

判断当前是否正在推流。

**类型**

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

**返回值**

  boolean
  - `true`：正在推流。
  - `false`：未推流。

### getStats()  

获取当前推流状态信息。用于监控推流质量，调整参数。

**类型**

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

**返回值**

  Promise<[StatsSnapshoot](#statssnapshoot) | [RTMPStats](#rtmpstats) | undefined\>  当前推流的统计数据（如丢包率、码率）。

### getPreviewElement()  

获取预览的 `video` 元素。用于设置预览区域的音量或样式。

**注意**

  开始预览后可以通过 `getPreviewElement` 获取到对应的预览元素设置预览的音量大小。

**类型**

  ```ts
  () => HTMLVideoElement | null | undefined
  ```

**返回值**

  HTMLVideoElement | null | undefined  预览画面的 `video` 元素。

### destroy()  

清理 SDK 实例，避免可能会产生的内存泄露。

**注意**

  如果正在推流，调用该接口会导致推流中断。

**类型**

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

**返回值**

  Promise  返回 `Promise` 对象。
  - 成功：无返回值。
  - 失败：返回错误信息。

### `static` isSupported()  

查询是否支持 RTM 或 WebTransport 推流。

**类型**

  ```ts
  (mode: PushMode) => Promise
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: null,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                      return ;
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: undefined,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: undefined,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: undefined,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"mode","Type":"PushMode","Required":"是","Default":"无","Description":"推流模式。
\nrtm：表示查询是否支持 RTM 推流。
\nwebTransport：表示查询是否支持 WebTransport 推流。\n\n","children":[],"key":"mode"}]
      return (
);
```
  

**返回值**

  Promise
  - `true`：支持该推流模式。
   - `false`：不支持该推流模式。


## IProperty 

类型：`interface`

用于精细化设置推流 SDK 内部的配置，包括视频采集分辨率、帧率以及音频相关参数等。

**注意**

  设置视频分辨率为 1920×1080，帧率为 30，代码示例：
  ```js
  livePusher.setProperty('setVideoResolution', { width: 1920, height: 1080 });
  livePusher.setProperty('setVideoFps', 30);
  ```

### setVideoResolution  

类型：{ width: number; height: number; }

设置视频采集的分辨率。


 **成员**

  | 名称 | 类型 | 说明 |
  | :-- | :-- | :-- |
  | width | `number` | 分辨率宽度。 |
  | height | `number` | 分辨率高度。 |

### setVideoFps  

类型：number

设置视频采集的帧率。

### setVideoBitrate  

类型：number

设置推流视频的码率，单位为 kbps。

### setAudioBitrate  

类型：number

设置推流时音频的码率，单位为 kbps。

### setAudioSampleRate  

类型：number

设置麦克风采集的采样率，单位为 Hz。

### setPushMode  

类型：[PushMode](1438157#pushmode)

设置推流模式。


## StatsSnapshoot 

描述 RTM 推流状态的详细信息，包括视频和音频的各项指标。

**注意**

  获取推流状态快照，示例如下：
  ```js
  const stats = await livePusher.getStats();
  console.log('当前视频码率:', stats.video.sendBitrate);
  console.log('音频丢包率:', stats.audio.packetsLostPercent);
  ```

**类型**

  ```ts
  {
    video?: {
      codec: string;
      sendBitrate: number;
      frameWidth: number;
      frameHeight: number;
      framesPerSecond: number;
      framesEncoded: number;
      keyFramesEncoded: number;
      framesSent: number;
      frameEncodeAvgTime: number;
      packetsSent: number;
      packetSendDelay: number;
      nackCount: number;
      firCount: number;
      pliCount: number;
      packetsLost: number;
      packetsLostPercent: number;
    };
    audio?: {
      codec: string | undefined;
      channels: number | undefined;
      sendBitrate: number | undefined;
      packetsSent: number | undefined;
      nackCount: number | undefined;
      packetsLost: number | undefined;
      packetsLostPercent: number | undefined;
    };
  }
  ```

**成员**

  | 名称 | 类型 | 说明 |
  | :-- | :-- | :-- |
  | video | { codec: string; sendBitrate: number; frameWidth: number; frameHeight: number; framesPerSecond: number; framesEncoded: number; keyFramesEncoded: number; framesSent: number; frameEncodeAvgTime: number; packetsSent: number; packetSendDelay: number; nackCount: number; firCount: number; pliCount: number; packetsLost: number; packetsLostPercent: number; } \| undefined | 视频信息。 |
  | codec | string | 推流视频编码方式，例如，H.264。 |
  | sendBitrate | number | 推流视频码率，单位为 bps。 |
  | frameWidth | number | 视频分辨率宽度。 |
  | frameHeight | number | 视频分辨率高度。 |
  | framesPerSecond | number | 视频帧率。 |
  | framesEncoded | number | 已编码的帧数。 |
  | keyFramesEncoded | number | 已编码的关键帧数。 |
  | framesSent | number | 已发送的帧数。 |
  | frameEncodeAvgTime | number | 单帧平均编码时间，单位为 ms。 |
  | packetsSent | number | 已发送的数据包数量。 |
  | packetSendDelay | number | 数据包发送前平均缓存时间，单位为 ms。 |
  | nackCount | number | 收到的 NACK 包数。 |
  | firCount | number | 收到的 FIR（全帧请求）包数。 |
  | pliCount | number | 收到的 PLI（图像丢失指示）包数。 |
  | packetsLost | number | 丢失的数据包数量。 |
  | packetsLostPercent | number | 丢包率。 |
  | codec | string \| undefined | 音频编码格式，例如 AAC。 |
  | channels | number \| undefined | 音频通道数，例如，单声道或立体声。 |
  | sendBitrate | number \| undefined | 推流音频码率，单位为 bps |
  | packetsSent | number \| undefined | 已发送的数据包数量。 |
  | nackCount | number \| undefined | 收到的 NACK 包数。 |
  | packetsLost | number \| undefined | 丢失的数据包数量。 |
  | packetsLostPercent | number \| undefined | 丢包率。 |


## RTMPStats 

描述 WebTransport 推流状态信息。

**注意**

  查看视频推流分辨率，代码示例：
  ```js
  const rtmpStats = await livePusher.getStats(); console.log('视频分辨率:', rtmpStats.video.frameWidth, '×', rtmpStats.video.frameHeight);
  ```

**类型**

  ```ts
  {
    video: {
      sendBitrate: number;
      framesPerSecond: number;
      framesEncoded: number;
      keyFramesEncoded: number;
      sendSpeed: number;
      codec: string;
      frameWidth: number;
      frameHeight: number;
      gopSize: number;
    };
    audio: {
      sendBitrate: number;
      framesEncoded: number;
      codec: string;
      channels: number;
      sampleRate: number;
    };
  }
  ```

**成员**

  | 名称 | 类型 | 说明 |
  | :-- | :-- | :-- |
  | sendBitrate | number | 推流视频码率，单位为 bps。 |
  | framesPerSecond | number | 推流帧率。 |
  | framesEncoded | number | 已编码帧数。 |
  | keyFramesEncoded | number | 已编码关键帧数。 |
  | sendSpeed | number | 视频推流上传速度，单位为 bps。 |
  | codec | string | 视频编码格式，例如，H.264。 |
  | frameWidth | number | 视频分辨率宽度。 |
  | frameHeight | number | 视频分辨率高度。 |
  | gopSize | number | GOP（关键帧间隔）大小。 |
  | sendBitrate | number | 推流音频码率，单位为 bps。 |
  | framesEncoded | number | 已编码帧数。 |
  | codec | string | 音频编码格式。 |
  | channels | number | 音频通道数，例如，单声道和立体声。 |
  | sampleRate | number | 音频采样率，单位为 Hz。 |