Replace console with logger

react/features/always-on-top/AudioMuteButton.js

 import type { AbstractButtonProps as Props } from '../base/toolbox';
 
 const { api } = window.alwaysOnTop;
+const logger = require('jitsi-meet-logger').getLogger(__filename);
 
 /**
  * The type of the React {@code Component} state of {@link AudioMuteButton}.
                     audioAvailable,
                     audioMuted
                 }))
-            .catch(console.error);
+            .catch(logger.error);
     }
 
     /**

react/features/always-on-top/VideoMuteButton.js

 import type { AbstractButtonProps as Props } from '../base/toolbox';
 
 const { api } = window.alwaysOnTop;
+const logger = require('jitsi-meet-logger').getLogger(__filename);
 
 /**
  * The type of the React {@code Component} state of {@link VideoMuteButton}.
                     videoAvailable,
                     videoMuted
                 }))
-            .catch(console.error);
+            .catch(logger.error);
     }
 
     /**

react/features/app/components/App.native.js

 
 declare var __DEV__;
 
+const logger = require('jitsi-meet-logger').getLogger(__filename);
+
 /**
  * The type of React {@code Component} props of {@link App}.
  */
         // an unhandled JavascriptException for an unhandled JavaScript error.
         // This will effectively kill the app. In accord with the Web, do not
         // kill the app.
-        console.error(error);
+        logger.error(error);
     } else {
         // Forward to the next globalHandler of ErrorUtils.
         const { next } = _handleException;

react/features/base/conference/functions.js

     JITSI_CONFERENCE_URL_KEY
 } from './constants';
 
+const logger = require('jitsi-meet-logger').getLogger(__filename);
+
 /**
  * Attach a set of local tracks to a conference.
  *
 function _reportError(msg, err) {
     // TODO This is a good point to call some global error handler when we have
     // one.
-    console.error(msg, err);
+    logger.error(msg, err);
 }
 
 /**

react/features/base/conference/middleware.js

         try {
             conference.setLastN(action.lastN);
         } catch (err) {
-            console.error(`Failed to set lastN: ${err}`);
+            logger.error(`Failed to set lastN: ${err}`);
         }
     }
 

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

 const JitsiConferenceErrors = JitsiMeetJS.errors.conference;
 const JitsiConnectionErrors = JitsiMeetJS.errors.connection;
 
+const logger = require('jitsi-meet-logger').getLogger(__filename);
+
 /**
  * Creates a {@link JitsiLocalTrack} model from the given device id.
  *
                     return config;
                 })
                 .catch(err => {
-                    console.error(`Failed to load config from ${url}`, err);
+                    logger.error(`Failed to load config from ${url}`, err);
 
                     throw err;
                 });

react/features/base/lib-jitsi-meet/native/RTCPeerConnection.js

 import { NativeModules } from 'react-native';
 import { RTCPeerConnection, RTCSessionDescription } from 'react-native-webrtc';
 
+const logger = require('jitsi-meet-logger').getLogger(__filename);
+
 /* eslint-disable no-unused-vars */
 
 // Address families.
  * @returns {void}
  */
 function _LOGE(...args) {
-    console && console.error && console.error(...args);
+    logger.error(...args);
 }
 
 /**

react/features/base/tracks/functions.js

         // Track might be already disposed so ignore such an error.
         if (error.name !== JitsiTrackErrors.TRACK_IS_DISPOSED) {
             // FIXME Emit mute failed, so that the app can show error dialog.
-            console.error(`set track ${f} failed`, error);
+            logger.error(`set track ${f} failed`, error);
         }
     });
 }

react/features/base/util/uri.js

 // @flow
 
+const logger = require('jitsi-meet-logger').getLogger(__filename);
+
 /**
  * The app linking scheme.
  * TODO: This should be read from the manifest files later.
             params.push(
                 `${key}=${encodeURIComponent(JSON.stringify(obj[key]))}`);
         } catch (e) {
-            console.warn(`Error encoding ${key}: ${e}`);
+            logger.warn(`Error encoding ${key}: ${e}`);
         }
     }
 

react/features/mobile/audio-mode/middleware.js

-/* @flow */
+// @flow
 
 import { NativeModules } from 'react-native';
 
 } from '../../base/conference';
 import { MiddlewareRegistry } from '../../base/redux';
 
-const AudioMode = NativeModules.AudioMode;
+const { AudioMode } = NativeModules;
+const logger = require('jitsi-meet-logger').getLogger(__filename);
 
 /**
  * Middleware that captures conference actions and sets the correct audio mode
         if (typeof mode !== 'undefined') {
             AudioMode.setMode(mode)
                 .catch(err =>
-                    console.error(
+                    logger.error(
                         `Failed to set audio mode ${String(mode)}: ${err}`));
         }
     }

react/features/mobile/picture-in-picture/actions.js

 
 import { ENTER_PICTURE_IN_PICTURE } from './actionTypes';
 
+const logger = require('jitsi-meet-logger').getLogger(__filename);
+
 /**
  * Enters (or rather initiates entering) picture-in-picture.
  * Helper function to enter PiP mode. This is triggered by user request
 
             p.then(
                 () => dispatch({ type: ENTER_PICTURE_IN_PICTURE }),
-                e => console.warn(`Error entering PiP mode: ${e}`));
+                e => logger.warn(`Error entering PiP mode: ${e}`));
         }
     };
 }

react/features/share-room/middleware.js

 import { endShareRoom } from './actions';
 import { BEGIN_SHARE_ROOM } from './actionTypes';
 
+const logger = require('jitsi-meet-logger').getLogger(__filename);
+
 /**
  * Middleware that captures room URL sharing actions and starts the sharing
  * process.
                 onFulfilled(value.action === Share.sharedAction);
             },
             /* onRejected */ reason => {
-                console.error(
+                logger.error(
                     `Failed to share conference/room URL ${roomURL}:`,
                     reason);
                 onFulfilled(false);

react/index.native.js

 import { equals } from './features/base/redux';
 import { IncomingCallApp } from './features/mobile/incoming-call';
 
+const logger = require('jitsi-meet-logger').getLogger(__filename);
+
 /**
  * The type of the React {@code Component} props of {@link Root}.
  */
                     }
                 })
                 .catch(err => {
-                    console.error('Failed to get initial URL', err);
+                    logger.error('Failed to get initial URL', err);
 
                     if (typeof this.state.url === 'undefined') {
                         // Start with an empty URL if getting the initial URL