Merge branch 'talk-muted'

JitsiConference.js

@@ -20,6 +20,7 @@ var VideoType = require('./service/RTC/VideoType');
 var Transcriber = require("./modules/transcription/transcriber");
 var ParticipantConnectionStatus
     = require("./modules/connectivity/ParticipantConnectionStatus");
+import TalkMutedDetection from "./modules/TalkMutedDetection";
 
 /**
  * Creates a JitsiConference object with the given name and properties.
@@ -116,6 +117,12 @@ JitsiConference.prototype._init = function (options) {
     // Always add listeners because on reload we are executing leave and the
     // listeners are removed from statistics module.
     this.eventManager.setupStatisticsListeners();
+
+    if (this.options.config.enableTalkWhileMuted) {
+        new TalkMutedDetection(this, () => {
+            this.eventEmitter.emit(JitsiConferenceEvents.TALK_WHILE_MUTED);
+        });
+    }
 }
 
 /**

JitsiConferenceEvents.js

@@ -118,6 +118,10 @@ export const STARTED_MUTED = "conference.started_muted";
  * Indicates that subject of the conference has changed.
  */
 export const SUBJECT_CHANGED = "conference.subjectChanged";
+/**
+ * Event indicates that local user is talking while he muted himself
+ */
+export const TALK_WHILE_MUTED = "conference.talk_while_muted";
 /**
  * A new media track was added to the conference. The event provides the
  * following parameters to its listeners:

doc/API.md

@@ -219,6 +219,7 @@ This objects represents the server connection. You can create new ```JitsiConnec
         3. jirecon
         4. callStatsID - callstats credentials
         5. callStatsSecret - callstats credentials
+        6. enableTalkWhileMuted - boolean property. Enables/disables talk while muted detection, by default the value is false/disabled.
         **NOTE: if 4 and 5 are set the library is going to send events to callstats. Otherwise the callstats integration will be disabled.**
 
 5. addEventListener(event, listener) - Subscribes the passed listener to the event.

modules/TalkMutedDetection.js

@@ -0,0 +1,110 @@
+import * as JitsiConferenceEvents from "../JitsiConferenceEvents";
+
+export default class TalkMutedDetection {
+    /**
+     * Creates TalkMutedDetection
+     * @param conference the JitsiConference instance that created us.
+     * @param callback the callback to call when detected that the local user is
+     * talking while her microphone is muted.
+     * @constructor
+     */
+    constructor(conference, callback) {
+        /**
+         * The callback to call when detected that the local user is talking
+         * while her microphone is muted.
+         *
+         * @private
+         */
+        this._callback = callback;
+
+        /**
+         * The indicator which determines whether <tt>callback</tt> has been
+         * invoked for the current local audio track of <tt>conference</tt> so
+         * that it is invoked once only.
+         *
+         * @private
+         */
+        this._eventFired = false;
+
+        // XXX I went back and forth on the subject of where to put the access
+        // to statistics. On the one had, (1) statistics is likely intended to
+        // be private to conference and (2) there is a desire to keep the
+        // dependencies of modules to the minimum (i.e. not have
+        // TalkMutedDetection depend on statistics). On the other hand, (1)
+        // statistics is technically not private because
+        // JitsiConferenceEventManager accesses it and (2) TalkMutedDetection
+        // works exactly because it knows that there are no audio levels for
+        // JitsiLocalTrack but there are audio levels for the local participant
+        // through statistics.
+        conference.statistics.addAudioLevelListener(
+            this._audioLevel.bind(this));
+
+        conference.on(
+            JitsiConferenceEvents.TRACK_MUTE_CHANGED,
+            this._trackMuteChanged.bind(this));
+        conference.on(
+            JitsiConferenceEvents.TRACK_ADDED,
+            this._trackAdded.bind(this));
+    }
+
+    /**
+     * Receives audio level events for all send and receive streams.
+     *
+     * @param ssrc - The synchronization source identifier (SSRC) of the
+     * endpoint/participant/stream being reported.
+     * @param {number} audioLevel - The audio level of <tt>ssrc</tt>.
+     * @param {boolean} isLocal - <tt>true</tt> if <tt>ssrc</tt> represents a
+     * local/send stream or <tt>false</tt> for a remote/receive stream.
+     */
+    _audioLevel(ssrc, audioLevel, isLocal) {
+        // We are interested in the local audio stream only and if event is not
+        // sent yet.
+        if (!isLocal || !this.audioTrack || this._eventFired)
+            return;
+
+        if (this.audioTrack.isMuted() && audioLevel > 0.6) {
+            this._eventFired = true;
+            this._callback();
+        }
+    }
+
+    /**
+     * Determines whether a specific {@link JitsiTrack} represents a local audio
+     * track.
+     *
+     * @param {JitsiTrack} track - The <tt>JitsiTrack</tt> to be checked whether
+     * it represents a local audio track.
+     * @private
+     * @return {boolean} - <tt>true</tt> if the specified <tt>track</tt>
+     * represents a local audio track; otherwise, <tt>false</tt>.
+     */
+    _isLocalAudioTrack(track) {
+        return track.isAudioTrack() && track.isLocal();
+    }
+
+    /**
+     * Notifies this <tt>TalkMutedDetection</tt> that a {@link JitsiTrack} was
+     * added to the associated {@link JitsiConference}. Looks for the local
+     * audio track only.
+     *
+     * @param {JitsiTrack} track - The added <tt>JitsiTrack</tt>.
+     * @private
+     */
+    _trackAdded(track) {
+        if (this._isLocalAudioTrack(track))
+            this.audioTrack = track;
+    }
+
+    /**
+     * Notifies this <tt>TalkMutedDetection</tt> that the mute state of a
+     * {@link JitsiTrack} has changed. Looks for the local audio track only.
+     *
+     * @param {JitsiTrack} track - The <tt>JitsiTrack</tt> whose mute state has
+     * changed.
+     * @private
+     */
+    _trackMuteChanged(track) {
+        if (this._isLocalAudioTrack(track) && track.isMuted())
+            this._eventFired = false;
+    }
+}

modules/statistics/RTPStatsCollector.js

@@ -1,10 +1,10 @@
 /* global require */
 /* jshint -W101 */
 
+var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
 var logger = require("jitsi-meet-logger").getLogger(__filename);
 var RTCBrowserType = require("../RTC/RTCBrowserType");
-var StatisticsEvents = require("../../service/statistics/Events");
-var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
+import * as StatisticsEvents from "../../service/statistics/Events";
 
 /* Whether we support the browser we are running into for logging statistics */
 var browserSupported = RTCBrowserType.isChrome() ||
@@ -731,9 +731,9 @@ StatsCollector.prototype.processStatsReport = function () {
             calculatePacketLoss(lostPackets.upload, totalPackets.upload)
     };
     this.eventEmitter.emit(StatisticsEvents.CONNECTION_STATS, {
+            "bandwidth": this.conferenceStats.bandwidth,
             "bitrate": this.conferenceStats.bitrate,
             "packetLoss": this.conferenceStats.packetLoss,
-            "bandwidth": this.conferenceStats.bandwidth,
             "resolution": resolutions,
             "transport": this.conferenceStats.transport
         });
@@ -753,10 +753,8 @@ StatsCollector.prototype.processAudioLevelReport = function () {
     for (var idx in this.currentAudioLevelsReport) {
         var now = this.currentAudioLevelsReport[idx];
 
-        //if we don't have "packetsReceived" this is local stream
-        if (now.type != 'ssrc' || !getStatValue(now, 'packetsReceived')) {
+        if (now.type != 'ssrc')
             continue;
-        }
 
         var before = this.baselineAudioLevelsReport[idx];
         var ssrc = getStatValue(now, 'ssrc');
@@ -788,12 +786,14 @@ StatsCollector.prototype.processAudioLevelReport = function () {
         }
 
         if (audioLevel) {
-            // TODO: can't find specs about what this value really is,
-            // but it seems to vary between 0 and around 32k.
+            const isLocal = !getStatValue(now, 'packetsReceived');
+
+            // TODO: Can't find specs about what this value really is, but it
+            // seems to vary between 0 and around 32k.
             audioLevel = audioLevel / 32767;
             ssrcStats.setSsrcAudioLevel(audioLevel);
             this.eventEmitter.emit(
-                StatisticsEvents.AUDIO_LEVEL, ssrc, audioLevel);
+                StatisticsEvents.AUDIO_LEVEL, ssrc, audioLevel, isLocal);
         }
     }
 };

modules/statistics/statistics.js

@@ -1,13 +1,13 @@
 /* global require */
-var LocalStats = require("./LocalStatsCollector.js");
-var logger = require("jitsi-meet-logger").getLogger(__filename);
-var RTPStats = require("./RTPStatsCollector.js");
-var EventEmitter = require("events");
-var StatisticsEvents = require("../../service/statistics/Events");
 var AnalyticsAdapter = require("./AnalyticsAdapter");
 var CallStats = require("./CallStats");
-var ScriptUtil = require('../util/ScriptUtil');
+var EventEmitter = require("events");
 import JitsiTrackError from "../../JitsiTrackError";
+var logger = require("jitsi-meet-logger").getLogger(__filename);
+var LocalStats = require("./LocalStatsCollector.js");
+var RTPStats = require("./RTPStatsCollector.js");
+var ScriptUtil = require('../util/ScriptUtil');
+import * as StatisticsEvents from "../../service/statistics/Events";
 
 /**
  * True if callstats API is loaded

service/statistics/Events.js

@@ -1,18 +1,33 @@
-module.exports = {
-    /**
-     * FIXME: needs documentation.
-     */
-    AUDIO_LEVEL: "statistics.audioLevel",
-    /**
-     * Notifies about audio problem with remote participant.
-     */
-    AUDIO_NOT_WORKING: "statistics.audio_not_working",
-    /**
-     * An event carrying connection statistics.
-     */
-    CONNECTION_STATS: "statistics.connectionstats",
-    /**
-     * An event carrying all statistics by ssrc.
-     */
-    BYTE_SENT_STATS: "statistics.byte_sent_stats"
-};
+/**
+ * Notifies about audio level in RTP statistics by SSRC.
+ *
+ * @param ssrc - The synchronization source identifier (SSRC) of the
+ * endpoint/participant whose audio level is being reported.
+ * @param {number} audioLevel - The audio level of <tt>ssrc</tt> according to
+ * RTP statistics.
+ * @param {boolean} isLocal - <tt>true</tt> if <tt>ssrc</tt> identifies the
+ * local endpoint/participant; otherwise, <tt>false</tt>.
+ */
+export const AUDIO_LEVEL = "statistics.audioLevel";
+
+/**
+ * Notifies about audio problem with remote participant.
+ *
+ * @param ssrc - The synchronization source identifier (SSRC) of the remote
+ * participant whose audio exhibits problems.
+ */
+export const AUDIO_NOT_WORKING = "statistics.audio_not_working";
+
+/**
+ * An event carrying all statistics by ssrc.
+ */
+export const BYTE_SENT_STATS = "statistics.byte_sent_stats";
+
+/**
+ * An event carrying connection statistics.
+ *
+ * @param {object} connectionStats - The connection statistics carried by the
+ * event such as <tt>bandwidth</tt>, <tt>bitrate</tt>, <tt>packetLoss</tt>,
+ * <tt>resolution</tt>, and <tt>transport</tt>.
+ */
+export const CONNECTION_STATS = "statistics.connectionstats";