Comply w/ coding style

- Maximum of 80 characters per line.
- Group first and then sort in alphabetical order.
- Fields should begin with a lowercase letter.

android/app/src/main/AndroidManifest.xml

     android:versionCode="1"
     android:versionName="1.0">
 
-    <!-- XXX: ACCESS_NETWORK_STATE is needed by react-native-webrtc -->
+    <!-- XXX: ACCESS_NETWORK_STATE is required by WebRTC. -->
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
     <uses-permission android:name="android.permission.BLUETOOTH" />
     <uses-permission android:name="android.permission.CAMERA" />

android/app/src/main/java/org/jitsi/meet/audiomode/AudioModeModule.java

 import java.util.List;
 import java.util.Map;
 
-
 /**
- * Module implementing a simple API to select the appropriate audio device for a conference call.
+ * Module implementing a simple API to select the appropriate audio device for a
+ * conference call.
  *
- * Audio calls should use <tt>AudioModeModule.AUDIO_CALL</tt>, which uses the builtin earpiece,
- * wired headset or bluetooth headset. The builtin earpiece is the default audio device.
+ * Audio calls should use <tt>AudioModeModule.AUDIO_CALL</tt>, which uses the
+ * builtin earpiece, wired headset or bluetooth headset. The builtin earpiece is
+ * the default audio device.
  *
- * Video calls should should use <tt>AudioModeModule.VIDEO_CALL</tt>, which uses the builtin
- * speaker, earpiece, wired headset or bluetooth headset. The builtin speaker is the default
- * audio device.
+ * Video calls should should use <tt>AudioModeModule.VIDEO_CALL</tt>, which uses
+ * the builtin speaker, earpiece, wired headset or bluetooth headset. The
+ * builtin speaker is the default audio device.
  *
- * Before a call has started and after it has ended the <tt>AudioModeModule.DEFAULT</tt> mode
- * should be used.
+ * Before a call has started and after it has ended the
+ * <tt>AudioModeModule.DEFAULT</tt> mode should be used.
  */
 public class AudioModeModule extends ReactContextBaseJavaModule {
     /**
      * Constants representing the audio mode.
-     * - DEFAULT: Used before and after every call.  It represents the default audio routing scheme.
-     * - AUDIO_CALL: Used for audio only calls.  It will use the earpiece by default, unless a
-     *   wired or Bluetooth headset is connected.
-     * - VIDEO_CALL: Used for video calls.  It will use the speaker by default, unless a wired or
-     *   Bluetooth headset is connected.
+     * - DEFAULT: Used before and after every call. It represents the default
+     *   audio routing scheme.
+     * - AUDIO_CALL: Used for audio only calls. It will use the earpiece by
+     *   default, unless a wired or Bluetooth headset is connected.
+     * - VIDEO_CALL: Used for video calls. It will use the speaker by default,
+     *   unless a wired or Bluetooth headset is connected.
      */
     private static final int DEFAULT    = 0;
     private static final int AUDIO_CALL = 1;
     private static final int VIDEO_CALL = 2;
 
+    /**
+     *
+     */
+    private static final String ACTION_HEADSET_PLUG
+        = (android.os.Build.VERSION.SDK_INT >= 21)
+            ? AudioManager.ACTION_HEADSET_PLUG
+            : Intent.ACTION_HEADSET_PLUG;
+
     /**
      * React Native module name.
      */
     static final String TAG = MODULE_NAME;
 
     /**
-     * Audio mode currently in use.
+     * {@link AudioManager} instance used to interact with the Android audio
+     * subsystem.
      */
-    private int mode = -1;
+    private final AudioManager audioManager;
 
     /**
-     * {@link AudioManager} instance used to interact with the Android audio subsystem.
+     * {@link BluetoothHeadsetMonitor} for detecting Bluetooth device changes in
+     * old (< M) Android versions.
      */
-    private final AudioManager audioManager;
+    private BluetoothHeadsetMonitor bluetoothHeadsetMonitor;
 
     /**
      * {@link Handler} for running all operations on the main thread.
     private final Runnable mainThreadRunner;
 
     /**
-     * {@link BluetoothHeadsetMonitor} for detecting Bluetooth device changes in old (< M)
-     * Android versions.
-     */
-    private BluetoothHeadsetMonitor bluetoothHeadsetMonitor;
-
-    /**
-     *
+     * Audio mode currently in use.
      */
-    private static final String ACTION_HEADSET_PLUG = (android.os.Build.VERSION.SDK_INT >= 21) ?
-            AudioManager.ACTION_HEADSET_PLUG : Intent.ACTION_HEADSET_PLUG;
+    private int mode = -1;
 
     /**
-     * Initializes a new module instance. There shall be a single instance of this module throughout
-     * the lifetime of the application.
+     * Initializes a new module instance. There shall be a single instance of
+     * this module throughout the lifetime of the application.
      *
-     * @param reactContext the {@link ReactApplicationContext} where this module is created.
+     * @param reactContext the {@link ReactApplicationContext} where this module
+     * is created.
      */
     public AudioModeModule(ReactApplicationContext reactContext) {
         super(reactContext);
 
-        audioManager = ((AudioManager) reactContext.getSystemService(Context.AUDIO_SERVICE));
+        audioManager
+            = (AudioManager)
+                reactContext.getSystemService(Context.AUDIO_SERVICE);
         mainThreadHandler = new Handler(Looper.getMainLooper());
         mainThreadRunner = new Runnable() {
             @Override
             }
         };
 
-        // Setup runtime device change detection
+        // Setup runtime device change detection.
         setupAudioRouteChangeDetection();
     }
 
-    /**
-     * Gets the name for this module, to be used in the React Native bridge.
-     *
-     * @return a string with the module name.
-     */
-    @Override
-    public String getName() {
-        return MODULE_NAME;
-    }
-
     /**
      * Gets a mapping with the constants this module is exporting.
      *
-     * @return a {@link Map} mapping the constants to be exported with their values.
+     * @return a {@link Map} mapping the constants to be exported with their
+     * values.
      */
     @Override
     public Map<String, Object> getConstants() {
         Map<String, Object> constants = new HashMap<>();
-        constants.put("DEFAULT", DEFAULT);
+
         constants.put("AUDIO_CALL", AUDIO_CALL);
+        constants.put("DEFAULT", DEFAULT);
         constants.put("VIDEO_CALL", VIDEO_CALL);
+
         return constants;
     }
 
     /**
-     * Updates the audio route for the given mode.
+     * Gets the name for this module, to be used in the React Native bridge.
      *
-     * @param mode the audio mode to be used when computing the audio route.
-     * @return true if the audio route was updated successfully, false otherwise.
+     * @return a string with the module name.
      */
-    private boolean updateAudioRoute(int mode) {
-        Log.d(TAG, "Update audio route for mode: " + mode);
-
-        if (mode == DEFAULT) {
-            audioManager.setMode(AudioManager.MODE_NORMAL);
-            audioManager.abandonAudioFocus(null);
-            audioManager.setSpeakerphoneOn(false);
-            audioManager.setMicrophoneMute(true);
-            setBluetoothAudioRoute(false);
-
-            return true;
-        }
-
-        audioManager.setMode(AudioManager.MODE_IN_COMMUNICATION);
-        audioManager.setMicrophoneMute(false);
-
-        if (audioManager.requestAudioFocus(
-                    null,
-                    AudioManager.STREAM_VOICE_CALL,
-                    AudioManager.AUDIOFOCUS_GAIN)
-                == AudioManager.AUDIOFOCUS_REQUEST_FAILED) {
-            Log.d(TAG, "Audio focus request failed");
-            return false;
-        }
+    @Override
+    public String getName() {
+        return MODULE_NAME;
+    }
 
-        boolean useSpeaker = (mode == VIDEO_CALL);
+    /**
+     * Helper method to trigger an audio route update when devices change. It
+     * makes sure the operation is performed on the main thread.
+     */
+    void onAudioDeviceChange() {
+        mainThreadHandler.post(mainThreadRunner);
+    }
 
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-            // On Android >= M we use the AudioDeviceCallback API, so turn on Bluetooth SCO
-            // from the start.
-            if (audioManager.isBluetoothScoAvailableOffCall()) {
-                audioManager.startBluetoothSco();
-            }
+    /**
+     * Helper method to set the output route to a Bluetooth device.
+     *
+     * @param enabled true if Bluetooth should use used, false otherwise.
+     */
+    private void setBluetoothAudioRoute(boolean enabled) {
+        if (enabled) {
+            audioManager.startBluetoothSco();
+            audioManager.setBluetoothScoOn(true);
         } else {
-            // On older Android versions we must set the Bluetooth route manually. Also disable
-            // the speaker in that case.
-            setBluetoothAudioRoute(bluetoothHeadsetMonitor.isHeadsetAvailable());
-            if (bluetoothHeadsetMonitor.isHeadsetAvailable()) {
-                useSpeaker = false;
-            }
+            audioManager.setBluetoothScoOn(false);
+            audioManager.stopBluetoothSco();
         }
-
-        // XXX: isWiredHeadsetOn is not deprecated when used just for knowing if there is a wired
-        // headset connected, regardless of audio being routed to it.
-        audioManager.setSpeakerphoneOn(useSpeaker &&
-                !(audioManager.isWiredHeadsetOn() || audioManager.isBluetoothScoOn()));
-
-        return true;
     }
 
     /**
      * Public method to set the current audio mode.
      *
      * @param mode the desired audio mode.
-     * @param promise a {@link Promise} which will be resolved if the audio mode could be updated
-     *                successfully, and it will be rejected otherwise.
+     * @param promise a {@link Promise} which will be resolved if the audio mode
+     * could be updated successfully, and it will be rejected otherwise.
      */
     @ReactMethod
     public void setMode(final int mode, final Promise promise) {
                     AudioModeModule.this.mode = mode;
                     promise.resolve(null);
                 } else {
-                    promise.reject("setMode", "Failed to set the requested audio mode");
+                    promise.reject(
+                            "setMode",
+                            "Failed to set the requested audio mode");
                 }
             }
         };
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
             setupAudioRouteChangeDetectionM();
         } else {
-            setupAudioRouteChangeDetectionOld();
+            setupAudioRouteChangeDetectionPreM();
         }
     }
 
         android.media.AudioDeviceCallback audioDeviceCallback =
                 new android.media.AudioDeviceCallback() {
                     @Override
-                    public void onAudioDevicesAdded(AudioDeviceInfo[] addedDevices) {
+                    public void onAudioDevicesAdded(
+                            AudioDeviceInfo[] addedDevices) {
                         Log.d(TAG, "Audio devices added");
                         onAudioDeviceChange();
                     }
 
                     @Override
-                    public void onAudioDevicesRemoved(AudioDeviceInfo[] removedDevices) {
+                    public void onAudioDevicesRemoved(
+                            AudioDeviceInfo[] removedDevices) {
                         Log.d(TAG, "Audio devices removed");
                         onAudioDeviceChange();
                     }
     /**
      * Audio route change detection mechanism for Android API < 23.
      */
-    private void setupAudioRouteChangeDetectionOld() {
+    private void setupAudioRouteChangeDetectionPreM() {
         ReactContext reactContext = getReactApplicationContext();
 
-        // Detect changes in wired headset connections
+        // Detect changes in wired headset connections.
         IntentFilter wiredHeadSetFilter = new IntentFilter(ACTION_HEADSET_PLUG);
         BroadcastReceiver wiredHeadsetReceiver = new BroadcastReceiver() {
             @Override
         };
         reactContext.registerReceiver(wiredHeadsetReceiver, wiredHeadSetFilter);
 
-        // Detect Bluetooth device changes
-        bluetoothHeadsetMonitor =
-                new BluetoothHeadsetMonitor(this, this.getReactApplicationContext());
+        // Detect Bluetooth device changes.
+        bluetoothHeadsetMonitor
+            = new BluetoothHeadsetMonitor(
+                    this,
+                    getReactApplicationContext());
         bluetoothHeadsetMonitor.start();
     }
 
     /**
-     * Helper method to set the output route to a Bluetooth device.
-     * @param enabled true if Bluetooth should use used, false otherwise.
+     * Updates the audio route for the given mode.
+     *
+     * @param mode the audio mode to be used when computing the audio route.
+     * @return true if the audio route was updated successfully, false
+     * otherwise.
      */
-    private void setBluetoothAudioRoute(boolean enabled) {
-        if (enabled) {
-            audioManager.startBluetoothSco();
-            audioManager.setBluetoothScoOn(true);
+    private boolean updateAudioRoute(int mode) {
+        Log.d(TAG, "Update audio route for mode: " + mode);
+
+        if (mode == DEFAULT) {
+            audioManager.setMode(AudioManager.MODE_NORMAL);
+            audioManager.abandonAudioFocus(null);
+            audioManager.setSpeakerphoneOn(false);
+            audioManager.setMicrophoneMute(true);
+            setBluetoothAudioRoute(false);
+
+            return true;
+        }
+
+        audioManager.setMode(AudioManager.MODE_IN_COMMUNICATION);
+        audioManager.setMicrophoneMute(false);
+
+        if (audioManager.requestAudioFocus(
+                    null,
+                    AudioManager.STREAM_VOICE_CALL,
+                    AudioManager.AUDIOFOCUS_GAIN)
+                == AudioManager.AUDIOFOCUS_REQUEST_FAILED) {
+            Log.d(TAG, "Audio focus request failed");
+            return false;
+        }
+
+        boolean useSpeaker = (mode == VIDEO_CALL);
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            // On Android >= M we use the AudioDeviceCallback API, so turn on
+            // Bluetooth SCO from the start.
+            if (audioManager.isBluetoothScoAvailableOffCall()) {
+                audioManager.startBluetoothSco();
+            }
         } else {
-            audioManager.setBluetoothScoOn(false);
-            audioManager.stopBluetoothSco();
+            // On older Android versions we must set the Bluetooth route
+            // manually. Also disable the speaker in that case.
+            setBluetoothAudioRoute(
+                    bluetoothHeadsetMonitor.isHeadsetAvailable());
+            if (bluetoothHeadsetMonitor.isHeadsetAvailable()) {
+                useSpeaker = false;
+            }
         }
-    }
 
-    /**
-     * Helper method to trigger an audio route update when devices change.  It makes sure the
-     * operation is performed on the main thread.
-     */
-    void onAudioDeviceChange() {
-        mainThreadHandler.post(mainThreadRunner);
+        // XXX: isWiredHeadsetOn is not deprecated when used just for knowing if
+        // there is a wired headset connected, regardless of audio being routed
+        // to it.
+        audioManager.setSpeakerphoneOn(
+                useSpeaker
+                    && !(audioManager.isWiredHeadsetOn()
+                        || audioManager.isBluetoothScoOn()));
+
+        return true;
     }
 }

android/app/src/main/java/org/jitsi/meet/audiomode/AudioModePackage.java

 import java.util.Collections;
 import java.util.List;
 
+/**
+ * Implements {@link ReactPackage} for {@link AudioModeModule}.
+ */
 public class AudioModePackage implements ReactPackage {
     /**
      * {@inheritDoc}
-     * @return List of native modules to be exposed by React Native.
      */
     @Override
-    public List<NativeModule> createNativeModules(
-                                ReactApplicationContext reactContext) {
-        List<NativeModule> modules = new ArrayList<>();
-        modules.add(new AudioModeModule(reactContext));
-        return modules;
+    public List<Class<? extends JavaScriptModule>> createJSModules() {
+        return Collections.emptyList();
     }
 
     /**
      * {@inheritDoc}
+     *
+     * @return List of native modules to be exposed by React Native.
      */
     @Override
-    public List<Class<? extends JavaScriptModule>> createJSModules() {
-        return Collections.emptyList();
+    public List<NativeModule> createNativeModules(
+            ReactApplicationContext reactContext) {
+        List<NativeModule> modules = new ArrayList<>();
+
+        modules.add(new AudioModeModule(reactContext));
+
+        return modules;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
-    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+    public List<ViewManager> createViewManagers(
+            ReactApplicationContext reactContext) {
         return Collections.emptyList();
     }
 }

android/app/src/main/java/org/jitsi/meet/audiomode/BluetoothHeadsetMonitor.java

 import java.util.List;
 
 /**
- * Helper class to detect and handle Bluetooth device changes.  It monitors Bluetooth headsets
- * being connected / disconnected and notifies the module about device changes when this occurs.
+ * Helper class to detect and handle Bluetooth device changes.  It monitors
+ * Bluetooth headsets being connected / disconnected and notifies the module
+ * about device changes when this occurs.
  */
 public class BluetoothHeadsetMonitor {
     /**
-     * {@link AudioModeModule} where this monitor reports.
-     */
-    private final AudioModeModule AudioModeModule;
-
-    /**
-     * {@link AudioManager} instance used to interact with the Android audio subsystem.
+     * {@link AudioManager} instance used to interact with the Android audio
+     * subsystem.
      */
     private final AudioManager audioManager;
 
     /**
-     * {@link ReactContext} instance where the main module runs.
+     * {@link AudioModeModule} where this monitor reports.
      */
-    private final ReactContext reactContext;
+    private final AudioModeModule audioModeModule;
 
     /**
-     * Reference to the Bluetooth adapter, needed for managing <tt>BluetoothProfile.HEADSET</tt>
-     * devices.
+     * Reference to the Bluetooth adapter, needed for managing
+     * <tt>BluetoothProfile.HEADSET</tt> devices.
      */
     private BluetoothAdapter bluetoothAdapter;
 
     private BluetoothHeadset bluetoothHeadset;
 
     /**
-     * Listener for Bluetooth service profiles, allows us to get the proxy object to
-     * {@link BluetoothHeadset}.
+     * Listener for Bluetooth service profiles, allows us to get the proxy
+     * object to {@link BluetoothHeadset}.
      */
     private BluetoothProfile.ServiceListener bluetoothProfileListener;
 
-    /**
-     * {@link Handler} for running all operations on the main thread.
-     */
-    private final Handler mainThreadHandler;
-
     /**
      * Helper for running Bluetooth operations on the main thread.
      */
     private Runnable bluetoothRunnable;
 
     /**
-     * Flag indicating if there are any Bluetooth headset devices currently available.
+     * Flag indicating if there are any Bluetooth headset devices currently
+     * available.
      */
     private boolean headsetAvailable = false;
 
-    public BluetoothHeadsetMonitor(AudioModeModule audioModeModule, ReactContext reactContext) {
-        this.AudioModeModule = audioModeModule;
+    /**
+     * {@link Handler} for running all operations on the main thread.
+     */
+    private final Handler mainThreadHandler;
+
+    /**
+     * {@link ReactContext} instance where the main module runs.
+     */
+    private final ReactContext reactContext;
+
+    public BluetoothHeadsetMonitor(
+            AudioModeModule audioModeModule,
+            ReactContext reactContext) {
+        this.audioModeModule = audioModeModule;
         this.reactContext = reactContext;
 
-        audioManager = ((AudioManager) reactContext.getSystemService(Context.AUDIO_SERVICE));
+        audioManager
+            = (AudioManager)
+                reactContext.getSystemService(Context.AUDIO_SERVICE);
         bluetoothAdapter = null;
         bluetoothHeadset = null;
         bluetoothProfileListener = null;
         mainThreadHandler = new Handler(Looper.getMainLooper());
     }
 
+    /**
+     * Returns the current headset availability.
+     *
+     * @return true if there is a Bluetooth headset connected, false otherwise.
+     */
+    public boolean isHeadsetAvailable() {
+        return headsetAvailable;
+    }
+
     /**
      * Start monitoring Bluetooth device activity.
      */
                 if (bluetoothHeadset == null) {
                     headsetAvailable = false;
                 } else {
-                    List<BluetoothDevice> devices = bluetoothHeadset.getConnectedDevices();
+                    List<BluetoothDevice> devices
+                        = bluetoothHeadset.getConnectedDevices();
                     headsetAvailable = !devices.isEmpty();
                 }
-                BluetoothHeadsetMonitor.this.AudioModeModule.onAudioDeviceChange();
+                audioModeModule.onAudioDeviceChange();
             }
         };
 
             return;
         }
 
-        // XXX: The profile listener listens for system services of the given type being available
-        // to the application.  That is, if our Bluetooth adapter has the "headset" profile.
+        // XXX: The profile listener listens for system services of the given
+        // type being available to the application. That is, if our Bluetooth
+        // adapter has the "headset" profile.
         bluetoothProfileListener = new BluetoothProfile.ServiceListener() {
             @Override
-            public void onServiceConnected(int profile, BluetoothProfile proxy) {
+            public void onServiceConnected(
+                    int profile,
+                    BluetoothProfile proxy) {
                 if (profile == BluetoothProfile.HEADSET) {
                     bluetoothHeadset = (BluetoothHeadset) proxy;
                     updateDevices();
 
         IntentFilter bluetoothFilter = new IntentFilter();
         bluetoothFilter.addAction(AudioManager.ACTION_SCO_AUDIO_STATE_UPDATED);
-        bluetoothFilter.addAction(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED);
+        bluetoothFilter.addAction(
+                BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED);
         BroadcastReceiver bluetoothReceiver = new BroadcastReceiver() {
             @Override
             public void onReceive(Context context, Intent intent) {
                 final String action = intent.getAction();
-                if (action.equals(BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED)) {
-                    // XXX: This action will be fired when a Bluetooth headset is connected or
-                    // disconnected to the system.  This is not related to audio routing.
-                    final int state = intent.getIntExtra(BluetoothHeadset.EXTRA_STATE, -99);
+                if (action.equals(
+                        BluetoothHeadset.ACTION_CONNECTION_STATE_CHANGED)) {
+                    // XXX: This action will be fired when a Bluetooth headset
+                    // is connected or disconnected to the system. This is not
+                    // related to audio routing.
+                    final int state
+                        = intent.getIntExtra(BluetoothHeadset.EXTRA_STATE, -99);
                     switch (state) {
                     case BluetoothHeadset.STATE_CONNECTED:
                     case BluetoothHeadset.STATE_DISCONNECTED:
-                        Log.d(AudioModeModule.TAG, "BT headset connection state changed: " + state);
+                        Log.d(
+                                AudioModeModule.TAG,
+                                "BT headset connection state changed: "
+                                    + state);
                         updateDevices();
                         break;
                     default:
                         break;
                     }
-                } else if (action.equals(AudioManager.ACTION_SCO_AUDIO_STATE_UPDATED)) {
-                    // XXX: This action will be fired when the connection established with a
-                    // Bluetooth headset (called a SCO connection) changes state.  When the SCO
-                    // connection is active we route audio to it.
-                    final int state = intent.getIntExtra(AudioManager.EXTRA_SCO_AUDIO_STATE, -99);
+                } else if (action.equals(
+                        AudioManager.ACTION_SCO_AUDIO_STATE_UPDATED)) {
+                    // XXX: This action will be fired when the connection
+                    // established with a Bluetooth headset (called a SCO
+                    // connection) changes state.  When the SCO connection is
+                    // active we route audio to it.
+                    final int state
+                        = intent.getIntExtra(
+                                AudioManager.EXTRA_SCO_AUDIO_STATE,
+                                -99);
                     switch (state) {
                     case AudioManager.SCO_AUDIO_STATE_CONNECTED:
                     case AudioManager.SCO_AUDIO_STATE_DISCONNECTED:
-                        Log.d(AudioModeModule.TAG, "BT SCO connection state changed: " + state);
+                        Log.d(
+                                AudioModeModule.TAG,
+                                "BT SCO connection state changed: " + state);
                         updateDevices();
                         break;
                     default:
         };
         reactContext.registerReceiver(bluetoothReceiver, bluetoothFilter);
 
-        // Initial detection
+        // Initial detection.
         updateDevices();
     }
 
     /**
-     * Detect if there are new devices connected / disconnected and fires the
-     * <tt>onAudioDeviceChange</tt> callback.
+     * Detects if there are new devices connected / disconnected and fires the
+     * {@link AudioModeModule#onAudioDeviceChange()} callback.
      */
     private void updateDevices() {
         mainThreadHandler.post(bluetoothRunnable);
     }
-
-    /**
-     * Returns the current headset availability.
-     * @return true if there is a Bluetooth headset connected, false otherwise.
-     */
-    public boolean isHeadsetAvailable() {
-        return headsetAvailable;
-    }
-}
+}