Source: lib/util/fake_event_target.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.util.FakeEventTarget');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.log');
  11. goog.require('shaka.util.FakeEvent');
  12. goog.require('shaka.util.IReleasable');
  13. goog.require('shaka.util.MultiMap');
  16. /**
  17.  * @summary A work-alike for EventTarget.  Only DOM elements may be true
  18.  * EventTargets, but this can be used as a base class to provide event dispatch
  19.  * to non-DOM classes.  Only FakeEvents should be dispatched.
  20.  *
  21.  * @implements {EventTarget}
  22.  * @implements {shaka.util.IReleasable}
  23.  * @exportInterface
  24.  */
  25. shaka.util.FakeEventTarget = class {
  26.   /** */
  27.   constructor() {
  28.     /**
  29.      * @private {shaka.util.MultiMap<shaka.util.FakeEventTarget.ListenerType>}
  30.      */
  31.     this.listeners_ = new shaka.util.MultiMap();
  33.     /**
  34.      * The target of all dispatched events.  Defaults to |this|.
  35.      * @type {EventTarget}
  36.      */
  37.     this.dispatchTarget = this;
  38.   }
  40.   /**
  41.    * Add an event listener to this object.
  42.    *
  43.    * @param {string} type The event type to listen for.
  44.    * @param {shaka.util.FakeEventTarget.ListenerType} listener The callback or
  45.    *   listener object to invoke.
  46.    * @param {(!AddEventListenerOptions|boolean)=} options Ignored.
  47.    * @override
  48.    * @exportInterface
  49.    */
  50.   addEventListener(type, listener, options) {
  51.     if (!this.listeners_) {
  52.       return;
  53.     }
  54.     this.listeners_.push(type, listener);
  55.   }
  57.   /**
  58.    * Add an event listener to this object that is invoked for all events types
  59.    * the object fires.
  60.    *
  61.    * @param {shaka.util.FakeEventTarget.ListenerType} listener The callback or
  62.    *   listener object to invoke.
  63.    * @exportInterface
  64.    */
  65.   listenToAllEvents(listener) {
  66.     this.addEventListener(shaka.util.FakeEventTarget.ALL_EVENTS_, listener);
  67.   }
  69.   /**
  70.    * Remove an event listener from this object.
  71.    *
  72.    * @param {string} type The event type for which you wish to remove a
  73.    *   listener.
  74.    * @param {shaka.util.FakeEventTarget.ListenerType} listener The callback or
  75.    *   listener object to remove.
  76.    * @param {(EventListenerOptions|boolean)=} options Ignored.
  77.    * @override
  78.    * @exportInterface
  79.    */
  80.   removeEventListener(type, listener, options) {
  81.     if (!this.listeners_) {
  82.       return;
  83.     }
  84.     this.listeners_.remove(type, listener);
  85.   }
  87.   /**
  88.    * Dispatch an event from this object.
  89.    *
  90.    * @param {!Event} event The event to be dispatched from this object.
  91.    * @return {boolean} True if the default action was prevented.
  92.    * @override
  93.    * @exportInterface
  94.    */
  95.   dispatchEvent(event) {
  96.     // In many browsers, it is complex to overwrite properties of actual Events.
  97.     // Here we expect only to dispatch FakeEvents, which are simpler.
  98.     goog.asserts.assert(event instanceof shaka.util.FakeEvent,
  99.         'FakeEventTarget can only dispatch FakeEvents!');
  101.     if (!this.listeners_) {
  102.       return true;
  103.     }
  105.     let listeners = this.listeners_.get(event.type) || [];
  106.     const universalListeners =
  107.       this.listeners_.get(shaka.util.FakeEventTarget.ALL_EVENTS_);
  108.     if (universalListeners) {
  109.       listeners = listeners.concat(universalListeners);
  110.     }
  112.     // Execute this event on listeners until the event has been stopped or we
  113.     // run out of listeners.
  114.     for (const listener of listeners) {
  115.       // Do this every time, since events can be re-dispatched from handlers.
  116.       event.target = this.dispatchTarget;
  117.       event.currentTarget = this.dispatchTarget;
  119.       try {
  120.         // Check for the |handleEvent| member to test if this is a
  121.         // |EventListener| instance or a basic function.
  122.         if (listener.handleEvent) {
  123.           listener.handleEvent(event);
  124.         } else {
  125.           // eslint-disable-next-line no-restricted-syntax
  126.           listener.call(this, event);
  127.         }
  128.       } catch (exception) {
  129.         // Exceptions during event handlers should not affect the caller,
  130.         // but should appear on the console as uncaught, according to MDN:
  131.         // https://mzl.la/2JXgwRo
  132.         shaka.log.error('Uncaught exception in event handler', exception,
  133.             exception ? exception.message : null,
  134.             exception ? exception.stack : null);
  135.       }
  137.       if (event.stopped) {
  138.         break;
  139.       }
  140.     }
  142.     return event.defaultPrevented;
  143.   }
  145.   /**
  146.    * @override
  147.    * @exportInterface
  148.    */
  149.   release() {
  150.     this.listeners_ = null;
  151.   }
  152. };
  154. /**
  155.  * These are the listener types defined in the closure extern for EventTarget.
  156.  * @typedef {EventListener|function(!Event):*}
  157.  * @exportInterface
  158.  */
  159. shaka.util.FakeEventTarget.ListenerType;
  162. /**
  163.  * @const {string}
  164.  * @private
  165.  */
  166. shaka.util.FakeEventTarget.ALL_EVENTS_ = 'All';