support DTMF

.editorconfig

+# http://editorconfig.org
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_size = 4
+indent_style = space
+max_line_length = 80
+trim_trailing_whitespace = true

JitsiConference.js

-
+/* global Strophe, $ */
+/* jshint -W101 */
 var logger = require("jitsi-meet-logger").getLogger(__filename);
 var RTC = require("./modules/RTC/RTC");
 var XMPPEvents = require("./service/xmpp/XMPPEvents");
 var JitsiConferenceEvents = require("./JitsiConferenceEvents");
 var JitsiParticipant = require("./JitsiParticipant");
 var Statistics = require("./modules/statistics/statistics");
+var JitsiDTMFManager = require('./modules/DTMF/JitsiDTMFManager');
 var JitsiTrackEvents = require("./JitsiTrackEvents");
 
 /**
  * @param options.connection the JitsiConnection object for this JitsiConference.
  * @constructor
  */
-
 function JitsiConference(options) {
     if(!options.name || options.name.toLowerCase() !== options.name) {
         logger.error("Invalid conference name (no conference name passed or it"
     setupListeners(this);
     this.participants = {};
     this.lastActiveSpeaker = null;
+    this.dtmfManager = null;
+    this.somebodySupportsDTMF = false;
 }
 
 /**
 JitsiConference.prototype.join = function (password) {
     if(this.room)
         this.room.join(password, this.connection.tokenPassword);
-}
+};
 
 /**
  * Leaves the conference.
     if(this.xmpp)
         this.xmpp.leaveRoom(this.room.roomjid);
     this.room = null;
-}
+};
 
 /**
  * Returns the local tracks.
  */
 JitsiConference.prototype.getLocalTracks = function () {
-    if(this.rtc)
+    if (this.rtc) {
         return this.rtc.localStreams;
+    } else {
+        return [];
+    }
 };
 
 
 JitsiConference.prototype.on = function (eventId, handler) {
     if(this.eventEmitter)
         this.eventEmitter.on(eventId, handler);
-}
+};
 
 /**
  * Removes event listener
 JitsiConference.prototype.off = function (eventId, handler) {
     if(this.eventEmitter)
         this.eventEmitter.removeListener(eventId, handler);
-}
+};
 
 // Common aliases for event emitter
 JitsiConference.prototype.addEventListener = JitsiConference.prototype.on;
  JitsiConference.prototype.addCommandListener = function (command, handler) {
     if(this.room)
         this.room.addPresenceListener(command, handler);
- }
+ };
 
 /**
   * Removes command  listener
  JitsiConference.prototype.removeCommandListener = function (command) {
     if(this.room)
         this.room.removePresenceListener(command);
- }
+ };
 
 /**
  * Sends text message to the other participants in the conference
 JitsiConference.prototype.sendTextMessage = function (message) {
     if(this.room)
         this.room.sendMessage(message);
-}
+};
 
 /**
  * Send presence command.
         this.room.addToPresence(name, values);
         this.room.sendPresence();
     }
-}
+};
 
 /**
  * Send presence command one time.
 JitsiConference.prototype.sendCommandOnce = function (name, values) {
     this.sendCommand(name, values);
     this.removeCommand(name);
-}
+};
 
 /**
  * Send presence command.
 JitsiConference.prototype.removeCommand = function (name) {
     if(this.room)
         this.room.removeFromPresence(name);
-}
+};
 
 /**
  * Sets the display name for this conference.
         this.room.addToPresence("nick", {attributes: {xmlns: 'http://jabber.org/protocol/nick'}, value: name});
         this.room.sendPresence();
     }
-}
+};
 
 /**
  * Adds JitsiLocalTrack object to the conference.
         var audioLevelHandler = this._fireAudioLevelChangeEvent.bind(this);
         track.addEventListener(JitsiTrackEvents.TRACK_MUTE_CHANGED, muteHandler);
         track.addEventListener(JitsiTrackEvents.TRACK_STOPPED, stopHandler);
-        track.addEventListener(JitsiTrackEvents.TRACK_AUDIO_LEVEL_CHANGED,
-            audioLevelHandler);
-        this.addEventListener(JitsiConferenceEvents.TRACK_REMOVED, function (track) {
-            track.removeEventListener(JitsiTrackEvents.TRACK_MUTE_CHANGED,
-                muteHandler);
-            track.removeEventListener(JitsiTrackEvents.TRACK_STOPPED,
-                stopHandler);
-            track.removeEventListener(
-                JitsiTrackEvents.TRACK_AUDIO_LEVEL_CHANGED, audioLevelHandler);
-        })
+        track.addEventListener(JitsiTrackEvents.TRACK_AUDIO_LEVEL_CHANGED, audioLevelHandler);
+        this.addEventListener(JitsiConferenceEvents.TRACK_REMOVED, function (someTrack) {
+            if (someTrack !== track) {
+                return;
+            }
+            track.removeEventListener(JitsiTrackEvents.TRACK_MUTE_CHANGED, muteHandler);
+            track.removeEventListener(JitsiTrackEvents.TRACK_STOPPED, stopHandler);
+            track.removeEventListener(JitsiTrackEvents.TRACK_AUDIO_LEVEL_CHANGED, audioLevelHandler);
+        });
         this.eventEmitter.emit(JitsiConferenceEvents.TRACK_ADDED, track);
     }.bind(this));
-
-}
+};
 
 /**
  * Fires TRACK_AUDIO_LEVEL_CHANGED change conference event.
     this.eventEmitter.emit(
         JitsiConferenceEvents.TRACK_AUDIO_LEVEL_CHANGED,
         this.myUserId(), audioLevel);
-}
+};
 
 /**
  * Fires TRACK_MUTE_CHANGED change conference event.
         this.rtc.removeLocalStream(track);
         this.eventEmitter.emit(JitsiConferenceEvents.TRACK_REMOVED, track);
     }.bind(this));
-}
+};
+
+/**
+ * Get role of the local user.
+ * @returns {string} user role: 'moderator' or 'none'
+ */
+JitsiConference.prototype.getRole = function () {
+    return this.room.role;
+};
+
+/**
+ * Check if local user is moderator.
+ * @returns {boolean} true if local user is moderator, false otherwise.
+ */
+JitsiConference.prototype.isModerator = function () {
+    return this.room.isModerator();
+};
 
 /**
  * Elects the participant with the given id to be the selected participant or the speaker.
     if (this.rtc) {
         this.rtc.selectedEndpoint(participantId);
     }
-}
+};
 
 /**
  *
  * @param id the identifier of the participant
  */
 JitsiConference.prototype.pinParticipant = function(participantId) {
-    if(this.rtc)
+    if (this.rtc) {
         this.rtc.pinEndpoint(participantId);
-}
+    }
+};
 
 /**
  * Returns the list of participants for this conference.
- * @return Object a list of participant identifiers containing all conference participants.
+ * @return Array<JitsiParticipant> a list of participant identifiers containing all conference participants.
  */
 JitsiConference.prototype.getParticipants = function() {
-    return this.participants;
-}
+    return Object.keys(this.participants).map(function (key) {
+        return this.participants[key];
+    }, this);
+};
 
 /**
  * @returns {JitsiParticipant} the participant in this conference with the specified id (or
- * null if there isn't one).
+ * undefined if there isn't one).
  * @param id the id of the participant.
  */
 JitsiConference.prototype.getParticipantById = function(id) {
-    if(this.participants)
-        return this.participants[id];
-    return null;
-}
+    return this.participants[id];
+};
 
 JitsiConference.prototype.onMemberJoined = function (jid, email, nick) {
-    if(this.eventEmitter)
-        this.eventEmitter.emit(JitsiConferenceEvents.USER_JOINED, Strophe.getResourceFromJid(jid));
-//    this.participants[jid] = new JitsiParticipant();
-}
+    var id = Strophe.getResourceFromJid(jid);
+    var participant = new JitsiParticipant(id, this, nick);
+    this.eventEmitter.emit(JitsiConferenceEvents.USER_JOINED, id);
+    this.participants[id] = participant;
+    this.connection.xmpp.connection.disco.info(
+        jid, "" /* node */, function(iq) {
+            participant._supportsDTMF = $(iq).find('>query>feature[var="urn:xmpp:jingle:dtmf:0"]').length > 0;
+            this.updateDTMFSupport();
+        }.bind(this)
+    );
+};
+
+JitsiConference.prototype.onMemberLeft = function (jid) {
+    var id = Strophe.getResourceFromJid(jid);
+    delete this.participants[id];
+    this.eventEmitter.emit(JitsiConferenceEvents.USER_LEFT, id);
+};
+
+JitsiConference.prototype.onUserRoleChanged = function (jid, role) {
+    var id = Strophe.getResourceFromJid(jid);
+    var participant = this.getParticipantById(id);
+    if (!participant) {
+        return;
+    }
+    participant._role = role;
+    this.eventEmitter.emit(JitsiConferenceEvents.USER_ROLE_CHANGED, id, role);
+};
+
+JitsiConference.prototype.onDisplayNameChanged = function (jid, displayName) {
+    var id = Strophe.getResourceFromJid(jid);
+    var participant = this.getParticipantById(id);
+    if (!participant) {
+        return;
+    }
+    participant._displayName = displayName;
+    this.eventEmitter.emit(JitsiConferenceEvents.DISPLAY_NAME_CHANGED, id, displayName);
+};
+
+JitsiConference.prototype.onTrackAdded = function (track) {
+    var id = track.getParticipantId();
+    var participant = this.getParticipantById(id);
+    if (!participant) {
+        return;
+    }
+    // add track to JitsiParticipant
+    participant._tracks.push(track);
+
+    var emitter = this.eventEmitter;
+    track.addEventListener(
+        JitsiTrackEvents.TRACK_STOPPED,
+        function () {
+            // remove track from JitsiParticipant
+            var pos = participant._tracks.indexOf(track);
+            if (pos > -1) {
+                participant._tracks.splice(pos, 1);
+            }
+            emitter.emit(JitsiConferenceEvents.TRACK_REMOVED, track);
+        }
+    );
+    track.addEventListener(
+        JitsiTrackEvents.TRACK_MUTE_CHANGED,
+        function () {
+            emitter.emit(JitsiConferenceEvents.TRACK_MUTE_CHANGED, track);
+        }
+    );
+    track.addEventListener(
+        JitsiTrackEvents.TRACK_AUDIO_LEVEL_CHANGED,
+        function (audioLevel) {
+            emitter.emit(JitsiConferenceEvents.TRACK_AUDIO_LEVEL_CHANGED, id, audioLevel);
+        }
+    );
+
+    this.eventEmitter.emit(JitsiConferenceEvents.TRACK_ADDED, track);
+};
+
+JitsiConference.prototype.updateDTMFSupport = function () {
+    var somebodySupportsDTMF = false;
+    var participants = this.getParticipants();
+
+    // check if at least 1 participant supports DTMF
+    for (var i = 0; i < participants.length; i += 1) {
+        if (participants[i].supportsDTMF()) {
+            somebodySupportsDTMF = true;
+            break;
+        }
+    }
+    if (somebodySupportsDTMF !== this.somebodySupportsDTMF) {
+        this.somebodySupportsDTMF = somebodySupportsDTMF;
+        this.eventEmitter.emit(JitsiConferenceEvents.DTMF_SUPPORT_CHANGED, somebodySupportsDTMF);
+    }
+};
+
+/**
+ * Allows to check if there is at least one user in the conference
+ * that supports DTMF.
+ * @returns {boolean} true if somebody supports DTMF, false otherwise
+ */
+JitsiConference.prototype.isDTMFSupported = function () {
+    return this.somebodySupportsDTMF;
+};
 
 /**
  * Returns the local user's ID
  */
 JitsiConference.prototype.myUserId = function () {
     return (this.room && this.room.myroomjid)? Strophe.getResourceFromJid(this.room.myroomjid) : null;
-}
+};
+
+JitsiConference.prototype.sendTones = function (tones, duration, pause) {
+    if (!this.dtmfManager) {
+        var connection = this.connection.xmpp.connection.jingle.activecall.peerconnection;
+        if (!connection) {
+            logger.warn("cannot sendTones: no conneciton");
+            return;
+        }
+
+        var tracks = this.getLocalTracks().filter(function (track) {
+            return track.isAudioTrack();
+        });
+        if (!tracks.length) {
+            logger.warn("cannot sendTones: no local audio stream");
+            return;
+        }
+        this.dtmfManager = new JitsiDTMFManager(tracks[0], connection);
+    }
+
+    this.dtmfManager.sendTones(tones, duration, pause);
+};
 
 /**
  * Setups the listeners needed for the conference.
     conference.room.addListener(XMPPEvents.REMOTE_STREAM_RECEIVED,
         function (data, sid, thessrc) {
             var track = conference.rtc.createRemoteStream(data, sid, thessrc);
-            if(!track)
-                return;
-            conference.eventEmitter.emit(JitsiConferenceEvents.TRACK_ADDED,
-                track);
-            track.addEventListener(JitsiTrackEvents.TRACK_STOPPED,
-                function () {
-                    conference.eventEmitter.emit(
-                        JitsiConferenceEvents.TRACK_REMOVED, track);
-                });
-            track.addEventListener(JitsiTrackEvents.TRACK_MUTE_CHANGED,
-                function () {
-                    conference.eventEmitter.emit(
-                        JitsiConferenceEvents.TRACK_MUTE_CHANGED, track);
-                });
-            var userId = track.getParitcipantId();
-            track.addEventListener(JitsiTrackEvents.TRACK_AUDIO_LEVEL_CHANGED,
-                function (audioLevel) {
-                    conference.eventEmitter.emit(
-                        JitsiConferenceEvents.TRACK_AUDIO_LEVEL_CHANGED,
-                        userId, audioLevel);
-                });
+            if (track) {
+                conference.onTrackAdded(track);
+            }
         }
     );
 
 //        conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_LEFT);
 //    });
 
-    conference.room.addListener(XMPPEvents.MUC_MEMBER_JOINED,
-        conference.onMemberJoined.bind(conference));
-    conference.room.addListener(XMPPEvents.MUC_MEMBER_LEFT,function (jid) {
-        conference.eventEmitter.emit(JitsiConferenceEvents.USER_LEFT,
-            Strophe.getResourceFromJid(jid));
-    });
+    conference.room.addListener(XMPPEvents.MUC_MEMBER_JOINED, conference.onMemberJoined.bind(conference));
+    conference.room.addListener(XMPPEvents.MUC_MEMBER_LEFT, conference.onMemberLeft.bind(conference));
 
-    conference.room.addListener(XMPPEvents.DISPLAY_NAME_CHANGED,
-        function (from, displayName) {
-            conference.eventEmitter.emit(
-                JitsiConferenceEvents.DISPLAY_NAME_CHANGED,
-                Strophe.getResourceFromJid(from), displayName);
-        });
+    conference.room.addListener(XMPPEvents.DISPLAY_NAME_CHANGED, conference.onDisplayNameChanged.bind(conference));
 
-    conference.room.addListener(XMPPEvents.CONNECTION_INTERRUPTED,
-        function () {
-            conference.eventEmitter.emit(
-                JitsiConferenceEvents.CONNECTION_INTERRUPTED);
-        });
+    conference.room.addListener(XMPPEvents.LOCAL_ROLE_CHANGED, function (role) {
+        conference.eventEmitter.emit(JitsiConferenceEvents.USER_ROLE_CHANGED, conference.myUserId(), role);
+    });
+    conference.room.addListener(XMPPEvents.MUC_ROLE_CHANGED, conference.onUserRoleChanged.bind(conference));
+
+    conference.room.addListener(XMPPEvents.CONNECTION_INTERRUPTED, function () {
+        conference.eventEmitter.emit(JitsiConferenceEvents.CONNECTION_INTERRUPTED);
+    });
 
     conference.room.addListener(XMPPEvents.CONNECTION_RESTORED, function () {
         conference.eventEmitter.emit(JitsiConferenceEvents.CONNECTION_RESTORED);
     });
-    conference.room.addListener(XMPPEvents.CONFERENCE_SETUP_FAILED, function() {
+    conference.room.addListener(XMPPEvents.CONFERENCE_SETUP_FAILED, function () {
         conference.eventEmitter.emit(JitsiConferenceEvents.SETUP_FAILED);
     });
 

JitsiConferenceEvents.js

     /**
      * Indicates that conference has been left.
      */
-    CONFERENCE_LEFT: "conference.left"
+    CONFERENCE_LEFT: "conference.left",
+    DTMF_SUPPORT_CHANGED: "conference.dtmf_support_changed"
 };
 
 module.exports = JitsiConferenceEvents;

JitsiParticipant.js

     this._id = id;
     this._conference = conference;
     this._displayName = displayName;
+    this._supportsDTMF = false;
 }
 
 /**
  */
 JitsiParticipant.prototype.getConference = function() {
     return this._conference;
-}
+};
 
 /**
  * @returns {Array.<JitsiTrack>} The list of media tracks for this participant.
  */
 JitsiParticipant.prototype.getTracks = function() {
 
-}
+};
 
 /**
  * @returns {String} The ID (i.e. JID) of this participant.
  */
 JitsiParticipant.prototype.getId = function() {
     return this._id;
-}
+};
 
 /**
  * @returns {String} The human-readable display name of this participant.
  */
 JitsiParticipant.prototype.getDisplayName = function() {
     return this._displayName;
-}
+};
 
 /**
  * @returns {Boolean} Whether this participant is a moderator or not.
  */
 JitsiParticipant.prototype.isModerator = function() {
-}
+};
 
 // Gets a link to an etherpad instance advertised by the participant?
 //JitsiParticipant.prototype.getEtherpad = function() {
  */
 JitsiParticipant.prototype.isAudioMuted = function() {
 
-}
+};
 
 /*
  * @returns {Boolean} Whether this participant has muted their video.
  */
 JitsiParticipant.prototype.isVideoMuted = function() {
 
-}
+};
 
 /*
  * @returns {???} The latest statistics reported by this participant (i.e. info used to populate the GSM bars)
  */
 JitsiParticipant.prototype.getLatestStats = function() {
 
-}
+};
 
 /**
  * @returns {String} The role of this participant.
  */
 JitsiParticipant.prototype.getRole = function() {
 
-}
+};
 
 /*
  * @returns {Boolean} Whether this participant is the conference focus (i.e. jicofo).
  */
 JitsiParticipant.prototype.isFocus = function() {
 
-}
+};
 
 /*
  * @returns {Boolean} Whether this participant is a conference recorder (i.e. jirecon).
  */
 JitsiParticipant.prototype.isRecorder = function() {
 
-}
+};
 
 /*
  * @returns {Boolean} Whether this participant is a SIP gateway (i.e. jigasi).
  */
 JitsiParticipant.prototype.isSipGateway = function() {
 
-}
+};
 
 /**
  * @returns {String} The ID for this participant's avatar.
  */
 JitsiParticipant.prototype.getAvatarId = function() {
 
-}
+};
 
 /**
  * @returns {Boolean} Whether this participant is currently sharing their screen.
  */
 JitsiParticipant.prototype.isScreenSharing = function() {
 
-}
+};
 
 /**
  * @returns {String} The user agent of this participant (i.e. browser userAgent string).
  */
 JitsiParticipant.prototype.getUserAgent = function() {
 
-}
+};
 
 /**
  * Kicks the participant from the conference (requires certain privileges).
  */
 JitsiParticipant.prototype.kick = function() {
 
-}
+};
 
 /**
  * Asks this participant to mute themselves.
  */
 JitsiParticipant.prototype.askToMute = function() {
 
-}
+};
+
+JitsiParticipant.prototype.supportsDTMF = function () {
+    return this._supportsDTMF;
+};
 
 
-module.exports = JitsiParticipant();
+module.exports = JitsiParticipant;

modules/DTMF/DTMF.js

-/* global APP */
-
-/**
- * A module for sending DTMF tones.
- */
-var DTMFSender;
-var initDtmfSender = function() {
-    // TODO: This needs to reset this if the peerconnection changes
-    // (e.g. the call is re-made)
-    if (DTMFSender)
-        return;
-
-    var localAudio = APP.RTC.localAudio;
-    if (localAudio && localAudio.getTracks().length > 0)
-    {
-        var peerconnection
-            = APP.xmpp.getConnection().jingle.activecall.peerconnection;
-        if (peerconnection) {
-            DTMFSender =
-                peerconnection.peerconnection
-                    .createDTMFSender(localAudio.getTracks()[0]);
-            console.log("Initialized DTMFSender");
-        }
-        else {
-            console.log("Failed to initialize DTMFSender: no PeerConnection.");
-        }
-    }
-    else {
-        console.log("Failed to initialize DTMFSender: no audio track.");
-    }
-};
-
-var DTMF = {
-    sendTones: function (tones, duration, pause) {
-        if (!DTMFSender)
-            initDtmfSender();
-
-        if (DTMFSender){
-            DTMFSender.insertDTMF(tones,
-                                  (duration || 200),
-                                  (pause || 200));
-        }
-    }
-};
-
-module.exports = DTMF;
-

modules/DTMF/JitsiDTMFManager.js

+var logger = require("jitsi-meet-logger").getLogger(__filename);
+
+function JitsiDTMFManager (localAudio, peerConnection) {
+    var tracks = localAudio._getTracks();
+    if (!tracks.length) {
+        throw new Error("Failed to initialize DTMFSender: no audio track.");
+    }
+    this.dtmfSender = peerConnection.peerconnection.createDTMFSender(tracks[0]);
+    logger.debug("Initialized DTMFSender");
+}
+
+
+JitsiDTMFManager.prototype.sendTones = function (tones, duration, pause) {
+    this.dtmfSender.insertDTMF(tones, (duration || 200), (pause || 200));
+};

modules/RTC/JitsiTrack.js

     return this.type;
 };
 
+/**
+ * Check if this is audiotrack.
+ */
+JitsiTrack.prototype.isAudioTrack = function () {
+    return this.getType() === JitsiTrack.AUDIO;
+};
+
+/**
+ * Check if this is videotrack.
+ */
+JitsiTrack.prototype.isVideoTrack = function () {
+    return this.getType() === JitsiTrack.VIDEO;
+};
+
 /**
  * Returns the RTCMediaStream from the browser (?).
  */

modules/members/MemberList.js

-/* global APP, require, $ */
-
-/**
- * This module is meant to (eventually) contain and manage all information
- * about members/participants of the conference, so that other modules don't
- * have to do it on their own, and so that other modules can access members'
- * information from a single place.
- *
- * Currently this module only manages information about the support of jingle
- * DTMF of the members. Other fields, as well as accessor methods are meant to
- * be added as needed.
- */
-
-var XMPPEvents = require("../../service/xmpp/XMPPEvents");
-var Events = require("../../service/members/Events");
-var EventEmitter = require("events");
-
-var eventEmitter = new EventEmitter();
-
-/**
- * The actual container.
- */
-var members = {};
-
-/**
- * There is at least one member that supports DTMF (i.e. is jigasi).
- */
-var atLeastOneDtmf = false;
-
-
-function registerListeners() {
-    APP.xmpp.addListener(XMPPEvents.MUC_MEMBER_JOINED, onMucMemberJoined);
-    APP.xmpp.addListener(XMPPEvents.MUC_MEMBER_LEFT, onMucMemberLeft);
-}
-
-/**
- * Handles a new member joining the MUC.
- */
-function onMucMemberJoined(jid, id, displayName) {
-    var member = {
-        displayName: displayName
-    };
-
-    APP.xmpp.getConnection().disco.info(
-        jid, "" /* node */, function(iq) { onDiscoInfoReceived(jid, iq); });
-
-    members[jid] = member;
-}
-
-/**
- * Handles a member leaving the MUC.
- */
-function onMucMemberLeft(jid) {
-    delete members[jid];
-    updateAtLeastOneDtmf();
-}
-
-/**
- * Handles the reception of a disco#info packet from a particular JID.
- * @param jid the JID sending the packet.
- * @param iq the packet.
- */
-function onDiscoInfoReceived(jid, iq) {
-    if (!members[jid])
-        return;
-
-    var supportsDtmf
-        = $(iq).find('>query>feature[var="urn:xmpp:jingle:dtmf:0"]').length > 0;
-    updateDtmf(jid, supportsDtmf);
-}
-
-/**
- * Updates the 'supportsDtmf' field for a member.
- * @param jid the jid of the member.
- * @param newValue the new value for the 'supportsDtmf' field.
- */
-function updateDtmf(jid, newValue) {
-    var oldValue = members[jid].supportsDtmf;
-    members[jid].supportsDtmf = newValue;
-
-    if (newValue != oldValue) {
-        updateAtLeastOneDtmf();
-    }
-}
-
-/**
- * Checks each member's 'supportsDtmf' field and updates
- * 'atLastOneSupportsDtmf'.
- */
-function updateAtLeastOneDtmf() {
-    var newAtLeastOneDtmf = false;
-    for (var key in members) {
-        if (typeof members[key].supportsDtmf !== 'undefined'
-            && members[key].supportsDtmf) {
-            newAtLeastOneDtmf= true;
-            break;
-        }
-    }
-
-    if (atLeastOneDtmf != newAtLeastOneDtmf) {
-        atLeastOneDtmf = newAtLeastOneDtmf;
-        eventEmitter.emit(Events.DTMF_SUPPORT_CHANGED, atLeastOneDtmf);
-    }
-}
-
-
-/**
- * Exported interface.
- */
-var Members = {
-    start: function() {
-        registerListeners();
-    },
-    addListener: function(type, listener) {
-        eventEmitter.on(type, listener);
-    },
-    removeListener: function (type, listener) {
-        eventEmitter.removeListener(type, listener);
-    },
-    size: function () {
-        return Object.keys(members).length;
-    },
-    getMembers: function () {
-        return members;
-    }
-};
-
-module.exports = Members;

service/members/Events.js

-var Events = {
-    DTMF_SUPPORT_CHANGED: "members.dtmf_support_changed"
-};
-
-module.exports = Events;