Source: lib/util/state_history.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.util.StateHistory');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.log');
  13. /**
  14.  * This class is used to track the time spent in arbitrary states. When told of
  15.  * a state, it will assume that state was active until a new state is provided.
  16.  * When provided with identical states back-to-back, the existing entry will be
  17.  * updated.
  18.  *
  19.  * @final
  20.  */
  21. shaka.util.StateHistory = class {
  22.   /** */
  23.   constructor() {
  24.     /**
  25.      * The state that we think is still the current change. It is "open" for
  26.      * updating.
  27.      *
  28.      * @private {?shaka.extern.StateChange}
  29.      */
  30.     this.open_ = null;
  32.     /**
  33.      * The stats that are "closed" for updating. The "open" state becomes closed
  34.      * once we move to a new state.
  35.      *
  36.      * @private {!Array.<shaka.extern.StateChange>}
  37.      */
  38.     this.closed_ = [];
  39.   }
  41.   /**
  42.    * @param {string} state
  43.    */
  44.   update(state) {
  45.     // |open_| will only be |null| when we first call |update|.
  46.     if (this.open_ == null) {
  47.       this.start_(state);
  48.     } else {
  49.       this.update_(state);
  50.     }
  51.   }
  53.   /**
  54.    * Go through all entries in the history and count how much time was spend in
  55.    * the given state.
  56.    *
  57.    * @param {string} state
  58.    * @return {number}
  59.    */
  60.   getTimeSpentIn(state) {
  61.     let sum = 0;
  63.     if (this.open_ && this.open_.state == state) {
  64.       sum += this.open_.duration;
  65.     }
  67.     for (const entry of this.closed_) {
  68.       sum += entry.state == state ? entry.duration : 0;
  69.     }
  71.     return sum;
  72.   }
  74.   /**
  75.    * Get a copy of each state change entry in the history. A copy of each entry
  76.    * is created to break the reference to the internal data.
  77.    *
  78.    * @return {!Array.<shaka.extern.StateChange>}
  79.    */
  80.   getCopy() {
  81.     const clone = (entry) => {
  82.       return {
  83.         timestamp: entry.timestamp,
  84.         state: entry.state,
  85.         duration: entry.duration,
  86.       };
  87.     };
  89.     const copy = [];
  90.     for (const entry of this.closed_) {
  91.       copy.push(clone(entry));
  92.     }
  93.     if (this.open_) {
  94.       copy.push(clone(this.open_));
  95.     }
  97.     return copy;
  98.   }
  100.   /**
  101.    * @param {string} state
  102.    * @private
  103.    */
  104.   start_(state) {
  105.     goog.asserts.assert(
  106.         this.open_ == null,
  107.         'There must be no open entry in order when we start');
  108.     shaka.log.v1('Changing Player state to', state);
  110.     this.open_ = {
  111.       timestamp: this.getNowInSeconds_(),
  112.       state: state,
  113.       duration: 0,
  114.     };
  115.   }
  117.   /**
  118.    * @param {string} state
  119.    * @private
  120.    */
  121.   update_(state) {
  122.     goog.asserts.assert(
  123.         this.open_,
  124.         'There must be an open entry in order to update it');
  126.     const currentTimeSeconds = this.getNowInSeconds_();
  128.     // Always update the duration so that it can always be as accurate as
  129.     // possible.
  130.     this.open_.duration = currentTimeSeconds - this.open_.timestamp;
  132.     // If the state has not changed, there is no need to add a new entry.
  133.     if (this.open_.state == state) {
  134.       return;
  135.     }
  137.     // We have changed states, so "close" the open state.
  138.     shaka.log.v1('Changing Player state to', state);
  139.     this.closed_.push(this.open_);
  140.     this.open_ = {
  141.       timestamp: currentTimeSeconds,
  142.       state: state,
  143.       duration: 0,
  144.     };
  145.   }
  147.   /**
  148.    * Get the system time in seconds.
  149.    *
  150.    * @return {number}
  151.    * @private
  152.    */
  153.   getNowInSeconds_() {
  154.     return Date.now() / 1000;
  155.   }
  156. };