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.    * @return {boolean} True if this changed the state
  44.    */
  45.   update(state) {
  46.     // |open_| will only be |null| when we first call |update|.
  47.     if (this.open_ == null) {
  48.       this.start_(state);
  49.       return true;
  50.     } else {
  51.       return this.update_(state);
  52.     }
  53.   }
  55.   /**
  56.    * Go through all entries in the history and count how much time was spend in
  57.    * the given state.
  58.    *
  59.    * @param {string} state
  60.    * @return {number}
  61.    */
  62.   getTimeSpentIn(state) {
  63.     let sum = 0;
  65.     if (this.open_ && this.open_.state == state) {
  66.       sum += this.open_.duration;
  67.     }
  69.     for (const entry of this.closed_) {
  70.       sum += entry.state == state ? entry.duration : 0;
  71.     }
  73.     return sum;
  74.   }
  76.   /**
  77.    * Get a copy of each state change entry in the history. A copy of each entry
  78.    * is created to break the reference to the internal data.
  79.    *
  80.    * @return {!Array.<shaka.extern.StateChange>}
  81.    */
  82.   getCopy() {
  83.     const clone = (entry) => {
  84.       return {
  85.         timestamp: entry.timestamp,
  86.         state: entry.state,
  87.         duration: entry.duration,
  88.       };
  89.     };
  91.     const copy = [];
  92.     for (const entry of this.closed_) {
  93.       copy.push(clone(entry));
  94.     }
  95.     if (this.open_) {
  96.       copy.push(clone(this.open_));
  97.     }
  99.     return copy;
  100.   }
  102.   /**
  103.    * @param {string} state
  104.    * @private
  105.    */
  106.   start_(state) {
  107.     goog.asserts.assert(
  108.         this.open_ == null,
  109.         'There must be no open entry in order when we start');
  110.     shaka.log.v1('Changing Player state to', state);
  112.     this.open_ = {
  113.       timestamp: this.getNowInSeconds_(),
  114.       state: state,
  115.       duration: 0,
  116.     };
  117.   }
  119.   /**
  120.    * @param {string} state
  121.    * @return {boolean} True if this changed the state
  122.    * @private
  123.    */
  124.   update_(state) {
  125.     goog.asserts.assert(
  126.         this.open_,
  127.         'There must be an open entry in order to update it');
  129.     const currentTimeSeconds = this.getNowInSeconds_();
  131.     // Always update the duration so that it can always be as accurate as
  132.     // possible.
  133.     this.open_.duration = currentTimeSeconds - this.open_.timestamp;
  135.     // If the state has not changed, there is no need to add a new entry.
  136.     if (this.open_.state == state) {
  137.       return false;
  138.     }
  140.     // We have changed states, so "close" the open state.
  141.     shaka.log.v1('Changing Player state to', state);
  142.     this.closed_.push(this.open_);
  143.     this.open_ = {
  144.       timestamp: currentTimeSeconds,
  145.       state: state,
  146.       duration: 0,
  147.     };
  148.     return true;
  149.   }
  151.   /**
  152.    * Get the system time in seconds.
  153.    *
  154.    * @return {number}
  155.    * @private
  156.    */
  157.   getNowInSeconds_() {
  158.     return Date.now() / 1000;
  159.   }
  160. };