## VePlayerLive 类型：`class` ### 属性 | 属性 | 类型 | 说明 | | :-- | :-- | :-- | | playTime | number | `只读` 获取已经播放的时长，不包含暂停和等待时间，单位为秒。 | | readyState | 0 \| 2 \| 1 \| 3 \| 4 | `只读` 获取视频的就绪状态，其状态枚举值、枚举名称和说明如下：\ |||- `0`：HAVE_NOTHING，没有关于媒体资源的可用信息 |\ |||- `1`：HAVE_METADATA，已检索到足够多的媒体资源来初始化元数据, 快进/快退不会引发异常 |\ |||- `2`：HAVE_CURRENT_DATA，当前播放位置的数据可用，但不足以播放下一帧 |\ |||- `3`：HAVE_FUTURE_DATA，当前播放位置以及未来至少一小段时间的数据是可用的（至少有两帧以上的数据） |\ |||- `4`：HAVE_ENOUGH_DATA，有足够的数据可用，并且下载速率足够，媒体可以不间断地播放到最后 | | | buffered | TimeRanges | `只读` 获取当前已缓冲的时间范围。 | | played | TimeRanges | `只读` 获取已经播放的音频/视频的时间范围。 | | cumulateTime | number | `只读` 设置/获取视频当前的播放时间, 单位为 s。 | | isFocused | boolean | `只读` 获取是否处于焦点状态，处于焦点状态会显示控制栏。 | | isFullscreen | boolean | `只读` 获取播放器是否处于全屏状态。 | | isCssFullscreen | boolean | `只读` 获取播放器是否处于网页全屏状态。 | | networkState | 0 \| 2 \| 1 \| 3 | `只读` 获取视频的网络状态，其状态枚举值、枚举名称和说明如下：\ |||- `0`：NETWORK_EMPTY，目前还没有数据，readyState 的值是 HAVE_NOTHING |\ |||- `1`：NETWORK_IDLE，HTMLMediaElement 处于活动状态并已选择资源，但未使用网络 |\ |||- `2`：NETWORK_LOADING，浏览器正在下载 HTMLMediaElement 数据 |\ |||- `3`：NETWORK_NO_SOURCE，未找到 HTMLMediaElement src。 | | | paused | boolean | `只读` 获取当前视频是否处于暂停状态。 | | ended | boolean | `只读` 获取当前视频是否播放结束。 | | state | number | `只读` 获取播放器当前所处的状态，其状态枚举值、枚举名称和说明如下：\ |||- `0`：ERROR，播放出现错误 |\ |||- `1`：INITIAL，初始化 |\ |||- `2`：READY，配置/事件/插件等均已经初始化/绑定/实例化完成 |\ |||- `3`：ATTACHING，进入媒体对象挂载阶段 |\ |||- `4`：ATTACHED，媒体对象已经挂载到了 DOM 中 |\ |||- `5`：NOTALLOW，播放被阻止 |\ |||- `6`：RUNNING，已经成功起播进入播放流程 |\ |||- `7`：ENDED，播放结束 |\ |||- `8`：DESTROYED，播放器实例处于已被销毁 | | | url | string | `只读` 获取当前播放视频的拉流地址。 | | source | string | `只读` 获取当前播放视频的线路名称唯一标识（name）。 | | playerVersion | string | `只读` 获取播放器 SDK 版本号。 | | definition | string | `只读` 获取当前播放视频的清晰度唯一标识（definition）。 | | crossOrigin | string | 获取和设置播放器的跨域配置信息，更多信息参考 [crossorigin](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/crossorigin) 属性介绍。 | | volume | number | 获取和设置视频的音量，取值范围为 [0,1]。 | | muted | boolean | 获取和设置视频静音状态。\ |||- `true`：静音 |\ |||- `false`：非静音 | | | lang | string | 获取和设置当前语言。 | ### openLog() 调用此方法开启直播日志上报。 **类型** ```ts () => void ``` ### closeLog() 调用此方法关闭直播日志上报。 **类型** ```ts () => void ``` ### openInfoPanel() 调用此方法将打开直播信息面板，面板将展示拉流格式、帧率、码率、GOP、视频分辨率、编码方式、Buffer 水位、播放进度等基础信息。如果当前是软解，还会显示软解解码效率和解码消耗。 **类型** ```ts () => void ``` ### closeInfoPanel() 调用此方法关闭直播信息面板。 **类型** ```ts () => void ``` ### openAbr() 打开码率自适应（ABR）切换功能。 **类型** ```ts () => void ``` ### closeAbr() 关闭码率自适应（ABR）切换功能。 **类型** ```ts () => void ``` ### updateDrmConfig() 调用此方法更新 DRM 配置。 **类型** ```ts (config: FairplayDrmConfig) => void ``` **参数** ```mixin-react const columns = [{ title: '名称', dataIndex: 'Name', width: 260, },{ title: '类型', dataIndex: 'Type', width: undefined, render: (col, item, index) => { if(col.includes('')){ const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi; const new1 = regex.exec(col); return {new1?.[1]}{new1?.[4]}{new1?.[5]} } 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":"FairplayDrmConfig","Required":"是","Default":"无","Description":"-","children":[],"key":"config"}]
      return ();
```
  

### switchAbr()  

修改 ABR 配置，包含修改是否开启 ABR 功能，和修改其他清晰度。

**类型**

  ```ts
  (options: { enable: boolean; bitrate: number;}) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: undefined,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    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":"-","Required":"是","Default":"-","Description":"ABR 的配置。
\n","children":[{"Name":"enable","Type":"boolean","Required":"是","Default":"无","Description":"是否开启 ABR 功能。
\ntrue：开启
\nfalse：关闭
","children":[],"key":"options-enable"},{"Name":"bitrate","Type":"number","Required":"是","Default":"无","Description":"切换自适应码率直播流对应的码率。\n","children":[],"key":"options-bitrate"}],"key":"options"}]
      return (
);
```
  

**返回值**



### getRTMNetWorkInfo()  

获取 RTM 拉流的网络评估信息。

**类型**

  ```ts
  () => RTMNetWorkInfo
  ```

**返回值**

  [RTMNetWorkInfo](1155423#rtmnetworkinfo)

### getRTMStats()  

获取 RTM 拉流的播放信息。

**类型**

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

**返回值**

  Promise<[StatsSnapShoot](1155423#statssnapshoot)\>

### getFLVStats()  

获取 FLV 拉流的播放信息。

**类型**

  ```ts
  () => FlvStats
  ```

**返回值**

  [FlvStats](1155423#flvstats)

### switch()  

调用此方法切换拉流地址、线路、清晰度。

**类型**

  ```ts
  (target: string | { definition?: string; source?: string;}, options?: { fallbackToFirstDefinition?: boolean; seamless?: boolean;}) => Promise
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: undefined,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    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":"target","Type":"-","Required":"是","Default":"-","Description":"目标地址，可以是播放地址，也可以是线路和清晰度。
\n","children":[{"Name":"definition","Type":"string | undefined","Required":"否","Default":"无","Description":"清晰度的唯一标识。
\n","children":[],"key":"target-definition"},{"Name":"source","Type":"string | undefined","Required":"否","Default":"无","Description":"线路的唯一标识。
\n","children":[],"key":"target-source"}],"key":"target"},{"Name":"options","Type":"-","Required":"否","Default":"-","Description":"更多配置信息。
\n","children":[{"Name":"fallbackToFirstDefinition","Type":"boolean | undefined","Required":"否","Default":"false","Description":"清晰度 definition 配置无效时，是否降级到播放列表第一个清晰度地址。
\n","children":[],"key":"options-fallbackToFirstDefinition"},{"Name":"seamless","Type":"boolean | undefined","Required":"否","Default":"false","Description":"是否无缝切换，true 为无缝切换，false 为非无缝切换。\n","children":[],"key":"options-seamless"}],"key":"options"}]
      return (
);
```
  

**返回值**

  Promise<[ExposedDefinition](1155423#definition)\>

### updatePlaylist()  

调用此方法更新拉流地址列表。

**类型**

  ```ts
  (playlist: Source[] | string, target?: string | { definition?: string; source?: string;}) => Promise
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: undefined,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    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":"playlist","Type":"string | Source[]","Required":"是","Default":"无","Description":"要更新的播放列表。
\n","children":[],"key":"playlist"},{"Name":"target","Type":"-","Required":"否","Default":"-","Description":"更新后默认播放的资源。
\n","children":[{"Name":"definition","Type":"string | undefined","Required":"否","Default":"无","Description":"清晰度唯一标识。
\n","children":[],"key":"target-definition"},{"Name":"source","Type":"string | undefined","Required":"否","Default":"无","Description":"线路的唯一标识。\n","children":[],"key":"target-source"}],"key":"target"}]
      return (
);
```
  

**返回值**

  Promise

### once()  

调用此方法监听指定事件，事件处理函数只执行一次。

**类型**

  ```ts
  (event: string, callback: (data?: any) => any) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: undefined,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    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":"event","Type":"string","Required":"是","Default":"无","Description":"表示事件的名称。
\n","children":[],"key":"event"},{"Name":"callback","Type":"(data?: any) => any","Required":"是","Default":"无","Description":"表示事件的回调函数。\n","children":[],"key":"callback"}]
      return (
);
```
  

### off()  

调用此方法解绑或移除指定事件的事件监听。

**类型**

  ```ts
  (event: string, callback: (data?: any) => any) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: undefined,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    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":"event","Type":"string","Required":"是","Default":"无","Description":"表示事件的名称。
\n","children":[],"key":"event"},{"Name":"callback","Type":"(data?: any) => any","Required":"是","Default":"无","Description":"表示事件的回调函数。\n","children":[],"key":"callback"}]
      return (
);
```
  

### emit()  

调用此方法触发指定事件。

**类型**

  ```ts
  (event: string, data?: any) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: undefined,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    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":"event","Type":"string","Required":"是","Default":"无","Description":"表示事件的名称。
\n","children":[],"key":"event"},{"Name":"data","Type":"any","Required":"是","Default":"无","Description":"事件信息。\n","children":[],"key":"data"}]
      return (
);
```
  

### offAll()  

调用此方法解绑或移除指定事件的所有事件监听。

**类型**

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

### on()  

调用此方法监听指定事件。

**类型**

  ```ts
  (event: string, callback: (data?: any) => any) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: undefined,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    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":"event","Type":"string","Required":"是","Default":"无","Description":"表示事件名称。
\n","children":[],"key":"event"},{"Name":"callback","Type":"(data?: any) => any","Required":"是","Default":"无","Description":"表示事件的回调函数。\n","children":[],"key":"callback"}]
      return (
);
```
  

### play()  

调用此方法开始播放 。

**类型**

  ```ts
  () => any
  ```

**返回值**

  any

### pause()  

调用此方法暂停播放。

**类型**

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

### requestPIP()  

调用此方法打开画中画。

**类型**

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

### exitPIP()  

调用此方法关闭画中画。

**类型**

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

### retry()  

调用此方法重新拉流。

**类型**

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

### focus()  

播放器获取焦点，调用该方法 `veplayer.isFocused` 将会变为 `true`，并触发 `PLAYER_FOCUS` 事件。

**类型**

  ```ts
  (data?: { autoHide?: boolean; delay?: number;}) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: undefined,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    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":"data","Type":"-","Required":"否","Default":"-","Description":"播放器获取焦点配置信息。
\n","children":[{"Name":"autoHide","Type":"boolean | undefined","Required":"否","Default":"true","Description":"是否需要自动失焦，默认为 true，即经过 delay 时长之后，会自动调用 blur() 进行失焦。
\n","children":[],"key":"data-autoHide"},{"Name":"delay","Type":"number | undefined","Required":"否","Default":"3000","Description":"自动失焦延迟时长，单位ms，autoHide 为 true 时生效。\n","children":[],"key":"data-delay"}],"key":"data"}]
      return (
);
```
  

### blur()  

播放器失去焦点，调用该方法 `veplayer.isFocused` 将会变为 `false`，并触发 `PLAYER_BLUR` 事件。

**类型**

  ```ts
  (data?: { ignorePaused?: boolean;}) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: undefined,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    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":"data","Type":"-","Required":"否","Default":"-","Description":"播放器失去焦点配置信息。
\n","children":[{"Name":"ignorePaused","Type":"boolean | undefined","Required":"否","Default":"false","Description":"播放器失焦是否忽略暂停状态，默认值是 true，即默认暂停的时候不取消播放器焦点状态。\n","children":[],"key":"data-ignorePaused"}],"key":"data"}]
      return (
);
```
  

### canPlayType()  

判断浏览器是否支持播放格式。

**类型**

  ```ts
  (type: string) => boolean
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: undefined,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    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":"type","Type":"string","Required":"是","Default":"无","Description":"播放格式。\n","children":[],"key":"type"}]
      return (
);
```
  

**返回值**

  boolean

### requestFullscreen()  

调用此方法进入系统全屏状态。如果该方法调用的时候处于网页全屏状态会自动退出网页全屏，下发事件 `Events.FULLSCREEN_CHANGE`。

**类型**

  ```ts
  (el?: HTMLElement) => Promise
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: undefined,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    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":"el","Type":"HTMLElement | undefined","Required":"否","Default":"无","Description":"全屏作用的 DOM 节点。\n","children":[],"key":"el"}]
      return (
);
```
  

**返回值**

  Promise

### exitFullscreen()  

调用此方法退出系统全屏状态，调用该方法 `veplayer.isFullscreen` 将会变为 `false`，并触发 `Events.FULLSCREEN_CHANGE` 事件。

**类型**

  ```ts
  (el?: HTMLElement) => Promise
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: undefined,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    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":"el","Type":"HTMLElement | undefined","Required":"否","Default":"无","Description":"全屏作用的 DOM 节点。\n","children":[],"key":"el"}]
      return (
);
```
  

**返回值**

  Promise

### requestCssFullscreen()  

调用此方法进入网页样式全屏状态，播放器进入网页全屏，利用 CSS 模拟实现全屏效果。如果该接口调用的时候处于全屏状态，会自动退出全屏，下发事件 `Events.CSS_FULLSCREEN_CHANGE`。

**类型**

  ```ts
  (el?: HTMLElement) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: undefined,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    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":"el","Type":"HTMLElement | undefined","Required":"否","Default":"无","Description":"全屏作用的 DOM 节点。\n","children":[],"key":"el"}]
      return (
);
```
  

### exitCssFullscreen()  

调用此方法退出网页样式全屏状态。 调用该方法 `veplayer.isFullscreen` 将会变为 `false`，并触发 `Events.CSS_FULLSCREEN_CHANGE` 事件。

**类型**

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

### registerPlugin()  

调用此方法在当前播放器上注册指定插件。

**类型**

  ```ts
  (plugin: Function | { plugin: Function; options: object;}, config?: { [propName: string]: any; } | undefined) => any
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: undefined,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    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":"plugin","Type":"-","Required":"是","Default":"-","Description":"插件构造函数。
\n","children":[{"Name":"plugin","Type":"Function","Required":"是","Default":"无","Description":"插件构造函数。
\n","children":[],"key":"plugin-plugin"},{"Name":"options","Type":"object","Required":"是","Default":"无","Description":"插件配置参数。
\n","children":[],"key":"plugin-options"}],"key":"plugin"},{"Name":"config","Type":"{ [propName: string]: any; } | undefined","Required":"否","Default":"无","Description":"插件的配置列表。\n","children":[],"key":"config"}]
      return (
);
```
  

**返回值**

  any

### unRegisterPlugin()  

调用此方法在当前播放器上销毁/注销指定插件。

**类型**

  ```ts
  (plugin: any) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: undefined,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    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":"plugin","Type":"any","Required":"是","Default":"无","Description":"插件实例或者插件名称。\n","children":[],"key":"plugin"}]
      return (
);
```
  

### showIcon()  

调用此接口显示指定插件图标。

**类型**

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

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: undefined,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    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":"pluginNames","Type":"string[]","Required":"是","Default":"无","Description":"插件名称。\n","children":[],"key":"pluginNames"}]
      return (
);
```
  

### hideIcon()  

调用此接口隐藏指定插件图标。

**类型**

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

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: undefined,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    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":"pluginNames","Type":"string[]","Required":"是","Default":"无","Description":"插件名称。\n","children":[],"key":"pluginNames"}]
      return (
);
```
  

### destroy()  

调用此方法销毁播放器实例。

**类型**

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


## createLivePlayer() 

创建直播播放器。

**类型**

  ```ts
  (options?: LiveVePlayerOptions) => Promise
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: undefined,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    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":"LiveVePlayerOptions | undefined","Required":"否","Default":"无","Description":"配置播放器参数。\n","children":[],"key":"options"}]
      return (
);
```
  

**返回值**

  Promise<[VePlayerLive](#veplayerlive)\>  播放器实例。

**示例**

  ```js
  VePlayer.createLivePlayer({
   height: 360,
   url: options.url,
  }).then(function (veplayer) {
   veplayer.on(VePlayer.live.Events.CANPLAY, function () {
     console.log('监听到 canplay 事件')
   });
  }).catch(error => {
   console.log('创建播放器失败，报错信息:', error);
  });;
  ```


## isRTMSupported() 

当前浏览器是否支持 RTM 流播放。

**类型**

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

**返回值**

  Promise


## isRTMSupportCodec() 

当前浏览器是否支持 H264 RTM 流播放。

**类型**

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

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: undefined,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    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":"codec","Type":"string","Required":"是","Default":"'h264'\n\n","Description":"播放格式，目前只支持 H264。\n","children":[],"key":"codec"}]
      return (
);
```
  

**返回值**

  Promise


## isMseSupported() 

检查当前浏览器是否支持 MSE（MediaSource Extends）API，并检查 MSE API 是否支持传入的视频编码信息（MIME 格式）。
:::tip
使用场景：检查 PC 端浏览器和 Android 端浏览器是否支持传入的编码信息。
:::

**类型**

  ```ts
  (codec?: string | undefined) => boolean
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: undefined,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    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":"codec","Type":"string | undefined","Required":"否","Default":"'h264'\n\n","Description":"待检查的媒体类型和编解码信息字符串，使用 MIME 格式表示，例如video/mp4;codecs=\"av01.0.01M.08\"。\n您也可以使用如下参数值快速检查是否支持 H.264 和 H.265 视频编码格式。
\nCodec.H264（默认值）：检查 MSE 是否支持 H.264 编码格式，如果支持可满足大部分 H.264 视频播放。
\nCodec.H265：检查 MSE 是否支持 H.265 编码格式，如果支持可满足大部分 H.265 视频播放。\n\n","children":[],"key":"codec"}]
      return (
);
```
  

**返回值**

  boolean


## isSoftDecodeSupported() 

当前浏览器是否支持软解。

**类型**

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

**返回值**

  Promise


## isMMSSupported() 

判断当前浏览器是否支持 MMS（ManagedMediaSource） API，并检查 MMS API 是否支持传入的视频编码信息（MIME 格式）。
:::tip
- 使用场景：检查 iOS 端 Safari 浏览器和 Chrome 浏览器是否支持传入的编码信息。
- Safari 17.1 以上版本浏览器开始支持 MMS。
:::

**类型**

  ```ts
  (codec?: string | undefined) => any
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: undefined,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    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":"codec","Type":"string | undefined","Required":"否","Default":"'h264'\n\n","Description":"待检查的媒体类型和编解码信息字符串，使用 MIME 格式表示，例如video/mp4;codecs=\"av01.0.01M.08\"。\n您也可以使用如下参数值快速检查是否支持 H.264 和 H.265 视频编码格式。
\nCodec.H264（默认值）：检查 MMS 是否支持 H.264 编码格式，如果支持可满足大部分 H.264 视频播放。
\nCodec.H265：检查 MMS 是否支持 H.265 编码格式。如果支持可满足大部分 H.265 视频播放。\n\n","children":[],"key":"codec"}]
      return (
);
```
  

**返回值**

  any


## isFLVSupported() 

检查当前浏览器是否支持 FLV 格式流的编码信息。
:::tip
- 在 PC 端或 Android 端浏览器调用此方法，实现方法与 isMseSupported 方法实现相同。
- 在 iOS 端浏览器调用此方法，实现与 isMMSSupported 方法实现相同。
:::

**类型**

  ```ts
  (codec?: string | undefined) => boolean
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 260,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: undefined,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    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":"codec","Type":"string | undefined","Required":"否","Default":"'h264'\n\n","Description":"待检查的媒体类型和编解码信息字符串，使用 MIME 格式表示，例如video/mp4;codecs=\"av01.0.01M.08\"。\n您也可以使用如下参数值快速检查是否支持 H.264 和 H.265 视频编码格式。
\nCodec.H264（默认值）：检查是否支持 H.264 编码格式，如果支持可满足大部分 H.264 视频播放。
\nCodec.H265：检查是否支持 H.265 编码格式。如果支持可满足大部分 H.265 视频播放。\n\n","children":[],"key":"codec"}]
      return (
);
```
  

**返回值**

  boolean
视频直播
