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.IReleasable');
  11. goog.require('shaka.util.Timer');
  14. /**
  15.  * A playhead observer is a system that watches for meaningful changes in state
  16.  * that are dependent on playhead information. The observer is responsible for
  17.  * managing its own listeners.
  18.  *
  19.  * @extends {shaka.util.IReleasable}
  20.  * @interface
  21.  */
  22. shaka.media.IPlayheadObserver = class {
  23.   /**
  24.    * Check again (using an update playhead summary) if an event should be fired.
  25.    * If an event should be fired, fire it.
  26.    *
  27.    * @param {number} positionInSeconds
  28.    * @param {boolean} wasSeeking
  29.    */
  30.   poll(positionInSeconds, wasSeeking) {}
  31. };
  34. /**
  35.  * The playhead observer manager is responsible for owning playhead observer
  36.  * instances and polling them when needed. Destroying the manager will destroy
  37.  * all observers managed by the manager.
  38.  *
  39.  * @implements {shaka.util.IReleasable}
  40.  * @final
  41.  */
  42. shaka.media.PlayheadObserverManager = class {
  43.   /**
  44.    * @param {!HTMLMediaElement} mediaElement
  45.    */
  46.   constructor(mediaElement) {
  47.     /** @private {HTMLMediaElement} */
  48.     this.mediaElement_ = mediaElement;
  50.     /**
  51.      * The set of all observers that this manager is responsible for updating.
  52.      * We are using a set to ensure that we don't double update an observer if
  53.      * it is accidentally added twice.
  54.      *
  55.      * @private {!Set.<shaka.media.IPlayheadObserver>}
  56.      */
  57.     this.observers_ = new Set();
  59.     /**
  60.      * To fire events semi-accurately, poll the observers 4 times a second. This
  61.      * should be frequent enough to trigger an event close enough to its actual
  62.      * occurrence without the user noticing a delay.
  63.      *
  64.      * @private {shaka.util.Timer}
  65.      */
  66.     this.pollingLoop_ = new shaka.util.Timer(() => {
  67.       this.pollAllObservers_(/* seeking= */ false);
  68.     }).tickEvery(/* seconds= */ 0.25);
  69.   }
  71.   /** @override */
  72.   release() {
  73.     // We need to stop the loop or else we may try to use a released resource.
  74.     this.pollingLoop_.stop();
  76.     for (const observer of this.observers_) {
  77.       observer.release();
  78.     }
  80.     this.observers_.clear();
  81.   }
  83.   /**
  84.    * Have the playhead observer manager manage a new observer. This will ensure
  85.    * that observers are only tracked once within the manager. After this call,
  86.    * the manager will be responsible for the life cycle of |observer|.
  87.    *
  88.    * @param {!shaka.media.IPlayheadObserver} observer
  89.    */
  90.   manage(observer) {
  91.     this.observers_.add(observer);
  92.   }
  94.   /**
  95.    * Notify all the observers that we just seeked.
  96.    */
  97.   notifyOfSeek() {
  98.     this.pollAllObservers_(/* seeking= */ true);
  99.   }
  101.   /**
  102.    * @param {boolean} seeking
  103.    * @private
  104.    */
  105.   pollAllObservers_(seeking) {
  106.     for (const observer of this.observers_) {
  107.       observer.poll(
  108.           this.mediaElement_.currentTime,
  109.           seeking);
  110.     }
  111.   }
  112. };