@shijiu/jsview-vue 2.1.6-alpha.0 → 2.1.25

package/utils/JsViewPlugin/JsvPlayer/JsvMedia.js

@@ -0,0 +1,1847 @@
+/* eslint-disable no-prototype-builtins */
+import {getPluginInfo} from './GetVersion'
+
+let EVENT_STATUS_NONE = 0;
+let EVENT_STATUS_LOADSTART = 1;
+let EVENT_STATUS_LOAD = 2;
+let EVENT_STATUS_SEEK = 3;
+let EVENT_STATUS_SEEKED = 4;
+let EVENT_STATUS_STALLED = 5;
+let EVENT_STATUS_RESUME = 6;
+let EVENT_STATUS_DISPLAY = 7;
+let EVENT_STATUS_TIMESHIFT = 8;
+let EVENT_STATUS_TIMESHIFTED = 9;
+let EVENT_STATUS_BACKLIVE = 10;
+let EVENT_STATUS_BACKLIVED = 11;
+let EVENT_STATUS_END = 12;
+
+
+let MediaPluginInfo = getPluginInfo();
+
+var mediaArray = [];
+
+var pluginLoadListener = [];
+var PluginEventKey = "JsvPlayer";
+var chipType = "";
+
+let LOG_LEVEL_FATAL = 5;
+let LOG_LEVEL_ERROR = 4;
+let LOG_LEVEL_WARNING = 3;
+let LOG_LEVEL_DEBUG = 2;
+let LOG_LEVEL_TRACE = 1;
+let LogLevel = LOG_LEVEL_TRACE;
+function logPrint(level, message){
+    if(level >= LogLevel){
+        console.log(message);
+    }
+}
+
+function logFatal(message){
+    logPrint(LOG_LEVEL_FATAL, message);
+}
+
+function logError(message){
+    logPrint(LOG_LEVEL_ERROR, message);
+}
+
+function logWarning(message){
+    logPrint(LOG_LEVEL_WARNING, message);
+}
+
+function logDebug(message){
+    logPrint(LOG_LEVEL_DEBUG, message);
+}
+
+function logTrace(message){
+    logPrint(LOG_LEVEL_TRACE, message);
+}
+
+function setLogLevel(level){
+    LogLevel = level;
+}
+
+var PLUGIN_EVENT_STATUS_START_LOAD      = 1;
+var PLUGIN_EVENT_STATUS_DOWNLOAD        = 2;
+var PLUGIN_EVENT_STATUS_UNZIPED         = 3;
+var PLUGIN_EVENT_STATUS_DEXLOADED       = 4;
+var PLUGIN_EVENT_STATUS_COMPLETE        = 5;
+
+/** 
+ * 0：未加载；
+ * 1：开始加载；
+ * 2：加载旧插件；
+ * 3：加载新插件；
+ * 4：加载成功；
+ * 5：加载失败。
+*/
+var pluginLoadState = 0;
+
+function JsvPlayerPluginStatus(status){
+    logDebug("JsvPlayerPluginStatus: "+status);
+    let ret = JSON.parse(status);
+    
+    let notify_obj = {};
+    notify_obj.status = 1;
+    if(ret && ret.first_load){
+        pluginLoadState = 3;
+        notify_obj.code = 1;
+    }else{
+        pluginLoadState = 2;
+        notify_obj.code = 2;
+    }
+
+    for(let i=0; i<pluginLoadListener.length; i++){
+        pluginLoadListener[i](notify_obj);
+    }
+}
+
+window.top.JsvPlayerPluginStatus = function(status){
+    JsvPlayerPluginStatus(status);
+}
+
+function JsvPlayerPluginLoadResult(result){
+    logDebug("JsvPlayerPluginLoadResult: "+result);
+    var ret_obj = JSON.parse(result)
+    let notify_obj = {};
+    if(ret_obj && (ret_obj.status === 5 || ret_obj.status === 1)){
+        pluginLoadState = 4;
+        notify_obj.status = 3;
+        notify_obj.code = 0;
+    }else if(ret_obj && ret_obj.status === -12){
+        pluginLoadState = 5;
+        notify_obj.status = 4;
+        notify_obj.code = ret_obj.status;
+    }else{
+        pluginLoadState = 5;
+        notify_obj.status = 4;
+        if(ret_obj){
+            notify_obj.code = ret_obj.status;
+        }else{
+            notify_obj.code = -1;
+        }
+    }
+
+    if(pluginLoadState === 5){
+        logFatal("*************************JsvPlayer plugin load failed, error code is "+ret_obj.status+"*************************");
+    }
+
+    UnregisterJsvPlayerPluginEvent();
+    
+    if(pluginLoadState === 4){
+        let capabilitySet = getJsvPlayerCapabilitySet();
+        if(capabilitySet !== null && capabilitySet !== ""){
+            let capabilitySetObj = JSON.parse(capabilitySet);
+            if(capabilitySetObj !== null && capabilitySetObj.hasOwnProperty("chipType")){
+                chipType = capabilitySetObj.chipType;
+            }
+        }
+    }
+
+    for(let i=0; i<mediaArray.length; i++){
+        mediaArray[i].buildPlatformInstance();
+    }
+
+    for(let i=0; i<pluginLoadListener.length; i++){
+        pluginLoadListener[i](notify_obj);
+    }
+}
+
+window.top.JsvPlayerPluginLoadResult = function (result) {
+    JsvPlayerPluginLoadResult(result);
+}
+
+window.top.CreatePlayerResult = function (result) {
+    logDebug("CreatePlayerResult: "+result);
+    let result_obj = JSON.parse(result);
+    if(result_obj.code == 0){
+        for(var i=0; i<mediaArray.length; i++){
+            if(mediaArray[i].key === result_obj.key){
+                mediaArray[i].initPlayer();
+               break;
+            }
+        }
+    }else{
+        logError("Create player failed, key="+result_obj.key);
+    }
+}.bind(this);
+
+function JsvPlayerPluginEvent(data){
+    console.log("LoadPlugin2 result: "+data);
+    let obj = JSON.parse(data);
+    let event_obj = JSON.parse(obj.param);
+    if(event_obj.hasOwnProperty("status")){
+        let status = event_obj.status;
+        let notify_obj = {};
+        switch(status){
+            case PLUGIN_EVENT_STATUS_START_LOAD:
+                {
+                    let code = 1;
+                    if(event_obj.hasOwnProperty("code")){
+                        code = event_obj.code;
+                    }
+                    notify_obj.status = 1;
+                    notify_obj.code = code;
+                    if(code === 1){
+                        pluginLoadState = 3;
+                    }else{
+                        pluginLoadState = 2;
+                    }
+                }
+                break;
+            case PLUGIN_EVENT_STATUS_DOWNLOAD:
+                notify_obj.status = 2;
+                notify_obj.code = 1;
+                notify_obj.progress = 100;
+                break;
+            case PLUGIN_EVENT_STATUS_UNZIPED:
+                notify_obj.status = 2;
+                notify_obj.code = 2;
+                break;
+            case PLUGIN_EVENT_STATUS_DEXLOADED:
+                notify_obj.status = 2;
+                notify_obj.code = 3;
+                break;
+            case PLUGIN_EVENT_STATUS_COMPLETE:
+                {
+                    let code = 0;
+                    if(event_obj.hasOwnProperty("code")){
+                        code = event_obj.code;
+                    }
+                    if(code === 0){
+                        notify_obj.status = 3;
+                        notify_obj.code = 0;
+                        pluginLoadState = 4;
+                    }else{
+                        notify_obj.status = 4;
+                        notify_obj.code = code;
+                        pluginLoadState = 5;
+                    }
+                    UnregisterJsvPlayerPluginEvent();
+                }
+                break;
+            default:
+                logWarning("Load plugin status, invalid status: "+status)
+                return;
+        } 
+        for(let i=0; i<pluginLoadListener.length; i++){
+            pluginLoadListener[i](notify_obj);
+        }
+        if(pluginLoadState === 4){
+            let capabilitySet = getJsvPlayerCapabilitySet();
+            if(capabilitySet !== null && capabilitySet !== ""){
+                let capabilitySetObj = JSON.parse(capabilitySet);
+                if(capabilitySetObj !== null && capabilitySetObj.hasOwnProperty("chipType")){
+                    chipType = capabilitySetObj.chipType;
+                }
+            }
+            for(let i=0; i<mediaArray.length; i++){
+                mediaArray[i].buildPlatformInstance();
+            }
+        }
+    }else{
+        let type = event_obj.type;
+        let param = event_obj.param;
+        if(type === 1){
+            JsvPlayerPluginStatus(param)
+        }else if(type === 2){
+            JsvPlayerPluginLoadResult(param);
+        }else{
+            logError("Invalid type: "+type);
+        }
+    }
+}
+
+function RegisterJsvPlayerPluginEvent(){
+    window.JMD.subscribe(PluginEventKey, JsvPlayerPluginEvent);
+}
+
+function UnregisterJsvPlayerPluginEvent(){
+    window.JMD.unsubscribe(PluginEventKey, JsvPlayerPluginEvent);
+}
+
+/**
+ * listener回调处理中参数信息的说明:
+ * 插件加载状态回调。
+ * 回调函数的参数定义如下：
+ * object结构，包含status和code两个变量：
+ * 1）开始加载插件：
+ *    obj.status=1；
+ *    obj.code表示是否是首次加载：1：首次加载，此时插件需要经历下载、解压等过程，用时较长，可以考虑给用户相关提示；
+ *                             2：非首次加载，此时插件加载过程很短，可以不用出现用户提示界面。
+ * 2）插件加载中，加载新插件时上报此状态完整状态，加载旧插件时，只上报dexload完成状态（code=3）：
+ *    obj.status=2；
+ *    obj.code表示加载过程中的状态：1：插件下载进度，目前只上报下载结束；2：插件解压完成；3：插件dexload完成。
+ *    obj.progress：当code=1时（下载进度），progress为实际下载进度，百分制，目前只有100（100%，完成状态）。
+ * 3）插件加载成功
+ *    obj.status=3;
+ *    obj.code无效。
+ * 4）插件加载失败
+ *    obj.status=4;
+ *    obj.code表示插件加载失败原因：1：插件管理模块不存在（未真正开始加载插件），下面的负值为插件管理模块返回的错误；
+ *                              -1：请求插件加载的参数不正确，需要确认构造的PluginInfo内容；
+ *                              -2：未找到插件更新链接；
+ *                              -3：插件HTTP请求失败；
+ *                              -4：插件下载失败；
+ *                              -5：插件MD5校验失败；
+ *                              -6：解压失败；
+ *                              -7：文件大小为0；
+ *                              -8：未找到dex文件；
+ *                              -9：dex文件load失败；
+ *                              -10：插件初始化失败；
+ *                              -11：取消插件下载；
+ *                              -12：版本检查失败，比如已经加载了其他版本，此版本不能再加载。
+ * 
+ * 备注：不管插件加载处于什么状态，都可以正常使用播放器组件，播放器对象在插件未加载完成的情况下，会把相关状态保存，等完成加载后再自动下发。
+ */
+function globalLoadJsvPlayerPlugin(listener){
+    logDebug("globalLoadJsvPlayerPlugin");
+    let notify_obj = {};
+    if(typeof window.jPluginManagerBridge==='undefined' || !window.jPluginManagerBridge){
+        notify_obj.status = 4;
+        notify_obj.code = 1;
+    }else if(pluginLoadState === 2){
+        notify_obj.status = 1;
+        notify_obj.code = 2;
+    }else if(pluginLoadState === 3){
+        notify_obj.status = 1;
+        notify_obj.code = 1;
+    }else if(pluginLoadState === 4){
+        notify_obj.status = 3;
+        notify_obj.code = 0;
+    }
+
+    if(notify_obj.hasOwnProperty("status")){
+        if(typeof listener !== "undefined" && listener){
+            setTimeout(()=>{listener(notify_obj)}, 0);
+        }
+    }
+
+    if(pluginLoadState === 4 || typeof window.jPluginManagerBridge==='undefined' || !window.jPluginManagerBridge){
+        return;
+    }else if(pluginLoadState === 5){
+        pluginLoadState = 0;
+    }
+
+    if(typeof listener !== "undefined" && listener){
+        pluginLoadListener.push(listener);
+    }
+
+    if(pluginLoadState > 0){
+        return;
+    }
+    pluginLoadState = 1;
+
+    RegisterJsvPlayerPluginEvent();
+
+    if(typeof window.jPluginManagerBridge.LoadPlugin2 !== "undefined"){
+        window.jPluginManagerBridge.LoadPlugin2(PluginEventKey, JSON.stringify(MediaPluginInfo));
+    }else{
+        window.jPluginManagerBridge.LoadPlugin(JSON.stringify(MediaPluginInfo));
+    }
+}
+
+var preLoadingJsvPlayerPlugin = 0;
+var prePluginLoadListener = [];
+var PreLoadPluginEventKey = "PreJsvPlayer";
+
+function JsvPlayerPrePluginEvent(data){
+    console.log("PreLoadPlugin result: "+data);
+    let obj = JSON.parse(data);
+    let event_obj = JSON.parse(obj.param);
+    if(event_obj.hasOwnProperty("status")){
+        let status = event_obj.status;
+        let notify_obj = {};
+        switch(status){
+            case PLUGIN_EVENT_STATUS_START_LOAD:
+                {
+                    notify_obj.status = 1;
+                    notify_obj.code = 0
+                }
+                break;
+            case PLUGIN_EVENT_STATUS_DOWNLOAD:
+                notify_obj.status = 2;
+                notify_obj.code = 1;
+                notify_obj.progress = 100;
+                break;
+            case PLUGIN_EVENT_STATUS_UNZIPED:
+                notify_obj.status = 2;
+                notify_obj.code = 2;
+                break;
+            case PLUGIN_EVENT_STATUS_COMPLETE:
+                {
+                    let code = 0;
+                    if(event_obj.hasOwnProperty("code")){
+                        code = event_obj.code;
+                    }
+                    if(code === 0){
+                        notify_obj.status = 3;
+                        notify_obj.code = 0;
+                    }else{
+                        notify_obj.status = 4;
+                        notify_obj.code = code;
+                    }
+                    UnregisterPreLoadJsvPlayerPluginEvent();
+                }
+                break;
+            default:
+                logWarning("Load plugin status, invalid status: "+status)
+                return;
+        } 
+        for(let i=0; i<prePluginLoadListener.length; i++){
+            prePluginLoadListener[i](notify_obj);
+        }
+    }
+}
+
+function RegisterPreLoadJsvPlayerPluginEvent(){
+    window.JMD.subscribe(PreLoadPluginEventKey, JsvPlayerPrePluginEvent);
+}
+
+function UnregisterPreLoadJsvPlayerPluginEvent(){
+    window.JMD.unsubscribe(PreLoadPluginEventKey, JsvPlayerPrePluginEvent);
+}
+
+/**
+ * listener回调处理中参数信息的说明:
+ * 插件加载状态回调。
+ * 回调函数的参数定义如下：
+ * object结构，包含status和code两个变量：
+ * 1）开始预加载插件：
+ *    obj.status=1；
+ *    obj.code=0，未使用。
+ * 2）插件预下载中：
+ *    obj.status=2；
+ *    obj.code表示加载过程中的状态：1：插件下载进度，目前只上报下载结束；2：插件解压完成。
+ *    obj.progress：当code=1时（下载进度），progress为实际下载进度，百分制，目前只有100（100%，完成状态）。
+ * 3）插件预下载成功
+ *    obj.status=3;
+ *    obj.code表示是否新下载插件：1：新预下载插件。
+ *                             2：插件已下载成功，本次完成解压动作。
+ *                             3：插件已存在。
+ * 4）插件预加载失败
+ *    obj.status=4;
+ *    obj.code表示插件加载失败原因：1：插件管理模块不存在（未真正开始预加载插件），下面的负值为插件管理模块返回的错误；
+ *                              2：已经预加载了一个插件，不允许预加载第二次，即使版本不相同；
+ *                              3：本地已经存在了此版本的插件；
+ *                              -1：请求插件加载的参数不正确；
+ *                              -2：未找到插件更新链接；
+ *                              -3：插件HTTP请求失败；
+ *                              -4：插件下载失败；
+ *                              -5：插件MD5校验失败；
+ *                              -6：解压失败；
+ *                              -7：文件大小为0；
+ *                              -8：未找到dex文件；
+ * 
+ * @param {Number} versionCode 插件版本号
+ * @param {String} url 插件下载链接，为空时自动构造下载链接
+ * @param {String} md5 插件文件的md5值
+ * @param {listener} 状态监听函数
+ * @returns 
+ */
+function globalPreLoadJsvPlayerPlugin(versionCode, url, md5, listener){
+    logDebug("globaPrelLoadJsvPlayerPlugin");
+    let notify_obj = {};
+    if(preLoadingJsvPlayerPlugin !== 0){
+        /**已经预加载了同一个插件，不允许第二次预加载 */
+        notify_obj.status = 4;
+        notify_obj.code = 2;
+    }else if(typeof versionCode !== "number" || versionCode <= 0){
+        notify_obj.status = 4;
+        notify_obj.code = -1;
+    }else if(typeof window.jPluginManagerBridge==='undefined' || !window.jPluginManagerBridge || typeof window.jPluginManagerBridge.PreLoadPlugin !== "function"){
+        notify_obj.status = 4;
+        notify_obj.code = 1;
+    }
+
+    if(notify_obj.hasOwnProperty("status")){
+        if(typeof listener !== "undefined" && listener){
+            setTimeout(()=>{listener(notify_obj)}, 0);
+        }
+        return;
+    }
+
+    let plugin_info = {};
+    plugin_info.name = "播放器插件";
+    plugin_info.packageName = MediaPluginInfo.packageName;
+    plugin_info.versionCode = versionCode;
+    if(typeof url === "string" && url !== ""){
+        plugin_info.downloadUrl = url;
+    }
+
+    if(typeof md5 === "string" && md5 !== ""){
+        plugin_info.md5 = md5;
+    }
+
+    let ret = window.jPluginManagerBridge.PreLoadPlugin(PreLoadPluginEventKey, JSON.stringify(plugin_info));
+    if(ret === -1){
+        /**参数错误，无法加载插件 */
+        notify_obj.status = 4;
+        notify_obj.code = -1;
+    }else if(ret === -2){
+        /**加载了一个不同版本的插件，无法加载此插件 */
+        notify_obj.status = 4;
+        notify_obj.code = 2;
+    }else if(ret === 1){
+        /**加载了一个相同版本的插件，不再通知到此处 */
+        notify_obj.status = 4;
+        notify_obj.code = 2;
+    }else if(ret === 2){
+        /**已经存在了此版本的插件 */
+        notify_obj.status = 4;
+        notify_obj.code = 3;
+    }
+
+    if(notify_obj.hasOwnProperty("status")){
+        if(typeof listener !== "undefined" && listener){
+            setTimeout(()=>{listener(notify_obj)}, 0);
+        }
+    }else{
+        if(typeof listener !== "undefined" && listener){
+            prePluginLoadListener.push(listener);
+        }    
+        preLoadingJsvPlayerPlugin = 1;
+        RegisterPreLoadJsvPlayerPluginEvent();
+    }
+}
+
+/**
+ * 根据key查询是否已经有Media对象了，如果已经有了，就不需要再创建，而是调用setRef接口将当前的对象索引+1。
+ * @param {string} key Player索引。 
+ * @returns {object} Media对象。
+ */
+function findMediaObjectByKey(key){
+    for(var i=0; i<mediaArray.length; i++){
+        if(mediaArray[i].key === key){
+            return mediaArray[i];
+        }
+    }
+
+    return null;
+}
+
+class JsvBaseMedia {
+    constructor(type, window_mode, hole_id, player_type, key, background, design_map_width, decode_type) {
+        logTrace("Create JsvBaseMedia, type="+type+", hole_id="+hole_id+", player_type="+player_type+", key="+key+", background="+background+", design_map_width="+design_map_width+", decode_type="+decode_type);
+        
+        this.state = {
+			muted: false,
+			paused: true,
+			repeat: false,
+            enablePlayer: false,
+            autoplay: false,
+			startTime: 0.0,
+            currentTime: 0.0,
+			aspectRatio: "origin",
+            keepLastFrame: true,
+            timeUpdateLess: false,
+            rate: 1.0,
+            volume: 1.0,
+            chromaKey: null,
+            audioTrack: -1,
+        };
+        
+		this.local = {
+			currentTime: 0.0,
+			playableDuration: 0.0,
+			duration: 0.0,
+			isRenderable: false,
+            paused: true,
+        };
+        
+        this.type = type;
+        this.playerCreate = false;
+        this.key = key;
+        this.windowMode = window_mode;
+        this.background = background;
+        this.holeId = hole_id;
+        this.holeIdModify = hole_id;
+        this.playerType = player_type;
+        this.designMapWidth = design_map_width;
+        this.decodeType = decode_type;
+        this.channelID = -1;
+        this.ref = 1;
+        this.appVisible = window.JsView&&window.JsView.getVisibility?(window.JsView.getVisibility()==="show"):true;
+        this.eventReport = true;
+        this.currentEventStatus = EVENT_STATUS_NONE;
+        this.frameRateLimit = false;
+        this._onEvent = this.onEvent.bind(this);
+        this._onVisibilityChangeCallBack = this.onVisibilityChangeCallBack.bind(this);
+
+        let found = false;
+        for(let i=0; i<mediaArray.length; i++){
+            if(mediaArray[i].key === this.key){
+                found = true;
+                break;
+            }
+        }
+
+        if(!found){
+            mediaArray.push(this)
+        }
+
+        if(typeof window.jsvPlayerBridge=='undefined' || !window.jsvPlayerBridge){
+            globalLoadJsvPlayerPlugin();
+        }else{
+            this.buildPlatformInstance();
+        }
+    }
+
+    /**
+     * 私有接口，外部不需要调用此接口。
+     */
+    buildPlatformInstance() {
+        logTrace("buildPlatformInstance, key="+this.key);
+
+        if(typeof window.jsvPlayerBridge=='undefined' || !window.jsvPlayerBridge){
+            logError("no jsvPlayerBridge");
+            return;
+        }
+
+        let share_view = true;
+
+        window.jsvPlayerBridge.CreatePlayer2(this.key, this.windowMode, this.holeId, this.background, this.designMapWidth, share_view, this.playerType, this.decodeType).then(
+            result=>{
+                logDebug("CreatePlayerResult: "+result);
+                let result_obj = JSON.parse(result);
+                if(result_obj.code == 0){
+                    //当播放器释放后，不需要进一步进行初始化，所以这里做了查找过程，没有直接调用initPlayer接口。
+                    for(var i=0; i<mediaArray.length; i++){
+                        if(mediaArray[i].key === result_obj.key){
+                            mediaArray[i].initPlayer();
+                           break;
+                        }
+                    }
+                }else{
+                    logError("Create player failed, key="+result_obj.key);
+                }
+            }, data=>{
+                logError("Create player failed, reject("+data+")");
+            }
+        );
+    }
+
+    /**
+     * 私有接口，外部不需要调用此接口。
+     */
+    initPlayer(){
+        if(this.playerCreate)
+            return;
+
+        logDebug("InitPlayer:1, key="+this.key);
+        
+        this.playerCreate = true;
+
+        window.JMD.subscribe(this.key, this._onEvent);
+        if (window.JsView && window.JsView.onVisibilityChange) {
+            logDebug("playerKey: "+this.key+", onVisibilityChange register");
+            window.JsView.onVisibilityChange(this._onVisibilityChangeCallBack);
+        }
+
+        if(this.holeIdModify !== this.holeId){
+            window.jsvPlayerBridge.setHoleID(this.key, this.holeIdModify);
+            this.holeId = this.holeIdModify;
+        }
+
+        this.appVisible = window.JsView&&window.JsView.getVisibility?(window.JsView.getVisibility()==="show"):true;
+
+        if(this.appVisible){
+            this.initParams();
+        }
+    }
+
+    initParams(){
+        logDebug("InitPlayer:2, key="+this.key);
+
+        if(this.channelID >= 0){
+            this.joinChannelPrivate(this.channelID);
+        }else if(this.state["src"]){
+            this.setState("src", this.state["src"], "string");
+            if(this.state["currentTime"]){
+                this.setState("currentTime", this.state["currentTime"], "number");
+            }else if(this.state["startTime"]){
+                this.setState("startTime", this.state["startTime"], "number");
+            }
+        }
+
+        if(this.state["paused"] == false){
+            this.setState("paused", this.state["paused"], "boolean");
+        }
+
+        if(this.state["autoplay"]){
+            this.setState("autoplay", this.state["autoplay"], "boolean");
+        }
+
+        if(this.state["repeat"]){
+            this.setState("repeat", this.state["repeat"], "boolean");
+        }
+
+        if(this.state["muted"]){
+            this.setState("muted", this.state["muted"], "boolean");
+        }
+
+        if(this.state["timeUpdateLess"]){
+            this.setState("timeUpdateLess", this.state["timeUpdateLess"], "boolean");
+        }
+
+        if(this.state["keepLastFrame"] == false){
+            this.setState("keepLastFrame", this.state["keepLastFrame"], "boolean");
+        }
+
+        if(this.state["aspectRatio"] !== "origin"){
+            this.setState("aspectRatio", this.state["aspectRatio"], "string");
+        }
+
+        if(this.state["chromaKey"]){
+            this.setState("chromaKey", this.state["chromaKey"], "string");
+        }
+
+        if(this.state["audioTrack"] !== -1){
+            this.setState("audioTrack", this.state["audioTrack"], "number");
+        }
+    }
+
+    onVisibilityChangeCallBack(){
+        let visible = window.JsView&&window.JsView.getVisibility?(window.JsView.getVisibility()==="show"):true;
+
+        this.setVisibility(visible);
+    }
+
+    /**
+     * 设置可见状态，在可见状态发生变化时，释放或者启动流。
+     * @param {boolean} visible true：可见，false，不可见。
+     */
+    setVisibility(visible){
+        logDebug("playerKey:"+this.key+", 小程序可见状态: "+visible);
+    
+        if(typeof visible !== "boolean"){
+            logError("playerKey:"+this.key+", setVisibility, param type is invalid");
+            return;
+        }
+
+        if(visible === this.appVisible){
+            logDebug("playerKey:"+this.key+", 小程序可见状态未发生变化，不执行动作");
+            return;
+        }
+
+        if(visible){
+            this.appVisible = visible;
+            this.state.paused = this.local.paused;
+            this.state.currentTime = this.local.currentTime;
+            logDebug("currentTime: "+this.state.currentTime);
+            this.initParams();
+        }else{
+            logDebug("playerKey:"+this.key+", playerCreate: "+this.playerCreate+", channelID: "+this.channelID+", src: "+this.state["src"]);
+            if(this.playerCreate){
+                this.eventReport = false;
+                if(this.channelID > 0){
+                    logDebug("leaveChannel");
+                    window.jsvPlayerBridge.leaveChannel(this.key);
+                }else if(this.state["src"]){
+                    logDebug("unload");
+                    this.local.currentTime = this.currentTime;
+                    this.local.paused = this.paused;
+                    logDebug("currentTime: "+this.local.currentTime);
+                    this.unloadPrivate();
+                }
+            }
+            this.appVisible = visible;
+        }
+    }
+
+    /**
+     * 当使用一个已有的Media对象时，需要通过这个接口追加一个ref，在调用releasePlayer接口释放时，会ref--，当ref==0才真正释放播放器实例。
+     */
+    setRef(){
+        this.ref++;
+    }
+
+    /**
+     * 释放播放器，一般不需要应用逻辑调用，在JsvPlayer高阶组件unmounted处理时调用此接口释放。
+     */
+    releasePlayer(){
+        logTrace("releasePlayer, key="+this.key+", ref="+this.ref);
+        this.ref--;
+        if(this.ref === 0){
+            if(typeof window.jsvPlayerBridge != "undefined" && window.jsvPlayerBridge){
+                this.changeFrameRate(false);
+                window.JMD.unsubscribe(this.key, this._onEvent);
+                window.jsvPlayerBridge.ReleasePlayer(this.key);
+                if (window.JsView && window.JsView.removeEventCallback) {
+                    logDebug("playerKey: "+this.key+", onVisibilityChange unregister");
+                    window.JsView.removeEventCallback(this._onVisibilityChangeCallBack);
+                }
+            }
+
+            for(let i=0; i<mediaArray.length; i++){
+                if(mediaArray[i].key === this.key){
+                    mediaArray.splice(i, 1);
+                    break;
+                }
+            }
+        }
+    }
+
+    setHoleID(hole_id){
+        logTrace("setHoleID, key="+this.key+", hole_id="+hole_id);
+        if(this.playerCreate){
+            this.holeId = hole_id;
+            this.holeIdModify = hole_id;
+            window.jsvPlayerBridge.setHoleID(this.key, hole_id);
+        }else{
+            this.holeIdModify = hole_id;
+        }
+    }
+
+    /**
+     * 当full模式且播放器模式是2（jsvplayer），如果是H2芯片，需要修改动画帧率到30帧，否则会导致播放器音画不同步。
+     * @param {boolean} enable  开关，视频起播时打开；视频停止，或者播放器释放时，关闭。
+     */
+    changeFrameRate(enable){
+        if(this.windowMode === "full" && this.playerType === 2 && chipType === "allwinnerh2"){
+            if(this.frameRateLimit != enable){
+                logDebug("changeFrameRate, key="+this.key+", enable="+enable);
+                this.frameRateLimit = enable;
+                if(enable){
+                    window.JsView?.reduceFps?.(30);
+                }else{
+                    window.JsView?.reduceFps?.(0);
+                }
+            }
+        }
+    }
+
+    needReportEvent(event){
+        let ret = true;
+        if(!this.eventReport){
+            ret = false;
+            switch(this.currentEventStatus){
+                case EVENT_STATUS_NONE:
+                    this.eventReport = true;
+                    ret = true;
+                    break;
+                case EVENT_STATUS_LOADSTART:
+                    if(event == EVENT_STATUS_LOADSTART || event == EVENT_STATUS_LOAD || event == EVENT_STATUS_DISPLAY || event == EVENT_STATUS_BACKLIVED || event == EVENT_STATUS_TIMESHIFTED){
+                        this.eventReport = true;
+                    }
+                    if(event == EVENT_STATUS_LOADSTART){
+                        ret = false;
+                    }else{
+                        ret = true;
+                    }
+                    break;
+                case EVENT_STATUS_LOAD:
+                    if(event == EVENT_STATUS_LOAD || event == EVENT_STATUS_DISPLAY || event == EVENT_STATUS_BACKLIVED || event == EVENT_STATUS_TIMESHIFTED){
+                        this.eventReport = true;
+                    }
+                    if(event == EVENT_STATUS_LOADSTART || event == EVENT_STATUS_LOAD){
+                        ret = false;
+                    }else{
+                        ret = true;
+                    }
+                    break;
+                case EVENT_STATUS_DISPLAY:
+                    if(event == EVENT_STATUS_DISPLAY || event == EVENT_STATUS_BACKLIVED || event == EVENT_STATUS_TIMESHIFTED){
+                        this.eventReport = true;
+                    }
+                    if(event != EVENT_STATUS_END){
+                        ret = false;
+                    }else{
+                        ret = true;
+                    }
+                    break;
+                case EVENT_STATUS_TIMESHIFT:
+                    if(event == EVENT_STATUS_TIMESHIFT || event == EVENT_STATUS_TIMESHIFTED || event == EVENT_STATUS_BACKLIVE || event == EVENT_STATUS_BACKLIVED || event == EVENT_STATUS_DISPLAY){
+                        this.eventReport = true;
+                    }
+                    if(event == EVENT_STATUS_TIMESHIFT){
+                        ret = false;
+                    }else{
+                        ret = true;
+                    }
+                    break;
+                case EVENT_STATUS_TIMESHIFTED:
+                    if(event == EVENT_STATUS_TIMESHIFTED || event == EVENT_STATUS_BACKLIVE || event == EVENT_STATUS_BACKLIVED || event == EVENT_STATUS_DISPLAY){
+                        this.eventReport = true;
+                    }
+                    if(event == EVENT_STATUS_TIMESHIFT || event == EVENT_STATUS_TIMESHIFTED){
+                        ret = false;
+                    }else{
+                        ret = true;
+                    }
+                    break;
+                case EVENT_STATUS_BACKLIVE:
+                    if(event == EVENT_STATUS_TIMESHIFT || event == EVENT_STATUS_TIMESHIFTED || event == EVENT_STATUS_BACKLIVE || event == EVENT_STATUS_BACKLIVED || event == EVENT_STATUS_DISPLAY){
+                        this.eventReport = true;
+                    }
+                    if(event == EVENT_STATUS_BACKLIVE){
+                        ret = false;
+                    }else{
+                        ret = true;
+                    }
+                    break;
+                case EVENT_STATUS_BACKLIVED:
+                    if(event == EVENT_STATUS_TIMESHIFTED || event == EVENT_STATUS_TIMESHIFT || event == EVENT_STATUS_BACKLIVED || event == EVENT_STATUS_DISPLAY){
+                        this.eventReport = true;
+                    }
+                    if(event == EVENT_STATUS_BACKLIVE || event == EVENT_STATUS_BACKLIVED){
+                        ret = false;
+                    }else{
+                        ret = true;
+                    }
+                    break;
+                case EVENT_STATUS_END:
+                    this.eventReport = true;
+                    ret = true;
+                    break;
+                default:
+                    logWarning("current event status is "+this.currentEventStatus);
+                    this.eventReport = true;
+                    ret = true;
+                    break;
+            }
+
+            logTrace("eventReport:"+this.eventReport+", ret="+ret);
+        }
+
+        return ret;
+    }
+
+    /**
+     * 私有接口，外部不需要调用此接口。
+     */
+    onEvent(event_str){
+        logTrace("player event: "+event_str);
+        let obj = JSON.parse(event_str);
+        let event_obj = JSON.parse(obj.param);
+        let event = event_obj.event;
+        let data = event_obj.data;
+        switch(event){
+            case "onProgress":
+                {
+                    // logDebug("onProgress:"+data);
+                    if (this.local.isRenderable == false) {
+                        return;
+                    }
+
+                    let time_update = this.local.currentTime != data.currentTime;
+                    this.local.currentTime = data.currentTime;
+                    if (time_update && this.hasOwnProperty("ontimeupdate")) {
+                        this["ontimeupdate"](data.currentTime);
+                    }
+
+                    let progress_update = this.local.playableDuration != data.playableDuration;
+                    this.local.playableDuration = data.playableDuration;
+                    if (progress_update && this.hasOwnProperty("onprogress")) {
+                        this["onprogress"]();
+                    }
+
+                    let canplay_through = this.local.playableDuration == this.local.duration;
+                    if (canplay_through && progress_update && this.hasOwnProperty("oncanplaythrough")) {
+                        this["oncanplaythrough"](); // only called one time
+                    }
+                }
+                break;
+            case "onEnd":
+                if(this.needReportEvent(EVENT_STATUS_END)){
+                    this.local.isRenderable = false;
+                    this.setState("paused", true, "boolean");
+                    if(this.hasOwnProperty("onend")){
+                        this["onend"]();
+                    }
+                    this.currentEventStatus = EVENT_STATUS_END;
+                }
+                break;
+            case "onLoadStart":
+                logDebug("onLoadStart:"+data);
+                if(this.needReportEvent(EVENT_STATUS_LOADSTART)){
+                    if(this.hasOwnProperty("onloadstart")){
+                        this["onloadstart"]();
+                    }
+                    this.currentEventStatus = EVENT_STATUS_LOADSTART;
+                }
+                break;
+            case "onLoad":
+                logDebug("onLoad:"+data);
+                if(this.needReportEvent(EVENT_STATUS_LOAD)){
+                    this.local.currentTime = data.currentTime;
+                    this.local.duration = data.duration;
+
+                    if (this.hasOwnProperty("onloadedmetadata")) {
+                        this["onloadedmetadata"]();
+                    }
+
+                    if (this.hasOwnProperty("onload")) {
+                        this["onload"]();
+                    }
+
+                    if (this.hasOwnProperty("ondurationchange")) {
+                        this["ondurationchange"]();
+                    }
+                    this.currentEventStatus = EVENT_STATUS_LOAD;
+                }
+                break;
+            case "onError":
+                logDebug("onError:"+data);
+                this.local.isRenderable = false;
+                if(this.hasOwnProperty("onerror")){
+                    const Error = {
+                        MEDIA_ERR_ABORTED: 1,
+                        MEDIA_ERR_NETWORK: 2,
+                        MEDIA_ERR_DECODE: 3,
+                        MEDIA_ERR_SRC_NOT_SUPPORTED: 4,
+                        MEDIA_ERR_ONLY_ONE_4K: 5,
+                        MEDIA_ERR_NO_DECODE_RESOURCE: 6,
+                    };
+                    const platform_error = data.error.what;
+                    let e = Error.MEDIA_ERR_ABORTED;
+                    switch (platform_error) {
+                        case -1004 : // MediaPlayer.MEDIA_ERROR_IO
+                            e = Error.MEDIA_ERR_NETWORK;
+                            break;
+                        case -1007 : // MediaPlayer.MEDIA_ERROR_MALFORMED
+                            e = Error.MEDIA_ERR_DECODE;
+                            break;
+                        case -1010 : // MediaPlayer.MEDIA_ERROR_UNSUPPORTED
+                            e = Error.MEDIA_ERR_SRC_NOT_SUPPORTED;
+                            break;
+                        case -50001:
+                            e = Error.MEDIA_ERR_ONLY_ONE_4K;
+                            break;
+                        case -50002:
+                            e = Error.MEDIA_ERR_NO_DECODE_RESOURCE;
+                            break;
+                        default:
+                            break;
+                    }
+                    this["onerror"](e);
+                }
+                break;
+            case "onSeek":
+                logDebug("onSeek:"+data);
+                if(this.needReportEvent(EVENT_STATUS_SEEK)){
+                    this.local.isRenderable = false;
+                    if(this.hasOwnProperty("onseeking")){
+                        this["onseeking"]();
+                    }
+                }
+                break;
+            case "onEventExt":
+                logDebug("onEventExt:"+data);
+                switch (data.eventExt) {
+                    case "videoMetadataUpdate" :
+                        if (this.hasOwnProperty("onloadedmetadata")) {
+                            this["onloadedmetadata"]();
+                        }
+                        break;
+                    case "videoSeekComplete" :
+                        if(this.needReportEvent(EVENT_STATUS_SEEKED)){
+                            //this.local.isRenderable = true; // waiting until BUFFERING END
+                            if (this.hasOwnProperty("onseeked")) {
+                                this["onseeked"]();
+                            }
+                        }
+                        break;
+                    default:
+                        logWarning("unimplentation event ext type = " + data.eventExt);
+                        break;
+                }
+                break;
+            case "onAudioFocusGain":
+                logDebug("onAudioFocusGain:"+data);
+                if(this.hasOwnProperty("onaudiofocusgain")){
+                    this["onaudiofocusgain"](data);
+                }
+                break;
+            case "onAudioFocusLoss":
+                logDebug("onAudioFocusLoss:"+data);
+                if(this.hasOwnProperty("onaudiofocusloss")){
+                    this["onaudiofocusloss"](data);
+                }
+                break;
+            case "onPlaybackStalled":
+                if(this.needReportEvent(EVENT_STATUS_STALLED)){
+                    this.local.isRenderable = false;
+                    if(this.hasOwnProperty("onstalled")){
+                        this["onstalled"]();
+                    }
+                }
+                break;
+            case "onPlaybackResume":
+                if(this.needReportEvent(EVENT_STATUS_RESUME)){
+                    this.local.isRenderable = true;
+                    if(this.hasOwnProperty("onplaying")){
+                        this["onplaying"]();
+                    }
+                }
+                break;
+            case "onReadyForDisplay":
+                this.changeFrameRate(true);
+                if(this.needReportEvent(EVENT_STATUS_DISPLAY)){
+                    this.local.isRenderable = true;
+                    if(this.hasOwnProperty("oncanplay")){
+                        this["oncanplay"]();
+                    }
+                    this.currentEventStatus = EVENT_STATUS_DISPLAY;
+                }
+                break;
+            case "onTimeShift":
+                logDebug("onTimeShift");
+                if(this.needReportEvent(EVENT_STATUS_TIMESHIFT)){
+                    if(this.hasOwnProperty("ontimeshift")){
+                        this["ontimeshift"](data.seekTime);
+                    }
+                    this.currentEventStatus = EVENT_STATUS_TIMESHIFT;
+                }
+                break;
+            case "onTimeShifted":
+                logDebug("onTimeShifted");
+                if(this.needReportEvent(EVENT_STATUS_TIMESHIFTED)){
+                    if(this.hasOwnProperty("ontimeshifted")){
+                        this["ontimeshifted"]();
+                    }
+                    this.currentEventStatus = EVENT_STATUS_TIMESHIFTED;
+                }
+                break;
+            case "onBackLive":
+                logDebug("onBackLive");
+                if(this.needReportEvent(EVENT_STATUS_BACKLIVE)){
+                    if(this.hasOwnProperty("onbacklive")){
+                        this["onbacklive"]();
+                    }
+                    this.currentEventStatus = EVENT_STATUS_BACKLIVE;
+                }
+                break;
+            case "onBackLived":
+                logDebug("onBackLived");
+                if(this.needReportEvent(EVENT_STATUS_BACKLIVED)){
+                    if(this.hasOwnProperty("onbacklived")){
+                        this["onbacklived"]();
+                    }
+                    this.currentEventStatus = EVENT_STATUS_BACKLIVED;
+                }
+                break;
+            default:
+                break; 
+       }
+    }
+
+    /**
+     * 属性，boolean类型，不支持读取，true表示自动播放。
+     */
+    set autoplay(value) {
+        this.setState("autoplay", value, "boolean");
+    }
+
+    /**
+     * 属性，double类型，当前时间，单位秒，set用于seek操作（起播后）或者设置起播时间（起播前），get用于读取当前时间。
+     */
+    get currentTime() {
+        if(!this.appVisible){
+            return this.local.currentTime;
+        }
+
+        let result = this.getProperty("currentTime");
+        if(result != null){
+            this.local.currentTime = result;
+            return result;
+        }
+        return 0;
+    }
+
+    set currentTime(value) {
+        this.local.isRenderable = false;
+        this.local.currentTime = value;
+        this.setState("currentTime", value, "number");
+    }
+
+    /**
+     * 属性，double类型，总时长，单位秒，只支持读取。
+     */
+    get duration() {
+        if(!this.appVisible){
+            return this.local.duration;
+        }
+
+        let result = this.getProperty("duration");
+        if(result != null)
+            return result;
+
+        return 0;
+    }
+
+    /**
+     * 属性，boolean类型，不支持读取，true表示循环播放。
+     */
+    set loop(value) {
+        if(typeof value == "boolean") {
+            this.setState("repeat", value, "boolean");
+        } else if(typeof value == "undefined") {
+            this.setState("repeat", false, "boolean");
+        } else {
+            this.setState("repeat", true, "boolean"); // html5标准用法, 任何value不为boolean|undefined都会转变为true
+        }
+    }
+
+    /**
+     * 属性，boolean类型，设置和获取静音状态。
+     */
+    get muted() {
+        return this.getState("muted");
+    }
+
+    set muted(value) {
+        this.setState("muted", value, "boolean");
+    }
+
+    /**
+     * 属性，boolean类型，当前pause状态，只支持读取。
+     */
+    get paused() {
+        return this.getState("paused");
+    }
+
+    /**
+     * 属性，float类型，设置或者读取倍速播放，通常的值是0.5、0.75、1.0、1.25、1.5、2.0、3.0。
+     */
+    get playbackRate() {
+        return this.getState("rate");
+    }
+
+    set playbackRate(value) {
+        logDebug("playbackRate")
+        this.setState("rate", value, "number");
+    }
+
+    /**
+     * 已废弃。
+     */
+    get preload() {
+		return (this.enablePlayer ? 'auto' : 'none');
+    }
+    
+    set preload(value) {
+		if (value !== 'none') { // preload = 'none' is default
+			this.load();
+		}
+	}
+
+
+    /**
+     * 属性，string类型，播放地址，不支持读取。
+     */
+    set src(value) {
+        this.setSrc(value, null, null, 1)
+    }
+
+    /**
+     * 属性，float类型，播放器音量，0-1.0，只影响当前播放器实例。
+     */
+    get volume() {
+        return this.getState("volume");
+    }
+
+    set volume(value) {
+        this.setState("volume", value, "number");
+    }
+
+    /**
+     * 属性，double类型，起播时间，单位秒，可使用currentTime代替。
+     */
+	get startTime() {
+		return this.getState("startTime");
+	}
+
+	set startTime(value) {
+		this.setState("startTime", value, "number");
+    }
+    
+    /**
+     * 属性，double类型，可播放时长，本地缓存的视频时长，只支持读取。
+     */
+    get playableDuration() {
+		return this.local.playableDuration;
+    }
+    
+    /**
+     * 属性，boolean类型，true表示关闭timeupdate事件上报。
+     */
+    set timeupdateless(value) {
+        this.setState("timeUpdateLess", !!value, "boolean");
+    }
+
+    /**
+     * 属性，boolean类型，true表示保留最后一帧，false表示不保留。
+     */
+    set keepLastFrame(value) {
+        this.setState("keepLastFrame", !!value, "boolean");
+    }
+
+    /**
+     * 设置播放地址。
+     * @param {string} url 播放地址。
+     * @param {String} windowMode 播放器窗口模式。
+     *                 null：使用this.windowMode作为窗口模式。
+     *                 full：观影模式，全屏方式，不建议修改w/h/l/t，视频清晰度/流畅度最佳；
+     *                 resizable：可变窗口模式，可以随意修改w/h/l/t，支持动画效果，视频清晰度/流畅度表现可能不如full模式；
+     *                 pip：画中画模式，只在支持多路硬解的情况下使用，用户画中画的小窗播放，对清晰度/流畅度要求较差，可能会有反交错问题。
+     * @param {string} head 网络请求的head信息，可以为NULL。
+     * @param {int} type 类型，1表示点播，2表示直播，3表示时移，4表示回看，默认1。
+     * @param {double} timeShift 时移时间，只有在type=3时才有效，表示从当前时间时移多长时间，单位秒。
+     * @param {int} 分辨率类型 0:unknown或其它；1:标清；2:高清；3:超清（720P）；4:蓝光（1080P）；5:2K；6:4K；7:8K。
+     * @param {int} 用户频道号，只在直播回看状态下需要设置 
+     */
+    setSrc(url, windowMode, head, type, timeShift, resolution, mixNo){
+        let src = {};
+        src.url = url;
+        if(head){
+            src.head = head;
+        }
+        if(windowMode){
+            src.windowMode = windowMode;
+        }
+        if(type){
+            src.type = type;
+        }else{
+            src.type = 1;
+        }
+        if(type === 3 && timeShift){
+            src.timeShift = timeShift;
+        }
+
+        if(resolution && typeof resolution === "number"){
+            src.resolution = resolution;
+        }
+
+        if(mixNo && typeof mixNo == "number"){
+            src.channelID = mixNo;
+        }
+
+        this.currentEventStatus = EVENT_STATUS_NONE;
+        this.setState("src", JSON.stringify(src), "string");
+        this.eventReport = true;
+    }
+
+    /**
+     * 添加监听事件。
+     * @param {string} type 事件类型。
+     * @param {callback} listener 事件处理函数。
+     */
+    addEventListener(type, listener) {
+        this['on' + type] = listener;
+    }
+
+    /**
+     * 重新加载视频流，初始化播放器。
+     */
+    load() {
+		this.setState("enablePlayer", true, "boolean");
+    }
+    
+    /**
+     * 暂停
+     */
+    pause() {
+        this.local.paused = true;
+        this.setState("paused", true, "boolean");
+        if (this.hasOwnProperty("onpause")) {
+			this["onpause"]();
+		}
+    }
+
+    /**
+     * 播放
+     */
+    play() {
+        this.local.paused = false;
+        this.setState("paused", false, "boolean");
+        if (this.hasOwnProperty("onplay")) {
+			this["onplay"]();
+		}
+    }
+
+    /**
+     * 获取AudioTrack个数
+     * @returns total number of audio track.
+     */
+    getAudioTrackCount(){
+        let count = this.getProperty("audioTrackCount");
+        if(count === null){
+            return 1;
+        }
+
+        return count;
+    }
+
+    /**
+     * 获取当前使用的audio track
+     * @returns the current playing track，-1 is invalid
+     */
+    getSelectedAudioTrack(){
+        return this.getState("audioTrack");
+    }
+
+    /**
+     * 选择audio track
+     * @param {*} track audio track index
+     */
+    selectAudioTrack(track){
+        this.setState("audioTrack", track, "number");
+    }
+
+    /**
+     * 停止视频流。
+     */
+    unload() {
+        this.unloadPrivate();
+        this.currentEventStatus = EVENT_STATUS_NONE;
+        this.eventReport = true;
+	}
+
+    unloadPrivate(){
+        this.setState("paused", true, "boolean");
+        this.local.isRenderable = false;
+		this.setState("enablePlayer", false, "boolean");
+        this.changeFrameRate(false);
+    }
+
+    /**
+     * 要求终端访问指定的频道，并立即返回。对由本地设置为跳过的频道，也返回-1。
+     * 频道地址为通过 CTCSetConfig 设置的频道列表中的地址：
+     * 如频道地址为 igmp：//的组播地址，则加入组播频道，播放器开始播放组播频道，并处理相应的时移等功能；
+     * 如频道地址为 rtsp：//的单播地址，则连接单播频道，播放器开始播放；
+     * 如频道地址为 http：//的地址，则浏览器直接发起请求，访问该页面。
+     * @param {int} mixNo 用户频道号。
+     * @returns {int} 0，表示成功；-1：表示频道号无效。
+     */
+    joinChannel(mixNo){
+        logTrace("joinChannel, key="+this.key+", mixNo="+mixNo);
+        if(this.type === "audio"){
+            logWarning("Audio player do not support joinChannel.");
+            return 0;
+        }
+
+        let ret = this.joinChannelPrivate(mixNo);
+        if(ret >= 0){
+            this.currentEventStatus = EVENT_STATUS_NONE;
+            this.eventReport = true;
+        }
+        return ret;
+    }
+
+    joinChannelPrivate(mixNo){
+        if(this.type === "audio"){
+            logWarning("Audio player do not support joinChannelPrivate.");
+            return 0;
+        }
+
+        if(mixNo <= 0){
+            return -1;
+        }
+
+        let ret = 0; 
+        if(this.playerCreate && this.appVisible){
+            ret = window.jsvPlayerBridge.JoinChannel(this.key, mixNo);
+        }
+
+        if(ret >= 0){
+            this.channelID = mixNo;
+            this.local.paused = false;
+            
+            this.setState("paused", false, "boolean");
+        }
+
+        return ret;
+    }
+
+    /**
+     * 要求终端离开指定的频道，并立即返回。
+     * 如原频道地址为 igmp：//的组播地址，则立即离开组播频道，播放器停止播放组播频道，并断开相应的时移连接；
+     * 如频道地址为 rtsp：//的单播地址，则断开单播频道，播放器停止播放；
+     * 如频道地址为 http：//的地址，则浏览器不作操作。
+     * 【注】：本方法只用于离开通过 joinChannel 方法加入的频道。
+     * @returns {int} 0，表示成功；-1：表示频道号无效。
+     */
+    leaveChannel(){
+        logTrace("leaveChannel, key="+this.key+", channelID="+this.channelID);
+        if(this.type === "audio"){
+            logWarning("Audio player do not support leaveChannel.");
+            return 0;
+        }
+
+        let ret = this.leaveChannelPrivate();
+
+        this.currentEventStatus = EVENT_STATUS_NONE;
+        this.eventReport = true;
+        return ret;
+    }
+
+    leaveChannelPrivate(){
+        let ret = 0;
+        if(this.type === "audio"){
+            logWarning("Audio player do not support leaveChannelPrivate.");
+            return ret;
+        }
+
+        if(this.playerCreate && this.appVisible){
+            ret = window.jsvPlayerBridge.leaveChannel(this.key);
+        }
+
+        this.channelID = -1;
+        return ret;
+    }
+
+    // /**
+    //  * 快进。
+    //  * @param {float} speed 2至32
+    //  */
+    // fastForward(value) {
+    //     this.setState("fastForward", value, "number");
+    // }
+
+    // /**
+    //  * 快退。
+    //  * @param {float} speed -2至-32
+    //  */
+    // fastRewind(value) {
+    //     this.setState("fastForward", value, "number");
+    // }
+
+    /**
+     * 当流停止后，不需要显示最后一帧，调用此接口清除。
+     */
+    clearLastFrame(){
+        logTrace("clearLastFrame, key="+this.key);
+        if(typeof window.jsvPlayerBridge !== "undefined"){
+            window.jsvPlayerBridge.clearLastFrame(this.key);
+        }
+
+        return;
+    }
+    /**
+     * @return {int} 当前音量，0-100。
+     * */
+    getGlobalVolume(){
+        logTrace("getGlobalVolume, key="+this.key);
+        if(typeof window.jsvPlayerBridge !== "undefined"){
+            return window.jsvPlayerBridge.getGlobalVolume(100);
+        }
+
+        return 0;
+    }
+
+    /**
+     * 设置系统音量。
+     * @param {int} volume 0-100，音量值。
+     * @param {int} flags 1表示显示音量调节UI；4表示使用提示音；5表示同时显示音量调节UI和使用提示音。
+     * */
+    setGlobalVolume(volume, flags){
+        logTrace("setGlobalVolume, key="+this.key+", volume="+volume+", flags="+flags);
+        if(typeof window.jsvPlayerBridge !== "undefined"){
+            return window.jsvPlayerBridge.setGlobalVolume(volume, typeof flags!="undefined"?flags:0, 100);
+        }
+    }
+
+    /**
+     * 调整系统音量，一次设置一个步长。
+     * @param {int} direction 1增大音量；-1减小音量。
+     * @param {int} flags FLAG_SHOW_UI(1)表示显示音量调节UI；FLAG_PLAY_SOUND(4)表示使用提示音。两个值可以是或的关系。
+     * */
+    adjustGlobalVolume(direction, flags){
+        logTrace("adjustGlobalVolume, key="+this.key+", direction="+direction+", flags="+flags);
+        if(typeof window.jsvPlayerBridge !== "undefined"){
+            return window.jsvPlayerBridge.adjustGlobalVolume(direction, typeof flags!="undefined"?flags:0);
+        }
+    }
+
+    /**
+     * 设置系统静音状态。
+     * @param {boolean} status true表示静音，false表示取消静音。
+     * @param {int} flags FLAG_SHOW_UI(1)表示显示音量调节UI；FLAG_PLAY_SOUND(4)表示使用提示音。两个值可以是或的关系。android 6.0（包含）以上有效。
+     * */
+     setGlobalMuted(status, flags){
+        logTrace("setGlobalMuted, key="+this.key+", status="+status+", flags="+flags);
+        if(typeof window.jsvPlayerBridge !== "undefined"){
+            logDebug("setMuted:"+status);
+            window.jsvPlayerBridge.setGlobalMuted(status,  typeof flags!="undefined"?flags:0);
+        }
+     }
+
+    /**
+     * 获取系统静音状态。
+     * @return {boolean} true表示静音，false表示非静音。
+     * */
+    getGlobalMutedStatus(){
+        logTrace("getGlobalMutedStatus, key="+this.key);
+        if(typeof window.jsvPlayerBridge !== "undefined"){
+            return window.jsvPlayerBridge.getGlobalMutedStatus();
+        }  
+    }
+
+    /**
+     * 回到视频的开头。
+     */
+    gotoStart(){
+        logTrace("gotoStart, key="+this.key);
+        if(this.playerCreate && this.appVisible){
+            window.jsvPlayerBridge.gotoStart(this.key);
+        }else{
+            this.state["currentTime"] = 0;
+        }
+    }
+
+    /**
+     * 到达视频的末尾。
+     */
+     gotoEnd(){
+        logTrace("gotoEnd, key="+this.key);
+        if(this.playerCreate && this.appVisible){
+            window.jsvPlayerBridge.gotoEnd(this.key);
+        }
+    }
+
+    /**
+     * 获取timeShift状态，包含是否支持时移以及最大时移时间。
+     * @returns {JsonObject} 包含两个字段：1、timeShift，boolean类型，true表示支持时移；2、timeShiftLength，int类型，最大时移时长。
+     */
+    getTimeShiftInfo(){
+        logTrace("getTimeShiftInfo, key="+this.key);
+        let result = this.getProperty("timeShift");
+        if(result != null && result != "")
+            return JSON.parse(result);
+
+        return null;
+    }
+
+    /**
+     * 设置时移时间。
+     * @param {double} time，值为从当前时间计算向前移动了多长时间，单位秒。
+     */
+    setTimeShift(time){
+        logTrace("setTimeShift, key="+this.key+", time="+time);
+        if(this.type === "audio"){
+            logWarning("Audio player do not support setTimeShift.");
+            return;
+        }
+        if(this.playerCreate && this.appVisible){
+            window.jsvPlayerBridge.setTimeShift(this.key, time);
+        }
+    }
+
+    /**
+     * 设置色度抠像参数，只支持扣绿。
+     * 参考格式：{color: 0x30FF30, colorDistance: 0.15, edgeDistance: 0.4, greenOffset: 0.05}
+     * @param {JSON object} chromaKey，抠像参数，JSON Object包含的参数如下：
+     *                                 color，色值，int类型，为抠图色值范围的中心点，格式为0xRRGGBB。
+     *                                 colorDistance，float类型，色域范围，范围0-1.0。
+     *                                 edgeDistance，float类型，alpha透明度距离，范围colorDistance-1.0，从colorDistance到edgeDistance的alpha值从1.0-0线性递减。
+     *                                 greenOffset，float类型，红蓝差值，范围0-1.0。
+     */
+     setChromaKey(chromaKey){
+        logTrace("setChromaKey, key="+this.key+", chroma key="+JSON.stringify(chromaKey));
+        if(this.type === "audio"){
+            logWarning("Audio player do not support setChromaKey.");
+            return;
+        }
+        this.setState("chromaKey", JSON.stringify(chromaKey), "string");
+    }
+
+    setDebugMode(mode){
+        logTrace("setDebugMode, key="+this.key+", mode="+mode);
+        if(typeof window.jsvPlayerBridge !== "undefined"){
+            return window.jsvPlayerBridge.setDebugMode(this.key, mode);
+        }
+    }
+
+    /**
+     * 获取是否支持倍速设置，在onCanPlay事件发送以后，通过此接口查询。
+     * @returns {boolean} true:支持播放倍速设置；false：不支持播放倍速设置。
+     * */
+    supportPlaybackRateSet(){
+        logTrace("supportPlaybackRateSet, key="+this.key);
+        if(typeof window.jsvPlayerBridge !== "undefined"){
+            return window.jsvPlayerBridge.supportRateSet(this.key);
+        }
+
+        return false;
+    }
+
+    /**
+     * 私有接口，外部不需要调用此接口。
+     */
+    setState(key, value, type) {
+        if (typeof(value) !== type) {
+            logWarning("invalid paramter type to set " + key + ". value is not " + type);
+            return;
+        }
+
+        this.state[key] = value;
+        logDebug("set " + key + " = " + value);
+
+        let param = {};
+        param[key] = value;
+
+        if(this.playerCreate && this.appVisible){
+            window.jsvPlayerBridge.SetProperty(this.key, JSON.stringify(param));
+        }
+    }
+
+    /**
+     * 私有接口，外部不需要调用此接口。
+     */
+    getState(key) {
+        let value = this.state[key];
+        logDebug("get " + key + " = " + value);
+        if (typeof value == "undefined" && this.playerCreate && this.appVisible) {
+            value = window.jsvPlayerBridge.GetProperty(this.key, key);
+            this.state[key] = value;
+        }
+
+        return value;
+    }
+
+    /**
+     * 私有接口，外部不需要调用此接口。
+     */
+    getProperty(key){
+        if (this.playerCreate && typeof window.jsvPlayerBridge != "undefined" && this.appVisible) {
+            let result_str = window.jsvPlayerBridge.GetProperty(this.key, key);
+            if(result_str == null || result_str == "")
+                return null;
+            
+            let result = JSON.parse(result_str);
+            if(result.hasOwnProperty(key))
+                return result[key];
+
+            return null;
+        }
+
+        return null;
+    }
+}
+
+class JsvMedia extends JsvBaseMedia {
+    constructor(type, window_mode, hole_id, player_type, key, background, design_map_width, decode_type) {
+        super(type, window_mode, hole_id, player_type, key, background, design_map_width, decode_type);
+        //super.buildPlatformInstance(type);
+    }
+}
+
+class JsvMediaAudio extends JsvMedia {
+    constructor(key, design_map_width) {
+        super("audio", "resizable", 0, 3, key, true, design_map_width, 0);
+    }
+}
+
+class JsvMediaVideo extends JsvMedia {
+    constructor(hole_id, window_mode, player_type, key, background, design_map_width, decode_type) {
+        super("video", window_mode, hole_id, player_type, key, background, design_map_width, decode_type);
+        
+        this.state.aspectRatio = 'origin'; // 'origin', 'full', '16:9', '4:3',
+    }
+
+    /**
+     * 属性，string类型，设置海报地址，未实现。
+     */
+    set poster(value) {
+        logWarning("Video.poster() TODO");
+    }
+
+    /**
+     * 属性，string类型，设置和读取显示模式。
+     * full（fill模式）表示拉升至充满显示区域；origin（contain模式）表示原始比例缩放至宽或高和显示区域相等（不超过显示区域）；x:y表示按照指定比例显示。
+     */
+    get videoAspectRatio() {
+        return this.getState("aspectRatio");
+    }
+
+    set videoAspectRatio(value) {
+        this.setState("aspectRatio", value, "string");
+    }
+
+    /**
+     * 属性，int类型，只读，获取视频的宽。
+     */
+    get videoHeight() {
+        return this.getState("videoHeight");
+    }
+
+    /**
+     * 属性，int类型，只读，获取视频的宽。
+     */
+    get videoWidth() {
+        return this.getState("videoWidth");
+    }
+}
+
+/**
+ * 获取播放器能力集，当前主要是对4K多播放器的支持以及H265解码能力的支持。
+ * @return {string} json string，能力集JSON数据格式。
+ */
+function getJsvPlayerCapabilitySet(){
+    if(typeof window.jsvPlayerBridge !== "undefined"){
+        return window.jsvPlayerBridge.getCapabilitySet();
+    }
+    return null;
+}
+
+/**
+     * 设置指定视频类型的同时使用播放器个数，会check硬件是否支持系统设置的播放器个数，最好在小程序初始化的时候，使用播放器资源之前调用。
+     * @param {string} videoType，对于H264，是video/avc，对于H265，是video/hevc，其他可以参考相关定义。
+     * @param {int} num，需要使用的播放器个数。
+     * @return {String} json string，对设置的播放器个数的支持状态,返回的总数不会大于设置的个数（实际硬件能力可能大于设置的个数）。
+     *                  支持三个属性：1、total：总的播放器个数；2、hardware：硬解播放器个数；3、软解播放器个数，如果硬解播放器个数不满足需求，会根据cpu能力确定是否提供软解播放器。
+     * */
+function setJsvPlayerNumber(videoType, num){
+    logTrace("setPlayerNumber, videoType="+videoType+", num="+num);
+    if(typeof window.jsvPlayerBridge !== "undefined"){
+        return window.jsvPlayerBridge.setPlayerNumber(videoType, num);
+    }else{
+        return null;
+    }
+}
+
+function setJsvPlayerDebugMode(mode){
+    logTrace("setJsvPlayerDebugMode, mode="+mode);
+    if(typeof window.jsvPlayerBridge !== "undefined"){
+        window.jsvPlayerBridge.setDebugMode(null, mode);
+    }
+}
+
+function getJsvPlayerRunningNum(){
+    logTrace("getJsvPlayerRunningNum");
+    if(typeof window.jsvPlayerBridge !== "undefined"){
+        return window.jsvPlayerBridge.getRunningPlayerNum();
+    }
+    return -1;
+}
+
+function setOperator(operator){
+    logTrace("setOperator");
+    if(typeof window.jsvPlayerBridge !== "undefined"){
+        return window.jsvPlayerBridge.setOperator(operator);
+    }
+}
+
+function globalLoadSetOperator(operator){
+    setOperator(operator)
+}
+
+export {
+    JsvMediaVideo,
+    JsvMediaAudio,
+    globalLoadJsvPlayerPlugin,
+    globalPreLoadJsvPlayerPlugin,
+    globalLoadSetOperator,
+    findMediaObjectByKey,
+    getJsvPlayerCapabilitySet,
+    setJsvPlayerNumber,
+    setLogLevel,
+    logFatal,
+    logError,
+    logWarning,
+    logDebug,
+    logTrace,
+    setJsvPlayerDebugMode,
+    getJsvPlayerRunningNum,
+    setOperator,
+}