ref(analytics): centralize all event names (#2272)

* ref(analytics): centralize all event names

* squash: fix typo and alpha ordering

* squash: rename file to AnalyticsEvents to parallel lib-jitsi-meet

conference.js

 import UIUtil from './modules/UI/util/UIUtil';
 import * as JitsiMeetConferenceEvents from './ConferenceEvents';
 
-import { initAnalytics, sendAnalyticsEvent } from './react/features/analytics';
+import {
+    CONFERENCE_AUDIO_INITIALLY_MUTED,
+    CONFERENCE_SHARING_DESKTOP_START,
+    CONFERENCE_SHARING_DESKTOP_STOP,
+    CONFERENCE_VIDEO_INITIALLY_MUTED,
+    DEVICE_LIST_CHANGED_AUDIO_MUTED,
+    DEVICE_LIST_CHANGED_VIDEO_MUTED,
+    SELECT_PARTICIPANT_FAILED,
+    SETTINGS_CHANGE_DEVICE_AUDIO_OUT,
+    SETTINGS_CHANGE_DEVICE_AUDIO_IN,
+    SETTINGS_CHANGE_DEVICE_VIDEO,
+    STREAM_SWITCH_DELAY,
+    initAnalytics,
+    sendAnalyticsEvent
+} from './react/features/analytics';
 
 import EventEmitter from 'events';
 
             .then(([ tracks, con ]) => {
                 tracks.forEach(track => {
                     if (track.isAudioTrack() && this.isLocalAudioMuted()) {
-                        sendAnalyticsEvent('conference.audio.initiallyMuted');
+                        sendAnalyticsEvent(CONFERENCE_AUDIO_INITIALLY_MUTED);
                         logger.log('Audio mute: initially muted');
                         track.mute();
                     } else if (track.isVideoTrack()
                                     && this.isLocalVideoMuted()) {
-                        sendAnalyticsEvent('conference.video.initiallyMuted');
+                        sendAnalyticsEvent(CONFERENCE_VIDEO_INITIALLY_MUTED);
                         logger.log('Video mute: initially muted');
                         track.mute();
                     }
             promise = createLocalTracksF({ devices: [ 'video' ] })
                 .then(([ stream ]) => this.useVideoStream(stream))
                 .then(() => {
-                    sendAnalyticsEvent(
-                        'conference.sharingDesktop.stop');
+                    sendAnalyticsEvent(CONFERENCE_SHARING_DESKTOP_STOP);
                     logger.log('switched back to local video');
                     if (!this.localVideo && wasVideoMuted) {
                         return Promise.reject('No local video to be muted!');
             .then(stream => this.useVideoStream(stream))
             .then(() => {
                 this.videoSwitchInProgress = false;
-                sendAnalyticsEvent('conference.sharingDesktop.start');
+                sendAnalyticsEvent(CONFERENCE_SHARING_DESKTOP_START);
                 logger.log('sharing local desktop');
             })
             .catch(error => {
 
                     room.selectParticipant(id);
                 } catch (e) {
-                    sendAnalyticsEvent(
-                        'selectParticipant.failed');
+                    sendAnalyticsEvent(SELECT_PARTICIPANT_FAILED);
                     reportError(e);
                 }
             });
                 // Longer delays will be caused by something else and will just
                 // poison the data.
                 if (delay < 2000) {
-                    sendAnalyticsEvent('stream.switch.delay', { value: delay });
+                    sendAnalyticsEvent(STREAM_SWITCH_DELAY, { value: delay });
                 }
             });
 
             cameraDeviceId => {
                 const videoWasMuted = this.isLocalVideoMuted();
 
-                sendAnalyticsEvent('settings.changeDevice.video');
+                sendAnalyticsEvent(SETTINGS_CHANGE_DEVICE_VIDEO);
                 createLocalTracksF({
                     devices: [ 'video' ],
                     cameraDeviceId,
             micDeviceId => {
                 const audioWasMuted = this.isLocalAudioMuted();
 
-                sendAnalyticsEvent(
-                    'settings.changeDevice.audioIn');
+                sendAnalyticsEvent(SETTINGS_CHANGE_DEVICE_AUDIO_IN);
                 createLocalTracksF({
                     devices: [ 'audio' ],
                     cameraDeviceId: null,
         APP.UI.addListener(
             UIEvents.AUDIO_OUTPUT_DEVICE_CHANGED,
             audioOutputDeviceId => {
-                sendAnalyticsEvent(
-                    'settings.changeDevice.audioOut');
+                sendAnalyticsEvent(SETTINGS_CHANGE_DEVICE_AUDIO_OUT);
                 APP.settings.setAudioOutputDeviceId(audioOutputDeviceId)
                     .then(() => logger.log('changed audio output device'))
                     .catch(err => {
                     // If audio was muted before, or we unplugged current device
                     // and selected new one, then mute new audio track.
                     if (audioWasMuted) {
-                        sendAnalyticsEvent('deviceListChanged.audio.muted');
+                        sendAnalyticsEvent(DEVICE_LIST_CHANGED_AUDIO_MUTED);
                         logger.log('Audio mute: device list changed');
                         muteLocalAudio(true);
                     }
                     // If video was muted before, or we unplugged current device
                     // and selected new one, then mute new video track.
                     if (!this.isSharingScreen && videoWasMuted) {
-                        sendAnalyticsEvent('deviceListChanged.video.muted');
+                        sendAnalyticsEvent(DEVICE_LIST_CHANGED_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 { sendAnalyticsEvent } from '../../react/features/analytics';
+import {
+    API_TOGGLE_AUDIO,
+    API_TOGGLE_VIDEO,
+    sendAnalyticsEvent
+} from '../../react/features/analytics';
 import { getJitsiMeetTransport } from '../transport';
 
 import { API_ID } from './constants';
         'display-name':
             APP.conference.changeLocalDisplayName.bind(APP.conference),
         'toggle-audio': () => {
-            sendAnalyticsEvent('api.toggle.audio');
+            sendAnalyticsEvent(API_TOGGLE_AUDIO);
             logger.log('Audio toggle: API command received');
             APP.conference.toggleAudioMuted(false /* no UI */);
         },
         'toggle-video': () => {
-            sendAnalyticsEvent('api.toggle.video');
+            sendAnalyticsEvent(API_TOGGLE_VIDEO);
             logger.log('Video toggle: API command received');
             APP.conference.toggleVideoMuted(false /* no UI */);
         },

modules/UI/recording/Recording.js

     JitsiRecordingStatus
 } from '../../../react/features/base/lib-jitsi-meet';
 import {
+    RECORDING_CANCELED,
+    RECORDING_CLICKED,
+    RECORDING_STARTED,
+    RECORDING_STOPPED,
     sendAnalyticsEvent
 } from '../../../react/features/analytics';
 import { setToolboxEnabled } from '../../../react/features/toolbox';
             return;
         }
 
-        sendAnalyticsEvent('recording.clicked');
+        sendAnalyticsEvent(RECORDING_CLICKED);
         switch (this.currentState) {
         case JitsiRecordingStatus.ON:
         case JitsiRecordingStatus.RETRYING:
             _showStopRecordingPrompt(this.recordingType).then(
                 () => {
                     this.eventEmitter.emit(UIEvents.RECORDING_TOGGLED);
-                    sendAnalyticsEvent('recording.stopped');
+                    sendAnalyticsEvent(RECORDING_STOPPED);
                 },
                 () => {}); // eslint-disable-line no-empty-function
             break;
                     this.eventEmitter.emit(
                         UIEvents.RECORDING_TOGGLED,
                         { streamId });
-                    sendAnalyticsEvent('recording.started');
+                    sendAnalyticsEvent(RECORDING_STARTED);
                 })
                 .catch(reason => {
                     if (reason === APP.UI.messageHandler.CANCEL) {
-                        sendAnalyticsEvent('recording.canceled');
+                        sendAnalyticsEvent(RECORDING_CANCELED);
                     } else {
                         logger.error(reason);
                     }
                     this.eventEmitter.emit(
                         UIEvents.RECORDING_TOGGLED,
                         { token: this.predefinedToken });
-                    sendAnalyticsEvent('recording.started');
+                    sendAnalyticsEvent(RECORDING_STARTED);
 
                     return;
                 }
                     this.eventEmitter.emit(
                         UIEvents.RECORDING_TOGGLED,
                         { token });
-                    sendAnalyticsEvent('recording.started');
+                    sendAnalyticsEvent(RECORDING_STARTED);
                 })
                 .catch(reason => {
                     if (reason === APP.UI.messageHandler.CANCEL) {
-                        sendAnalyticsEvent('recording.canceled');
+                        sendAnalyticsEvent(RECORDING_CANCELED);
                     } else {
                         logger.error(reason);
                     }

modules/UI/shared_video/SharedVideo.js

 import LargeContainer from '../videolayout/LargeContainer';
 import Filmstrip from '../videolayout/Filmstrip';
 
-import { sendAnalyticsEvent } from '../../../react/features/analytics';
+import {
+    SHARED_VIDEO_ALREADY_SHARED,
+    SHARED_VIDEO_AUDIO_MUTED,
+    SHARED_VIDEO_AUDIO_UNMUTED,
+    SHARED_VIDEO_CANCELED,
+    SHARED_VIDEO_PAUSED,
+    SHARED_VIDEO_STARTED,
+    SHARED_VIDEO_STOPPED,
+    SHARED_VIDEO_VOLUME_CHANGED,
+    sendAnalyticsEvent
+} from '../../../react/features/analytics';
 import {
     participantJoined,
     participantLeft
                     url => {
                         this.emitter.emit(
                             UIEvents.UPDATE_SHARED_VIDEO, url, 'start');
-                        sendAnalyticsEvent('sharedvideo.started');
+                        sendAnalyticsEvent(SHARED_VIDEO_STARTED);
                     },
                     err => {
                         logger.log('SHARED VIDEO CANCELED', err);
-                        sendAnalyticsEvent('sharedvideo.canceled');
+                        sendAnalyticsEvent(SHARED_VIDEO_CANCELED);
                     }
             );
 
                     }
                     this.emitter.emit(
                         UIEvents.UPDATE_SHARED_VIDEO, this.url, 'stop');
-                    sendAnalyticsEvent('sharedvideo.stoped');
+                    sendAnalyticsEvent(SHARED_VIDEO_STOPPED);
                 },
                 () => {}); // eslint-disable-line no-empty-function
         } else {
                 descriptionKey: 'dialog.alreadySharedVideoMsg',
                 titleKey: 'dialog.alreadySharedVideoTitle'
             });
-            sendAnalyticsEvent('sharedvideo.alreadyshared');
+            sendAnalyticsEvent(SHARED_VIDEO_ALREADY_SHARED);
         }
     }
 
                 // eslint-disable-next-line eqeqeq
             } else if (event.data == YT.PlayerState.PAUSED) {
                 self.smartAudioUnmute();
-                sendAnalyticsEvent('sharedvideo.paused');
+                sendAnalyticsEvent(SHARED_VIDEO_PAUSED);
             }
             // eslint-disable-next-line eqeqeq
             self.fireSharedVideoEvent(event.data == YT.PlayerState.PAUSED);
             } else if (event.data.volume <= 0 || event.data.muted) {
                 self.smartAudioUnmute();
             }
-            sendAnalyticsEvent('sharedvideo.volumechanged');
+            sendAnalyticsEvent(SHARED_VIDEO_VOLUME_CHANGED);
         };
 
         window.onPlayerReady = function(event) {
         if (APP.conference.isLocalAudioMuted()
             && !this.mutedWithUserInteraction
             && !this.isSharedVideoVolumeOn()) {
-            sendAnalyticsEvent('sharedvideo.audio.unmuted');
+            sendAnalyticsEvent(SHARED_VIDEO_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()) {
-            sendAnalyticsEvent('sharedvideo.audio.muted');
+            sendAnalyticsEvent(SHARED_VIDEO_AUDIO_MUTED);
             logger.log('Shared video: audio muted');
             this.emitter.emit(UIEvents.AUDIO_MUTED, true, false);
             this.showMicMutedPopup(true);

modules/UI/side_pannels/profile/Profile.js

 import UIEvents from '../../../../service/UI/UIEvents';
 import Settings from '../../../settings/Settings';
 
-import { sendAnalyticsEvent } from '../../../../react/features/analytics';
+import {
+    AUTHENTICATE_LOGIN_CLICKED,
+    AUTHENTICATE_LOGOUT_CLICKED,
+    sendAnalyticsEvent
+} from '../../../../react/features/analytics';
 
 const sidePanelsContainerId = 'sideToolbarContainer';
 const htmlStr = `
          *
          */
         function loginClicked() {
-            sendAnalyticsEvent('authenticate.login.clicked');
+            sendAnalyticsEvent(AUTHENTICATE_LOGIN_CLICKED);
             emitter.emit(UIEvents.AUTH_CLICKED);
         }
 
             const titleKey = 'dialog.logoutTitle';
             const msgKey = 'dialog.logoutQuestion';
 
-            sendAnalyticsEvent('authenticate.logout.clicked');
+            sendAnalyticsEvent(AUTHENTICATE_LOGOUT_CLICKED);
 
             // Ask for confirmation
             APP.UI.messageHandler.openTwoButtonDialog({

modules/UI/videolayout/Filmstrip.js

 import UIEvents from '../../../service/UI/UIEvents';
 import UIUtil from '../util/UIUtil';
 
-import { sendAnalyticsEvent } from '../../../react/features/analytics';
+import {
+    TOOLBAR_FILMSTRIP_TOGGLED,
+    sendAnalyticsEvent
+} from '../../../react/features/analytics';
 
 const Filmstrip = {
     /**
             return;
         }
         if (sendAnalytics) {
-            sendAnalyticsEvent('toolbar.filmstrip.toggled');
+            sendAnalyticsEvent(TOOLBAR_FILMSTRIP_TOGGLED);
         }
         this.filmstrip.toggleClass('hidden');
 

modules/keyboardshortcut/keyboardshortcut.js

 /* global APP, $, interfaceConfig */
 
 import { toggleDialog } from '../../react/features/base/dialog';
-import { sendAnalyticsEvent } from '../../react/features/analytics';
+import {
+    SHORTCUT_HELP,
+    SHORTCUT_SPEAKER_STATS_CLICKED,
+    SHORTCUT_TALK_CLICKED,
+    SHORTCUT_TALK_RELEASED,
+    sendAnalyticsEvent
+} from '../../react/features/analytics';
 import { KeyboardShortcutsDialog }
     from '../../react/features/keyboard-shortcuts';
 import { SpeakerStats } from '../../react/features/speaker-stats';
                 || $(':focus').is('textarea'))) {
                 if (this._getKeyboardKey(e).toUpperCase() === ' ') {
                     if (APP.conference.isLocalAudioMuted()) {
-                        sendAnalyticsEvent('shortcut.talk.released');
+                        sendAnalyticsEvent(SHORTCUT_TALK_RELEASED);
                         logger.log('Talk shortcut released');
                         APP.conference.muteAudio(false);
                     }
      */
     _initGlobalShortcuts() {
         this.registerShortcut('?', null, () => {
-            sendAnalyticsEvent('shortcut.shortcut.help');
+            sendAnalyticsEvent(SHORTCUT_HELP);
             APP.store.dispatch(toggleDialog(KeyboardShortcutsDialog, {
                 shortcutDescriptions: _shortcutsHelp
             }));
         // register SPACE shortcut in two steps to insure visibility of help
         // message
         this.registerShortcut(' ', null, () => {
-            sendAnalyticsEvent('shortcut.talk.clicked');
+            sendAnalyticsEvent(SHORTCUT_TALK_CLICKED);
             logger.log('Talk shortcut pressed');
             APP.conference.muteAudio(true);
         });
 
         if (!interfaceConfig.filmStripOnly) {
             this.registerShortcut('T', null, () => {
-                sendAnalyticsEvent('shortcut.speakerStats.clicked');
+                sendAnalyticsEvent(SHORTCUT_SPEAKER_STATS_CLICKED);
                 APP.store.dispatch(toggleDialog(SpeakerStats, {
                     conference: APP.conference
                 }));

react/features/analytics/AnalyticsEvents.js

+/**
+ * The target of a pin or unpin event was the local participant.
+ *
+ * Known full event names:
+ * pinned.local
+ * unpinned.local
+ *
+ * @type {String}
+ */
+export const _LOCAL = 'local';
+
+/**
+ * The target of a pin or unpin event was a remote participant.
+ *
+ * Known full event names:
+ * pinned.remote
+ * unpinned.remote
+ *
+ * @type {String}
+ */
+export const _REMOTE = 'remote';
+
+/**
+ * Audio mute toggled was triggered through the jitsi-meet api.
+ *
+ * @type {String}
+ */
+export const API_TOGGLE_AUDIO = 'api.toggle.audio';
+
+/**
+ * Video mute toggling was triggered through the jitsi-meet api.
+ *
+ * @type {String}
+ */
+export const API_TOGGLE_VIDEO = 'api.toggle.video';
+
+/**
+ * Audio only mode has been turned off.
+ *
+ * @type {String}
+ */
+export const AUDIO_ONLY_DISABLED = 'audioonly.disabled';
+
+/**
+ * The login button in the profile pane was clicked.
+ *
+ * @type {String}
+ */
+export const AUTHENTICATE_LOGIN_CLICKED = 'authenticate.login.clicked';
+
+/**
+ * The logout button in the profile pane was clicked.
+ *
+ * @type {String}
+ */
+export const AUTHENTICATE_LOGOUT_CLICKED = 'authenticate.logout.clicked';
+
+/**
+ * Performing a mute or unmute event based on a callkit setMuted event.
+ *
+ * Known full event names:
+ * callkit.audio.muted
+ * callkit.audio.unmuted
+ *
+ * @type {String}
+ */
+export const CALLKIT_AUDIO_ = 'callkit.audio';
+
+/**
+ * Toggling remote and local video display when entering or exiting backgrounded
+ * app state.
+ *
+ * @type {String}
+ */
+export const CALLKIT_BACKGROUND_VIDEO_MUTED = 'callkit.background.video.muted';
+
+/**
+ * The local participant joined audio muted.
+ *
+ * @type {String}
+ */
+export const CONFERENCE_AUDIO_INITIALLY_MUTED
+    = 'conference.audio.initiallyMuted';
+
+/**
+ * The local participant has started desktop sharing.
+ *
+ * @type {String}
+ */
+export const CONFERENCE_SHARING_DESKTOP_START
+    = 'conference.sharingDesktop.start';
+
+/**
+ * The local participant was desktop sharing but has stopped.
+ *
+ * @type {String}
+ */
+export const CONFERENCE_SHARING_DESKTOP_STOP
+    = 'conference.sharingDesktop.stop';
+
+/**
+ * The local participant joined video muted.
+ *
+ * @type {String}
+ */
+export const CONFERENCE_VIDEO_INITIALLY_MUTED
+    = 'conference.video.initiallyMuted';
+
+/**
+ * The list of known input/output devices was changed and new audio input has
+ * been used and should start as muted.
+ *
+ * @type {String}
+ */
+export const DEVICE_LIST_CHANGED_AUDIO_MUTED = 'deviceListChanged.audio.muted';
+
+/**
+ * The list of known devices was changed and new video input has been used
+ * and should start as muted.
+ *
+ * @type {String}
+ */
+export const DEVICE_LIST_CHANGED_VIDEO_MUTED = 'deviceListChanged.video.muted';
+
+/**
+ * The feedback dialog is displayed.
+ *
+ * @type {String}
+ */
+export const FEEDBACK_OPEN = 'feedback.open';
+
+/**
+ * Page reload overlay has been displayed.
+ *
+ * Properties: label: reason for reload
+ *
+ * @type {String}
+ */
+export const PAGE_RELOAD = 'page.reload';
+
+/**
+ * The local participant has pinned a participant to remain on large video.
+ *
+ * Known full event names:
+ * pinned.local
+ * pinned.remote
+ *
+ * @type {String}
+ */
+export const PINNED_ = 'pinned';
+
+/**
+ * Recording start was attempted but the local user canceled the request.
+ *
+ * @type {String}
+ */
+export const RECORDING_CANCELED = 'recording.canceled';
+
+/**
+ * Recording button has been clicked.
+ *
+ * @type {String}
+ */
+export const RECORDING_CLICKED = 'recording.clicked';
+
+/**
+ * Recording has been started.
+ *
+ * @type {String}
+ */
+export const RECORDING_STARTED = 'recording.started';
+
+/**
+ * Recording has been stopped by clicking the recording button.
+ *
+ * @type {String}
+ */
+export const RECORDING_STOPPED = 'recording.stopped';
+
+/**
+ * Clicked on the button to kick a remote participant from the conference.
+ *
+ * Properties: value: 1, label: participantID
+ *
+ * @type {String}
+ */
+export const REMOTE_VIDEO_MENU_KICK = 'remotevideomenu.kick';
+
+/**
+ * Clicked on the button to audio mute a remote participant.
+ *
+ * Properties: value: 1, label: participantID
+ *
+ * @type {String}
+ */
+export const REMOTE_VIDEO_MENU_MUTE_CLICKED = 'remotevideomenu.mute.clicked';
+
+/**
+ * Confirmed the muting of a remote participant.
+ *
+ * Properties: value: 1, label: participantID
+ *
+ * @type {String}
+ */
+export const REMOTE_VIDEO_MENU_MUTE_CONFIRMED
+    = 'remotevideomenu.mute.confirmed';
+
+/**
+ * Clicked on the remote control option in the remote menu.
+ *
+ * Properties: value: 1, label: participantID
+ *
+ * Known full event names:
+ * remotevideomenu.remotecontrol.stop
+ * remotevideomenu.remotecontrol.start
+ *
+ * @type {String}
+ */
+export const REMOTE_VIDEO_MENU_REMOTE_CONTROL_
+    = 'remotevideomenu.remotecontrol';
+
+/**
+ * Replacing the currently used track of specified type with a new track of the
+ * same type. The event is fired when changing devices.
+ *
+ * Known full event names:
+ * replacetrack.audio
+ * replacetrack.video
+ *
+ * @type {String}
+ */
+export const REPLACE_TRACK_ = 'replacetrack';
+
+/**
+ * The local participant failed to start receiving high quality video from
+ * a remote participant, which is usually initiated by the remote participant
+ * being put on large video.
+ *
+ * @type {String}
+ */
+export const SELECT_PARTICIPANT_FAILED = 'selectParticipant.failed';
+
+/**
+ * The local participant began using a different audio input device (mic).
+ *
+ * @type {String}
+ */
+export const SETTINGS_CHANGE_DEVICE_AUDIO_IN = 'settings.changeDevice.audioIn';
+
+/**
+ * The local participant began using a different audio output device (speaker).
+ *
+ * @type {String}
+ */
+export const SETTINGS_CHANGE_DEVICE_AUDIO_OUT
+    = 'settings.changeDevice.audioOut';
+
+/**
+ * The local participant began using a different camera.
+ *
+ * @type {String}
+ */
+export const SETTINGS_CHANGE_DEVICE_VIDEO = 'settings.changeDevice.video';
+
+/**
+ * Attempted to start sharing a YouTube video but one is already being shared.
+ *
+ * @type {String}
+ */
+export const SHARED_VIDEO_ALREADY_SHARED = 'sharedvideo.alreadyshared';
+
+/**
+ * The local participant's mic was muted automatically during a shared video.
+ *
+ * @type {String}
+ */
+export const SHARED_VIDEO_AUDIO_MUTED = 'sharedvideo.audio.muted';
+
+/**
+ * The local participant's mic was unmuted automatically during a shared video.
+ *
+ * @type {String}
+ */
+export const SHARED_VIDEO_AUDIO_UNMUTED = 'sharedvideo.audio.unmuted';
+
+/**
+ * Canceled the prompt to enter a YouTube video to share.
+ *
+ * @type {String}
+ */
+export const SHARED_VIDEO_CANCELED = 'sharedvideo.canceled';
+
+/**
+ * The shared YouTube video has been paused.
+ *
+ * @type {String}
+ */
+export const SHARED_VIDEO_PAUSED = 'sharedvideo.paused';
+
+/**
+ * Started sharing a YouTube video.
+ *
+ * @type {String}
+ */
+export const SHARED_VIDEO_STARTED = 'sharedvideo.started';
+
+/**
+ * Confirmed stoppage of the shared YouTube video.
+ *
+ * @type {String}
+ */
+export const SHARED_VIDEO_STOPPED = 'sharedvideo.stoped';
+
+/**
+ * The shared YouTube video had its volume change.
+ *
+ * @type {String}
+ */
+export const SHARED_VIDEO_VOLUME_CHANGED = 'sharedvideo.volumechanged';
+
+/**
+ * Pressed the keyboard shortcut for toggling audio mute.
+ *
+ * @type {String}
+ */
+export const SHORTCUT_AUDIO_MUTE_TOGGLED = 'shortcut.audiomute.toggled';
+
+/**
+ * Pressed the keyboard shortcut for toggling chat panel display.
+ *
+ * @type {String}
+ */
+export const SHORTCUT_CHAT_TOGGLED = 'shortcut.chat.toggled';
+
+/**
+ * Toggled the display of the keyboard shortcuts help dialog.
+ *
+ * @type {String}
+ */
+export const SHORTCUT_HELP = 'shortcut.shortcut.help';
+
+/**
+ * Pressed the keyboard shortcut for togglgin raise hand status.
+ *
+ * @type {String}
+ */
+export const SHORTCUT_RAISE_HAND_CLICKED = 'shortcut.raisehand.clicked';
+
+/**
+ * Pressed the keyboard shortcut for toggling screenshare.
+ *
+ * @type {String}
+ */
+export const SHORTCUT_SCREEN_TOGGLED = 'shortcut.screen.toggled';
+
+/**
+ * Toggled the display of the speaker stats dialog.
+ *
+ * @type {String}
+ */
+export const SHORTCUT_SPEAKER_STATS_CLICKED = 'shortcut.speakerStats.clicked';
+
+/**
+ * Started pressing the key that undoes audio mute while the key is pressed.
+ *
+ * @type {String}
+ */
+export const SHORTCUT_TALK_CLICKED = 'shortcut.talk.clicked';
+
+/**
+ * Released the key used to talk while audio muted, returning to the audio muted
+ * state.
+ *
+ * @type {String}
+ */
+export const SHORTCUT_TALK_RELEASED = 'shortcut.talk.released';
+
+/**
+ * Toggling video mute state using a keyboard shortcut.
+ *
+ * @type {String}
+ */
+export const SHORTCUT_VIDEO_MUTE_TOGGLED = 'shortcut.videomute.toggled';
+
+/**
+ * The config specifies the local participant should start with audio only mode
+ * enabled or disabled.
+ *
+ * Known full event names:
+ * startaudioonly.enabled
+ * startaudioonly.disabled
+ *
+ * @type {String}
+ */
+export const START_AUDIO_ONLY_ = 'startaudioonly';
+
+/**
+ * The config specifies the local participant should start with audio mute
+ * enabled or disabled.
+ *
+ * Known full event names:
+ * startmuted.client.audio.muted
+ * startmuted.client.audio.unmuted
+ *
+ * @type {String}
+ */
+export const START_MUTED_CLIENT_AUDIO_ = 'startmuted.client.audio';
+
+/**
+ * The config specifies the local participant should start with video mute
+ * enabled or disabled.
+ *
+ * Known full event names:
+ * startmuted.client.video.muted
+ * startmuted.client.video.unmuted
+ *
+ * @type {String}
+ */
+export const START_MUTED_CLIENT_VIDEO_ = 'startmuted.client.video';
+
+/**
+ * The local participant has received an event from the server stating to
+ * start audio muted or unmuted.
+ *
+ * Known full event names:
+ * startmuted.server.audio.muted
+ * startmuted.server.audio.unmuted
+ *
+ * @type {String}
+ */
+export const START_MUTED_SERVER_AUDIO_ = 'startmuted.server.audio';
+
+/**
+ * The local participant has received an event from the server stating to
+ * start video muted or unmuted.
+ *
+ * Known full event names:
+ * startmuted.server.video.muted
+ * startmuted.server.video.unmuted
+ *
+ * @type {String}
+ */
+export const START_MUTED_SERVER_VIDEO_ = 'startmuted.server.video';
+
+/**
+ * How long it took to switch between simulcast streams.
+ *
+ * Properties: value
+ *
+ * @type {String}
+ */
+export const STREAM_SWITCH_DELAY = 'stream.switch.delay';
+
+/**
+ * Automatically changing the mute state of a media track in order to match
+ * the current stored state in redux.
+ *
+ * Known full event names:
+ * synctrackstate.audio.muted
+ * synctrackstate.audio.unmuted
+ * synctrackstate.video.muted
+ * synctrackstate.video.unmuted
+ *
+ * @type {String}
+ */
+export const SYNC_TRACK_STATE_ = 'synctrackstate';
+
+/**
+ * Clicked the toolbar button to enter audio mute state.
+ *
+ * @type {String}
+ */
+export const TOOLBAR_AUDIO_MUTED = 'toolbar.audio.muted';
+
+/**
+ * Clicked within a toolbar menu to enable audio only.
+ *
+ * @type {String}
+ */
+export const TOOLBAR_AUDIO_ONLY_ENABLED = 'toolbar.audioonly.enabled';
+
+/**
+ * Clicked the toolbar button to exit audio mute state.
+ *
+ * @type {String}
+ */
+export const TOOLBAR_AUDIO_UNMUTED = 'toolbar.audio.unmuted';
+
+/**
+ * Clicked the toolbar button for toggling chat panel display.
+ *
+ * @type {String}
+ */
+export const TOOLBAR_CHAT_TOGGLED = 'toolbar.chat.toggled';
+
+/**
+ * Clicked the toolbar button for toggling contact list panel display.
+ *
+ * @type {String}
+ */
+export const TOOLBAR_CONTACTS_TOGGLED = 'toolbar.contacts.toggled';
+
+/**
+ * Clicked the toolbar button to toggle display of etherpad (collaborative
+ * document writing).
+ *
+ * @type {String}
+ */
+export const TOOLBAR_ETHERPACK_CLICKED = 'toolbar.etherpad.clicked';
+
+/**
+ * Pressed the keyboard shortcut to open the device selection window while in
+ * filmstrip only mode.
+ *
+ * @type {String}
+ */
+export const TOOLBAR_FILMSTRIP_ONLY_DEVICE_SELECTION_TOGGLED
+    = 'toolbar.fodeviceselection.toggled';
+
+/**
+ * Visibility of the filmstrip has been toggled.
+ *
+ * @type {String}
+ */
+export const TOOLBAR_FILMSTRIP_TOGGLED = 'toolbar.filmstrip.toggled';
+
+/**
+ * Clicked the toolbar button to toggle display full screen mode.
+ *
+ * @type {String}
+ */
+export const TOOLBAR_FULLSCREEN_ENABLED = 'toolbar.fullscreen.enabled';
+
+/**
+ * Clicked the toolbar button to leave the conference.
+ *
+ * @type {String}
+ */
+export const TOOLBAR_HANGUP = 'toolbar.hangup';
+
+/**
+ * Clicked the toolbar button to open the invite dialog.
+ *
+ * @type {String}
+ */
+export const TOOLBAR_INVITE_CLICKED = 'toolbar.invite.clicked';
+
+/**
+ * The invite dialog has been dismissed.
+ *
+ * @type {String}
+ */
+export const TOOLBAR_INVITE_CLOSE = 'toolbar.invite.close';
+
+/**
+ * Clicked the toolbar button for toggling the display of the profile panel.
+ *
+ * @type {String}
+ */
+export const TOOLBAR_PROFILE_TOGGLED = 'toolbar.profile.toggled';
+
+/**
+ * Clicked the toolbar button for toggling raise hand status.
+ *
+ * @type {String}
+ */
+export const TOOLBAR_RAISE_HAND_CLICKED = 'toolbar.raiseHand.clicked';
+
+/**
+ * Clicked the toolbar button to stop screensharing.
+ *
+ * @type {String}
+ */
+export const TOOLBAR_SCREEN_DISABLED = 'toolbar.screen.disabled';
+
+/**
+ * Clicked the toolbar button to start screensharing.
+ *
+ * @type {String}
+ */
+export const TOOLBAR_SCREEN_ENABLED = 'toolbar.screen.enabled';
+
+/**
+ * Clicked the toolbar button for toggling display of the settings menu.
+ *
+ * @type {String}
+ */
+export const TOOLBAR_SETTINGS_TOGGLED = 'toolbar.settings.toggled';
+
+/**
+ * Clicked the toolbar button for toggling a shared YouTube video.
+ *
+ * @type {String}
+ */
+export const TOOLBAR_SHARED_VIDEO_CLICKED = 'toolbar.sharedvideo.clicked';
+
+/**
+ * Clicked the toolbar button to open the dial-out feature.
+ *
+ * @type {String}
+ */
+export const TOOLBAR_SIP_DIALPAD_CLICKED = 'toolbar.sip.dialpad.clicked';
+
+/**
+ * In the mobile app, clicked on the toolbar button to toggle video mute.
+ *
+ * Known full event names:
+ * toolbar.video.muted
+ * toolbar.video.unmuted
+ *
+ * @type {String}
+ */
+export const TOOLBAR_VIDEO_ = 'toolbar.video';
+
+/**
+ * Clicked on the toolbar to video unmute.
+ *
+ * @type {String}
+ */
+export const TOOLBAR_VIDEO_DISABLED = 'toolbar.video.disabled';
+
+/**
+ * Clicked on the toolbar to video mute.
+ *
+ * @type {String}
+ */
+export const TOOLBAR_VIDEO_ENABLED = 'toolbar.video.enabled';
+
+/**
+ * Clicked within a toolbar menu to set max incoming video quality to high
+ * definition.
+ *
+ * @type {String}
+ */
+export const TOOLBAR_VIDEO_QUALITY_HIGH = 'toolbar.videoquality.high';
+
+/**
+ * Clicked within a toolbar menu to set max incoming video quality to low
+ * definition.
+ *
+ * @type {String}
+ */
+export const TOOLBAR_VIDEO_QUALITY_LOW = 'toolbar.videoquality.low';
+
+/**
+ * Clicked within a toolbar menu to set max incoming video quality to standard
+ * definition.
+ *
+ * @type {String}
+ */
+export const TOOLBAR_VIDEO_QUALITY_STANDARD = 'toolbar.videoquality.standard';
+
+/**
+ * The local participant has unpinned a participant so the participant doesn't
+ * remain permanently on local large video.
+ *
+ * Known full event names:
+ * unpinned.local
+ * unpinned.remote
+ *
+ * @type {String}
+ */
+export const UNPINNED_ = 'unpinned';

react/features/analytics/index.js

+export * from './AnalyticsEvents';
 export * from './functions';
 
 import './middleware';

react/features/base/conference/actions.js

 
 import UIEvents from '../../../../service/UI/UIEvents';
 
-import { sendAnalyticsEvent } from '../../analytics';
+import {
+    START_MUTED_SERVER_AUDIO_,
+    START_MUTED_SERVER_VIDEO_,
+    sendAnalyticsEvent
+} from '../../analytics';
 import { getName } from '../../app';
 import { JitsiConferenceEvents } from '../lib-jitsi-meet';
 import { setAudioMuted, setVideoMuted } from '../media';
             const videoMuted = Boolean(conference.startVideoMuted);
 
             sendAnalyticsEvent(
-                `startmuted.server.audio.${audioMuted ? 'muted' : 'unmuted'}`);
+                `${START_MUTED_SERVER_AUDIO_}.${
+                    audioMuted ? 'muted' : 'unmuted'}`);
             sendAnalyticsEvent(
-                `startmuted.server.video.${videoMuted ? 'muted' : 'unmuted'}`);
+                `${START_MUTED_SERVER_VIDEO_}.${
+                    videoMuted ? 'muted' : 'unmuted'}`);
             logger.log(`Start muted: ${audioMuted ? 'audio, ' : ''}${
                 videoMuted ? 'video' : ''}`);
 

react/features/base/conference/middleware.js

 
 import UIEvents from '../../../../service/UI/UIEvents';
 
-import { sendAnalyticsEvent } from '../../analytics';
+import {
+    _LOCAL,
+    _REMOTE,
+    AUDIO_ONLY_DISABLED,
+    PINNED_,
+    UNPINNED_,
+    sendAnalyticsEvent
+} from '../../analytics';
 import { CONNECTION_ESTABLISHED } from '../connection';
 import { setVideoMuted, VIDEO_MUTISM_AUTHORITY } from '../media';
 import {
     const result = next(action);
 
     if (getState()['features/base/conference'].audioOnly) {
-        sendAnalyticsEvent('audioonly.disabled');
+        sendAnalyticsEvent(AUDIO_ONLY_DISABLED);
         logger.log('Audio only disabled');
         dispatch(setAudioOnly(false));
     }
 
     if (typeof APP !== 'undefined') {
         const pinnedParticipant = getPinnedParticipant(participants);
-        const actionName = action.participant.id ? 'pinned' : 'unpinned';
+        const actionName = action.participant.id ? PINNED_ : UNPINNED_;
         let videoType;
 
         if ((participantById && participantById.local)
                 || (!id && pinnedParticipant && pinnedParticipant.local)) {
-            videoType = 'local';
+            videoType = _LOCAL;
         } else {
-            videoType = 'remote';
+            videoType = _REMOTE;
         }
 
         sendAnalyticsEvent(

react/features/base/media/middleware.js

 /* @flow */
 
-import { sendAnalyticsEvent } from '../../analytics';
+import {
+    START_AUDIO_ONLY_,
+    START_MUTED_CLIENT_AUDIO_,
+    START_MUTED_CLIENT_VIDEO_,
+    SYNC_TRACK_STATE_,
+    sendAnalyticsEvent
+} from '../../analytics';
 import { SET_ROOM, setAudioOnly } from '../conference';
 import { parseURLParams } from '../config';
 import JitsiMeetJS from '../lib-jitsi-meet';
     // Apply the config.
 
     sendAnalyticsEvent(
-        `startmuted.client.audio.${audioMuted ? 'muted' : 'unmuted'}`);
+        `${START_MUTED_CLIENT_AUDIO_}.${audioMuted ? 'muted' : 'unmuted'}`);
     sendAnalyticsEvent(
-        `startmuted.client.video.${videoMuted ? 'muted' : 'unmuted'}`);
+        `${START_MUTED_CLIENT_VIDEO_}.${videoMuted ? 'muted' : 'unmuted'}`);
 
     logger.log(`Start muted: ${audioMuted ? 'audio, ' : ''}${
         videoMuted ? 'video' : ''}`);
         }
 
         sendAnalyticsEvent(
-            `startaudioonly.${audioOnly ? 'enabled' : 'disabled'}`);
+            `${START_AUDIO_ONLY_}.${audioOnly ? 'enabled' : 'disabled'}`);
         logger.log(`Start audio only set to ${audioOnly.toString()}`);
         dispatch(setAudioOnly(audioOnly));
     }
     // fired before track gets to state.
     if (track.muted !== muted) {
         sendAnalyticsEvent(
-            `synctrackstate.${track.mediaType}.${muted ? 'muted' : 'unmuted'}`);
+            `${SYNC_TRACK_STATE_}.${track.mediaType}.${
+                muted ? 'muted' : 'unmuted'}`);
         logger.log(`Sync ${track.mediaType} track muted state to ${
             muted ? 'muted' : 'unmuted'}`);
         track.muted = muted;

react/features/base/tracks/actions.js

-import { sendAnalyticsEvent } from '../../analytics';
+import {
+    REPLACE_TRACK_,
+    sendAnalyticsEvent
+} from '../../analytics';
 import { JitsiTrackErrors, JitsiTrackEvents } from '../lib-jitsi-meet';
 import {
     CAMERA_FACING_MODE,
                                     : setAudioMuted;
                             const isMuted = newTrack.isMuted();
 
-                            sendAnalyticsEvent(`replacetrack.${
+                            sendAnalyticsEvent(`${REPLACE_TRACK_}.${
                                 newTrack.getType()}.${
                                 isMuted ? 'muted' : 'unmuted'}`);
                             logger.log(`Replace ${newTrack.getType()} track - ${

react/features/feedback/components/FeedbackDialog.web.js

 import React, { Component } from 'react';
 import { connect } from 'react-redux';
 
-import { sendAnalyticsEvent } from '../../analytics';
+import {
+    FEEDBACK_OPEN,
+    sendAnalyticsEvent
+} from '../../analytics';
 import { Dialog } from '../../base/dialog';
 import { translate } from '../../base/i18n';
 
      * @inheritdoc
      */
     componentDidMount() {
-        sendAnalyticsEvent('feedback.open');
+        sendAnalyticsEvent(FEEDBACK_OPEN);
     }
 
     /**

react/features/invite/components/InviteDialog.web.js

 import React, { Component } from 'react';
 import { connect } from 'react-redux';
 
-import { sendAnalyticsEvent } from '../../analytics';
+import {
+    TOOLBAR_INVITE_CLOSE,
+    sendAnalyticsEvent
+} from '../../analytics';
 import { getInviteURL } from '../../base/connection';
 import { Dialog } from '../../base/dialog';
 import { translate } from '../../base/i18n';
      * @inheritdoc
      */
     componentWillUnmount() {
-        sendAnalyticsEvent('toolbar.invite.close');
+        sendAnalyticsEvent(TOOLBAR_INVITE_CLOSE);
     }
 
     /**

react/features/mobile/background/actions.js

 /* @flow */
 
-import { sendAnalyticsEvent } from '../../analytics';
+import {
+    CALLKIT_BACKGROUND_VIDEO_MUTED,
+    sendAnalyticsEvent
+} from '../../analytics';
 import { setLastN } from '../../base/conference';
 import { setVideoMuted, VIDEO_MUTISM_AUTHORITY } from '../../base/media';
 
 
         audioOnly || dispatch(setLastN(muted ? 0 : undefined));
 
-        sendAnalyticsEvent('callkit.background.video.muted');
+        sendAnalyticsEvent(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 { sendAnalyticsEvent } from '../../analytics';
+import {
+    CALLKIT_AUDIO_,
+    sendAnalyticsEvent
+} from '../../analytics';
 import { APP_WILL_MOUNT, APP_WILL_UNMOUNT, appNavigate } from '../../app';
 import {
     CONFERENCE_FAILED,
         if (oldValue !== newValue) {
             const value = Boolean(newValue);
 
-            sendAnalyticsEvent(`callkit.audio.${value ? 'muted' : 'unmuted'}`);
+            sendAnalyticsEvent(`${CALLKIT_AUDIO_}.${
+                value ? 'muted' : 'unmuted'}`);
             dispatch(setAudioMuted(value));
         }
     }

react/features/overlay/components/AbstractPageReloadOverlay.js

 import PropTypes from 'prop-types';
 import React, { Component } from 'react';
 
+import { PAGE_RELOAD } from '../../analytics';
 import {
     isFatalJitsiConferenceError,
     isFatalJitsiConnectionError
         // sent to the backed.
         // FIXME: We should dispatch action for this.
         APP.conference.logEvent(
-            'page.reload',
+            PAGE_RELOAD,
             /* value */ undefined,
             /* label */ this.props.reason);
         logger.info(

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

 import React, { Component } from 'react';
 import { connect } from 'react-redux';
 
-import { sendAnalyticsEvent } from '../../analytics';
+import {
+    REMOTE_VIDEO_MENU_KICK,
+    sendAnalyticsEvent
+} from '../../analytics';
 import { translate } from '../../base/i18n';
 import { kickParticipant } from '../../base/participants';
 
         const { dispatch, onClick, participantID } = this.props;
 
         sendAnalyticsEvent(
-            'remotevideomenu.kick',
+            REMOTE_VIDEO_MENU_KICK,
             {
                 value: 1,
                 label: participantID

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

 import React, { Component } from 'react';
 import { connect } from 'react-redux';
 
-import { sendAnalyticsEvent } from '../../analytics';
+import {
+    REMOTE_VIDEO_MENU_MUTE_CLICKED,
+    sendAnalyticsEvent
+} from '../../analytics';
 import { translate } from '../../base/i18n';
 import { openDialog } from '../../base/dialog';
 
         const { dispatch, onClick, participantID } = this.props;
 
         sendAnalyticsEvent(
-            'remotevideomenu.mute.clicked',
+            REMOTE_VIDEO_MENU_MUTE_CLICKED,
             {
                 value: 1,
                 label: participantID

react/features/remote-video-menu/components/MuteRemoteParticipantDialog.web.js

 import { Dialog } from '../../base/dialog';
 import { translate } from '../../base/i18n';
 
-import { sendAnalyticsEvent } from '../../analytics';
+import {
+    REMOTE_VIDEO_MENU_MUTE_CONFIRMED,
+    sendAnalyticsEvent
+} from '../../analytics';
 import { muteRemoteParticipant } from '../../base/participants';
 
 /**
         const { dispatch, participantID } = this.props;
 
         sendAnalyticsEvent(
-            'remotevideomenu.mute.confirmed',
+            REMOTE_VIDEO_MENU_MUTE_CONFIRMED,
             {
                 value: 1,
                 label: participantID

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

 import PropTypes from 'prop-types';
 import React, { Component } from 'react';
 
-import { sendAnalyticsEvent } from '../../analytics';
+import {
+    REMOTE_VIDEO_MENU_REMOTE_CONTROL_,
+    sendAnalyticsEvent
+} from '../../analytics';
 import { translate } from '../../base/i18n';
 
 import RemoteVideoMenuButton from './RemoteVideoMenuButton';
 
         if (eventName) {
             sendAnalyticsEvent(
-                `remotevideomenu.remotecontrol.${eventName}`,
+                `${REMOTE_VIDEO_MENU_REMOTE_CONTROL_}.${eventName}`,
                 {
                     value: 1,
                     label: participantID

react/features/toolbox/components/ProfileButton.web.js

 import React, { Component } from 'react';
 import { connect } from 'react-redux';
 
-import { sendAnalyticsEvent } from '../../analytics';
+import { TOOLBAR_PROFILE_TOGGLED, sendAnalyticsEvent } from '../../analytics';
 import { DEFAULT_AVATAR_RELATIVE_PATH } from '../../base/participants';
 import UIEvents from '../../../../service/UI/UIEvents';
 
      */
     _onClick() {
         if (!this.props._unclickable) {
-            sendAnalyticsEvent('toolbar.profile.toggled');
+            sendAnalyticsEvent(TOOLBAR_PROFILE_TOGGLED);
             APP.UI.emitEvent(UIEvents.TOGGLE_PROFILE);
         }
     }

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

 import { View } from 'react-native';
 import { connect } from 'react-redux';
 
-import { sendAnalyticsEvent } from '../../analytics';
+import {
+    TOOLBAR_AUDIO_MUTED,
+    TOOLBAR_AUDIO_UNMUTED,
+    TOOLBAR_VIDEO_,
+    sendAnalyticsEvent
+} from '../../analytics';
 import {
     isNarrowAspectRatio,
     makeAspectRatioAware
     _onToggleAudio() {
         const mute = !this.props._audioMuted;
 
-        sendAnalyticsEvent(`toolbar.audio.${mute ? 'muted' : 'unmuted'}`);
+        sendAnalyticsEvent(mute ? TOOLBAR_AUDIO_MUTED : TOOLBAR_AUDIO_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
     _onToggleVideo() {
         const mute = !this.props._videoMuted;
 
-        sendAnalyticsEvent(`toolbar.video.${mute ? 'muted' : 'unmuted'}`);
+        sendAnalyticsEvent(`${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

react/features/toolbox/defaultToolbarButtons.web.js

 
 import React from 'react';
 
-import { sendAnalyticsEvent } from '../analytics';
+import {
+    SHORTCUT_AUDIO_MUTE_TOGGLED,
+    SHORTCUT_CHAT_TOGGLED,
+    SHORTCUT_RAISE_HAND_CLICKED,
+    SHORTCUT_SCREEN_TOGGLED,
+    SHORTCUT_VIDEO_MUTE_TOGGLED,
+    TOOLBAR_AUDIO_MUTED,
+    TOOLBAR_AUDIO_UNMUTED,
+    TOOLBAR_CHAT_TOGGLED,
+    TOOLBAR_CONTACTS_TOGGLED,
+    TOOLBAR_ETHERPACK_CLICKED,
+    TOOLBAR_FILMSTRIP_ONLY_DEVICE_SELECTION_TOGGLED,
+    TOOLBAR_FULLSCREEN_ENABLED,
+    TOOLBAR_HANGUP,
+    TOOLBAR_INVITE_CLICKED,
+    TOOLBAR_RAISE_HAND_CLICKED,
+    TOOLBAR_SCREEN_DISABLED,
+    TOOLBAR_SCREEN_ENABLED,
+    TOOLBAR_SETTINGS_TOGGLED,
+    TOOLBAR_SHARED_VIDEO_CLICKED,
+    TOOLBAR_SIP_DIALPAD_CLICKED,
+    TOOLBAR_VIDEO_DISABLED,
+    TOOLBAR_VIDEO_ENABLED,
+    sendAnalyticsEvent
+} from '../analytics';
 import { ParticipantCounter } from '../contact-list';
 import { openDeviceSelectionDialog } from '../device-selection';
 import { InfoDialogButton, openInviteDialog } from '../invite';
                 const newVideoMutedState = !APP.conference.isLocalVideoMuted();
 
                 if (newVideoMutedState) {
-                    sendAnalyticsEvent('toolbar.video.enabled');
+                    sendAnalyticsEvent(TOOLBAR_VIDEO_ENABLED);
                 } else {
-                    sendAnalyticsEvent('toolbar.video.disabled');
+                    sendAnalyticsEvent(TOOLBAR_VIDEO_DISABLED);
                 }
                 APP.UI.emitEvent(UIEvents.VIDEO_MUTED, newVideoMutedState);
             },
                     return;
                 }
 
-                sendAnalyticsEvent('shortcut.videomute.toggled');
+                sendAnalyticsEvent(SHORTCUT_VIDEO_MUTE_TOGGLED);
                 APP.conference.toggleVideoMuted();
             },
             shortcutDescription: 'keyboardShortcuts.videoMute',
                 <span id = 'unreadMessages' /></span>,
             id: 'toolbar_button_chat',
             onClick() {
-                sendAnalyticsEvent('toolbar.chat.toggled');
+                sendAnalyticsEvent(TOOLBAR_CHAT_TOGGLED);
                 APP.UI.emitEvent(UIEvents.TOGGLE_CHAT);
             },
             shortcut: 'C',
             shortcutAttr: 'toggleChatPopover',
             shortcutFunc() {
-                sendAnalyticsEvent('shortcut.chat.toggled');
+                sendAnalyticsEvent(SHORTCUT_CHAT_TOGGLED);
                 APP.UI.toggleChat();
             },
             shortcutDescription: 'keyboardShortcuts.toggleChat',
             enabled: true,
             id: 'toolbar_contact_list',
             onClick() {
-                sendAnalyticsEvent(
-                    'toolbar.contacts.toggled');
+                sendAnalyticsEvent(TOOLBAR_CONTACTS_TOGGLED);
                 APP.UI.emitEvent(UIEvents.TOGGLE_CONTACT_LIST);
             },
             sideContainerId: 'contacts_container',
             id: 'toolbar_button_desktopsharing',
             onClick() {
                 if (APP.conference.isSharingScreen) {
-                    sendAnalyticsEvent('toolbar.screen.disabled');
+                    sendAnalyticsEvent(TOOLBAR_SCREEN_DISABLED);
                 } else {
-                    sendAnalyticsEvent('toolbar.screen.enabled');
+                    sendAnalyticsEvent(TOOLBAR_SCREEN_ENABLED);
                 }
                 APP.UI.emitEvent(UIEvents.TOGGLE_SCREENSHARING);
             },
             shortcut: 'D',
             shortcutAttr: 'toggleDesktopSharingPopover',
             shortcutFunc() {
-                sendAnalyticsEvent('shortcut.screen.toggled');
+                sendAnalyticsEvent(SHORTCUT_SCREEN_TOGGLED);
 
                 // eslint-disable-next-line no-empty-function
                 APP.conference.toggleScreenSharing().catch(() => {});
             id: 'toolbar_button_fodeviceselection',
             onClick(dispatch: Function) {
                 sendAnalyticsEvent(
-                    'toolbar.fodeviceselection.toggled');
+                    TOOLBAR_FILMSTRIP_ONLY_DEVICE_SELECTION_TOGGLED);
 
                 dispatch(openDeviceSelectionDialog());
             },
             hidden: true,
             id: 'toolbar_button_dialpad',
             onClick() {
-                sendAnalyticsEvent('toolbar.sip.dialpad.clicked');
+                sendAnalyticsEvent(TOOLBAR_SIP_DIALPAD_CLICKED);
             },
             tooltipKey: 'toolbar.dialpad'
         },
             hidden: true,
             id: 'toolbar_button_etherpad',
             onClick() {
-                sendAnalyticsEvent('toolbar.etherpad.clicked');
+                sendAnalyticsEvent(TOOLBAR_ETHERPACK_CLICKED);
                 APP.UI.emitEvent(UIEvents.ETHERPAD_CLICKED);
             },
             tooltipKey: 'toolbar.etherpad'
             enabled: true,
             id: 'toolbar_button_fullScreen',
             onClick() {
-                sendAnalyticsEvent('toolbar.fullscreen.enabled');
+                sendAnalyticsEvent(TOOLBAR_FULLSCREEN_ENABLED);
 
                 APP.UI.emitEvent(UIEvents.TOGGLE_FULLSCREEN);
             },
             isDisplayed: () => true,
             id: 'toolbar_button_hangup',
             onClick() {
-                sendAnalyticsEvent('toolbar.hangup');
+                sendAnalyticsEvent(TOOLBAR_HANGUP);
                 APP.UI.emitEvent(UIEvents.HANGUP);
             },
             tooltipKey: 'toolbar.hangup'
             enabled: true,
             id: 'toolbar_button_link',
             onClick(dispatch: Function) {
-                sendAnalyticsEvent('toolbar.invite.clicked');
+                sendAnalyticsEvent(TOOLBAR_INVITE_CLICKED);
 
                 dispatch(openInviteDialog());
             },
                         APP.UI.showCustomToolbarPopup(
                             'microphone', 'unableToUnmutePopup', true, 5000);
                     } else {
-                        sendAnalyticsEvent('toolbar.audio.unmuted');
+                        sendAnalyticsEvent(TOOLBAR_AUDIO_UNMUTED);
                         APP.UI.emitEvent(UIEvents.AUDIO_MUTED, false, true);
                     }
                 } else {
-                    sendAnalyticsEvent('toolbar.audio.muted');
+                    sendAnalyticsEvent(TOOLBAR_AUDIO_MUTED);
                     APP.UI.emitEvent(UIEvents.AUDIO_MUTED, true, true);
                 }
             },
             shortcut: 'M',
             shortcutAttr: 'mutePopover',
             shortcutFunc() {
-                sendAnalyticsEvent('shortcut.audiomute.toggled');
+                sendAnalyticsEvent(SHORTCUT_AUDIO_MUTE_TOGGLED);
                 APP.conference.toggleAudioMuted();
             },
             shortcutDescription: 'keyboardShortcuts.mute',
             enabled: true,
             id: 'toolbar_button_raisehand',
             onClick() {
-                sendAnalyticsEvent('toolbar.raiseHand.clicked');
+                sendAnalyticsEvent(TOOLBAR_RAISE_HAND_CLICKED);
                 APP.conference.maybeToggleRaisedHand();
             },
             shortcut: 'R',
             shortcutAttr: 'raiseHandPopover',
             shortcutDescription: 'keyboardShortcuts.raiseHand',
             shortcutFunc() {
-                sendAnalyticsEvent('shortcut.raisehand.clicked');
+                sendAnalyticsEvent(SHORTCUT_RAISE_HAND_CLICKED);
                 APP.conference.maybeToggleRaisedHand();
             },
             tooltipKey: 'toolbar.raiseHand'
             enabled: true,
             id: 'toolbar_button_settings',
             onClick() {
-                sendAnalyticsEvent('toolbar.settings.toggled');
+                sendAnalyticsEvent(TOOLBAR_SETTINGS_TOGGLED);
                 APP.UI.emitEvent(UIEvents.TOGGLE_SETTINGS);
             },
             sideContainerId: 'settings_container',
             enabled: true,
             id: 'toolbar_button_sharedvideo',
             onClick() {
-                sendAnalyticsEvent('toolbar.sharedvideo.clicked');
+                sendAnalyticsEvent(TOOLBAR_SHARED_VIDEO_CLICKED);
                 APP.UI.emitEvent(UIEvents.SHARED_VIDEO_CLICKED);
             },
             popups: [

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

 import React, { Component } from 'react';
 import { connect } from 'react-redux';
 
-import { sendAnalyticsEvent } from '../../analytics';
+import {
+    TOOLBAR_AUDIO_ONLY_ENABLED,
+    TOOLBAR_VIDEO_QUALITY_HIGH,
+    TOOLBAR_VIDEO_QUALITY_LOW,
+    TOOLBAR_VIDEO_QUALITY_STANDARD,
+    sendAnalyticsEvent
+} from '../../analytics';
 import {
     setAudioOnly,
     setReceiveVideoQuality,
      * @returns {void}
      */
     _enableAudioOnly() {
-        sendAnalyticsEvent('toolbar.audioonly.enabled');
+        sendAnalyticsEvent(TOOLBAR_AUDIO_ONLY_ENABLED);
         logger.log('Video quality: audio only enabled');
         this.props.dispatch(setAudioOnly(true));
     }
      * @returns {void}
      */
     _enableHighDefinition() {
-        sendAnalyticsEvent('toolbar.videoquality.high');
+        sendAnalyticsEvent(TOOLBAR_VIDEO_QUALITY_HIGH);
         logger.log('Video quality: high enabled');
         this.props.dispatch(setReceiveVideoQuality(HIGH));
     }
      * @returns {void}
      */
     _enableLowDefinition() {
-        sendAnalyticsEvent('toolbar.videoquality.low');
+        sendAnalyticsEvent(TOOLBAR_VIDEO_QUALITY_LOW);
         logger.log('Video quality: low enabled');
         this.props.dispatch(setReceiveVideoQuality(LOW));
     }
      * @returns {void}
      */
     _enableStandardDefinition() {
-        sendAnalyticsEvent('toolbar.videoquality.standard');
+        sendAnalyticsEvent(TOOLBAR_VIDEO_QUALITY_STANDARD);
         logger.log('Video quality: standard enabled');
         this.props.dispatch(setReceiveVideoQuality(STANDARD));
     }