address code review

modules/RTC/JitsiTrack.js

         throw new Error('Not implemented by subclass');
     }
 
+    /**
+     * Check whether this is a local audio track.
+     *
+     * @return {boolean} -  true if track represents a local audio track, false otherwise.
+     */
+    isLocalAudioTrack() {
+        return this.isAudioTrack() && this.isLocal();
+    }
+
     /**
      * Returns the WebRTC MediaStream instance.
      */

modules/detection/NoAudioSignalDetection.js

 // potential abnormalities and for a better use experience i.e. don't generate event the instant
 // an audio track is added to the tcr.
 // Potential improvement - add this as a configurable parameter.
-const SILENCE_PERIOD_SEC = 4;
+const SILENCE_PERIOD_MS = 4000;
 
 /**
  * Detect if there is no audio input on the current TraceAblePeerConnection selected track. The no audio
     constructor(conference, callback) {
         this._conference = conference;
         this._callback = callback;
-        this._firstSilentSignalDate = null;
+        this._timeoutTrigger = null;
 
         conference.statistics.addAudioLevelListener(this._audioLevel.bind(this));
         conference.on(JitsiConferenceEvents.TRACK_ADDED, this._trackAdded.bind(this));
     }
 
     /**
-     * Checks if the configured period in which no audio was received has elapsed.
-     *
-     * @returns {boolean}
+     * Clear the timeout state.
      */
-    _hasSilencePeriodElapsed() {
-        const currentDate = new Date();
-        const elapsedSec = (currentDate.getTime() - this._firstSilentSignalDate.getTime()) / 1000;
-
-        if (elapsedSec > SILENCE_PERIOD_SEC) {
-            return true;
-        }
-
-        return false;
+    _clearTriggerTimeout() {
+        clearTimeout(this._timeoutTrigger);
+        this._timeoutTrigger = null;
     }
 
-    /**
-     * Trigger the set callback for no audio input if expected conditions are met.
-     */
-    _triggerNoAudioCallback() {
-        // In case this is the first time 0 audio level was detected initialize the interval check start
-        // date
-        if (!this._firstSilentSignalDate) {
-            this._firstSilentSignalDate = new Date();
-
-        // If the configured interval has elapsed trigger the callback
-        } else if (this._hasSilencePeriodElapsed()) {
-            this._eventFired = true;
-            this._callback();
-        }
-    }
 
     /**
      * Receives audio level events for all send and receive streams on the current TraceablePeerConnection.
             return;
         }
 
-        if (audioLevel === 0) {
-            this._triggerNoAudioCallback();
-        } else {
-            // Reset the period start date in order to check for consistent silence over the configured
-            // time interval.
-            this._firstSilentSignalDate = null;
+        if (audioLevel === 0 && !this._timeoutTrigger) {
+            this._timeoutTrigger = setTimeout(() => {
+                this._eventFired = true;
+                this._callback();
+            }, SILENCE_PERIOD_MS);
+        } else if (audioLevel !== 0 && this._timeoutTrigger) {
+            this._clearTriggerTimeout();
         }
     }
 
-    /**
-     * Determines if a specific JitsiTrack is a local audio track.
-     *
-     * @param {JitsiTrack} track - The JitsiTrack to be checked whether it represents a local audio track.
-     * @return {boolean} -  true if track represents a local audio track, false otherwise.
-     */
-    _isLocalAudioTrack(track) {
-        return track.isAudioTrack() && track.isLocal();
-    }
-
     /**
      * Notifies NoAudioSignalDetection that a JitsiTrack was added to the associated JitsiConference.
      * Only take into account local audio tracks.
      * @param {JitsiTrack} track - The added JitsiTrack.
      */
     _trackAdded(track) {
-        if (this._isLocalAudioTrack(track)) {
+        if (track.isLocalAudioTrack()) {
             // Reset state for the new track.
-            this._firstSilentSignalDate = null;
             this._audioTrack = track;
             this._eventFired = false;
+            this._clearTriggerTimeout();
         }
     }
 }

modules/detection/TrackVADEmitter.js

      *
      * @param {string} micDeviceId - Target microphone device id.
      * @param {number} procNodeSampleRate - Sample rate of the proc node.
+     * @param {Object} vadProcessor -Module that calculates the voice activity score for a certain audio PCM sample.
+     * The processor needs to implement the following functions:
+     * - <tt>getSampleLength()</tt> - Returns the sample size accepted by getSampleLength.
+     * - <tt>getRequiredPCMFrequency()</tt> - Returns the PCM frequency at which the processor operates.
+     * - <tt>calculateAudioFrameVAD(pcmSample)</tt> - Process a 32 float pcm sample of getSampleLength size.
      * @returns {Promise<TrackVADEmitter>} - Promise resolving in a new instance of TrackVADEmitter.
      */
     static create(micDeviceId, procNodeSampleRate, vadProcessor) {

modules/detection/VADTalkMutedDetection.js

          */
         this._vadInitTracker = Promise.resolve();
 
+
+        this._processVADScore = this._processVADScore.bind(this);
+
         /**
          * {@link JitsiConference} bindings.
          */
      * @returns {void}
      */
     _startVADEmitter() {
-        this._vadEmitter.on(VAD_SCORE_PUBLISHED, this._processVADScore.bind(this));
+        this._vadEmitter.on(VAD_SCORE_PUBLISHED, this._processVADScore);
         this._vadEmitter.start();
     }
 
      * @returns {void}
      */
     _stopVADEmitter() {
-        this._vadEmitter.removeAllListeners(VAD_SCORE_PUBLISHED);
+        this._vadEmitter.removeListener(VAD_SCORE_PUBLISHED, this._processVADScore);
         this._vadEmitter.stop();
     }
 
         }
     }
 
-    /**
-     * Determines whether a specific {@link JitsiTrack} represents a local audio track.
-     *
-     * @param {JitsiTrack} track - The track to be checked whether it represents a local audio track.
-     * @return {boolean} - true if the specified track represents a local audio track; otherwise, false.
-     */
-    _isLocalAudioTrack(track) {
-        return track.isAudioTrack() && track.isLocal();
-    }
-
     /**
      * Reset the processing context, clear buffer, cancel the timeout trigger.
      *
      * @listens TRACK_ADDED
      */
     _trackAdded(track) {
-        if (this._isLocalAudioTrack(track)) {
+        if (track.isLocalAudioTrack()) {
             // Keep a track promise so we take into account successive TRACK_ADD events being generated so that we
             // destroy/create the processing context in the proper order.
             this._vadInitTracker
      * @listens TRACK_MUTE_CHANGED
      */
     _trackMuteChanged(track) {
-        if (this._isLocalAudioTrack(track)) {
+        if (track.isLocalAudioTrack()) {
             // On a mute toggle reset the state.
             this._vadInitTracker.then(() => {
 
      * @listens TRACK_REMOVED
      */
     _trackRemoved(track) {
-        if (this._isLocalAudioTrack(track)) {
+        if (track.isLocalAudioTrack()) {
             // Use the promise to make sure operations are in sequence.
             this._vadInitTracker.then(() => {
                 logger.debug('Removing track from VAD detection - ', track.getTrackLabel());