ref(analytics): Use analytics from features/analytics

conference.js

 import UIUtil from './modules/UI/util/UIUtil';
 import * as JitsiMeetConferenceEvents from './ConferenceEvents';
 
-import { initAnalytics } from './react/features/analytics';
+import { initAnalytics, sendEvent } from './react/features/analytics';
 
 import EventEmitter from "events";
 
             promise = createLocalTracksF({ devices: ['video'] })
                 .then(([stream]) => this.useVideoStream(stream))
                 .then(() => {
-                    JitsiMeetJS.analytics.sendEvent(
+                    sendEvent(
                         'conference.sharingDesktop.stop');
                     logger.log('switched back to local video');
                     if (!this.localVideo && wasVideoMuted) {
             return this.useVideoStream(stream);
         }).then(() => {
             this.videoSwitchInProgress = false;
-            JitsiMeetJS.analytics.sendEvent('conference.sharingDesktop.start');
+            sendEvent('conference.sharingDesktop.start');
             logger.log('sharing local desktop');
         }).catch(error => {
             this.videoSwitchInProgress = false;
 
                     room.selectParticipant(id);
                 } catch (e) {
-                    JitsiMeetJS.analytics.sendEvent(
+                    sendEvent(
                         'selectParticipant.failed');
                     reportError(e);
                 }
                 // Longer delays will be caused by something else and will just
                 // poison the data.
                 if (delay < 2000) {
-                    JitsiMeetJS.analytics.sendEvent('stream.switch.delay',
+                    sendEvent('stream.switch.delay',
                         {value: delay});
                 }
             });
         APP.UI.addListener(
             UIEvents.VIDEO_DEVICE_CHANGED,
             (cameraDeviceId) => {
-                JitsiMeetJS.analytics.sendEvent('settings.changeDevice.video');
+                sendEvent('settings.changeDevice.video');
                 createLocalTracksF({
                     devices: ['video'],
                     cameraDeviceId: cameraDeviceId,
         APP.UI.addListener(
             UIEvents.AUDIO_DEVICE_CHANGED,
             (micDeviceId) => {
-                JitsiMeetJS.analytics.sendEvent(
+                sendEvent(
                     'settings.changeDevice.audioIn');
                 createLocalTracksF({
                     devices: ['audio'],
         APP.UI.addListener(
             UIEvents.AUDIO_OUTPUT_DEVICE_CHANGED,
             (audioOutputDeviceId) => {
-                JitsiMeetJS.analytics.sendEvent(
+                sendEvent(
                     'settings.changeDevice.audioOut');
                 APP.settings.setAudioOutputDeviceId(audioOutputDeviceId)
                     .then(() => logger.log('changed audio output device'))
      * NOTE: Should be used after conference.init
      */
     logEvent(name, value, label) {
-        if (JitsiMeetJS.analytics) {
-            JitsiMeetJS.analytics.sendEvent(name, {value, label});
-        }
+        sendEvent(name, {value, label});
         if (room) {
             room.sendApplicationLog(JSON.stringify({name, value, label}));
         }

modules/UI/recording/Recording.js

-/* global APP, $, config, interfaceConfig, JitsiMeetJS */
+/* global APP, $, config, interfaceConfig */
 /*
  * Copyright @ 2015 Atlassian Pty Ltd
  *
 import {
     JitsiRecordingStatus
 } from '../../../react/features/base/lib-jitsi-meet';
+import {
+    sendEvent
+} from '../../../react/features/analytics';
 import { setToolboxEnabled } from '../../../react/features/toolbox';
 import { setNotificationsEnabled } from '../../../react/features/notifications';
 import {
             return;
         }
 
-        JitsiMeetJS.analytics.sendEvent('recording.clicked');
+        sendEvent('recording.clicked');
         switch (this.currentState) {
         case JitsiRecordingStatus.ON:
         case JitsiRecordingStatus.RETRYING:
             _showStopRecordingPrompt(this.recordingType).then(
                 () => {
                     this.eventEmitter.emit(UIEvents.RECORDING_TOGGLED);
-                    JitsiMeetJS.analytics.sendEvent('recording.stopped');
+                    sendEvent('recording.stopped');
                 },
                 () => {});
             break;
                     this.eventEmitter.emit(
                         UIEvents.RECORDING_TOGGLED,
                         { streamId });
-                    JitsiMeetJS.analytics.sendEvent('recording.started');
+                    sendEvent('recording.started');
                 }).catch(reason => {
                     if (reason !== APP.UI.messageHandler.CANCEL)
                         logger.error(reason);
                     else
-                        JitsiMeetJS.analytics.sendEvent('recording.canceled');
+                        sendEvent('recording.canceled');
                 });
             else {
                 if (this.predefinedToken) {
                     this.eventEmitter.emit(
                         UIEvents.RECORDING_TOGGLED,
                         { token: this.predefinedToken });
-                    JitsiMeetJS.analytics.sendEvent('recording.started');
+                    sendEvent('recording.started');
                     return;
                 }
 
                     this.eventEmitter.emit(
                         UIEvents.RECORDING_TOGGLED,
                         { token });
-                    JitsiMeetJS.analytics.sendEvent('recording.started');
+                    sendEvent('recording.started');
                 }).catch(reason => {
                     if (reason !== APP.UI.messageHandler.CANCEL)
                         logger.error(reason);
                     else
-                        JitsiMeetJS.analytics.sendEvent('recording.canceled');
+                        sendEvent('recording.canceled');
                 });
             }
             break;

modules/UI/shared_video/SharedVideo.js

-/* global $, APP, YT, onPlayerReady, onPlayerStateChange, onPlayerError,
-JitsiMeetJS */
+/* global $, APP, YT, onPlayerReady, onPlayerStateChange, onPlayerError */
 const logger = require("jitsi-meet-logger").getLogger(__filename);
 
 import UIUtil from '../util/UIUtil';
 import LargeContainer from '../videolayout/LargeContainer';
 import Filmstrip from '../videolayout/Filmstrip';
 
+import { sendEvent } from '../../../react/features/analytics';
 import {
     participantJoined,
     participantLeft
                     url => {
                         this.emitter.emit(
                             UIEvents.UPDATE_SHARED_VIDEO, url, 'start');
-                        JitsiMeetJS.analytics.sendEvent('sharedvideo.started');
+                        sendEvent('sharedvideo.started');
                     },
                     err => {
                         logger.log('SHARED VIDEO CANCELED', err);
-                        JitsiMeetJS.analytics.sendEvent('sharedvideo.canceled');
+                        sendEvent('sharedvideo.canceled');
                     }
             );
             return;
                     }
                     this.emitter.emit(
                         UIEvents.UPDATE_SHARED_VIDEO, this.url, 'stop');
-                    JitsiMeetJS.analytics.sendEvent('sharedvideo.stoped');
+                    sendEvent('sharedvideo.stoped');
                 },
                 () => {});
         } else {
                     dialog = null;
                 }
             );
-            JitsiMeetJS.analytics.sendEvent('sharedvideo.alreadyshared');
+            sendEvent('sharedvideo.alreadyshared');
         }
     }
 
                 self.smartAudioMute();
             } else if (event.data == YT.PlayerState.PAUSED) {
                 self.smartAudioUnmute();
-                JitsiMeetJS.analytics.sendEvent('sharedvideo.paused');
+                sendEvent('sharedvideo.paused');
             }
             self.fireSharedVideoEvent(event.data == YT.PlayerState.PAUSED);
         };
             else if (event.data.volume <=0 || event.data.muted) {
                 self.smartAudioUnmute();
             }
-            JitsiMeetJS.analytics.sendEvent('sharedvideo.volumechanged');
+            sendEvent('sharedvideo.volumechanged');
         };
 
         window.onPlayerReady = function(event) {

modules/UI/side_pannels/profile/Profile.js

-/* global $, APP, JitsiMeetJS */
+/* global $, APP */
 import UIUtil from "../../util/UIUtil";
 import UIEvents from "../../../../service/UI/UIEvents";
 import Settings from '../../../settings/Settings';
 
+import { sendEvent } from '../../../../react/features/analytics';
+
 const sidePanelsContainerId = 'sideToolbarContainer';
 const htmlStr = `
     <div id="profile_container" class="sideToolbarContainer__inner">
 
         // LOGIN
         function loginClicked () {
-            JitsiMeetJS.analytics.sendEvent('authenticate.login.clicked');
+            sendEvent('authenticate.login.clicked');
             emitter.emit(UIEvents.AUTH_CLICKED);
         }
 
         function logoutClicked () {
             let titleKey = "dialog.logoutTitle";
             let msgKey = "dialog.logoutQuestion";
-            JitsiMeetJS.analytics.sendEvent('authenticate.logout.clicked');
+            sendEvent('authenticate.logout.clicked');
             // Ask for confirmation
             APP.UI.messageHandler.openTwoButtonDialog({
                 titleKey: titleKey,

modules/UI/videolayout/Filmstrip.js

-/* global $, APP, JitsiMeetJS, interfaceConfig */
+/* global $, APP, interfaceConfig */
 
 import { setFilmstripVisibility } from '../../../react/features/filmstrip';
 
 import UIEvents from "../../../service/UI/UIEvents";
 import UIUtil from "../util/UIUtil";
 
+import { sendEvent } from '../../../react/features/analytics';
+
 const Filmstrip = {
     /**
      *
             return;
         }
         if (sendAnalytics) {
-            JitsiMeetJS.analytics.sendEvent('toolbar.filmstrip.toggled');
+            sendEvent('toolbar.filmstrip.toggled');
         }
         this.filmstrip.toggleClass("hidden");
 

modules/keyboardshortcut/keyboardshortcut.js

-/* global APP, $, JitsiMeetJS, interfaceConfig */
+/* global APP, $, interfaceConfig */
 
 import { toggleDialog } from '../../react/features/base/dialog';
+import { sendEvent } from '../../react/features/analytics';
 import { SpeakerStats } from '../../react/features/speaker-stats';
 
 /**
     });
 
     KeyboardShortcut.registerShortcut("?", null, function() {
-        JitsiMeetJS.analytics.sendEvent("shortcut.shortcut.help");
+        sendEvent("shortcut.shortcut.help");
         showKeyboardShortcutsPanel(true);
     }, "keyboardShortcuts.toggleShortcuts");
 
     // register SPACE shortcut in two steps to insure visibility of help message
     KeyboardShortcut.registerShortcut(" ", null, function() {
-        JitsiMeetJS.analytics.sendEvent("shortcut.talk.clicked");
+        sendEvent("shortcut.talk.clicked");
         APP.conference.muteAudio(true);
     });
     KeyboardShortcut._addShortcutToHelp("SPACE","keyboardShortcuts.pushToTalk");
 
     if(!interfaceConfig.filmStripOnly) {
         KeyboardShortcut.registerShortcut("T", null, () => {
-            JitsiMeetJS.analytics.sendEvent("shortcut.speakerStats.clicked");
+            sendEvent("shortcut.speakerStats.clicked");
             APP.store.dispatch(toggleDialog(SpeakerStats, {
                 conference: APP.conference
             }));

react/features/analytics/functions.js

 // @flow
 
-import JitsiMeetJS, { isAnalyticsEnabled } from '../base/lib-jitsi-meet';
+import JitsiMeetJS, {
+    analytics,
+    isAnalyticsEnabled
+} from '../base/lib-jitsi-meet';
 import { getJitsiMeetGlobalNS, loadScript } from '../base/util';
 
 const logger = require('jitsi-meet-logger').getLogger(__filename);
 
+export const sendEvent = analytics.sendEvent.bind(analytics);
+
 /**
  * Loads the analytics scripts and inits JitsiMeetJS.analytics by setting
  * permanent properties and setting the handlers from the loaded scripts.
     getJitsiMeetGlobalNS().analyticsHandlers = [];
     window.analyticsHandlers = []; // Legacy support.
 
-    const { analytics } = JitsiMeetJS;
-
     if (!analytics || !isAnalyticsEnabled(getState)) {
         return;
     }

react/features/base/conference/middleware.js

 
 import UIEvents from '../../../../service/UI/UIEvents';
 
+import { sendEvent } from '../../analytics';
 import { CONNECTION_ESTABLISHED } from '../connection';
-import JitsiMeetJS from '../lib-jitsi-meet';
 import { setVideoMuted, VIDEO_MUTISM_AUTHORITY } from '../media';
 import {
     getLocalParticipant,
             videoType = 'remote';
         }
 
-        JitsiMeetJS.analytics.sendEvent(
+        sendEvent(
                 `${actionName}.${videoType}`,
                 { value: conference.getParticipantCount() });
     }

react/features/base/lib-jitsi-meet/index.js

 export const JitsiTrackErrors = JitsiMeetJS.errors.track;
 export const JitsiTrackEvents = JitsiMeetJS.events.track;
 
+export const analytics = JitsiMeetJS.analytics;
+
 export * from './actions';
 export * from './actionTypes';
 export * from './constants';

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

 import React, { Component } from 'react';
 import { connect } from 'react-redux';
 
+import { sendEvent } from '../../analytics';
 import { Dialog } from '../../base/dialog';
 import { translate } from '../../base/i18n';
-import JitsiMeetJS from '../../base/lib-jitsi-meet';
 
 import { cancelFeedback, submitFeedback } from '../actions';
 
      * @inheritdoc
      */
     componentDidMount() {
-        JitsiMeetJS.analytics.sendEvent('feedback.open');
+        sendEvent('feedback.open');
     }
 
     /**

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

 import React, { Component } from 'react';
 import { connect } from 'react-redux';
 
+import { sendEvent } from '../../analytics';
 import { getInviteURL } from '../../base/connection';
 import { Dialog } from '../../base/dialog';
 import { translate } from '../../base/i18n';
-import JitsiMeetJS from '../../base/lib-jitsi-meet';
 import { getLocalParticipant, PARTICIPANT_ROLE } from '../../base/participants';
 
 import DialInNumbersForm from './DialInNumbersForm';
      * @inheritdoc
      */
     componentWillUnmount() {
-        JitsiMeetJS.analytics.sendEvent('toolbar.invite.close');
+        sendEvent('toolbar.invite.close');
     }
 
     /**

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

 import React, { Component } from 'react';
 import { connect } from 'react-redux';
 
+import { sendEvent } from '../../analytics';
 import { translate } from '../../base/i18n';
-import JitsiMeetJS from '../../base/lib-jitsi-meet';
 import { kickParticipant } from '../../base/participants';
 
 import RemoteVideoMenuButton from './RemoteVideoMenuButton';
     _onClick() {
         const { dispatch, onClick, participantID } = this.props;
 
-        JitsiMeetJS.analytics.sendEvent(
+        sendEvent(
             '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 { translate } from '../../base/i18n';
-import JitsiMeetJS from '../../base/lib-jitsi-meet';
 import { muteRemoteParticipant } from '../../base/participants';
 
 import RemoteVideoMenuButton from './RemoteVideoMenuButton';
     _onClick() {
         const { dispatch, onClick, participantID } = this.props;
 
-        JitsiMeetJS.analytics.sendEvent(
+        sendEvent(
             'remotevideomenu.mute',
             {
                 value: 1,

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

 import PropTypes from 'prop-types';
 import React, { Component } from 'react';
 
-import JitsiMeetJS from '../../base/lib-jitsi-meet';
+import { sendEvent } from '../../analytics';
 import { translate } from '../../base/i18n';
 
 import RemoteVideoMenuButton from './RemoteVideoMenuButton';
         }
 
         if (eventName) {
-            JitsiMeetJS.analytics.sendEvent(
+            sendEvent(
                 `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 { DEFAULT_AVATAR_RELATIVE_PATH } from '../../base/participants';
 import UIEvents from '../../../../service/UI/UIEvents';
 
 import ToolbarButton from './ToolbarButton';
 
 declare var APP: Object;
-declare var JitsiMeetJS: Object;
 
 /**
  * The default configuration for the button.
      */
     _onClick() {
         if (!this.props._unclickable) {
-            JitsiMeetJS.analytics.sendEvent('toolbar.profile.toggled');
+            sendEvent('toolbar.profile.toggled');
             APP.UI.emitEvent(UIEvents.TOGGLE_PROFILE);
         }
     }

react/features/toolbox/defaultToolbarButtons.web.js

 
 import React from 'react';
 
+import { sendEvent } from '../analytics';
 import { ParticipantCounter } from '../contact-list';
 import { openDeviceSelectionDialog } from '../device-selection';
 import { InfoDialogButton, openInviteDialog } from '../invite';
 
 declare var APP: Object;
 declare var interfaceConfig: Object;
-declare var JitsiMeetJS: Object;
 
 /**
  * The cache of {@link getDefaultButtons()}.
                 const newVideoMutedState = !APP.conference.isLocalVideoMuted();
 
                 if (newVideoMutedState) {
-                    JitsiMeetJS.analytics.sendEvent('toolbar.video.enabled');
+                    sendEvent('toolbar.video.enabled');
                 } else {
-                    JitsiMeetJS.analytics.sendEvent('toolbar.video.disabled');
+                    sendEvent('toolbar.video.disabled');
                 }
                 APP.UI.emitEvent(UIEvents.VIDEO_MUTED, newVideoMutedState);
             },
                     return;
                 }
 
-                JitsiMeetJS.analytics.sendEvent('shortcut.videomute.toggled');
+                sendEvent('shortcut.videomute.toggled');
                 APP.conference.toggleVideoMuted();
             },
             shortcutDescription: 'keyboardShortcuts.videoMute',
                 <span id = 'unreadMessages' /></span>,
             id: 'toolbar_button_chat',
             onClick() {
-                JitsiMeetJS.analytics.sendEvent('toolbar.chat.toggled');
+                sendEvent('toolbar.chat.toggled');
                 APP.UI.emitEvent(UIEvents.TOGGLE_CHAT);
             },
             shortcut: 'C',
             shortcutAttr: 'toggleChatPopover',
             shortcutFunc() {
-                JitsiMeetJS.analytics.sendEvent('shortcut.chat.toggled');
+                sendEvent('shortcut.chat.toggled');
                 APP.UI.toggleChat();
             },
             shortcutDescription: 'keyboardShortcuts.toggleChat',
             enabled: true,
             id: 'toolbar_contact_list',
             onClick() {
-                JitsiMeetJS.analytics.sendEvent(
+                sendEvent(
                     'toolbar.contacts.toggled');
                 APP.UI.emitEvent(UIEvents.TOGGLE_CONTACT_LIST);
             },
             id: 'toolbar_button_desktopsharing',
             onClick() {
                 if (APP.conference.isSharingScreen) {
-                    JitsiMeetJS.analytics.sendEvent('toolbar.screen.disabled');
+                    sendEvent('toolbar.screen.disabled');
                 } else {
-                    JitsiMeetJS.analytics.sendEvent('toolbar.screen.enabled');
+                    sendEvent('toolbar.screen.enabled');
                 }
                 APP.UI.emitEvent(UIEvents.TOGGLE_SCREENSHARING);
             },
             shortcut: 'D',
             shortcutAttr: 'toggleDesktopSharingPopover',
             shortcutFunc() {
-                JitsiMeetJS.analytics.sendEvent('shortcut.screen.toggled');
+                sendEvent('shortcut.screen.toggled');
 
                 // eslint-disable-next-line no-empty-function
                 APP.conference.toggleScreenSharing().catch(() => {});
             },
             id: 'toolbar_button_fodeviceselection',
             onClick(dispatch: Function) {
-                JitsiMeetJS.analytics.sendEvent(
+                sendEvent(
                     'toolbar.fodeviceselection.toggled');
 
                 dispatch(openDeviceSelectionDialog());
             hidden: true,
             id: 'toolbar_button_dialpad',
             onClick() {
-                JitsiMeetJS.analytics.sendEvent('toolbar.sip.dialpad.clicked');
+                sendEvent('toolbar.sip.dialpad.clicked');
             },
             tooltipKey: 'toolbar.dialpad'
         },
             hidden: true,
             id: 'toolbar_button_etherpad',
             onClick() {
-                JitsiMeetJS.analytics.sendEvent('toolbar.etherpad.clicked');
+                sendEvent('toolbar.etherpad.clicked');
                 APP.UI.emitEvent(UIEvents.ETHERPAD_CLICKED);
             },
             tooltipKey: 'toolbar.etherpad'
             enabled: true,
             id: 'toolbar_button_fullScreen',
             onClick() {
-                JitsiMeetJS.analytics.sendEvent('toolbar.fullscreen.enabled');
+                sendEvent('toolbar.fullscreen.enabled');
 
                 APP.UI.emitEvent(UIEvents.TOGGLE_FULLSCREEN);
             },
             shortcutAttr: 'toggleFullscreenPopover',
             shortcutDescription: 'keyboardShortcuts.fullScreen',
             shortcutFunc() {
-                JitsiMeetJS.analytics.sendEvent('shortcut.fullscreen.toggled');
+                sendEvent('shortcut.fullscreen.toggled');
                 APP.UI.toggleFullScreen();
             },
             tooltipKey: 'toolbar.fullscreen'
             isDisplayed: () => true,
             id: 'toolbar_button_hangup',
             onClick() {
-                JitsiMeetJS.analytics.sendEvent('toolbar.hangup');
+                sendEvent('toolbar.hangup');
                 APP.UI.emitEvent(UIEvents.HANGUP);
             },
             tooltipKey: 'toolbar.hangup'
             enabled: true,
             id: 'toolbar_button_link',
             onClick(dispatch: Function) {
-                JitsiMeetJS.analytics.sendEvent('toolbar.invite.clicked');
+                sendEvent('toolbar.invite.clicked');
 
                 dispatch(openInviteDialog());
             },
                         APP.UI.showCustomToolbarPopup(
                             'microphone', 'unableToUnmutePopup', true, 5000);
                     } else {
-                        JitsiMeetJS.analytics
-                            .sendEvent('toolbar.audio.unmuted');
+                        sendEvent('toolbar.audio.unmuted');
                         APP.UI.emitEvent(UIEvents.AUDIO_MUTED, false, true);
                     }
                 } else {
-                    JitsiMeetJS.analytics.sendEvent('toolbar.audio.muted');
+                    sendEvent('toolbar.audio.muted');
                     APP.UI.emitEvent(UIEvents.AUDIO_MUTED, true, true);
                 }
             },
             shortcut: 'M',
             shortcutAttr: 'mutePopover',
             shortcutFunc() {
-                JitsiMeetJS.analytics.sendEvent('shortcut.audiomute.toggled');
+                sendEvent('shortcut.audiomute.toggled');
                 APP.conference.toggleAudioMuted();
             },
             shortcutDescription: 'keyboardShortcuts.mute',
             enabled: true,
             id: 'toolbar_button_raisehand',
             onClick() {
-                JitsiMeetJS.analytics.sendEvent('toolbar.raiseHand.clicked');
+                sendEvent('toolbar.raiseHand.clicked');
                 APP.conference.maybeToggleRaisedHand();
             },
             shortcut: 'R',
             shortcutAttr: 'raiseHandPopover',
             shortcutDescription: 'keyboardShortcuts.raiseHand',
             shortcutFunc() {
-                JitsiMeetJS.analytics.sendEvent('shortcut.raisehand.clicked');
+                sendEvent('shortcut.raisehand.clicked');
                 APP.conference.maybeToggleRaisedHand();
             },
             tooltipKey: 'toolbar.raiseHand'
             enabled: true,
             id: 'toolbar_button_settings',
             onClick() {
-                JitsiMeetJS.analytics.sendEvent('toolbar.settings.toggled');
+                sendEvent('toolbar.settings.toggled');
                 APP.UI.emitEvent(UIEvents.TOGGLE_SETTINGS);
             },
             sideContainerId: 'settings_container',
             enabled: true,
             id: 'toolbar_button_sharedvideo',
             onClick() {
-                JitsiMeetJS.analytics.sendEvent('toolbar.sharedvideo.clicked');
+                sendEvent('toolbar.sharedvideo.clicked');
                 APP.UI.emitEvent(UIEvents.SHARED_VIDEO_CLICKED);
             },
             popups: [