feat(mute): Add analytics and console logs for audio/video mutes

conference.js

             }).then(([tracks, con]) => {
                 tracks.forEach(track => {
                     if (track.isAudioTrack() && this.isLocalAudioMuted()) {
+                        sendEvent('conference.audio.initiallyMuted');
+                        logger.log('Audio mute: initially muted');
                         track.mute();
                     } else if (track.isVideoTrack()
                                     && this.isLocalVideoMuted()) {
+                        sendEvent('conference.video.initiallyMuted');
+                        logger.log('Video mute: initially muted');
                         track.mute();
                     }
                 });
                     if (audioWasMuted ||
                         currentDevices.audioinput.length >
                         availableAudioInputDevices.length) {
+                        sendEvent('deviceListChanged.audio.muted');
+                        logger.log('Audio mute: device list changed');
                         muteLocalAudio(true);
                     }
 
                         (videoWasMuted ||
                             currentDevices.videoinput.length >
                                 availableVideoInputDevices.length)) {
+                        sendEvent('deviceListChanged.video.muted');
+                        logger.log('Video mute: device list changed');
                         muteLocalVideo(true);
                     }
                 }));

modules/API/API.js

 
 import * as JitsiMeetConferenceEvents from '../../ConferenceEvents';
 import { parseJWTFromURLParams } from '../../react/features/base/jwt';
+import { sendEvent } from '../../react/features/analytics';
 import { getJitsiMeetTransport } from '../transport';
 
 import { API_ID } from './constants';
 
+const logger = require('jitsi-meet-logger').getLogger(__filename);
+
 declare var APP: Object;
 
 /**
         'display-name':
             APP.conference.changeLocalDisplayName.bind(APP.conference),
         'toggle-audio': () => {
+            sendEvent('api.toggle.audio');
+            logger.log('Audio toggle: API command received');
             APP.conference.toggleAudioMuted(false /* no UI */);
         },
         'toggle-video': () => {
+            sendEvent('api.toggle.video');
+            logger.log('Video toggle: API command received');
             APP.conference.toggleVideoMuted(false /* no UI */);
         },
         'toggle-film-strip': APP.UI.toggleFilmstrip,

modules/UI/shared_video/SharedVideo.js

         if (APP.conference.isLocalAudioMuted()
             && !this.mutedWithUserInteraction
             && !this.isSharedVideoVolumeOn()) {
-
+            sendEvent("sharedvideo.audio.unmuted");
+            logger.log('Shared video: audio unmuted');
             this.emitter.emit(UIEvents.AUDIO_MUTED, false, false);
             this.showMicMutedPopup(false);
         }
     smartAudioMute() {
         if (!APP.conference.isLocalAudioMuted()
             && this.isSharedVideoVolumeOn()) {
-
+            sendEvent("sharedvideo.audio.muted");
+            logger.log('Shared video: audio muted');
             this.emitter.emit(UIEvents.AUDIO_MUTED, true, false);
             this.showMicMutedPopup(true);
         }

modules/keyboardshortcut/keyboardshortcut.js

 import { sendEvent } from '../../react/features/analytics';
 import { SpeakerStats } from '../../react/features/speaker-stats';
 
+const logger = require('jitsi-meet-logger').getLogger(__filename);
+
 /**
  * The reference to the shortcut dialogs when opened.
  */
     // register SPACE shortcut in two steps to insure visibility of help message
     KeyboardShortcut.registerShortcut(" ", null, function() {
         sendEvent("shortcut.talk.clicked");
+        logger.log('Talk shortcut pressed');
         APP.conference.muteAudio(true);
     });
     KeyboardShortcut._addShortcutToHelp("SPACE","keyboardShortcuts.pushToTalk");
                 $(":focus").is("textarea"))) {
                 var key = self._getKeyboardKey(e).toUpperCase();
                 if(key === " ") {
-                    if(APP.conference.isLocalAudioMuted())
+                    if(APP.conference.isLocalAudioMuted()) {
+                        sendEvent("shortcut.talk.released");
+                        logger.log('Talk shortcut released');
                         APP.conference.muteAudio(false);
+                    }
                 }
             }
         };

react/features/base/conference/actions.js

 // @flow
 
+import { sendEvent } from '../../analytics';
 import { JitsiConferenceEvents } from '../lib-jitsi-meet';
 import { setAudioMuted, setVideoMuted } from '../media';
 import {
 
 import type { Dispatch } from 'redux';
 
+const logger = require('jitsi-meet-logger').getLogger(__filename);
+
 /**
  * Adds conference (event) listeners.
  *
     conference.on(
         JitsiConferenceEvents.STARTED_MUTED,
         () => {
+            const audioMuted = Boolean(conference.startAudioMuted);
+            const videoMuted = Boolean(conference.startVideoMuted);
+
+            sendEvent(
+                `startmuted.server.audio.${audioMuted ? 'muted' : 'unmuted'}`);
+            sendEvent(
+                `startmuted.server.video.${videoMuted ? 'muted' : 'unmuted'}`);
+            logger.log(`Start muted: ${audioMuted ? 'audio, ' : ''}${
+                videoMuted ? 'video' : ''}`);
+
             // XXX Jicofo tells lib-jitsi-meet to start with audio and/or video
             // muted i.e. Jicofo expresses an intent. Lib-jitsi-meet has turned
             // Jicofo's intent into reality by actually muting the respective
             // TODO Maybe the app needs to learn about Jicofo's intent and
             // transfer that intent to lib-jitsi-meet instead of lib-jitsi-meet
             // acting on Jicofo's intent without the app's knowledge.
-            dispatch(setAudioMuted(Boolean(conference.startAudioMuted)));
-            dispatch(setVideoMuted(Boolean(conference.startVideoMuted)));
+            dispatch(setAudioMuted(audioMuted));
+            dispatch(setVideoMuted(videoMuted));
         });
 
     // Dispatches into features/base/tracks follow:

react/features/base/conference/middleware.js

     _removeLocalTracksFromConference
 } from './functions';
 
+const logger = require('jitsi-meet-logger').getLogger(__filename);
+
 declare var APP: Object;
 
 /**
 function _conferenceFailedOrLeft({ dispatch, getState }, next, action) {
     const result = next(action);
 
-    getState()['features/base/conference'].audioOnly
-        && dispatch(setAudioOnly(false));
+    if (getState()['features/base/conference'].audioOnly) {
+        sendEvent('audioonly.disabled');
+        logger.log('Audio only disabled');
+        dispatch(setAudioOnly(false));
+    }
 
     return result;
 }

react/features/base/media/middleware.js

 /* @flow */
 
+import { sendEvent } from '../../analytics';
 import { SET_ROOM, setAudioOnly } from '../conference';
 import { parseURLParams } from '../config';
 import { MiddlewareRegistry } from '../redux';
 import { setAudioMuted, setCameraFacingMode, setVideoMuted } from './actions';
 import { CAMERA_FACING_MODE } from './constants';
 
+const logger = require('jitsi-meet-logger').getLogger(__filename);
+
 /**
  * Implements the entry point of the middleware of the feature base/media.
  *
     typeof videoMuted === 'undefined'
         && (videoMuted = config.startWithVideoMuted);
 
+    audioMuted = Boolean(audioMuted);
+    videoMuted = Boolean(videoMuted);
+
     // Apply the config.
 
+    sendEvent(`startmuted.client.audio.${audioMuted ? 'muted' : 'unmuted'}`);
+    sendEvent(`startmuted.client.video.${videoMuted ? 'muted' : 'unmuted'}`);
+
+    logger.log(`Start muted: ${audioMuted ? 'audio, ' : ''}${
+        videoMuted ? 'video' : ''}`);
+
     // Unconditionally express the desires/expectations/intents of the app and
     // the user i.e. the state of base/media. Eventually, practice/reality i.e.
     // the state of base/tracks will or will not agree with the desires.
-    dispatch(setAudioMuted(Boolean(audioMuted)));
+    dispatch(setAudioMuted(audioMuted));
     dispatch(setCameraFacingMode(CAMERA_FACING_MODE.USER));
-    dispatch(setVideoMuted(Boolean(videoMuted)));
+    dispatch(setVideoMuted(videoMuted));
 
     // config.startAudioOnly
     //
         let audioOnly = urlParams && urlParams['config.startAudioOnly'];
 
         typeof audioOnly === 'undefined' && (audioOnly = config.startAudioOnly);
-        dispatch(setAudioOnly(Boolean(audioOnly)));
+        audioOnly = Boolean(audioOnly);
+        sendEvent(`startaudioonly.${audioOnly ? 'enabled' : 'disabled'}`);
+        logger.log(`Start audio only set to ${audioOnly.toString()}`);
+        dispatch(setAudioOnly(audioOnly));
     }
 
     return next(action);
     // not yet in redux state and JitsiTrackEvents.TRACK_MUTE_CHANGED may be
     // fired before track gets to state.
     if (track.muted !== muted) {
+        sendEvent(
+            `synctrackstate.${track.mediaType}.${muted ? 'muted' : 'unmuted'}`);
+        logger.log(`Sync ${track.mediaType} track muted state to ${
+            muted ? 'muted' : 'unmuted'}`);
         track.muted = muted;
         setTrackMuted(track.jitsiTrack, muted);
     }

react/features/base/tracks/actions.js

+import { sendEvent } from '../../analytics';
 import { JitsiTrackErrors, JitsiTrackEvents } from '../lib-jitsi-meet';
 import {
     CAMERA_FACING_MODE,
 } from './actionTypes';
 import { createLocalTracksF } from './functions';
 
+const logger = require('jitsi-meet-logger').getLogger(__filename);
+
 /**
  * Requests the creating of the desired media type tracks. Desire is expressed
  * by base/media unless the function caller specifies desired media types
                                 = newTrack.isVideoTrack()
                                     ? setVideoMuted
                                     : setAudioMuted;
+                            const isMuted = newTrack.isMuted();
+
+                            sendEvent(`replacetrack.${newTrack.getType()}.${
+                                isMuted ? 'muted' : 'unmuted'}`);
+                            logger.log(`Replace ${newTrack.getType()} track - ${
+                                isMuted ? 'muted' : 'unmuted'}`);
 
-                            return dispatch(setMuted(newTrack.isMuted()));
+                            return dispatch(setMuted());
                         }
                     })
                     .then(() => {

react/features/mobile/background/actions.js

 /* @flow */
 
+import { sendEvent } from '../../analytics';
 import { setLastN } from '../../base/conference';
 import { setVideoMuted, VIDEO_MUTISM_AUTHORITY } from '../../base/media';
 
         const { audioOnly } = getState()['features/base/conference'];
 
         audioOnly || dispatch(setLastN(muted ? 0 : undefined));
+
+        sendEvent('callkit.background.video.muted');
+
         dispatch(setVideoMuted(muted, VIDEO_MUTISM_AUTHORITY.BACKGROUND));
     };
 }

react/features/mobile/callkit/middleware.js

 import { NativeModules } from 'react-native';
 import uuid from 'uuid';
 
+import { sendEvent } from '../../analytics';
 import { APP_WILL_MOUNT, APP_WILL_UNMOUNT, appNavigate } from '../../app';
 import {
     CONFERENCE_FAILED,
         const { muted: oldValue } = getState()['features/base/media'].audio;
 
         if (oldValue !== newValue) {
-            dispatch(setAudioMuted(Boolean(newValue)));
+            const value = Boolean(newValue);
+
+            sendEvent(`callkit.audio.${value ? 'muted' : 'unmuted'}`);
+            dispatch(setAudioMuted(value));
         }
     }
 }

react/features/remote-video-menu/components/MuteButton.js

         const { dispatch, onClick, participantID } = this.props;
 
         sendEvent(
-            'remotevideomenu.mute',
+            'remotevideomenu.mute.clicked',
             {
                 value: 1,
                 label: participantID

react/features/toolbox/components/Toolbox.native.js

 import { View } from 'react-native';
 import { connect } from 'react-redux';
 
+import { sendEvent } from '../../analytics';
 import { toggleAudioOnly } from '../../base/conference';
 import {
     MEDIA_TYPE,
      * @returns {void}
      */
     _onToggleAudio() {
+        const mute = !this.props._audioMuted;
+
+        sendEvent(`toolbar.audio.${mute ? 'muted' : 'unmuted'}`);
+
         // The user sees the reality i.e. the state of base/tracks and intends
         // to change reality by tapping on the respective button i.e. the user
         // sets the state of base/media. Whether the user's intention will turn
         // tapping.
         this.props.dispatch(
             setAudioMuted(
-                !this.props._audioMuted,
+                mute,
                 VIDEO_MUTISM_AUTHORITY.USER,
                 /* ensureTrack */ true));
     }
      * @returns {void}
      */
     _onToggleVideo() {
+        const mute = !this.props._videoMuted;
+
+        sendEvent(`toolbar.video.${mute ? 'muted' : 'unmuted'}`);
+
         // The user sees the reality i.e. the state of base/tracks and intends
         // to change reality by tapping on the respective button i.e. the user
         // sets the state of base/media. Whether the user's intention will turn

react/features/video-quality/components/VideoQualityDialog.web.js

 import React, { Component } from 'react';
 import { connect } from 'react-redux';
 
+import { sendEvent } from '../../analytics';
 import {
     setAudioOnly,
     setReceiveVideoQuality,
 } from '../../base/conference';
 import { translate } from '../../base/i18n';
 
+const logger = require('jitsi-meet-logger').getLogger(__filename);
+
 const {
     HIGH,
     STANDARD,
      * @returns {void}
      */
     _enableAudioOnly() {
+        sendEvent('toolbar.audioonly.enabled');
+        logger.log('Video quality: audio only enabled');
         this.props.dispatch(setAudioOnly(true));
     }
 
      * @returns {void}
      */
     _enableHighDefinition() {
+        sendEvent('toolbar.videoquality.high');
+        logger.log('Video quality: high enabled');
         this.props.dispatch(setReceiveVideoQuality(HIGH));
     }
 
      * @returns {void}
      */
     _enableLowDefinition() {
+        sendEvent('toolbar.videoquality.low');
+        logger.log('Video quality: low enabled');
         this.props.dispatch(setReceiveVideoQuality(LOW));
     }
 
      * @returns {void}
      */
     _enableStandardDefinition() {
+        sendEvent('toolbar.videoquality.standard');
+        logger.log('Video quality: standard enabled');
         this.props.dispatch(setReceiveVideoQuality(STANDARD));
     }
 
 }
 
 export default translate(connect(_mapStateToProps)(VideoQualityDialog));
-