Source: lib/media/playhead_observer.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.media.IPlayheadObserver');
  8. goog.provide('shaka.media.PlayheadObserverManager');
  10. goog.require('shaka.util.EventManager');
  11. goog.require('shaka.util.IReleasable');
  12. goog.require('shaka.util.Timer');
  15. /**
  16.  * A playhead observer is a system that watches for meaningful changes in state
  17.  * that are dependent on playhead information. The observer is responsible for
  18.  * managing its own listeners.
  19.  *
  20.  * @extends {shaka.util.IReleasable}
  21.  * @interface
  22.  */
  23. shaka.media.IPlayheadObserver = class {
  24.   /**
  25.    * Check again (using an update playhead summary) if an event should be fired.
  26.    * If an event should be fired, fire it.
  27.    *
  28.    * @param {number} positionInSeconds
  29.    * @param {boolean} wasSeeking
  30.    */
  31.   poll(positionInSeconds, wasSeeking) {}
  32. };
  35. /**
  36.  * The playhead observer manager is responsible for owning playhead observer
  37.  * instances and polling them when needed. Destroying the manager will destroy
  38.  * all observers managed by the manager.
  39.  *
  40.  * @implements {shaka.util.IReleasable}
  41.  * @final
  42.  */
  43. shaka.media.PlayheadObserverManager = class {
  44.   /**
  45.    * @param {!HTMLMediaElement} mediaElement
  46.    */
  47.   constructor(mediaElement) {
  48.     /** @private {HTMLMediaElement} */
  49.     this.mediaElement_ = mediaElement;
  51.     /** @private {shaka.util.EventManager} */
  52.     this.eventManager_ = new shaka.util.EventManager();
  54.     /**
  55.      * The set of all observers that this manager is responsible for updating.
  56.      * We are using a set to ensure that we don't double update an observer if
  57.      * it is accidentally added twice.
  58.      *
  59.      * @private {!Set<shaka.media.IPlayheadObserver>}
  60.      */
  61.     this.observers_ = new Set();
  63.     /**
  64.      * To fire events semi-accurately, poll the observers 4 times a second. This
  65.      * should be frequent enough to trigger an event close enough to its actual
  66.      * occurrence without the user noticing a delay.
  67.      *
  68.      * @private {shaka.util.Timer}
  69.      */
  70.     this.pollingLoop_ = new shaka.util.Timer(() => {
  71.       this.pollAllObservers_(/* seeking= */ false);
  72.     }).tickNow();
  74.     if (!mediaElement.paused) {
  75.       this.pollingLoop_.tickEvery(/* seconds= */ 0.25);
  76.     }
  78.     this.eventManager_.listen(mediaElement, 'playing', () => {
  79.       this.pollingLoop_.tickNow().tickEvery(/* seconds= */ 0.25);
  80.     });
  81.     this.eventManager_.listen(mediaElement, 'pause', () => {
  82.       this.pollingLoop_.stop();
  83.     });
  84.   }
  86.   /** @override */
  87.   release() {
  88.     if (this.eventManager_) {
  89.       this.eventManager_.release();
  90.       this.eventManager_ = null;
  91.     }
  93.     // We need to stop the loop or else we may try to use a released resource.
  94.     this.pollingLoop_.stop();
  96.     for (const observer of this.observers_) {
  97.       observer.release();
  98.     }
  100.     this.observers_.clear();
  101.   }
  103.   /**
  104.    * Have the playhead observer manager manage a new observer. This will ensure
  105.    * that observers are only tracked once within the manager. After this call,
  106.    * the manager will be responsible for the life cycle of |observer|.
  107.    *
  108.    * @param {!shaka.media.IPlayheadObserver} observer
  109.    */
  110.   manage(observer) {
  111.     this.observers_.add(observer);
  112.   }
  114.   /**
  115.    * Notify all the observers that we just seeked.
  116.    */
  117.   notifyOfSeek() {
  118.     this.pollAllObservers_(/* seeking= */ true);
  119.   }
  121.   /**
  122.    * @param {boolean} seeking
  123.    * @private
  124.    */
  125.   pollAllObservers_(seeking) {
  126.     const currentTime = this.mediaElement_.currentTime;
  127.     for (const observer of this.observers_) {
  128.       observer.poll(currentTime, seeking);
  129.     }
  130.   }
  131. };