Source: lib/util/timer.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.util.Timer');
  9. goog.require('shaka.util.DelayedTick');
  12. /**
  13.  * A timer allows a single function to be executed at a later time or at
  14.  * regular intervals.
  15.  *
  16.  * @final
  17.  * @export
  18.  */
  19. shaka.util.Timer = class {
  20.   /**
  21.    * Create a new timer. A timer is committed to a single callback function.
  22.    * While there is no technical reason to do this, it is far easier to
  23.    * understand and use timers when they are connected to one functional idea.
  24.    *
  25.    * @param {function()} onTick
  26.    */
  27.   constructor(onTick) {
  28.     /**
  29.      * Each time our timer "does work", we call that a "tick". The name comes
  30.      * from old analog clocks.
  31.      *
  32.      * @private {function()}
  33.      */
  34.     this.onTick_ = onTick;
  36.     /** @private {shaka.util.DelayedTick} */
  37.     this.ticker_ = null;
  38.   }
  40.   /**
  41.    * Have the timer call |onTick| now.
  42.    *
  43.    * @return {!shaka.util.Timer}
  44.    * @export
  45.    */
  46.   tickNow() {
  47.     this.stop();
  48.     this.onTick_();
  50.     return this;
  51.   }
  53.   /**
  54.    * Have the timer call |onTick| after |seconds| has elapsed unless |stop| is
  55.    * called first.
  56.    *
  57.    * @param {number} seconds
  58.    * @return {!shaka.util.Timer}
  59.    * @export
  60.    */
  61.   tickAfter(seconds) {
  62.     this.stop();
  64.     this.ticker_ = new shaka.util.DelayedTick(() => {
  65.       this.onTick_();
  66.     }).tickAfter(seconds);
  68.     return this;
  69.   }
  71.   /**
  72.    * Have the timer call |onTick| every |seconds| until |stop| is called.
  73.    *
  74.    * @param {number} seconds
  75.    * @return {!shaka.util.Timer}
  76.    * @export
  77.    */
  78.   tickEvery(seconds) {
  79.     this.stop();
  81.     if (goog.DEBUG) {
  82.       // Capture the stack trace by making a fake error.
  83.       const stackTrace = Error('Timer created').stack;
  84.       shaka.util.Timer.activeTimers.set(this, stackTrace);
  85.     }
  86.     this.ticker_ = new shaka.util.DelayedTick(() => {
  87.       // Schedule the timer again first. |onTick_| could cancel the timer and
  88.       // rescheduling first simplifies the implementation.
  89.       this.ticker_.tickAfter(seconds);
  90.       this.onTick_();
  91.     }).tickAfter(seconds);
  93.     return this;
  94.   }
  96.   /**
  97.    * Stop the timer and clear the previous behaviour. The timer is still usable
  98.    * after calling |stop|.
  99.    *
  100.    * @export
  101.    */
  102.   stop() {
  103.     if (this.ticker_) {
  104.       this.ticker_.stop();
  105.       this.ticker_ = null;
  106.     }
  107.     if (goog.DEBUG) {
  108.       shaka.util.Timer.activeTimers.delete(this);
  109.     }
  110.   }
  111. };
  113. if (goog.DEBUG) {
  114.   /**
  115.    * Tracks all active timer instances, along with the stack trace that created
  116.    * that timer.
  117.    * @type {!Map.<!shaka.util.Timer, string>}
  118.    */
  119.   shaka.util.Timer.activeTimers = new Map();
  120. }