style(analytics): sendEvent -> sendAnalyticsEvent

conference.js

 import UIUtil from './modules/UI/util/UIUtil';
 import * as JitsiMeetConferenceEvents from './ConferenceEvents';
 
-import { initAnalytics, sendEvent } from './react/features/analytics';
+import { initAnalytics, sendAnalyticsEvent } from './react/features/analytics';
 
 import EventEmitter from 'events';
 
             .then(([ tracks, con ]) => {
                 tracks.forEach(track => {
                     if (track.isAudioTrack() && this.isLocalAudioMuted()) {
-                        sendEvent('conference.audio.initiallyMuted');
+                        sendAnalyticsEvent('conference.audio.initiallyMuted');
                         logger.log('Audio mute: initially muted');
                         track.mute();
                     } else if (track.isVideoTrack()
                                     && this.isLocalVideoMuted()) {
-                        sendEvent('conference.video.initiallyMuted');
+                        sendAnalyticsEvent('conference.video.initiallyMuted');
                         logger.log('Video mute: initially muted');
                         track.mute();
                     }
             promise = createLocalTracksF({ devices: [ 'video' ] })
                 .then(([ stream ]) => this.useVideoStream(stream))
                 .then(() => {
-                    sendEvent(
+                    sendAnalyticsEvent(
                         'conference.sharingDesktop.stop');
                     logger.log('switched back to local video');
                     if (!this.localVideo && wasVideoMuted) {
             .then(stream => this.useVideoStream(stream))
             .then(() => {
                 this.videoSwitchInProgress = false;
-                sendEvent('conference.sharingDesktop.start');
+                sendAnalyticsEvent('conference.sharingDesktop.start');
                 logger.log('sharing local desktop');
             })
             .catch(error => {
 
                     room.selectParticipant(id);
                 } catch (e) {
-                    sendEvent(
+                    sendAnalyticsEvent(
                         'selectParticipant.failed');
                     reportError(e);
                 }
                 // Longer delays will be caused by something else and will just
                 // poison the data.
                 if (delay < 2000) {
-                    sendEvent('stream.switch.delay', { value: delay });
+                    sendAnalyticsEvent('stream.switch.delay', { value: delay });
                 }
             });
 
         APP.UI.addListener(
             UIEvents.VIDEO_DEVICE_CHANGED,
             cameraDeviceId => {
-                sendEvent('settings.changeDevice.video');
+                sendAnalyticsEvent('settings.changeDevice.video');
                 createLocalTracksF({
                     devices: [ 'video' ],
                     cameraDeviceId,
         APP.UI.addListener(
             UIEvents.AUDIO_DEVICE_CHANGED,
             micDeviceId => {
-                sendEvent(
+                sendAnalyticsEvent(
                     'settings.changeDevice.audioIn');
                 createLocalTracksF({
                     devices: [ 'audio' ],
         APP.UI.addListener(
             UIEvents.AUDIO_OUTPUT_DEVICE_CHANGED,
             audioOutputDeviceId => {
-                sendEvent(
+                sendAnalyticsEvent(
                     'settings.changeDevice.audioOut');
                 APP.settings.setAudioOutputDeviceId(audioOutputDeviceId)
                     .then(() => logger.log('changed audio output device'))
                     if (audioWasMuted
                         || currentDevices.audioinput.length
                         > availableAudioInputDevices.length) {
-                        sendEvent('deviceListChanged.audio.muted');
+                        sendAnalyticsEvent('deviceListChanged.audio.muted');
                         logger.log('Audio mute: device list changed');
                         muteLocalAudio(true);
                     }
                         && (videoWasMuted
                             || currentDevices.videoinput.length
                                 > availableVideoInputDevices.length)) {
-                        sendEvent('deviceListChanged.video.muted');
+                        sendAnalyticsEvent('deviceListChanged.video.muted');
                         logger.log('Video mute: device list changed');
                         muteLocalVideo(true);
                     }
      * NOTE: Should be used after conference.init
      */
     logEvent(name, value, label) {
-        sendEvent(name, {
+        sendAnalyticsEvent(name, {
             value,
             label
         });

modules/API/API.js

 
 import * as JitsiMeetConferenceEvents from '../../ConferenceEvents';
 import { parseJWTFromURLParams } from '../../react/features/base/jwt';
-import { sendEvent } from '../../react/features/analytics';
+import { sendAnalyticsEvent } from '../../react/features/analytics';
 import { getJitsiMeetTransport } from '../transport';
 
 import { API_ID } from './constants';
         'display-name':
             APP.conference.changeLocalDisplayName.bind(APP.conference),
         'toggle-audio': () => {
-            sendEvent('api.toggle.audio');
+            sendAnalyticsEvent('api.toggle.audio');
             logger.log('Audio toggle: API command received');
             APP.conference.toggleAudioMuted(false /* no UI */);
         },
         'toggle-video': () => {
-            sendEvent('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 {
-    sendEvent
+    sendAnalyticsEvent
 } from '../../../react/features/analytics';
 import { setToolboxEnabled } from '../../../react/features/toolbox';
 import { setNotificationsEnabled } from '../../../react/features/notifications';
             return;
         }
 
-        sendEvent('recording.clicked');
+        sendAnalyticsEvent('recording.clicked');
         switch (this.currentState) {
         case JitsiRecordingStatus.ON:
         case JitsiRecordingStatus.RETRYING:
             _showStopRecordingPrompt(this.recordingType).then(
                 () => {
                     this.eventEmitter.emit(UIEvents.RECORDING_TOGGLED);
-                    sendEvent('recording.stopped');
+                    sendAnalyticsEvent('recording.stopped');
                 },
                 () => {}); // eslint-disable-line no-empty-function
             break;
                     this.eventEmitter.emit(
                         UIEvents.RECORDING_TOGGLED,
                         { streamId });
-                    sendEvent('recording.started');
+                    sendAnalyticsEvent('recording.started');
                 })
                 .catch(reason => {
                     if (reason === APP.UI.messageHandler.CANCEL) {
-                        sendEvent('recording.canceled');
+                        sendAnalyticsEvent('recording.canceled');
                     } else {
                         logger.error(reason);
                     }
                     this.eventEmitter.emit(
                         UIEvents.RECORDING_TOGGLED,
                         { token: this.predefinedToken });
-                    sendEvent('recording.started');
+                    sendAnalyticsEvent('recording.started');
 
                     return;
                 }
                     this.eventEmitter.emit(
                         UIEvents.RECORDING_TOGGLED,
                         { token });
-                    sendEvent('recording.started');
+                    sendAnalyticsEvent('recording.started');
                 })
                 .catch(reason => {
                     if (reason === APP.UI.messageHandler.CANCEL) {
-                        sendEvent('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 { sendEvent } from '../../../react/features/analytics';
+import { sendAnalyticsEvent } from '../../../react/features/analytics';
 import {
     participantJoined,
     participantLeft
                     url => {
                         this.emitter.emit(
                             UIEvents.UPDATE_SHARED_VIDEO, url, 'start');
-                        sendEvent('sharedvideo.started');
+                        sendAnalyticsEvent('sharedvideo.started');
                     },
                     err => {
                         logger.log('SHARED VIDEO CANCELED', err);
-                        sendEvent('sharedvideo.canceled');
+                        sendAnalyticsEvent('sharedvideo.canceled');
                     }
             );
 
                     }
                     this.emitter.emit(
                         UIEvents.UPDATE_SHARED_VIDEO, this.url, 'stop');
-                    sendEvent('sharedvideo.stoped');
+                    sendAnalyticsEvent('sharedvideo.stoped');
                 },
                 () => {}); // eslint-disable-line no-empty-function
         } else {
                     dialog = null;
                 }
             );
-            sendEvent('sharedvideo.alreadyshared');
+            sendAnalyticsEvent('sharedvideo.alreadyshared');
         }
     }
 
                 // eslint-disable-next-line eqeqeq
             } else if (event.data == YT.PlayerState.PAUSED) {
                 self.smartAudioUnmute();
-                sendEvent('sharedvideo.paused');
+                sendAnalyticsEvent('sharedvideo.paused');
             }
             // eslint-disable-next-line eqeqeq
             self.fireSharedVideoEvent(event.data == YT.PlayerState.PAUSED);
             } else if (event.data.volume <= 0 || event.data.muted) {
                 self.smartAudioUnmute();
             }
-            sendEvent('sharedvideo.volumechanged');
+            sendAnalyticsEvent('sharedvideo.volumechanged');
         };
 
         window.onPlayerReady = function(event) {
         if (APP.conference.isLocalAudioMuted()
             && !this.mutedWithUserInteraction
             && !this.isSharedVideoVolumeOn()) {
-            sendEvent('sharedvideo.audio.unmuted');
+            sendAnalyticsEvent('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');
+            sendAnalyticsEvent('sharedvideo.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 { sendEvent } from '../../../../react/features/analytics';
+import { sendAnalyticsEvent } from '../../../../react/features/analytics';
 
 const sidePanelsContainerId = 'sideToolbarContainer';
 const htmlStr = `
          *
          */
         function loginClicked() {
-            sendEvent('authenticate.login.clicked');
+            sendAnalyticsEvent('authenticate.login.clicked');
             emitter.emit(UIEvents.AUTH_CLICKED);
         }
 
             const titleKey = 'dialog.logoutTitle';
             const msgKey = 'dialog.logoutQuestion';
 
-            sendEvent('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 { sendEvent } from '../../../react/features/analytics';
+import { sendAnalyticsEvent } from '../../../react/features/analytics';
 
 const Filmstrip = {
     /**
             return;
         }
         if (sendAnalytics) {
-            sendEvent('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 { sendEvent } from '../../react/features/analytics';
+import { sendAnalyticsEvent } from '../../react/features/analytics';
 import { SpeakerStats } from '../../react/features/speaker-stats';
 
 const logger = require('jitsi-meet-logger').getLogger(__filename);
                 || $(':focus').is('textarea'))) {
                 if (this._getKeyboardKey(e).toUpperCase() === ' ') {
                     if (APP.conference.isLocalAudioMuted()) {
-                        sendEvent('shortcut.talk.released');
+                        sendAnalyticsEvent('shortcut.talk.released');
                         logger.log('Talk shortcut released');
                         APP.conference.muteAudio(false);
                     }
         });
 
         this.registerShortcut('?', null, () => {
-            sendEvent('shortcut.shortcut.help');
+            sendAnalyticsEvent('shortcut.shortcut.help');
             showKeyboardShortcutsPanel(true);
         }, 'keyboardShortcuts.toggleShortcuts');
 
         // register SPACE shortcut in two steps to insure visibility of help
         // message
         this.registerShortcut(' ', null, () => {
-            sendEvent('shortcut.talk.clicked');
+            sendAnalyticsEvent('shortcut.talk.clicked');
             logger.log('Talk shortcut pressed');
             APP.conference.muteAudio(true);
         });
 
         if (!interfaceConfig.filmStripOnly) {
             this.registerShortcut('T', null, () => {
-                sendEvent('shortcut.speakerStats.clicked');
+                sendAnalyticsEvent('shortcut.speakerStats.clicked');
                 APP.store.dispatch(toggleDialog(SpeakerStats, {
                     conference: APP.conference
                 }));

react/features/analytics/functions.js

 
 const logger = require('jitsi-meet-logger').getLogger(__filename);
 
-export const sendEvent = analytics.sendEvent.bind(analytics);
+export const sendAnalyticsEvent = analytics.sendEvent.bind(analytics);
 
 /**
  * Loads the analytics scripts and inits JitsiMeetJS.analytics by setting

react/features/base/conference/actions.js

 // @flow
 
-import { sendEvent } from '../../analytics';
+import { sendAnalyticsEvent } from '../../analytics';
 import { getName } from '../../app';
 import { JitsiConferenceEvents } from '../lib-jitsi-meet';
 import { setAudioMuted, setVideoMuted } from '../media';
             const audioMuted = Boolean(conference.startAudioMuted);
             const videoMuted = Boolean(conference.startVideoMuted);
 
-            sendEvent(
+            sendAnalyticsEvent(
                 `startmuted.server.audio.${audioMuted ? 'muted' : 'unmuted'}`);
-            sendEvent(
+            sendAnalyticsEvent(
                 `startmuted.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 { sendEvent } from '../../analytics';
+import { 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) {
-        sendEvent('audioonly.disabled');
+        sendAnalyticsEvent('audioonly.disabled');
         logger.log('Audio only disabled');
         dispatch(setAudioOnly(false));
     }
             videoType = 'remote';
         }
 
-        sendEvent(
+        sendAnalyticsEvent(
                 `${actionName}.${videoType}`,
                 { value: conference.getParticipantCount() });
     }

react/features/base/media/middleware.js

 /* @flow */
 
-import { sendEvent } from '../../analytics';
+import { sendAnalyticsEvent } from '../../analytics';
 import { SET_ROOM, setAudioOnly } from '../conference';
 import { parseURLParams } from '../config';
 import { MiddlewareRegistry } from '../redux';
 
     // Apply the config.
 
-    sendEvent(`startmuted.client.audio.${audioMuted ? 'muted' : 'unmuted'}`);
-    sendEvent(`startmuted.client.video.${videoMuted ? 'muted' : 'unmuted'}`);
+    sendAnalyticsEvent(
+        `startmuted.client.audio.${audioMuted ? 'muted' : 'unmuted'}`);
+    sendAnalyticsEvent(
+        `startmuted.client.video.${videoMuted ? 'muted' : 'unmuted'}`);
 
     logger.log(`Start muted: ${audioMuted ? 'audio, ' : ''}${
         videoMuted ? 'video' : ''}`);
 
         typeof audioOnly === 'undefined' && (audioOnly = config.startAudioOnly);
         audioOnly = Boolean(audioOnly);
-        sendEvent(`startaudioonly.${audioOnly ? 'enabled' : 'disabled'}`);
+        sendAnalyticsEvent(
+            `startaudioonly.${audioOnly ? 'enabled' : 'disabled'}`);
         logger.log(`Start audio only set to ${audioOnly.toString()}`);
         dispatch(setAudioOnly(audioOnly));
     }
     // not yet in redux state and JitsiTrackEvents.TRACK_MUTE_CHANGED may be
     // fired before track gets to state.
     if (track.muted !== muted) {
-        sendEvent(
+        sendAnalyticsEvent(
             `synctrackstate.${track.mediaType}.${muted ? 'muted' : 'unmuted'}`);
         logger.log(`Sync ${track.mediaType} track muted state to ${
             muted ? 'muted' : 'unmuted'}`);

react/features/base/tracks/actions.js

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

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

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

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

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

react/features/mobile/background/actions.js

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

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

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

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

 import React, { Component } from 'react';
 import { connect } from 'react-redux';
 
-import { sendEvent } from '../../analytics';
+import { sendAnalyticsEvent } from '../../analytics';
 import { translate } from '../../base/i18n';
 import { muteRemoteParticipant } from '../../base/participants';
 
     _onClick() {
         const { dispatch, onClick, participantID } = this.props;
 
-        sendEvent(
+        sendAnalyticsEvent(
             'remotevideomenu.mute.clicked',
             {
                 value: 1,

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

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

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

 import React, { Component } from 'react';
 import { connect } from 'react-redux';
 
-import { sendEvent } from '../../analytics';
+import { sendAnalyticsEvent } from '../../analytics';
 import { DEFAULT_AVATAR_RELATIVE_PATH } from '../../base/participants';
 import UIEvents from '../../../../service/UI/UIEvents';
 
      */
     _onClick() {
         if (!this.props._unclickable) {
-            sendEvent('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 { sendEvent } from '../../analytics';
+import { sendAnalyticsEvent } from '../../analytics';
 import { toggleAudioOnly } from '../../base/conference';
 import {
     MEDIA_TYPE,
     _onToggleAudio() {
         const mute = !this.props._audioMuted;
 
-        sendEvent(`toolbar.audio.${mute ? 'muted' : 'unmuted'}`);
+        sendAnalyticsEvent(`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
     _onToggleVideo() {
         const mute = !this.props._videoMuted;
 
-        sendEvent(`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 { sendEvent } from '../analytics';
+import { 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) {
-                    sendEvent('toolbar.video.enabled');
+                    sendAnalyticsEvent('toolbar.video.enabled');
                 } else {
-                    sendEvent('toolbar.video.disabled');
+                    sendAnalyticsEvent('toolbar.video.disabled');
                 }
                 APP.UI.emitEvent(UIEvents.VIDEO_MUTED, newVideoMutedState);
             },
                     return;
                 }
 
-                sendEvent('shortcut.videomute.toggled');
+                sendAnalyticsEvent('shortcut.videomute.toggled');
                 APP.conference.toggleVideoMuted();
             },
             shortcutDescription: 'keyboardShortcuts.videoMute',
                 <span id = 'unreadMessages' /></span>,
             id: 'toolbar_button_chat',
             onClick() {
-                sendEvent('toolbar.chat.toggled');
+                sendAnalyticsEvent('toolbar.chat.toggled');
                 APP.UI.emitEvent(UIEvents.TOGGLE_CHAT);
             },
             shortcut: 'C',
             shortcutAttr: 'toggleChatPopover',
             shortcutFunc() {
-                sendEvent('shortcut.chat.toggled');
+                sendAnalyticsEvent('shortcut.chat.toggled');
                 APP.UI.toggleChat();
             },
             shortcutDescription: 'keyboardShortcuts.toggleChat',
             enabled: true,
             id: 'toolbar_contact_list',
             onClick() {
-                sendEvent(
+                sendAnalyticsEvent(
                     'toolbar.contacts.toggled');
                 APP.UI.emitEvent(UIEvents.TOGGLE_CONTACT_LIST);
             },
             id: 'toolbar_button_desktopsharing',
             onClick() {
                 if (APP.conference.isSharingScreen) {
-                    sendEvent('toolbar.screen.disabled');
+                    sendAnalyticsEvent('toolbar.screen.disabled');
                 } else {
-                    sendEvent('toolbar.screen.enabled');
+                    sendAnalyticsEvent('toolbar.screen.enabled');
                 }
                 APP.UI.emitEvent(UIEvents.TOGGLE_SCREENSHARING);
             },
             shortcut: 'D',
             shortcutAttr: 'toggleDesktopSharingPopover',
             shortcutFunc() {
-                sendEvent('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) {
-                sendEvent(
+                sendAnalyticsEvent(
                     'toolbar.fodeviceselection.toggled');
 
                 dispatch(openDeviceSelectionDialog());
             hidden: true,
             id: 'toolbar_button_dialpad',
             onClick() {
-                sendEvent('toolbar.sip.dialpad.clicked');
+                sendAnalyticsEvent('toolbar.sip.dialpad.clicked');
             },
             tooltipKey: 'toolbar.dialpad'
         },
             hidden: true,
             id: 'toolbar_button_etherpad',
             onClick() {
-                sendEvent('toolbar.etherpad.clicked');
+                sendAnalyticsEvent('toolbar.etherpad.clicked');
                 APP.UI.emitEvent(UIEvents.ETHERPAD_CLICKED);
             },
             tooltipKey: 'toolbar.etherpad'
             enabled: true,
             id: 'toolbar_button_fullScreen',
             onClick() {
-                sendEvent('toolbar.fullscreen.enabled');
+                sendAnalyticsEvent('toolbar.fullscreen.enabled');
 
                 APP.UI.emitEvent(UIEvents.TOGGLE_FULLSCREEN);
             },
             shortcutAttr: 'toggleFullscreenPopover',
             shortcutDescription: 'keyboardShortcuts.fullScreen',
             shortcutFunc() {
-                sendEvent('shortcut.fullscreen.toggled');
+                sendAnalyticsEvent('shortcut.fullscreen.toggled');
                 APP.UI.toggleFullScreen();
             },
             tooltipKey: 'toolbar.fullscreen'
             isDisplayed: () => true,
             id: 'toolbar_button_hangup',
             onClick() {
-                sendEvent('toolbar.hangup');
+                sendAnalyticsEvent('toolbar.hangup');
                 APP.UI.emitEvent(UIEvents.HANGUP);
             },
             tooltipKey: 'toolbar.hangup'
             enabled: true,
             id: 'toolbar_button_link',
             onClick(dispatch: Function) {
-                sendEvent('toolbar.invite.clicked');
+                sendAnalyticsEvent('toolbar.invite.clicked');
 
                 dispatch(openInviteDialog());
             },
                         APP.UI.showCustomToolbarPopup(
                             'microphone', 'unableToUnmutePopup', true, 5000);
                     } else {
-                        sendEvent('toolbar.audio.unmuted');
+                        sendAnalyticsEvent('toolbar.audio.unmuted');
                         APP.UI.emitEvent(UIEvents.AUDIO_MUTED, false, true);
                     }
                 } else {
-                    sendEvent('toolbar.audio.muted');
+                    sendAnalyticsEvent('toolbar.audio.muted');
                     APP.UI.emitEvent(UIEvents.AUDIO_MUTED, true, true);
                 }
             },
             shortcut: 'M',
             shortcutAttr: 'mutePopover',
             shortcutFunc() {
-                sendEvent('shortcut.audiomute.toggled');
+                sendAnalyticsEvent('shortcut.audiomute.toggled');
                 APP.conference.toggleAudioMuted();
             },
             shortcutDescription: 'keyboardShortcuts.mute',
             enabled: true,
             id: 'toolbar_button_raisehand',
             onClick() {
-                sendEvent('toolbar.raiseHand.clicked');
+                sendAnalyticsEvent('toolbar.raiseHand.clicked');
                 APP.conference.maybeToggleRaisedHand();
             },
             shortcut: 'R',
             shortcutAttr: 'raiseHandPopover',
             shortcutDescription: 'keyboardShortcuts.raiseHand',
             shortcutFunc() {
-                sendEvent('shortcut.raisehand.clicked');
+                sendAnalyticsEvent('shortcut.raisehand.clicked');
                 APP.conference.maybeToggleRaisedHand();
             },
             tooltipKey: 'toolbar.raiseHand'
             enabled: true,
             id: 'toolbar_button_settings',
             onClick() {
-                sendEvent('toolbar.settings.toggled');
+                sendAnalyticsEvent('toolbar.settings.toggled');
                 APP.UI.emitEvent(UIEvents.TOGGLE_SETTINGS);
             },
             sideContainerId: 'settings_container',
             enabled: true,
             id: 'toolbar_button_sharedvideo',
             onClick() {
-                sendEvent('toolbar.sharedvideo.clicked');
+                sendAnalyticsEvent('toolbar.sharedvideo.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 { sendEvent } from '../../analytics';
+import { sendAnalyticsEvent } from '../../analytics';
 import {
     setAudioOnly,
     setReceiveVideoQuality,
      * @returns {void}
      */
     _enableAudioOnly() {
-        sendEvent('toolbar.audioonly.enabled');
+        sendAnalyticsEvent('toolbar.audioonly.enabled');
         logger.log('Video quality: audio only enabled');
         this.props.dispatch(setAudioOnly(true));
     }
      * @returns {void}
      */
     _enableHighDefinition() {
-        sendEvent('toolbar.videoquality.high');
+        sendAnalyticsEvent('toolbar.videoquality.high');
         logger.log('Video quality: high enabled');
         this.props.dispatch(setReceiveVideoQuality(HIGH));
     }
      * @returns {void}
      */
     _enableLowDefinition() {
-        sendEvent('toolbar.videoquality.low');
+        sendAnalyticsEvent('toolbar.videoquality.low');
         logger.log('Video quality: low enabled');
         this.props.dispatch(setReceiveVideoQuality(LOW));
     }
      * @returns {void}
      */
     _enableStandardDefinition() {
-        sendEvent('toolbar.videoquality.standard');
+        sendAnalyticsEvent('toolbar.videoquality.standard');
         logger.log('Video quality: standard enabled');
         this.props.dispatch(setReceiveVideoQuality(STANDARD));
     }