Source: lib/util/event_manager.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.EventManager');
  20. goog.require('goog.asserts');
  21. goog.require('shaka.util.IDestroyable');
  22. goog.require('shaka.util.MultiMap');
  26. /**
  27.  * Creates a new EventManager. An EventManager maintains a collection of "event
  28.  * bindings" between event targets and event listeners.
  29.  *
  30.  * @struct
  31.  * @constructor
  32.  * @implements {shaka.util.IDestroyable}
  33.  */
  34. shaka.util.EventManager = function() {
  35.   /**
  36.    * Maps an event type to an array of event bindings.
  37.    * @private {shaka.util.MultiMap.<!shaka.util.EventManager.Binding_>}
  38.    */
  39.   this.bindingMap_ = new shaka.util.MultiMap();
  40. };
  43. /**
  44.  * @typedef {function(!Event)}
  45.  */
  46. shaka.util.EventManager.ListenerType;
  49. /**
  50.  * Detaches all event listeners.
  51.  * @override
  52.  */
  53. shaka.util.EventManager.prototype.destroy = function() {
  54.   this.removeAll();
  55.   this.bindingMap_ = null;
  56.   return Promise.resolve();
  57. };
  60. /**
  61.  * Attaches an event listener to an event target.
  62.  * @param {EventTarget} target The event target.
  63.  * @param {string} type The event type.
  64.  * @param {shaka.util.EventManager.ListenerType} listener The event listener.
  65.  */
  66. shaka.util.EventManager.prototype.listen = function(target, type, listener) {
  67.   if (!this.bindingMap_) return;
  69.   let binding = new shaka.util.EventManager.Binding_(target, type, listener);
  70.   this.bindingMap_.push(type, binding);
  71. };
  74. /**
  75.  * Attaches an event listener to an event target.  The listener will be removed
  76.  * when the first instance of the event is fired.
  77.  * @param {EventTarget} target The event target.
  78.  * @param {string} type The event type.
  79.  * @param {shaka.util.EventManager.ListenerType} listener The event listener.
  80.  */
  81. shaka.util.EventManager.prototype.listenOnce =
  82.     function(target, type, listener) {
  83.   // Install a shim listener that will stop listening after the first event.
  84.   this.listen(target, type, function(event) {
  85.     // Stop listening to this event.
  86.     this.unlisten(target, type);
  87.     // Call the original listener.
  88.     listener(event);
  89.   }.bind(this));
  90. };
  93. /**
  94.  * Detaches an event listener from an event target.
  95.  * @param {EventTarget} target The event target.
  96.  * @param {string} type The event type.
  97.  */
  98. shaka.util.EventManager.prototype.unlisten = function(target, type) {
  99.   if (!this.bindingMap_) return;
  101.   let list = this.bindingMap_.get(type) || [];
  103.   for (let i = 0; i < list.length; ++i) {
  104.     let binding = list[i];
  106.     if (binding.target == target) {
  107.       binding.unlisten();
  108.       this.bindingMap_.remove(type, binding);
  109.     }
  110.   }
  111. };
  114. /**
  115.  * Detaches all event listeners from all targets.
  116.  */
  117. shaka.util.EventManager.prototype.removeAll = function() {
  118.   if (!this.bindingMap_) return;
  120.   let list = this.bindingMap_.getAll();
  122.   for (let i = 0; i < list.length; ++i) {
  123.     list[i].unlisten();
  124.   }
  126.   this.bindingMap_.clear();
  127. };
  131. /**
  132.  * Creates a new Binding_ and attaches the event listener to the event target.
  133.  * @param {EventTarget} target The event target.
  134.  * @param {string} type The event type.
  135.  * @param {shaka.util.EventManager.ListenerType} listener The event listener.
  136.  * @constructor
  137.  * @private
  138.  */
  139. shaka.util.EventManager.Binding_ = function(target, type, listener) {
  140.   /** @type {EventTarget} */
  141.   this.target = target;
  143.   /** @type {string} */
  144.   this.type = type;
  146.   /** @type {?shaka.util.EventManager.ListenerType} */
  147.   this.listener = listener;
  149.   this.target.addEventListener(type, listener, false);
  150. };
  153. /**
  154.  * Detaches the event listener from the event target. This does nothing if the
  155.  * event listener is already detached.
  156.  */
  157. shaka.util.EventManager.Binding_.prototype.unlisten = function() {
  158.   goog.asserts.assert(this.target, 'Missing target');
  159.   this.target.removeEventListener(this.type, this.listener, false);
  161.   this.target = null;
  162.   this.listener = null;
  163. };