Source: lib/util/fake_event_target.js

  1. /**
  2.  * @license
  3.  * Copyright 2016 Google Inc.
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  18. goog.provide('shaka.util.FakeEventTarget');
  20. goog.require('goog.asserts');
  21. goog.require('shaka.log');
  22. goog.require('shaka.util.FakeEvent');
  23. goog.require('shaka.util.MultiMap');
  27. /**
  28.  * A work-alike for EventTarget.  Only DOM elements may be true EventTargets,
  29.  * but this can be used as a base class to provide event dispatch to non-DOM
  30.  * classes.  Only FakeEvents should be dispatched.
  31.  *
  32.  * @struct
  33.  * @constructor
  34.  * @implements {EventTarget}
  35.  * @exportInterface
  36.  */
  37. shaka.util.FakeEventTarget = function() {
  38.   /**
  39.    * @private {!shaka.util.MultiMap.<shaka.util.FakeEventTarget.ListenerType>}
  40.    */
  41.   this.listeners_ = new shaka.util.MultiMap();
  43.   /**
  44.    * The target of all dispatched events.  Defaults to |this|.
  45.    * @type {EventTarget}
  46.    */
  47.   this.dispatchTarget = this;
  48. };
  51. /**
  52.  * These are the listener types defined in the closure extern for EventTarget.
  53.  * @typedef {EventListener|function(!Event):(boolean|undefined)}
  54.  * @exportInterface
  55.  */
  56. shaka.util.FakeEventTarget.ListenerType;
  59. /**
  60.  * Add an event listener to this object.
  61.  *
  62.  * @param {string} type The event type to listen for.
  63.  * @param {shaka.util.FakeEventTarget.ListenerType} listener The callback or
  64.  *   listener object to invoke.
  65.  * @param {(!AddEventListenerOptions|boolean)=} opt_options Ignored.
  66.  * @override
  67.  * @exportInterface
  68.  */
  69. shaka.util.FakeEventTarget.prototype.addEventListener =
  70.     function(type, listener, opt_options) {
  71.   this.listeners_.push(type, listener);
  72. };
  75. /**
  76.  * Remove an event listener from this object.
  77.  *
  78.  * @param {string} type The event type for which you wish to remove a listener.
  79.  * @param {shaka.util.FakeEventTarget.ListenerType} listener The callback or
  80.  *   listener object to remove.
  81.  * @param {(EventListenerOptions|boolean)=} opt_options Ignored.
  82.  * @override
  83.  * @exportInterface
  84.  */
  85. shaka.util.FakeEventTarget.prototype.removeEventListener =
  86.     function(type, listener, opt_options) {
  87.   this.listeners_.remove(type, listener);
  88. };
  91. /**
  92.  * Dispatch an event from this object.
  93.  *
  94.  * @param {!Event} event The event to be dispatched from this object.
  95.  * @return {boolean} True if the default action was prevented.
  96.  * @override
  97.  * @exportInterface
  98.  */
  99. shaka.util.FakeEventTarget.prototype.dispatchEvent = function(event) {
  100.   // In many browsers, it is complex to overwrite properties of actual Events.
  101.   // Here we expect only to dispatch FakeEvents, which are simpler.
  102.   goog.asserts.assert(event instanceof shaka.util.FakeEvent,
  103.                       'FakeEventTarget can only dispatch FakeEvents!');
  105.   var list = this.listeners_.get(event.type) || [];
  107.   for (var i = 0; i < list.length; ++i) {
  108.     // Do this every time, since events can be re-dispatched from handlers.
  109.     event.target = this.dispatchTarget;
  110.     event.currentTarget = this.dispatchTarget;
  112.     var listener = list[i];
  113.     try {
  114.       if (listener.handleEvent) {
  115.         listener.handleEvent(event);
  116.       } else {
  117.         listener.call(this, event);
  118.       }
  119.     } catch (exception) {
  120.       // Exceptions during event handlers should not affect the caller,
  121.       // but should appear on the console as uncaught, according to MDN:
  122.       // http://goo.gl/N6Ff27
  123.       shaka.log.error('Uncaught exception in event handler', exception);
  124.     }
  126.     if (event.stopped) {
  127.       break;
  128.     }
  129.   }
  131.   return event.defaultPrevented;
  132. };