Format all Java in WebRTC.

webrtc/examples/androidapp/src/org/appspot/apprtc/AppRTCAudioManager.java

 /*
  *  Copyright 2014 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 66 matching lines @@
 
   // This method is called when the proximity sensor reports a state change,
   // e.g. from "NEAR to FAR" or from "FAR to NEAR".
   private void onProximitySensorChangedState() {
     if (!useSpeakerphone.equals(SPEAKERPHONE_AUTO)) {
       return;
     }
 
     // The proximity sensor should only be activated when there are exactly two
     // available audio devices.
-    if (audioDevices.size() == 2
-        && audioDevices.contains(AppRTCAudioManager.AudioDevice.EARPIECE)
-        && audioDevices.contains(
-            AppRTCAudioManager.AudioDevice.SPEAKER_PHONE)) {
+    if (audioDevices.size() == 2 && audioDevices.contains(AppRTCAudioManager.AudioDevice.EARPIECE)
+        && audioDevices.contains(AppRTCAudioManager.AudioDevice.SPEAKER_PHONE)) {
       if (proximitySensor.sensorReportsNearState()) {
         // Sensor reports that a "handset is being held up to a person's ear",
         // or "something is covering the light sensor".
         setAudioDevice(AppRTCAudioManager.AudioDevice.EARPIECE);
       } else {
         // Sensor reports that a "handset is removed from a person's ear", or
         // "the light sensor is no longer covered".
         setAudioDevice(AppRTCAudioManager.AudioDevice.SPEAKER_PHONE);
       }
     }
   }
 
   /** Construction */
-  static AppRTCAudioManager create(Context context,
-      Runnable deviceStateChangeListener) {
+  static AppRTCAudioManager create(Context context, Runnable deviceStateChangeListener) {
     return new AppRTCAudioManager(context, deviceStateChangeListener);
   }
 
-  private AppRTCAudioManager(Context context,
-      Runnable deviceStateChangeListener) {
+  private AppRTCAudioManager(Context context, Runnable deviceStateChangeListener) {
     apprtcContext = context;
     onStateChangeListener = deviceStateChangeListener;
-    audioManager = ((AudioManager) context.getSystemService(
-        Context.AUDIO_SERVICE));
+    audioManager = ((AudioManager) context.getSystemService(Context.AUDIO_SERVICE));
 
     SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(context);
     useSpeakerphone = sharedPreferences.getString(context.getString(R.string.pref_speakerphone_key),
         context.getString(R.string.pref_speakerphone_default));
 
     if (useSpeakerphone.equals(SPEAKERPHONE_FALSE)) {
       defaultAudioDevice = AudioDevice.EARPIECE;
     } else {
       defaultAudioDevice = AudioDevice.SPEAKER_PHONE;
     }
@@ skipping 17 matching lines @@
     if (initialized) {
       return;
     }
 
     // Store current audio state so we can restore it when close() is called.
     savedAudioMode = audioManager.getMode();
     savedIsSpeakerPhoneOn = audioManager.isSpeakerphoneOn();
     savedIsMicrophoneMute = audioManager.isMicrophoneMute();
 
     // Request audio focus before making any device switch.
-    audioManager.requestAudioFocus(null, AudioManager.STREAM_VOICE_CALL,
-        AudioManager.AUDIOFOCUS_GAIN_TRANSIENT);
+    audioManager.requestAudioFocus(
+        null, AudioManager.STREAM_VOICE_CALL, AudioManager.AUDIOFOCUS_GAIN_TRANSIENT);
 
     // Start by setting MODE_IN_COMMUNICATION as default audio mode. It is
     // required to be in this mode when playout and/or recording starts for
     // best possible VoIP performance.
     // TODO(henrika): we migh want to start with RINGTONE mode here instead.
     audioManager.setMode(AudioManager.MODE_IN_COMMUNICATION);
 
     // Always disable microphone mute during a WebRTC call.
     setMicrophoneMute(false);
 
@@ skipping 79 matching lines @@
       private static final int STATE_UNPLUGGED = 0;
       private static final int STATE_PLUGGED = 1;
       private static final int HAS_NO_MIC = 0;
       private static final int HAS_MIC = 1;
 
       @Override
       public void onReceive(Context context, Intent intent) {
         int state = intent.getIntExtra("state", STATE_UNPLUGGED);
         int microphone = intent.getIntExtra("microphone", HAS_NO_MIC);
         String name = intent.getStringExtra("name");
-        Log.d(TAG, "BroadcastReceiver.onReceive" + AppRTCUtils.getThreadInfo()
-            + ": "
-            + "a=" + intent.getAction()
-            + ", s=" + (state == STATE_UNPLUGGED ? "unplugged" : "plugged")
-            + ", m=" + (microphone == HAS_MIC ? "mic" : "no mic")
-            + ", n=" + name
-            + ", sb=" + isInitialStickyBroadcast());
+        Log.d(TAG, "BroadcastReceiver.onReceive" + AppRTCUtils.getThreadInfo() + ": "
+                + "a=" + intent.getAction() + ", s="
+                + (state == STATE_UNPLUGGED ? "unplugged" : "plugged") + ", m="
+                + (microphone == HAS_MIC ? "mic" : "no mic") + ", n=" + name + ", sb="
+                + isInitialStickyBroadcast());
 
         boolean hasWiredHeadset = (state == STATE_PLUGGED);
         switch (state) {
           case STATE_UNPLUGGED:
             updateAudioDeviceState(hasWiredHeadset);
             break;
           case STATE_PLUGGED:
             if (selectedAudioDevice != AudioDevice.WIRED_HEADSET) {
               updateAudioDeviceState(hasWiredHeadset);
             }
@@ skipping 27 matching lines @@
   private void setMicrophoneMute(boolean on) {
     boolean wasMuted = audioManager.isMicrophoneMute();
     if (wasMuted == on) {
       return;
     }
     audioManager.setMicrophoneMute(on);
   }
 
   /** Gets the current earpiece state. */
   private boolean hasEarpiece() {
-    return apprtcContext.getPackageManager().hasSystemFeature(
-        PackageManager.FEATURE_TELEPHONY);
+    return apprtcContext.getPackageManager().hasSystemFeature(PackageManager.FEATURE_TELEPHONY);
   }
 
   /**
    * Checks whether a wired headset is connected or not.
    * This is not a valid indication that audio playback is actually over
    * the wired headset as audio routing depends on other conditions. We
    * only use it as an early indicator (during initialization) of an attached
    * wired headset.
    */
   @Deprecated
   private boolean hasWiredHeadset() {
     return audioManager.isWiredHeadsetOn();
   }
 
   /** Update list of possible audio devices and make new device selection. */
   private void updateAudioDeviceState(boolean hasWiredHeadset) {
     // Update the list of available audio devices.
     audioDevices.clear();
     if (hasWiredHeadset) {
       // If a wired headset is connected, then it is the only possible option.
       audioDevices.add(AudioDevice.WIRED_HEADSET);
     } else {
       // No wired headset, hence the audio-device list can contain speaker
       // phone (on a tablet), or speaker phone and earpiece (on mobile phone).
       audioDevices.add(AudioDevice.SPEAKER_PHONE);
-      if (hasEarpiece())  {
+      if (hasEarpiece()) {
         audioDevices.add(AudioDevice.EARPIECE);
       }
     }
     Log.d(TAG, "audioDevices: " + audioDevices);
 
     // Switch to correct audio device given the list of available audio devices.
     if (hasWiredHeadset) {
       setAudioDevice(AudioDevice.WIRED_HEADSET);
     } else {
       setAudioDevice(defaultAudioDevice);
     }
   }
 
   /** Called each time a new audio device has been added or removed. */
   private void onAudioManagerChangedState() {
-    Log.d(TAG, "onAudioManagerChangedState: devices=" + audioDevices
-        + ", selected=" + selectedAudioDevice);
+    Log.d(TAG, "onAudioManagerChangedState: devices=" + audioDevices + ", selected="
+            + selectedAudioDevice);
 
     // Enable the proximity sensor if there are two available audio devices
     // in the list. Given the current implementation, we know that the choice
     // will then be between EARPIECE and SPEAKER_PHONE.
     if (audioDevices.size() == 2) {
       AppRTCUtils.assertIsTrue(audioDevices.contains(AudioDevice.EARPIECE)
           && audioDevices.contains(AudioDevice.SPEAKER_PHONE));
       // Start the proximity sensor.
       proximitySensor.start();
     } else if (audioDevices.size() == 1) {
       // Stop the proximity sensor since it is no longer needed.
       proximitySensor.stop();
     } else {
       Log.e(TAG, "Invalid device list");
     }
 
     if (onStateChangeListener != null) {
       // Run callback to notify a listening client. The client can then
       // use public getters to query the new state.
       onStateChangeListener.run();
     }
   }
 }