## VePlayer 类型：`class` ### 属性 | 属性 | 类型 | 说明 | | :-- | :-- | :-- | | player | PlayerCore | 播放器内核实例，详情参考[播放器内核](https://www.volcengine.com/docs/4/1249083)。 | | src | string | 返回当前视频的地址。 | | musicMode | [PlayModeType](1248901#playmodetype) | 获取音乐播放模式 | | musicTimeScale | number | 获取音乐播放快进快退时间跨度 | | musicList | [IMusicListItem](1248901#imusiclistitem)[] | 获取音乐播放列表 | | region | [TRegionType](1248901#tregiontype) | `只读` 获取当前配置的 region | | `static` sdkVersion| string | SDK 版本 | ### new VePlayer() 构造函数。 **类型** ```ts constructor(configs: IPlayerConfig) ``` **参数** ```mixin-react const columns = [{ title: '名称', dataIndex: 'Name', width: 240, },{ title: '类型', dataIndex: 'Type', width: 240, render: (col, item, index) => { if(col.includes('')){ const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi; const new1 = regex.exec(col); return {new1?.[1]}{new1?.[4]}{new1?.[5]} } return col; } },{ title: '是否必选', dataIndex: 'Required', width: 120, },{ title: '默认值', dataIndex: 'Default', width: 120, render: (col, item, index) => { if(col.includes('')){ const regex = /(.*)
(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"configs","Type":"IPlayerConfig","Required":"是","Default":"无","Description":"播放器实例化配置。\n","children":[],"key":"configs"}]
      return ();
```
  

### on()  

监听事件。

**类型**

  ```ts
  (action: string, func: (...args: any[]) => void) => void
  ```

**参数**


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

### emit()  

触发事件。

**类型**

  ```ts
  (action: string, payload?: any) => void
  ```

**参数**


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

### once()  

监听事件。事件处理函数只执行一次。

**类型**

  ```ts
  (action: string, func: (...args: any[]) => void) => void
  ```

**参数**


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

### off()  

解绑事件监听。

**类型**

  ```ts
  (action: string, func: (...args: any[]) => void) => void
  ```

**参数**


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

### updateMediaSource()  

更新播放源。您可在视频播放地址过期前调用此方法更新地址及过期时间戳。

**类型**

  ```ts
  (source: SourceConfig) => Promise
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"source","Type":"Pick","Required":"是","Default":"无","Description":"播放源配置。详见 SourceConfig。支持传入视频播放地址 url、播放列表 playList 或者 vid 和 playAuthToken，还需包含新地址的过期时间戳 urlExpireTimestamp。\n","children":[],"key":"source"}]
      return (
);
```
  

**返回值**

  Promise

### switchAuthToken()  

播放时更换临时播放 Token，以更换视频源。

**注意**

  此接口不支持切换火山引擎私有加密 Token。

**类型**

  ```ts
  (config: IPlayAuthTokenConfig, isNewVideo?: boolean) => Promise
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"config","Type":"IPlayAuthTokenConfig","Required":"是","Default":"无","Description":"临时播放 Token 配置。
\n","children":[],"key":"config"},{"Name":"isNewVideo","Type":"boolean","Required":"是","Default":"true\n\n","Description":"是否为新视频。为 false 时，更换后，会从更换前的时间点继续播放。\n","children":[],"key":"isNewVideo"}]
      return (
);
```
  

**返回值**

  Promise

### updateAuthToken()  

更新临时播放 Token。

**注意**

  - 播放前临时播放 Token 过期（收到 `play_auth_token_expired` 事件或者 `onTokenExpired` 回调触发）时，调用此方法更新临时播放 Token。
  - 此接口不支持切换火山引擎私有加密 Token。

**类型**

  ```ts
  (config: IPlayAuthTokenConfig) => Promise
  ```

**参数**


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

**返回值**

  Promise

### switchURL()  

播放时更换视频 URL，以更换视频源。

**注意**

  更换后，会从更换前的时间点继续播放。

**类型**

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

**参数**


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

**返回值**

  Promise

### playNext()  

播放下一视频。

**注意**

  - 成功更换视频源后，默认是暂停状态。如果设置了自动播放，则会自动播放。
  - 此接口不支持切换火山引擎私有加密视频。

**类型**

  ```ts
  (config: IPlayerConfig, isNewVideo?: boolean) => Promise
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"config","Type":"IPlayerConfig","Required":"是","Default":"无","Description":"播放器实例化配置。此接口仅支持 IPlayerConfig 中的 url、playList、poster、getVideoByToken 字段。。
\n","children":[],"key":"config"},{"Name":"isNewVideo","Type":"boolean","Required":"是","Default":"true\n\n","Description":"是否为新视频。为 false 时，更换后，会从更换前的时间点继续播放。\n","children":[],"key":"isNewVideo"}]
      return (
);
```
  

**返回值**

  Promise

### changeDefinition()  

切换清晰度

**注意**

  如果传的清晰度不存在，则不处理。可以通过api: getDefinitionList()获取当前的清晰度列表

**类型**

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

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"definition","Type":"string","Required":"是","Default":"无","Description":"清晰度，如果在vid播放中有映射的清晰度，则对应映射之后的清晰度\n","children":[],"key":"definition"}]
      return (
);
```
  

### getDefinitionList()  

获取当前的清晰度列表，列表项中包含definition、url和selected，selected为true时表示当前被选中的清晰度

**类型**

  ```ts
  () => { [propName: string]: any; definition: string; url: IUrl; selected: boolean; }[]
  ```

**返回值**

  Array<{ definition: string; url: IUrl; selected: boolean; [propName: string]: any; }\>

### musicAdd()  

向播放列表中加入歌曲。

**注意**

  仅音乐播放模式开启时（`isMusic` 为 `true` 时）有效。

**类型**

  ```ts
  (meta: IMusicListItem) => void
  ```

**参数**


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

### musicRandom()  

随机获取播放列表中的一首歌曲。

**注意**

  仅音乐播放模式开启时（`isMusic` 为 `true` 时）有效。

**类型**

  ```ts
  () => IMusicListItem
  ```

**返回值**

  [IMusicListItem](1248901#imusiclistitem)  歌曲信息

### musicNext()  

播放播放列表中的下一首歌曲。

**注意**

  仅音乐播放模式开启时（`isMusic` 为 `true` 时）有效。

**类型**

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

### musicPrev()  

播放播放列表中的上一首歌曲。

**注意**

  仅音乐播放模式开启时（`isMusic` 为 `true` 时）有效。

**类型**

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

### musicSetIndex()  

播放播放列表中的指定歌曲。

**注意**

  仅音乐播放模式开启时（`isMusic` 为 `true` 时）有效。

**类型**

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

**参数**


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

### musicForward()  

歌曲快进。

**注意**

  仅音乐播放模式开启时（`isMusic` 为 `true` 时）有效。

**类型**

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

### musicBackward()  

歌曲后退。

**注意**

  仅音乐播放模式开启时（`isMusic` 为 `true` 时）有效。

**类型**

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

### musicRemove()  

移除播放列表中的指定歌曲。

**注意**

  仅音乐播放模式开启时（`isMusic` 为 `true` 时）有效。

**类型**

  ```ts
  (vid: string | number) => void
  ```

**参数**


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

### musicSetAbCycle()  

设置 AB 循环，即设置播放区域任意位置循环播放。

**注意**

  仅音乐播放模式开启时（`isMusic` 为 `true` 时）有效。

**类型**

  ```ts
  (start: number | IABCycle, end?: number, loop?: boolean, ext?: { [propName: string]: any; } | undefined) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"start","Type":"number | IABCycle","Required":"是","Default":"无","Description":"AB 循环段起始位置，单位为秒。
\n","children":[],"key":"start"},{"Name":"end","Type":"number | undefined","Required":"否","Default":"无","Description":"AB 循环段结束位置，单位为秒。
\n","children":[],"key":"end"},{"Name":"loop","Type":"boolean | undefined","Required":"否","Default":"无","Description":"是否循环播放。\n","children":[],"key":"loop"},{"Name":"ext","Type":"{ [propName: string]: any; } | undefined","Required":"否","Default":"无","Description":"-","children":[],"key":"ext"}]
      return (
);
```
  

### musicRemoveAbCycle()  

移除 AB 循环。

**类型**

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

### getLogUserId()  

获取质量日志上报的用户 ID。

**注意**

  获取用户 ID 后，您可进入视频点播控制台[单点追查](https://console.volcengine.com/vod/quality_control/SingleTracing/?Tab=play)页面，根据用户 ID 查询该用户的播放日志。

**类型**

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

**返回值**

  string

### getPlugin()  

获取插件实例。

**类型**

  ```ts
  (pluginName: string) => null | BasePlugin
  ```

**参数**


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

**返回值**

  null | BasePlugin

### destroy()  

销毁当前播放器实例。

**类型**

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

**返回值**

  Promise

### `static` prepare()  

播放策略预初始化配置

**类型**

  ```ts
  (options: StrategyInitOptions) => Promise
  ```

**参数**


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

**返回值**

  Promise

### `static` setPreloadScene()  

设置预加载模式

**类型**

  ```ts
  (preloadScene: PreloadScene, options?: IPreloadUpdateConfig) => void
  ```

**参数**


```mixin-react
      const columns = [{
            title: '名称',
            dataIndex: 'Name',
            width: 240,
            
            
            
        },{
            title: '类型',
            dataIndex: 'Type',
            width: 240,
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)]*?s+)?href=([\"'])(.*?)\2[^>]*>(.*?)<\/a>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[4]}{new1?.[5]}
                    }
                    return col;
                }
            
            
            
        },{
            title: '是否必选',
            dataIndex: 'Required',
            width: 120,
            
            
            
        },{
            title: '默认值',
            dataIndex: 'Default',
            width: 120,
            
            
                render: (col, item, index) => {
                    if(col.includes('')){
                        const regex = /(.*)(.*?)<\/code>(.*)/gi;
                        const new1 = regex.exec(col);
                        return {new1?.[1]}{new1?.[2]}{new1?.[3]}
                    }
                    return col;
                }
            
            
        },{
            title: '说明',
            dataIndex: 'Description',
            width: 500,
            
            
            
                render: (__html, item, index) => {
                  return ;
                }
            
        },
      ];
      const data = [{"Name":"preloadScene","Type":"PreloadScene","Required":"是","Default":"无","Description":"预加载模式，详情见
\n","children":[],"key":"preloadScene"},{"Name":"options","Type":"IPreloadUpdateConfig | undefined","Required":"否","Default":"无","Description":"预加载配置更新，详情见\n","children":[],"key":"options"}]
      return (
);
```
  

### `static` addPreloadList()  

添加待预加载视频列表

**类型**

  ```ts
  (list: IPreloadStream[]) => void
  ```

**参数**


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

### `static` setPreloadList()  

设置待预加载视频列表，替换当前已设置的待预加载列表

**类型**

  ```ts
  (list: IPreloadStream[]) => Promise
  ```

**参数**


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

**返回值**

  Promise