Source: lib/text/native_text_displayer.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. /**
  8.  * @fileoverview
  9.  */
  11. goog.provide('shaka.text.NativeTextDisplayer');
  13. goog.require('mozilla.LanguageMapping');
  14. goog.require('shaka.device.DeviceFactory');
  15. goog.require('shaka.device.IDevice');
  16. goog.require('shaka.text.Utils');
  17. goog.require('shaka.util.EventManager');
  18. goog.require('shaka.util.FakeEvent');
  19. goog.require('shaka.util.LanguageUtils');
  20. goog.require('shaka.util.Timer');
  21. goog.requireType('shaka.Player');
  23. /**
  24.  * A text displayer plugin using the browser's native VTTCue interface.
  25.  *
  26.  * @implements {shaka.extern.TextDisplayer}
  27.  * @export
  28.  */
  29. shaka.text.NativeTextDisplayer = class {
  30.   /**
  31.    * @param {shaka.Player} player
  32.    */
  33.   constructor(player) {
  34.     /** @private {?shaka.Player} */
  35.     this.player_ = player;
  37.     /** @private {shaka.util.EventManager} */
  38.     this.eventManager_ = new shaka.util.EventManager();
  40.     /** @private {?HTMLMediaElement} */
  41.     this.video_ = null;
  43.     /** @private {Map<number, !HTMLTrackElement>} */
  44.     this.trackNodes_ = new Map();
  46.     /** @private {number} */
  47.     this.trackId_ = -1;
  49.     /** @private {boolean} */
  50.     this.visible_ = false;
  52.     /** @private {?shaka.util.Timer} */
  53.     this.timer_ = null;
  55.     /** @private */
  56.     this.onUnloading_ = () => {
  57.       this.eventManager_.unlisten(this.player_,
  58.           shaka.util.FakeEvent.EventName.TextChanged, this.onTextChanged_);
  59.       this.eventManager_.unlisten(this.video_.textTracks, 'change',
  60.           this.onChange_);
  61.       for (const trackNode of this.trackNodes_.values()) {
  62.         trackNode.remove();
  63.       }
  64.       this.trackNodes_.clear();
  65.       this.trackId_ = -1;
  66.       this.video_ = null;
  67.     };
  69.     /** @private */
  70.     this.onTextChanged_ = () => {
  71.       /** @type {Map<number, !HTMLTrackElement>} */
  72.       const newTrackNodes = new Map();
  73.       const tracks = this.player_.getTextTracks();
  74.       for (const track of tracks) {
  75.         let trackNode;
  76.         if (this.trackNodes_.has(track.id)) {
  77.           trackNode = this.trackNodes_.get(track.id);
  78.           if (!track.active && trackNode.track.mode !== 'disabled') {
  79.             trackNode.track.mode = 'disabled';
  80.           }
  81.           this.trackNodes_.delete(track.id);
  82.         } else {
  83.           trackNode = /** @type {!HTMLTrackElement} */
  84.             (this.video_.ownerDocument.createElement('track'));
  85.           trackNode.kind = shaka.text.NativeTextDisplayer.getTrackKind_(track);
  86.           trackNode.label =
  87.             shaka.text.NativeTextDisplayer.getTrackLabel_(track);
  88.           if (track.language in mozilla.LanguageMapping) {
  89.             trackNode.srclang = track.language;
  90.           }
  91.           // The built-in captions menu in Chrome may refuse to list invalid
  92.           // subtitles.
  93.           // In Safari, when a TextTrack's mode is set to "disabled" or "hidden"
  94.           // and then "showing" again causes a blink if there is no src.
  95.           // The data URL is just to avoid this.
  96.           trackNode.src = 'data:,WEBVTT';
  97.           trackNode.track.mode = 'disabled';
  98.           this.video_.appendChild(trackNode);
  99.         }
  100.         newTrackNodes.set(track.id, trackNode);
  101.         if (track.active) {
  102.           this.trackId_ = track.id;
  103.         }
  104.       }
  105.       // Remove all tracks that are not in the new list.
  106.       for (const trackNode of this.trackNodes_.values()) {
  107.         trackNode.remove();
  108.       }
  109.       if (this.trackId_ > -1) {
  110.         if (!newTrackNodes.has(this.trackId_)) {
  111.           this.trackId_ = -1;
  112.         } else {
  113.           // enable current track after everything else is settled
  114.           const track = newTrackNodes.get(this.trackId_).track;
  115.           // Ignore if the mode is not disabled. Maybe the user has changed the
  116.           // mode manually. In that case, visible_ will be updated in onChange_
  117.           if (track.mode === 'disabled') {
  118.             track.mode = this.visible_ ? 'showing' : 'hidden';
  119.           }
  120.         }
  121.       }
  122.       this.trackNodes_ = newTrackNodes;
  123.     };
  125.     /** @private */
  126.     this.onChange_ = () => {
  127.       // The change event may fire multiple times consecutively. So we need to
  128.       // use a timer to ensure the real task runs only once.
  129.       if (this.timer_) {
  130.         return;
  131.       }
  132.       const video = this.video_;
  133.       this.timer_ = new shaka.util.Timer(() => {
  134.         this.timer_ = null;
  135.         if (this.video_ !== video) {
  136.           return;
  137.         }
  138.         let trackId = -1;
  139.         let found = false;
  140.         // Prefer previously selected track.
  141.         if (this.trackNodes_.has(this.trackId_)) {
  142.           const trackNode = this.trackNodes_.get(this.trackId_);
  143.           if (trackNode.track.mode === 'showing') {
  144.             trackId = this.trackId_;
  145.             found = true;
  146.           } else if (trackNode.track.mode === 'hidden') {
  147.             trackId = this.trackId_;
  148.           }
  149.         }
  150.         if (!found) {
  151.           for (const [
  152.             /** @type {number} */id,
  153.             /** @type {HTMLTrackElement} */trackNode,
  154.           ] of /** @type {!Map} */(this.trackNodes_)) {
  155.             if (trackNode.track.mode === 'showing') {
  156.               trackId = id;
  157.               break;
  158.             } else if (trackId < 0 && trackNode.track.mode === 'hidden') {
  159.               // If there is no showing track, we can use the hidden track
  160.               trackId = id;
  161.             }
  162.           }
  163.         }
  164.         for (const [
  165.           /** @type {number} */id,
  166.           /** @type {HTMLTrackElement} */trackNode,
  167.         ] of /** @type {!Map} */(this.trackNodes_)) {
  168.           // Avoid triggering unnecessary change events.
  169.           if (id !== trackId && trackNode.track.mode !== 'disabled') {
  170.             trackNode.track.mode = 'disabled';
  171.           }
  172.         }
  173.         if (this.trackId_ !== trackId) {
  174.           this.trackId_ = trackId;
  175.           if (trackId > -1) {
  176.             this.player_.selectTextTrack(
  177.                 /** @type {!shaka.extern.TextTrack} */({id: trackId}));
  178.           }
  179.         }
  180.         // The selectTextTrack() method does not accept null as parameter.
  181.         // So we need to use setTextTrackVisibility() if no track selected.
  182.         this.player_.setTextTrackVisibility(trackId > -1 &&
  183.             this.trackNodes_.get(trackId).track.mode === 'showing');
  184.       }).tickAfter(0);
  185.     };
  187.     this.eventManager_.listen(player, shaka.util.FakeEvent.EventName.Loaded,
  188.         () => this.enableTextDisplayer());
  190.     this.enableTextDisplayer();
  191.   }
  193.   /**
  194.    * @override
  195.    * @export
  196.    */
  197.   configure(config) {
  198.     // unused
  199.   }
  201.   /**
  202.    * @override
  203.    * @export
  204.    */
  205.   remove(start, end) {
  206.     // Should return false only if this instance is destroyed
  207.     if (!this.player_) {
  208.       return false;
  209.     } else if (this.trackNodes_.has(this.trackId_)) {
  210.       shaka.text.Utils.removeCuesFromTextTrack(
  211.           this.trackNodes_.get(this.trackId_).track,
  212.           (cue) => cue.startTime < end && cue.endTime > start);
  213.     }
  215.     return true;
  216.   }
  218.   /**
  219.    * @override
  220.    * @export
  221.    */
  222.   append(cues) {
  223.     if (this.trackNodes_.has(this.trackId_)) {
  224.       shaka.text.Utils.appendCuesToTextTrack(
  225.           this.trackNodes_.get(this.trackId_).track, cues);
  226.     }
  227.   }
  229.   /**
  230.    * @override
  231.    * @export
  232.    */
  233.   destroy() {
  234.     if (this.player_) {
  235.       if (this.video_) {
  236.         this.onUnloading_();
  237.       }
  238.       this.player_ = null;
  239.     }
  240.     if (this.eventManager_) {
  241.       this.eventManager_.release();
  242.       this.eventManager_ = null;
  243.     }
  244.     return Promise.resolve();
  245.   }
  247.   /**
  248.    * @override
  249.    * @export
  250.    */
  251.   isTextVisible() {
  252.     return this.visible_;
  253.   }
  255.   /**
  256.    * @override
  257.    * @export
  258.    */
  259.   setTextVisibility(on) {
  260.     this.visible_ = on;
  261.     if (this.trackNodes_.has(this.trackId_)) {
  262.       const textTrack = this.trackNodes_.get(this.trackId_).track;
  263.       if (textTrack.mode !== 'disabled') {
  264.         const mode = on ? 'showing' : 'hidden';
  265.         if (textTrack.mode !== mode) {
  266.           textTrack.mode = mode;
  267.         }
  268.       }
  269.     } else if (this.player_ && this.player_.getLoadMode() === 3) {
  270.       // shaka.Player.LoadMode.SRC_EQUALS
  271.       const textTracks = Array.from(this.player_.getMediaElement().textTracks)
  272.           .filter((track) =>
  273.             ['captions', 'subtitles', 'forced'].includes(track.kind));
  274.       if (on) {
  275.         let toShow = null;
  276.         for (const track of textTracks) {
  277.           if (track.mode === 'showing') {
  278.             // One showing track is just enough.
  279.             toShow = null;
  280.             break;
  281.           } else if (!toShow && track.mode === 'hidden') {
  282.             toShow = track;
  283.           }
  284.         }
  285.         if (toShow) {
  286.           toShow.mode = 'showing';
  287.         }
  288.       } else {
  289.         for (const track of textTracks) {
  290.           if (track.mode === 'showing') {
  291.             track.mode = 'hidden';
  292.           }
  293.         }
  294.       }
  295.     }
  296.   }
  298.   /**
  299.    * @override
  300.    * @export
  301.    */
  302.   setTextLanguage(language) {
  303.     // unused
  304.   }
  306.   /**
  307.    * @override
  308.    * @export
  309.    */
  310.   enableTextDisplayer() {
  311.     // shaka.Player.LoadMode.MEDIA_SOURCE
  312.     if (!this.video_ && this.player_ && this.player_.getLoadMode() === 2) {
  313.       this.video_ = this.player_.getMediaElement();
  314.       this.eventManager_.listenOnce(this.player_,
  315.           shaka.util.FakeEvent.EventName.Unloading, this.onUnloading_);
  316.       this.eventManager_.listen(this.player_,
  317.           shaka.util.FakeEvent.EventName.TextChanged, this.onTextChanged_);
  318.       this.eventManager_.listen(this.video_.textTracks, 'change',
  319.           this.onChange_);
  320.       this.onTextChanged_();
  321.     }
  322.   }
  324.   /**
  325.    * @param {!shaka.extern.TextTrack} track
  326.    * @return {string}
  327.    * @private
  328.    */
  329.   static getTrackKind_(track) {
  330.     const device = shaka.device.DeviceFactory.getDevice();
  331.     if (track.forced && device.getBrowserEngine() ===
  332.         shaka.device.IDevice.BrowserEngine.WEBKIT) {
  333.       return 'forced';
  334.     } else if (
  335.       track.kind === 'caption' || (
  336.         track.roles &&
  337.         track.roles.some(
  338.             (role) => role.includes('transcribes-spoken-dialog')) &&
  339.         track.roles.some(
  340.             (role) => role.includes('describes-music-and-sound'))
  341.       )
  342.     ) {
  343.       return 'captions';
  344.     }
  346.     return 'subtitles';
  347.   }
  349.   /**
  350.    * @param {!shaka.extern.TextTrack} track
  351.    * @return {string}
  352.    * @private
  353.    */
  354.   static getTrackLabel_(track) {
  355.     /** @type {string} */
  356.     let label;
  357.     if (track.label) {
  358.       label = track.label;
  359.     } else if (track.language) {
  360.       if (track.language in mozilla.LanguageMapping) {
  361.         label = mozilla.LanguageMapping[track.language];
  362.       } else {
  363.         const language = shaka.util.LanguageUtils.getBase(track.language);
  364.         if (language in mozilla.LanguageMapping) {
  365.           label =
  366.             `${mozilla.LanguageMapping[language]} (${track.language})`;
  367.         }
  368.       }
  369.     }
  370.     if (!label) {
  371.       label = /** @type {string} */(track.originalTextId);
  372.       if (track.language && track.language !== track.originalTextId) {
  373.         label += ` (${track.language})`;
  374.       }
  375.     }
  377.     return label;
  378.   }
  379. };