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('shaka.util.IDestroyable');
  21. goog.require('shaka.util.MultiMap');
  25. /**
  26.  * Creates a new EventManager. An EventManager maintains a collection of "event
  27.  * bindings" between event targets and event listeners.
  28.  *
  29.  * @struct
  30.  * @constructor
  31.  * @implements {shaka.util.IDestroyable}
  32.  */
  33. shaka.util.EventManager = function() {
  34.   /**
  35.    * Maps an event type to an array of event bindings.
  36.    * @private {shaka.util.MultiMap.<!shaka.util.EventManager.Binding_>}
  37.    */
  38.   this.bindingMap_ = new shaka.util.MultiMap();
  39. };
  42. /**
  43.  * @typedef {function(!Event)}
  44.  */
  45. shaka.util.EventManager.ListenerType;
  48. /**
  49.  * Detaches all event listeners.
  50.  * @override
  51.  */
  52. shaka.util.EventManager.prototype.destroy = function() {
  53.   this.removeAll();
  54.   this.bindingMap_ = null;
  55.   return Promise.resolve();
  56. };
  59. /**
  60.  * Attaches an event listener to an event target.
  61.  * @param {EventTarget} target The event target.
  62.  * @param {string} type The event type.
  63.  * @param {shaka.util.EventManager.ListenerType} listener The event listener.
  64.  */
  65. shaka.util.EventManager.prototype.listen = function(target, type, listener) {
  66.   var binding = new shaka.util.EventManager.Binding_(target, type, listener);
  67.   this.bindingMap_.push(type, binding);
  68. };
  71. /**
  72.  * Detaches an event listener from an event target.
  73.  * @param {EventTarget} target The event target.
  74.  * @param {string} type The event type.
  75.  */
  76. shaka.util.EventManager.prototype.unlisten = function(target, type) {
  77.   var list = this.bindingMap_.get(type) || [];
  79.   for (var i = 0; i < list.length; ++i) {
  80.     var binding = list[i];
  82.     if (binding.target == target) {
  83.       binding.unlisten();
  84.       this.bindingMap_.remove(type, binding);
  85.     }
  86.   }
  87. };
  90. /**
  91.  * Detaches all event listeners from all targets.
  92.  */
  93. shaka.util.EventManager.prototype.removeAll = function() {
  94.   var list = this.bindingMap_.getAll();
  96.   for (var i = 0; i < list.length; ++i) {
  97.     list[i].unlisten();
  98.   }
  100.   this.bindingMap_.clear();
  101. };
  105. /**
  106.  * Creates a new Binding_ and attaches the event listener to the event target.
  107.  * @param {EventTarget} target The event target.
  108.  * @param {string} type The event type.
  109.  * @param {shaka.util.EventManager.ListenerType} listener The event listener.
  110.  * @constructor
  111.  * @private
  112.  */
  113. shaka.util.EventManager.Binding_ = function(target, type, listener) {
  114.   /** @type {EventTarget} */
  115.   this.target = target;
  117.   /** @type {string} */
  118.   this.type = type;
  120.   /** @type {?shaka.util.EventManager.ListenerType} */
  121.   this.listener = listener;
  123.   this.target.addEventListener(type, listener, false);
  124. };
  127. /**
  128.  * Detaches the event listener from the event target. This does nothing if the
  129.  * event listener is already detached.
  130.  */
  131. shaka.util.EventManager.Binding_.prototype.unlisten = function() {
  132.   if (!this.target)
  133.     return;
  135.   this.target.removeEventListener(this.type, this.listener, false);
  137.   this.target = null;
  138.   this.listener = null;
  139. };