react-native/Libraries/EventEmitter/mixInEventEmitter.js
Nick Lockwood 516bf7bd94 Fixed NativeEventListener deregistration
Summary:
The `EmitterSubscription.remove()` method was previously calling `this.subscriber.removeSubscription(this)` directly, bypassing the mechanism in `NativeEventEmitter` that keeps track of the number of subscriptions.

This meant that native event modules (subclasses of `RCTEventEmitter`) would keep sending events even after all the listeners had been removed. This wasn't a huge overhead, since these modules are singletons and only send one message over the bridge per event, regardless of the number of listeners, but it's still undesirable.

This fixes the problem by routing the `EmitterSubscription.remove()` method through the `EventEmitter` so that `NativeEventEmitter` can apply the additional native calls.

I've also improved the architecture so that each `NativeEventEmitter` uses its own `EventEmitter`, but they currently all still share the same `EventSubscriptionVendor` so that legacy code which registers events via `RCTDeviceEventEmitter` still works.

Reviewed By: vjeux

Differential Revision: D3292361

fbshipit-source-id: d60e881d50351523d2112473703bea826641cdef
2016-05-16 04:13:56 -07:00

132 lines
3.9 KiB
JavaScript

/**
* Copyright (c) 2015-present, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant
* of patent rights can be found in the PATENTS file in the same directory.
*
* @providesModule mixInEventEmitter
* @flow
*/
const EventEmitter = require('EventEmitter');
const EventEmitterWithHolding = require('EventEmitterWithHolding');
const EventHolder = require('EventHolder');
const EventValidator = require('EventValidator');
const copyProperties = require('copyProperties');
const invariant = require('fbjs/lib/invariant');
const keyOf = require('fbjs/lib/keyOf');
const TYPES_KEY = keyOf({__types: true});
/**
* API to setup an object or constructor to be able to emit data events.
*
* @example
* function Dog() { ...dog stuff... }
* mixInEventEmitter(Dog, {bark: true});
*
* var puppy = new Dog();
* puppy.addListener('bark', function (volume) {
* console.log('Puppy', this, 'barked at volume:', volume);
* });
* puppy.emit('bark', 'quiet');
* // Puppy <puppy> barked at volume: quiet
*
*
* // A "singleton" object may also be commissioned:
*
* var Singleton = {};
* mixInEventEmitter(Singleton, {lonely: true});
* Singleton.emit('lonely', true);
*/
function mixInEventEmitter(cls: Function | Object, types: Object) {
invariant(types, 'Must supply set of valid event types');
// If this is a constructor, write to the prototype, otherwise write to the
// singleton object.
const target = cls.prototype || cls;
invariant(!target.__eventEmitter, 'An active emitter is already mixed in');
const ctor = cls.constructor;
if (ctor) {
invariant(
ctor === Object || ctor === Function,
'Mix EventEmitter into a class, not an instance'
);
}
// Keep track of the provided types, union the types if they already exist,
// which allows for prototype subclasses to provide more types.
if (target.hasOwnProperty(TYPES_KEY)) {
copyProperties(target.__types, types);
} else if (target.__types) {
target.__types = copyProperties({}, target.__types, types);
} else {
target.__types = types;
}
copyProperties(target, EventEmitterMixin);
}
const EventEmitterMixin = {
emit: function(eventType, a, b, c, d, e, _) {
return this.__getEventEmitter().emit(eventType, a, b, c, d, e, _);
},
emitAndHold: function(eventType, a, b, c, d, e, _) {
return this.__getEventEmitter().emitAndHold(eventType, a, b, c, d, e, _);
},
addListener: function(eventType, listener, context) {
return this.__getEventEmitter().addListener(eventType, listener, context);
},
once: function(eventType, listener, context) {
return this.__getEventEmitter().once(eventType, listener, context);
},
addRetroactiveListener: function(eventType, listener, context) {
return this.__getEventEmitter().addRetroactiveListener(
eventType,
listener,
context
);
},
addListenerMap: function(listenerMap, context) {
return this.__getEventEmitter().addListenerMap(listenerMap, context);
},
addRetroactiveListenerMap: function(listenerMap, context) {
return this.__getEventEmitter().addListenerMap(listenerMap, context);
},
removeAllListeners: function() {
this.__getEventEmitter().removeAllListeners();
},
removeCurrentListener: function() {
this.__getEventEmitter().removeCurrentListener();
},
releaseHeldEventType: function(eventType) {
this.__getEventEmitter().releaseHeldEventType(eventType);
},
__getEventEmitter: function() {
if (!this.__eventEmitter) {
let emitter = new EventEmitter();
emitter = EventValidator.addValidation(emitter, this.__types);
const holder = new EventHolder();
this.__eventEmitter = new EventEmitterWithHolding(emitter, holder);
}
return this.__eventEmitter;
}
};
module.exports = mixInEventEmitter;