create-jsview 2.1.367-test.0 → 2.1.428

package/template-vue-vite/dist-test-jsview-chunk/js/BrowserJsvPlayer.vue.8615ee65.js

@@ -0,0 +1,575 @@
+import { F as Forge } from "./jsview-forge-define.bfab260e.js";
+import { _ as _export_sfc } from "./export-sfc.2749ebea.js";
+import { s as shallowRef, o as openBlock, e as createElementBlock, f as createBaseVNode, g as normalizeStyle } from "./vue.889a9b8b.js";
+import "./jsview-dom-entry.280f04b1.js";
+//!
+//! utils/JsViewPlugin/JsvPlayer/JsvMediaBrowserInterface.js;
+//!
+let methods = {
+  /**
+   * 要求终端访问指定的频道，并立即返回。对由本地设置为跳过的频道，也返回-1。
+   * 频道地址为通过 CTCSetConfig 设置的频道列表中的地址：
+   * 如频道地址为 igmp：//的组播地址，则加入组播频道，播放器开始播放组播频道，并处理相应的时移等功能；
+   * 如频道地址为 rtsp：//的单播地址，则连接单播频道，播放器开始播放；
+   * 如频道地址为 http：//的地址，则浏览器直接发起请求，访问该页面。
+   * 【注】：在加入一个频道之前已经加入另外一个频道，需先调用 leaveChannel 方法离开前一个频道。
+   * @param {int} channelID 用户频道号。
+   * @returns {int} 0，表示成功；-1：表示频道号无效。
+   */
+  joinChannel(channelID) {
+    console.log(`PC simulate browser player joinChannel(${channelID})`);
+  },
+  /**
+   * 要求终端离开指定的频道，并立即返回。
+   * 如原频道地址为 igmp：//的组播地址，则立即离开组播频道，播放器停止播放组播频道，并断开相应的时移连接；
+   * 如频道地址为 rtsp：//的单播地址，则断开单播频道，播放器停止播放；
+   * 如频道地址为 http：//的地址，则浏览器不作操作。
+   * 【注】：本方法只用于离开通过 joinChannel 方法加入的频道。
+   * @returns {int} 0，表示成功；-1：表示频道号无效。
+   */
+  leaveChannel() {
+    console.log(`PC simulate browser player leaveChannel()`);
+    return 0;
+  },
+  // /**
+  //  * 快进。
+  //  * @param {float} speed 2至32
+  //  */
+  // fastForward(value) {
+  //     console.log(`browser player fastForward(${value})`);
+  // },
+  // /**
+  //  * 快退。
+  //  * @param {float} speed -2至-32
+  //  */
+  // fastRewind(value) {
+  //     console.log(`browser player fastRewind(${value})`);
+  // },
+  /**
+   * 获取系统音量。
+   * @param {int} max_volume 音量范围，即可设置的最大音量值，一般有16和100两种值。
+   * @return {int} 当前音量，根据max_volume进行了换算。
+   * */
+  getGlobalVolume(max_volume) {
+    console.log(`PC simulate browser player getGlobalVolume(${max_volume})`);
+    return 0;
+  },
+  /**
+   * 设置系统音量。
+   * @param {int} volume 0-max_volume，音量值。
+   * @param {int} flags 1表示显示音量调节UI；4表示使用提示音。两个值可以是或的关系。
+   * @param {int} max_volume 音量范围，即可设置的最大音量值，一般有16和100两种值。
+   * */
+  setGlobalVolume(volume, flags, max_volume) {
+    console.log(`PC simulate browser player setGlobalVolume(${volume}, ${flags}, ${max_volume})`);
+  },
+  /**
+   * 调整系统音量，一次设置一个步长。
+   * @param {int} direction 1增大音量；-1减小音量。
+   * @param {int} flags FLAG_SHOW_UI(1)表示显示音量调节UI；FLAG_PLAY_SOUND(4)表示使用提示音。两个值可以是或的关系。
+   * */
+  adjustGlobalVolume(direction, flags) {
+    console.log(`PC simulate browser player adjustGlobalVolume(${direction}, ${flags})`);
+  },
+  /**
+   * 回到视频的开头。
+   */
+  gotoStart() {
+    console.log(`PC simulate browser player gotoStart()`);
+  },
+  /**
+   * 到达视频的末尾。
+   */
+  gotoEnd() {
+    console.log(`PC simulate browser player gotoEnd()`);
+  },
+  /**
+   * 设置播放地址。
+   * @param {string} url 播放地址。
+   * @param {string} head 网络请求的head信息，可以为NULL。
+   * @param {int} type 类型，1表示点播，2表示直播，3表示时移，默认1。
+   */
+  setSrc(url, head, type) {
+    console.log(`PC simulate setSrc url=${url} head=${head} type=${type}`);
+    this.src = url;
+  }
+};
+//!
+//! utils/JsViewPlugin/JsvPlayer/BrowserJsvPlayer.vue;
+//!
+/*! 
+
+
+
+
+ */
+let logDebug = console.log;
+const _sfc_main = {
+  props: {
+    /**
+     * 回调函数，播放器对象通知接口
+     * @param {Object} video对象，可以通过此video对象调用video相关属性和方法，具体属性和方法定义见JsvMedia.js文件里相关说明。
+     */
+    onRef: { type: Function, default: () => {
+    } },
+    /**
+     * 属性，Boolean类型，true表示自动播放，默认false。
+     */
+    autoplay: { type: Boolean, default: false },
+    /**
+     * 属性，String类型，播放器实例索引，同样的key使用同一个播放器实例。
+     */
+    playerKey: { type: String, default: null },
+    /**
+     *  属性，String类型，播放器窗口模式，默认resizable模式。
+     *                  full：观影模式，全屏方式，不建议修改w/h/l/t，视频清晰度/流畅度最佳；
+     *                  resizable：可变窗口模式，可以随意修改w/h/l/t，支持动画效果，视频清晰度/流畅度表现可能不如full模式；
+     *                  pip：画中画模式，只在支持多路硬解的情况下使用，用户画中画的小窗播放，对清晰度/流畅度要求较差，可能会有反交错问题。
+     */
+    windowMode: { type: String, default: "resizable" },
+    /**
+     * 属性，int类型，底层使用的播放器类型。1：系统播放器；2:jsv播放器。默认2。
+     */
+    playerType: { type: Number, default: 2 },
+    /**
+     * 属性，int类型，播放器解码方式。0：根据硬件能力自动匹配；1:硬解码；2:软解码。默认0（根据芯片能力自动匹配）。
+     */
+    decodeType: { type: Number, default: 0 },
+    /**
+     * 属性，Boolean类型，层级关系，true表示在界面的下面，false表示在界面上面，默认true。
+     */
+    background: { type: Boolean, default: true },
+    /**
+     * 属性，Boolean类型，true表示静音，默认false。
+     */
+    muted: { type: Boolean, default: false },
+    /**
+     * 属性，Boolean类型，true表示循环播放，默认false。
+     */
+    loop: { type: Boolean, default: false },
+    /**
+     * 属性，String类型，播放地址。
+     */
+    src: { type: String, default: "" },
+    /**
+     * 属性，Double类型，起播时间，0-duration。
+     */
+    currentTime: { type: Number, default: 0 },
+    /**
+     * 属性，Boolean类型，是否保留最后一帧，true保留，false不保留。
+     */
+    keepLastFrame: { type: Boolean, default: true },
+    /**
+     * 属性，String类型，视频显示比例，origin原始比例显示，full全屏显示，x:y按照指定比例显示。
+     */
+    videoAspectRatio: { type: String, default: "origin" },
+    /**
+     * 属性，JSON Object类型，色度抠像参数，包含color，colorDistance，edgeDistance，greenOffset四个参数，
+     * 参考格式：{color: 0x30FF30, colorDistance: 0.15, edgeDistance: 0.4, greenOffset: 0.05}
+     *          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。
+     * 目前只支持扣绿。
+     */
+    chromaKey: { type: Object, default: null },
+    /**
+     * 回调函数，播放结束时通过此回调接口通知。
+     */
+    onEnded: {
+      type: Function,
+      default: () => {
+        return {};
+      }
+    },
+    /**
+     * 回调函数，播放错误时通过此接口通知。
+     * @param {int} 错误类型，当前定义了四种错误。1是异常中断；2是网络错误；3是解码错误；4是格式不支持。
+     */
+    onError: {
+      type: Function,
+      default: () => {
+        return {};
+      }
+    },
+    // onAbort: {type: Function, default: ()=>{return{}}},
+    /**
+     * 回调函数，当正常播放时，每0.5秒上报一次，回调接口里会带上当前时间，也可以使用video对象的currentTime属性去获取当前时间。
+     * @param {Long} 当前播放时间，单位秒。
+     */
+    onTimeUpdate: {
+      type: Function,
+      default: () => {
+        return {};
+      }
+    },
+    /**
+     * 回调函数，开始加载，设置完播放地址后，上报此事件。
+     */
+    onLoadStart: {
+      type: Function,
+      default: () => {
+        return {};
+      }
+    },
+    /**
+     * 回调函数，开始正常播放，同一个播放地址仅触发一次。
+     */
+    onCanPlayThrough: {
+      type: Function,
+      default: () => {
+        return {};
+      }
+    },
+    /**
+     * 回调函数，正常下载，duration不变的情况下只触发一次。
+     */
+    onProgress: {
+      type: Function,
+      default: () => {
+        return {};
+      }
+    },
+    /**
+     * 回调函数，视频准备好后触发。
+     */
+    onLoadedMetaData: {
+      type: Function,
+      default: () => {
+        return {};
+      }
+    },
+    /**
+     * 回调函数，视频准备好后触发，这个时候可以正常seek。
+     */
+    onLoad: {
+      type: Function,
+      default: () => {
+        return {};
+      }
+    },
+    /**
+     * 回调函数，视频准备好后触发，这个时候可以获取duration。
+     */
+    onDurationChange: {
+      type: Function,
+      default: () => {
+        return {};
+      }
+    },
+    /**
+     * 回调函数，视频准备好后，seek（修改currentTime）会出发此事件。
+     */
+    onSeeking: {
+      type: Function,
+      default: () => {
+        return {};
+      }
+    },
+    /**
+     * 回调函数，seek完成后触发此事件。
+     */
+    onSeeked: {
+      type: Function,
+      default: () => {
+        return {};
+      }
+    },
+    /**
+     * 回调函数，缓冲时触发。
+     */
+    onStalled: {
+      type: Function,
+      default: () => {
+        return {};
+      }
+    },
+    /**
+     * 回调函数，正常播放后触发。
+     */
+    onPlaying: {
+      type: Function,
+      default: () => {
+        return {};
+      }
+    },
+    /**
+     * 回调函数，正常显示后触发此事件。
+     */
+    onCanPlay: {
+      type: Function,
+      default: () => {
+        return {};
+      }
+    },
+    /**
+     * 回调函数，音频失去焦点后触发此事件，可能会导致pause（点播）或者离开频道（直播）。
+     */
+    onAudioFocusLoss: {
+      type: Function,
+      default: () => {
+        return {};
+      }
+    },
+    /**
+     * 回调函数，音频获取焦点后触发此事件，可能会触发resume（点播）或者加入频道（直播）。
+     */
+    onAudioFocusGain: {
+      type: Function,
+      default: () => {
+        return {};
+      }
+    },
+    /**
+     * 回调函数，直播进入时移状态时，触发此事件。
+     */
+    onTimeShift: {
+      type: Function,
+      default: () => {
+        return {};
+      }
+    },
+    /**
+     * 回调函数，直播进入时移状态时，成功播放触发此事件。
+     */
+    onTimeShifted: {
+      type: Function,
+      default: () => {
+        return {};
+      }
+    },
+    /**
+     * 回调函数，时移回到直播状态，触发此事件。
+     */
+    onBackLive: {
+      type: Function,
+      default: () => {
+        return {};
+      }
+    },
+    /**
+     * 回调函数，时移回到直播状态时，成功播放触发此事件。
+     */
+    onBackLived: {
+      type: Function,
+      default: () => {
+        return {};
+      }
+    },
+    /**
+     * 属性，Object类型，设置窗口属性，同其他组件的style设置。
+     */
+    style: {
+      type: Object,
+      default: () => {
+        return {};
+      }
+    },
+    /**
+     * 属性，Boolean类型，活跃状态，当多个JsvPlayer组件指向一个video对象时，只能有一个处于活跃状态。
+     * 视频显示在活跃JsvPlayer设置的显示区域内，事件通知也只会送给活跃的JsvPlayer组件注册的回调函数。
+     */
+    active: { type: Boolean, default: true }
+  },
+  components: {},
+  watch: {
+    active(newValue) {
+      console.log("LudlDebug active newValue: " + newValue);
+      if (this.video) {
+        if (newValue) {
+          this.registerEvent();
+          this.video.setHoleID(this.holeId);
+          this.holeStyle = {
+            left: 0,
+            top: 0,
+            width: this.style.width,
+            height: this.style.height
+          };
+        } else {
+          this.holeStyle = {
+            left: 0,
+            top: 0,
+            width: 0,
+            height: 0
+          };
+        }
+      }
+    },
+    style(newValue) {
+      logDebug(
+        "holeStyle newValue: left=" + newValue.left + ", top=" + newValue.top + ", width=" + newValue.width + ", height=" + newValue.height
+      );
+      if (this.active) {
+        this.holeStyle = {
+          left: 0,
+          top: 0,
+          width: newValue.width,
+          height: newValue.height
+        };
+      }
+    },
+    keepLastFrame(newValue) {
+      logDebug("keepLastFrame newValue: " + newValue);
+      if (this.video && this.active) {
+        this.video.keepLastFrame = this.keepLastFrame;
+      }
+    }
+  },
+  setup() {
+    return {
+      video: null,
+      holeId: "",
+      jsvMainView: shallowRef(null),
+      innerViewId: shallowRef(-1)
+    };
+  },
+  data() {
+    return {
+      holeStyle: {}
+    };
+  },
+  created() {
+  },
+  mounted() {
+    logDebug("JsvPlayer:", this.style);
+    let key = "Jsv_" + Math.floor(Math.random() * 1e4);
+    if (this.playerKey) {
+      key = this.playerKey;
+    }
+    logDebug("player key:" + key);
+    if (this.playerType)
+      this.playerType;
+    let background = true;
+    if (!this.background)
+      background = this.background;
+    logDebug("JsvPlayer background:" + background);
+    window.Forge.DesignMap();
+    logDebug("JsvPlayer:", this.holeId);
+    let first_create = true;
+    if (!this.video) {
+      this.video = window.originDocument.createElement("video");
+      this._extendsApi(this.video);
+    } else {
+      this.video.setRef();
+      first_create = false;
+    }
+    if (this.video != null) {
+      if (this.active) {
+        this.registerEvent();
+        if (this.src && this.src !== "")
+          this.video.src = this.src;
+        if (this.currentTime !== 0)
+          this.video.currentTime = this.currentTime;
+        if (this.autoplay) {
+          this.video.autoplay = this.autoplay;
+        }
+        if (this.muted) {
+          this.video.muted = this.muted;
+        }
+        if (this.loop) {
+          this.video.loop = this.loop;
+        }
+        if (!this.keepLastFrame) {
+          this.video.keepLastFrame = this.keepLastFrame;
+        }
+        if (this.videoAspectRatio !== "origin") {
+          this.video.videoAspectRatio = this.videoAspectRatio;
+        }
+        if (this.chromaKey && this.chromaKey !== "") {
+          this.video.setChromaKey(this.chromaKey);
+        }
+        if (!first_create) {
+          this.video.setHoleID(this.holeId);
+          this.holeStyle = {
+            left: 0,
+            top: 0,
+            width: this.style.width,
+            height: this.style.height
+          };
+        }
+      }
+      this.jsvMainView = new Forge.VideoView(this.video, null);
+      this.innerViewId = Forge.sViewStore.add(
+        new Forge.ViewInfo(this.jsvMainView)
+      );
+      this.onRef?.(this.video);
+    }
+  },
+  unmounted() {
+    if (this.video != null) {
+      if (this.innerViewId !== -1) {
+        Forge.sViewStore.remove(this.innerViewId);
+        this.innerViewId = -1;
+        this.jsvMainView = null;
+      }
+      this.onRef?.(null);
+    }
+  },
+  methods: {
+    getHoleId(id) {
+      logDebug("getHoleId:", id);
+      this.holeId = id;
+    },
+    registerEvent() {
+      if (this.video && this.active) {
+        this.video.addEventListener("end", this.onEnded);
+        this.video.addEventListener("error", this.onError);
+        this.video.addEventListener("timeupdate", this.onTimeUpdate);
+        this.video.addEventListener("loadstart", () => {
+          logDebug("JsvPlayer received loadstart event.");
+          this.holeStyle = {
+            left: 0,
+            top: 0,
+            width: this.style.width,
+            height: this.style.height
+          };
+          this.onLoadStart();
+        });
+        this.video.addEventListener("canplaythrough", this.onCanPlayThrough);
+        this.video.addEventListener("progress", this.onProgress);
+        this.video.addEventListener("loadedmetadata", this.onLoadedMetaData);
+        this.video.addEventListener("load", this.onLoad);
+        this.video.addEventListener("durationchange", this.onDurationChange);
+        this.video.addEventListener("seeking", this.onSeeking);
+        this.video.addEventListener("seeked", this.onSeeked);
+        this.video.addEventListener("stalled", this.onStalled);
+        this.video.addEventListener("playing", this.onPlaying);
+        this.video.addEventListener("canplay", this.onCanPlay);
+        this.video.addEventListener("audiofocusloss", this.onAudioFocusLoss);
+        this.video.addEventListener("audiofocusgain", this.onAudioFocusGain);
+        this.video.addEventListener("timeshift", this.onTimeShift);
+        this.video.addEventListener("timeshifted", this.onTimeShifted);
+        this.video.addEventListener("backlive", this.onBackLive);
+        this.video.addEventListener("backlived", this.onBackLived);
+      }
+    },
+    _extendsApi(videoRef) {
+      for (let method_name in methods) {
+        videoRef[method_name] = methods[method_name].bind(videoRef);
+      }
+    }
+  }
+};
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  return openBlock(), createElementBlock("div", {
+    style: normalizeStyle($data.holeStyle),
+    backgroundColor: "rgba(0,0,0,1)"
+  }, [
+    createBaseVNode("div", {
+      style: normalizeStyle({
+        left: $data.holeStyle.left,
+        top: $data.holeStyle.top,
+        width: $data.holeStyle.width,
+        height: $data.holeStyle.height
+      }),
+      "data-jsv-vw-innerview": $setup.innerViewId
+    }, null, 12, ["data-jsv-vw-innerview"])
+  ], 4);
+}
+const BrowserJsvPlayer = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+export {
+  BrowserJsvPlayer as default
+};
+//# sourceMappingURL=http://localhost:57245/map/BrowserJsvPlayer.vue.8615ee65.js.map
+
+/*jsvmd5:fdee8926a04f0180b7f7c6e83050915a*/

package/template-vue-vite/dist-test-jsview-chunk/js/BrowserPreload.fe21457d.js

@@ -0,0 +1,139 @@
+import { r as reactive, B as watchEffect, E as onBeforeUnmount, o as openBlock, e as createElementBlock, q as createCommentVNode } from "./vue.889a9b8b.js";
+const _sfc_main = {
+  __name: "BrowserPreload",
+  props: {
+    preloadList: Array,
+    downloadList: Array,
+    onPreloadDone: Function,
+    // 预加载完成回调
+    onDownloadDone: Function,
+    // 预下载完成回调
+    onPreloading: Function
+  },
+  setup(__props) {
+    const props = __props;
+    const loadViewList = reactive({
+      preloadViewList: [],
+      downloadViewList: []
+    });
+    let preloadIsNullNum = 0;
+    let downloadIsNullNum = 0;
+    let preloadResultMap = {};
+    let downloadResultMap = {};
+    let downloadUrlList = [];
+    let unmountStatus = { unmount: false };
+    let preloadStateList = null;
+    let downloadStateList = null;
+    const getPreloadList = () => {
+      preloadStateList = new Array(props.preloadList.length).fill(false);
+      let preloadListData = props.preloadList;
+      for (let i = 0; i < preloadListData.length; i++) {
+        if (!preloadListData[i] || !preloadListData[i].url) {
+          preloadListData.splice(i, 1);
+          preloadIsNullNum++;
+          i--;
+        }
+      }
+      loadViewList.preloadViewList = preloadListData.map((item, index) => {
+        if (!item || !item.url) {
+          preloadStateList[index] = true;
+          return null;
+        }
+        const image = new Image();
+        const unmount_track = unmountStatus;
+        image.onload = () => {
+          if (unmount_track.unmount) {
+            return;
+          }
+          preloadResultMap[item.url] = {
+            width: image.width,
+            height: image.height
+          };
+          preloadStateList[index] = true;
+          let loadedNum = 0;
+          preloadStateList.map((item2) => {
+            loadedNum += item2 ? 1 : 0;
+          });
+          props.onPreloading?.(loadedNum / preloadStateList.length);
+          if (props.onPreloadDone && loadedNum + preloadIsNullNum == preloadStateList.length) {
+            props.onPreloadDone?.(preloadResultMap);
+          }
+        };
+        image.src = item.url;
+      });
+    };
+    const getDownloadList = () => {
+      downloadStateList = new Array(props.downloadList.length).fill(false);
+      downloadUrlList = new Array(downloadStateList.length);
+      let downloadListData = props.downloadList;
+      for (let i = 0; i < downloadListData.length; i++) {
+        if (!downloadListData[i] || !downloadListData[i].url) {
+          downloadListData.splice(i, 1);
+          downloadUrlList[i] = "invalid";
+          downloadIsNullNum++;
+          i--;
+        }
+      }
+      loadViewList.downloadViewList = downloadListData.map((item, index) => {
+        if (!item || !item.url) {
+          downloadStateList[index] = true;
+          downloadUrlList[index] = "invalid";
+          return null;
+        }
+        const image = new Image();
+        const unmount_track = unmountStatus;
+        image.onload = () => {
+          if (unmount_track.unmount) {
+            return;
+          }
+          downloadStateList[index] = true;
+          downloadUrlList[index] = item.url;
+          downloadResultMap[item.url] = {
+            width: image.width,
+            height: image.height
+          };
+          console.log(`pre download succeed ${item.url}`);
+          if (props.onDownloadDone) {
+            let downloadNum = 0;
+            downloadStateList.map((item2) => {
+              downloadNum += item2 ? 1 : 0;
+            });
+            if (downloadNum + downloadIsNullNum == downloadStateList.length) {
+              props.onDownloadDone?.(downloadUrlList, downloadResultMap);
+            }
+          }
+        };
+        image.src = item.url;
+      });
+    };
+    watchEffect(() => {
+      if (props.preloadList) {
+        console.log("JsvPreload: update preloadList");
+        preloadIsNullNum = 0;
+        preloadResultMap = {};
+        getPreloadList();
+      }
+    });
+    watchEffect(() => {
+      if (props.downloadList) {
+        console.log("JsvPreload: update downloadList");
+        downloadIsNullNum = 0;
+        downloadResultMap = {};
+        downloadUrlList = [];
+        getDownloadList();
+      }
+    });
+    onBeforeUnmount(() => {
+      unmountStatus.unmount = true;
+    });
+    return (_ctx, _cache) => {
+      return !__props.preloadList ? (openBlock(), createElementBlock("div", { key: 0 })) : createCommentVNode("", true);
+    };
+  }
+};
+export {
+  _sfc_main as default
+};
+//# sourceMappingURL=http://localhost:57245/map/BrowserPreload.fe21457d.js.map
+
+/*jsvmd5:434a8b788cccef031709c37226ae2e68*/