Format all Java in WebRTC.

webrtc/examples/androidapp/src/org/appspot/apprtc/PeerConnectionClient.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 56 matching lines @@
 public class PeerConnectionClient {
   public static final String VIDEO_TRACK_ID = "ARDAMSv0";
   public static final String AUDIO_TRACK_ID = "ARDAMSa0";
   public static final String VIDEO_TRACK_TYPE = "video";
   private static final String TAG = "PCRTCClient";
   private static final String VIDEO_CODEC_VP8 = "VP8";
   private static final String VIDEO_CODEC_VP9 = "VP9";
   private static final String VIDEO_CODEC_H264 = "H264";
   private static final String AUDIO_CODEC_OPUS = "opus";
   private static final String AUDIO_CODEC_ISAC = "ISAC";
-  private static final String VIDEO_CODEC_PARAM_START_BITRATE =
-      "x-google-start-bitrate";
+  private static final String VIDEO_CODEC_PARAM_START_BITRATE = "x-google-start-bitrate";
   private static final String AUDIO_CODEC_PARAM_BITRATE = "maxaveragebitrate";
   private static final String AUDIO_ECHO_CANCELLATION_CONSTRAINT = "googEchoCancellation";
-  private static final String AUDIO_AUTO_GAIN_CONTROL_CONSTRAINT= "googAutoGainControl";
-  private static final String AUDIO_HIGH_PASS_FILTER_CONSTRAINT  = "googHighpassFilter";
+  private static final String AUDIO_AUTO_GAIN_CONTROL_CONSTRAINT = "googAutoGainControl";
+  private static final String AUDIO_HIGH_PASS_FILTER_CONSTRAINT = "googHighpassFilter";
   private static final String AUDIO_NOISE_SUPPRESSION_CONSTRAINT = "googNoiseSuppression";
   private static final String AUDIO_LEVEL_CONTROL_CONSTRAINT = "levelControl";
   private static final String DTLS_SRTP_KEY_AGREEMENT_CONSTRAINT = "DtlsSrtpKeyAgreement";
   private static final int HD_VIDEO_WIDTH = 1280;
   private static final int HD_VIDEO_HEIGHT = 720;
   private static final int MAX_VIDEO_WIDTH = 1280;
   private static final int MAX_VIDEO_HEIGHT = 1280;
   private static final int MAX_VIDEO_FPS = 30;
   private static final int BPS_IN_KBPS = 1000;
 
@@ skipping 62 matching lines @@
     public final int audioStartBitrate;
     public final String audioCodec;
     public final boolean noAudioProcessing;
     public final boolean aecDump;
     public final boolean useOpenSLES;
     public final boolean disableBuiltInAEC;
     public final boolean disableBuiltInAGC;
     public final boolean disableBuiltInNS;
     public final boolean enableLevelControl;
 
-    public PeerConnectionParameters(
-        boolean videoCallEnabled, boolean loopback, boolean tracing, boolean useCamera2,
-        int videoWidth, int videoHeight, int videoFps,
-        int videoMaxBitrate, String videoCodec, boolean videoCodecHwAcceleration,
-        boolean captureToTexture, int audioStartBitrate, String audioCodec,
-        boolean noAudioProcessing, boolean aecDump, boolean useOpenSLES,
-        boolean disableBuiltInAEC, boolean disableBuiltInAGC, boolean disableBuiltInNS,
-        boolean enableLevelControl) {
+    public PeerConnectionParameters(boolean videoCallEnabled, boolean loopback, boolean tracing,
+        boolean useCamera2, int videoWidth, int videoHeight, int videoFps, int videoMaxBitrate,
+        String videoCodec, boolean videoCodecHwAcceleration, boolean captureToTexture,
+        int audioStartBitrate, String audioCodec, boolean noAudioProcessing, boolean aecDump,
+        boolean useOpenSLES, boolean disableBuiltInAEC, boolean disableBuiltInAGC,
+        boolean disableBuiltInNS, boolean enableLevelControl) {
       this.videoCallEnabled = videoCallEnabled;
       this.useCamera2 = useCamera2;
       this.loopback = loopback;
       this.tracing = tracing;
       this.videoWidth = videoWidth;
       this.videoHeight = videoHeight;
       this.videoFps = videoFps;
       this.videoMaxBitrate = videoMaxBitrate;
       this.videoCodec = videoCodec;
       this.videoCodecHwAcceleration = videoCodecHwAcceleration;
@@ skipping 65 matching lines @@
   }
 
   public static PeerConnectionClient getInstance() {
     return instance;
   }
 
   public void setPeerConnectionFactoryOptions(PeerConnectionFactory.Options options) {
     this.options = options;
   }
 
-  public void createPeerConnectionFactory(
-      final Context context,
-      final PeerConnectionParameters peerConnectionParameters,
-      final PeerConnectionEvents events) {
+  public void createPeerConnectionFactory(final Context context,
+      final PeerConnectionParameters peerConnectionParameters, final PeerConnectionEvents events) {
     this.peerConnectionParameters = peerConnectionParameters;
     this.events = events;
     videoCallEnabled = peerConnectionParameters.videoCallEnabled;
     // Reset variables to initial states.
     this.context = null;
     factory = null;
     peerConnection = null;
     preferIsac = false;
     videoCapturerStopped = false;
     isError = false;
@@ skipping 10 matching lines @@
     statsTimer = new Timer();
 
     executor.execute(new Runnable() {
       @Override
       public void run() {
         createPeerConnectionFactoryInternal(context);
       }
     });
   }
 
-  public void createPeerConnection(
-      final EglBase.Context renderEGLContext,
-      final VideoRenderer.Callbacks localRender,
-      final VideoRenderer.Callbacks remoteRender,
+  public void createPeerConnection(final EglBase.Context renderEGLContext,
+      final VideoRenderer.Callbacks localRender, final VideoRenderer.Callbacks remoteRender,
       final SignalingParameters signalingParameters) {
     if (peerConnectionParameters == null) {
       Log.e(TAG, "Creating peer connection without initializing factory.");
       return;
     }
     this.localRender = localRender;
     this.remoteRender = remoteRender;
     this.signalingParameters = signalingParameters;
     executor.execute(new Runnable() {
       @Override
@@ skipping 16 matching lines @@
         closeInternal();
       }
     });
   }
 
   public boolean isVideoCallEnabled() {
     return videoCallEnabled;
   }
 
   private void createPeerConnectionFactoryInternal(Context context) {
-      PeerConnectionFactory.initializeInternalTracer();
-      if (peerConnectionParameters.tracing) {
-          PeerConnectionFactory.startInternalTracingCapture(
-                  Environment.getExternalStorageDirectory().getAbsolutePath() + File.separator
-                  + "webrtc-trace.txt");
-      }
-    Log.d(TAG, "Create peer connection factory. Use video: " +
-        peerConnectionParameters.videoCallEnabled);
+    PeerConnectionFactory.initializeInternalTracer();
+    if (peerConnectionParameters.tracing) {
+      PeerConnectionFactory.startInternalTracingCapture(
+          Environment.getExternalStorageDirectory().getAbsolutePath() + File.separator
+          + "webrtc-trace.txt");
+    }
+    Log.d(TAG,
+        "Create peer connection factory. Use video: " + peerConnectionParameters.videoCallEnabled);
     isError = false;
 
     // Initialize field trials.
     PeerConnectionFactory.initializeFieldTrials("");
 
     // Check preferred video codec.
     preferredVideoCodec = VIDEO_CODEC_VP8;
     if (videoCallEnabled && peerConnectionParameters.videoCodec != null) {
       if (peerConnectionParameters.videoCodec.equals(VIDEO_CODEC_VP9)) {
         preferredVideoCodec = VIDEO_CODEC_VP9;
@@ skipping 34 matching lines @@
 
     if (peerConnectionParameters.disableBuiltInNS) {
       Log.d(TAG, "Disable built-in NS even if device supports it");
       WebRtcAudioUtils.setWebRtcBasedNoiseSuppressor(true);
     } else {
       Log.d(TAG, "Enable built-in NS if device supports it");
       WebRtcAudioUtils.setWebRtcBasedNoiseSuppressor(false);
     }
 
     // Create peer connection factory.
-    if (!PeerConnectionFactory.initializeAndroidGlobals(context, true, true,
-        peerConnectionParameters.videoCodecHwAcceleration)) {
+    if (!PeerConnectionFactory.initializeAndroidGlobals(
+            context, true, true, peerConnectionParameters.videoCodecHwAcceleration)) {
       events.onPeerConnectionError("Failed to initializeAndroidGlobals");
     }
     if (options != null) {
       Log.d(TAG, "Factory networkIgnoreMask option: " + options.networkIgnoreMask);
     }
     this.context = context;
     factory = new PeerConnectionFactory(options);
     Log.d(TAG, "Peer connection factory created.");
   }
 
@@ skipping 35 matching lines @@
       videoWidth = Math.min(videoWidth, MAX_VIDEO_WIDTH);
       videoHeight = Math.min(videoHeight, MAX_VIDEO_HEIGHT);
       videoFps = Math.min(videoFps, MAX_VIDEO_FPS);
     }
 
     // Create audio constraints.
     audioConstraints = new MediaConstraints();
     // added for audio performance measurements
     if (peerConnectionParameters.noAudioProcessing) {
       Log.d(TAG, "Disabling audio processing");
-      audioConstraints.mandatory.add(new MediaConstraints.KeyValuePair(
-            AUDIO_ECHO_CANCELLATION_CONSTRAINT, "false"));
-      audioConstraints.mandatory.add(new MediaConstraints.KeyValuePair(
-            AUDIO_AUTO_GAIN_CONTROL_CONSTRAINT, "false"));
-      audioConstraints.mandatory.add(new MediaConstraints.KeyValuePair(
-            AUDIO_HIGH_PASS_FILTER_CONSTRAINT, "false"));
-      audioConstraints.mandatory.add(new MediaConstraints.KeyValuePair(
-           AUDIO_NOISE_SUPPRESSION_CONSTRAINT , "false"));
+      audioConstraints.mandatory.add(
+          new MediaConstraints.KeyValuePair(AUDIO_ECHO_CANCELLATION_CONSTRAINT, "false"));
+      audioConstraints.mandatory.add(
+          new MediaConstraints.KeyValuePair(AUDIO_AUTO_GAIN_CONTROL_CONSTRAINT, "false"));
+      audioConstraints.mandatory.add(
+          new MediaConstraints.KeyValuePair(AUDIO_HIGH_PASS_FILTER_CONSTRAINT, "false"));
+      audioConstraints.mandatory.add(
+          new MediaConstraints.KeyValuePair(AUDIO_NOISE_SUPPRESSION_CONSTRAINT, "false"));
     }
     if (peerConnectionParameters.enableLevelControl) {
       Log.d(TAG, "Enabling level control.");
-      audioConstraints.mandatory.add(new MediaConstraints.KeyValuePair(
-          AUDIO_LEVEL_CONTROL_CONSTRAINT, "true"));
+      audioConstraints.mandatory.add(
+          new MediaConstraints.KeyValuePair(AUDIO_LEVEL_CONTROL_CONSTRAINT, "true"));
     }
     // Create SDP constraints.
     sdpMediaConstraints = new MediaConstraints();
-    sdpMediaConstraints.mandatory.add(new MediaConstraints.KeyValuePair(
-        "OfferToReceiveAudio", "true"));
+    sdpMediaConstraints.mandatory.add(
+        new MediaConstraints.KeyValuePair("OfferToReceiveAudio", "true"));
     if (videoCallEnabled || peerConnectionParameters.loopback) {
-      sdpMediaConstraints.mandatory.add(new MediaConstraints.KeyValuePair(
-          "OfferToReceiveVideo", "true"));
+      sdpMediaConstraints.mandatory.add(
+          new MediaConstraints.KeyValuePair("OfferToReceiveVideo", "true"));
     } else {
-      sdpMediaConstraints.mandatory.add(new MediaConstraints.KeyValuePair(
-          "OfferToReceiveVideo", "false"));
+      sdpMediaConstraints.mandatory.add(
+          new MediaConstraints.KeyValuePair("OfferToReceiveVideo", "false"));
     }
   }
 
   private void createCapturer(CameraEnumerator enumerator) {
     final String[] deviceNames = enumerator.getDeviceNames();
 
     // First, try to find front facing camera
     Logging.d(TAG, "Looking for front facing cameras.");
     for (String deviceName : deviceNames) {
       if (enumerator.isFrontFacing(deviceName)) {
@@ skipping 39 matching lines @@
         new PeerConnection.RTCConfiguration(signalingParameters.iceServers);
     // TCP candidates are only useful when connecting to a server that supports
     // ICE-TCP.
     rtcConfig.tcpCandidatePolicy = PeerConnection.TcpCandidatePolicy.DISABLED;
     rtcConfig.bundlePolicy = PeerConnection.BundlePolicy.MAXBUNDLE;
     rtcConfig.rtcpMuxPolicy = PeerConnection.RtcpMuxPolicy.REQUIRE;
     rtcConfig.continualGatheringPolicy = PeerConnection.ContinualGatheringPolicy.GATHER_CONTINUALLY;
     // Use ECDSA encryption.
     rtcConfig.keyType = PeerConnection.KeyType.ECDSA;
 
-    peerConnection = factory.createPeerConnection(
-        rtcConfig, pcConstraints, pcObserver);
+    peerConnection = factory.createPeerConnection(rtcConfig, pcConstraints, pcObserver);
     isInitiator = false;
 
     // Set default WebRTC tracing and INFO libjingle logging.
     // NOTE: this _must_ happen while |factory| is alive!
-    Logging.enableTracing(
-        "logcat:",
-        EnumSet.of(Logging.TraceLevel.TRACE_DEFAULT));
+    Logging.enableTracing("logcat:", EnumSet.of(Logging.TraceLevel.TRACE_DEFAULT));
     Logging.enableLogToDebugOutput(Logging.Severity.LS_INFO);
 
     mediaStream = factory.createLocalMediaStream("ARDAMS");
     if (videoCallEnabled) {
       if (peerConnectionParameters.useCamera2) {
         if (!peerConnectionParameters.captureToTexture) {
           reportError(context.getString(R.string.camera2_texture_only_error));
           return;
         }
 
@@ skipping 12 matching lines @@
     }
 
     mediaStream.addTrack(createAudioTrack());
     peerConnection.addStream(mediaStream);
     if (videoCallEnabled) {
       findVideoSender();
     }
 
     if (peerConnectionParameters.aecDump) {
       try {
-        aecDumpFileDescriptor = ParcelFileDescriptor.open(
-            new File(Environment.getExternalStorageDirectory().getPath()
-                + File.separator
-                + "Download/audio.aecdump"),
-                ParcelFileDescriptor.MODE_READ_WRITE |
-                ParcelFileDescriptor.MODE_CREATE |
-                ParcelFileDescriptor.MODE_TRUNCATE);
+        aecDumpFileDescriptor =
+            ParcelFileDescriptor.open(new File(Environment.getExternalStorageDirectory().getPath()
+                                          + File.separator + "Download/audio.aecdump"),
+                ParcelFileDescriptor.MODE_READ_WRITE | ParcelFileDescriptor.MODE_CREATE
+                    | ParcelFileDescriptor.MODE_TRUNCATE);
         factory.startAecDump(aecDumpFileDescriptor.getFd(), -1);
-      } catch(IOException e) {
+      } catch (IOException e) {
         Log.e(TAG, "Can not open aecdump file", e);
       }
     }
 
     Log.d(TAG, "Peer connection created.");
   }
 
   private void closeInternal() {
     if (factory != null && peerConnectionParameters.aecDump) {
       factory.stopAecDump();
     }
     Log.d(TAG, "Closing peer connection.");
     statsTimer.cancel();
     if (peerConnection != null) {
       peerConnection.dispose();
       peerConnection = null;
     }
     Log.d(TAG, "Closing audio source.");
     if (audioSource != null) {
       audioSource.dispose();
       audioSource = null;
     }
     Log.d(TAG, "Stopping capture.");
     if (videoCapturer != null) {
       try {
         videoCapturer.stopCapture();
-      } catch(InterruptedException e) {
+      } catch (InterruptedException e) {
         throw new RuntimeException(e);
       }
       videoCapturer.dispose();
       videoCapturer = null;
     }
     Log.d(TAG, "Closing video source.");
     if (videoSource != null) {
       videoSource.dispose();
       videoSource = null;
     }
@@ skipping 145 matching lines @@
           return;
         }
         String sdpDescription = sdp.description;
         if (preferIsac) {
           sdpDescription = preferCodec(sdpDescription, AUDIO_CODEC_ISAC, true);
         }
         if (videoCallEnabled) {
           sdpDescription = preferCodec(sdpDescription, preferredVideoCodec, false);
         }
         if (peerConnectionParameters.audioStartBitrate > 0) {
-          sdpDescription = setStartBitrate(AUDIO_CODEC_OPUS, false,
-              sdpDescription, peerConnectionParameters.audioStartBitrate);
+          sdpDescription = setStartBitrate(
+              AUDIO_CODEC_OPUS, false, sdpDescription, peerConnectionParameters.audioStartBitrate);
         }
         Log.d(TAG, "Set remote SDP.");
-        SessionDescription sdpRemote = new SessionDescription(
-            sdp.type, sdpDescription);
+        SessionDescription sdpRemote = new SessionDescription(sdp.type, sdpDescription);
         peerConnection.setRemoteDescription(sdpObserver, sdpRemote);
       }
     });
   }
 
   public void stopVideoSource() {
     executor.execute(new Runnable() {
       @Override
       public void run() {
         if (videoCapturer != null && !videoCapturerStopped) {
           Log.d(TAG, "Stop video source.");
           try {
             videoCapturer.stopCapture();
-          } catch (InterruptedException e) {}
+          } catch (InterruptedException e) {
+          }
           videoCapturerStopped = true;
         }
       }
     });
   }
 
   public void startVideoSource() {
     executor.execute(new Runnable() {
       @Override
       public void run() {
@@ skipping 20 matching lines @@
         }
 
         RtpParameters parameters = localVideoSender.getParameters();
         if (parameters.encodings.size() == 0) {
           Log.w(TAG, "RtpParameters are not ready.");
           return;
         }
 
         for (RtpParameters.Encoding encoding : parameters.encodings) {
           // Null value means no limit.
-          encoding.maxBitrateBps = maxBitrateKbps == null
-              ? null
-              : maxBitrateKbps * BPS_IN_KBPS;
+          encoding.maxBitrateBps = maxBitrateKbps == null ? null : maxBitrateKbps * BPS_IN_KBPS;
         }
         if (!localVideoSender.setParameters(parameters)) {
           Log.e(TAG, "RtpSender.setParameters failed.");
         }
         Log.d(TAG, "Configured max video bitrate to: " + maxBitrateKbps);
       }
     });
   }
 
   private void reportError(final String errorMessage) {
@@ skipping 31 matching lines @@
       if (sender.track() != null) {
         String trackType = sender.track().kind();
         if (trackType.equals(VIDEO_TRACK_TYPE)) {
           Log.d(TAG, "Found video sender.");
           localVideoSender = sender;
         }
       }
     }
   }
 
-  private static String setStartBitrate(String codec, boolean isVideoCodec,
-      String sdpDescription, int bitrateKbps) {
+  private static String setStartBitrate(
+      String codec, boolean isVideoCodec, String sdpDescription, int bitrateKbps) {
     String[] lines = sdpDescription.split("\r\n");
     int rtpmapLineIndex = -1;
     boolean sdpFormatUpdated = false;
     String codecRtpMap = null;
     // Search for codec rtpmap in format
     // a=rtpmap:<payload type> <encoding name>/<clock rate> [/<encoding parameters>]
     String regex = "^a=rtpmap:(\\d+) " + codec + "(/\\d+)+[\r]?$";
     Pattern codecPattern = Pattern.compile(regex);
     for (int i = 0; i < lines.length; i++) {
       Matcher codecMatcher = codecPattern.matcher(lines[i]);
       if (codecMatcher.matches()) {
         codecRtpMap = codecMatcher.group(1);
         rtpmapLineIndex = i;
         break;
       }
     }
     if (codecRtpMap == null) {
       Log.w(TAG, "No rtpmap for " + codec + " codec");
       return sdpDescription;
     }
-    Log.d(TAG, "Found " +  codec + " rtpmap " + codecRtpMap
-        + " at " + lines[rtpmapLineIndex]);
+    Log.d(TAG, "Found " + codec + " rtpmap " + codecRtpMap + " at " + lines[rtpmapLineIndex]);
 
     // Check if a=fmtp string already exist in remote SDP for this codec and
     // update it with new bitrate parameter.
     regex = "^a=fmtp:" + codecRtpMap + " \\w+=\\d+.*[\r]?$";
     codecPattern = Pattern.compile(regex);
     for (int i = 0; i < lines.length; i++) {
       Matcher codecMatcher = codecPattern.matcher(lines[i]);
       if (codecMatcher.matches()) {
-        Log.d(TAG, "Found " +  codec + " " + lines[i]);
+        Log.d(TAG, "Found " + codec + " " + lines[i]);
         if (isVideoCodec) {
-          lines[i] += "; " + VIDEO_CODEC_PARAM_START_BITRATE
-              + "=" + bitrateKbps;
+          lines[i] += "; " + VIDEO_CODEC_PARAM_START_BITRATE + "=" + bitrateKbps;
         } else {
-          lines[i] += "; " + AUDIO_CODEC_PARAM_BITRATE
-              + "=" + (bitrateKbps * 1000);
+          lines[i] += "; " + AUDIO_CODEC_PARAM_BITRATE + "=" + (bitrateKbps * 1000);
         }
         Log.d(TAG, "Update remote SDP line: " + lines[i]);
         sdpFormatUpdated = true;
         break;
       }
     }
 
     StringBuilder newSdpDescription = new StringBuilder();
     for (int i = 0; i < lines.length; i++) {
       newSdpDescription.append(lines[i]).append("\r\n");
       // Append new a=fmtp line if no such line exist for a codec.
       if (!sdpFormatUpdated && i == rtpmapLineIndex) {
         String bitrateSet;
         if (isVideoCodec) {
-          bitrateSet = "a=fmtp:" + codecRtpMap + " "
-              + VIDEO_CODEC_PARAM_START_BITRATE + "=" + bitrateKbps;
+          bitrateSet =
+              "a=fmtp:" + codecRtpMap + " " + VIDEO_CODEC_PARAM_START_BITRATE + "=" + bitrateKbps;
         } else {
-          bitrateSet = "a=fmtp:" + codecRtpMap + " "
-              + AUDIO_CODEC_PARAM_BITRATE + "=" + (bitrateKbps * 1000);
+          bitrateSet = "a=fmtp:" + codecRtpMap + " " + AUDIO_CODEC_PARAM_BITRATE + "="
+              + (bitrateKbps * 1000);
         }
         Log.d(TAG, "Add remote SDP line: " + bitrateSet);
         newSdpDescription.append(bitrateSet).append("\r\n");
       }
-
     }
     return newSdpDescription.toString();
   }
 
-  private static String preferCodec(
-      String sdpDescription, String codec, boolean isAudio) {
+  private static String preferCodec(String sdpDescription, String codec, boolean isAudio) {
     String[] lines = sdpDescription.split("\r\n");
     int mLineIndex = -1;
     String codecRtpMap = null;
     // a=rtpmap:<payload type> <encoding name>/<clock rate> [/<encoding parameters>]
     String regex = "^a=rtpmap:(\\d+) " + codec + "(/\\d+)+[\r]?$";
     Pattern codecPattern = Pattern.compile(regex);
     String mediaDescription = "m=video ";
     if (isAudio) {
       mediaDescription = "m=audio ";
     }
-    for (int i = 0; (i < lines.length)
-        && (mLineIndex == -1 || codecRtpMap == null); i++) {
+    for (int i = 0; (i < lines.length) && (mLineIndex == -1 || codecRtpMap == null); i++) {
       if (lines[i].startsWith(mediaDescription)) {
         mLineIndex = i;
         continue;
       }
       Matcher codecMatcher = codecPattern.matcher(lines[i]);
       if (codecMatcher.matches()) {
         codecRtpMap = codecMatcher.group(1);
       }
     }
     if (mLineIndex == -1) {
       Log.w(TAG, "No " + mediaDescription + " line, so can't prefer " + codec);
       return sdpDescription;
     }
     if (codecRtpMap == null) {
       Log.w(TAG, "No rtpmap for " + codec);
       return sdpDescription;
     }
-    Log.d(TAG, "Found " +  codec + " rtpmap " + codecRtpMap + ", prefer at "
-        + lines[mLineIndex]);
+    Log.d(TAG, "Found " + codec + " rtpmap " + codecRtpMap + ", prefer at " + lines[mLineIndex]);
     String[] origMLineParts = lines[mLineIndex].split(" ");
     if (origMLineParts.length > 3) {
       StringBuilder newMLine = new StringBuilder();
       int origPartIndex = 0;
       // Format is: m=<media> <port> <proto> <fmt> ...
       newMLine.append(origMLineParts[origPartIndex++]).append(" ");
       newMLine.append(origMLineParts[origPartIndex++]).append(" ");
       newMLine.append(origMLineParts[origPartIndex++]).append(" ");
       newMLine.append(codecRtpMap);
       for (; origPartIndex < origMLineParts.length; origPartIndex++) {
@@ skipping 18 matching lines @@
       Log.d(TAG, "Add " + queuedRemoteCandidates.size() + " remote candidates");
       for (IceCandidate candidate : queuedRemoteCandidates) {
         peerConnection.addIceCandidate(candidate);
       }
       queuedRemoteCandidates = null;
     }
   }
 
   private void switchCameraInternal() {
     if (!videoCallEnabled || numberOfCameras < 2 || isError || videoCapturer == null) {
-      Log.e(TAG, "Failed to switch camera. Video: " + videoCallEnabled + ". Error : "
-          + isError + ". Number of cameras: " + numberOfCameras);
-      return;  // No video is sent or only one camera is available or error happened.
+      Log.e(TAG, "Failed to switch camera. Video: " + videoCallEnabled + ". Error : " + isError
+              + ". Number of cameras: " + numberOfCameras);
+      return; // No video is sent or only one camera is available or error happened.
     }
     Log.d(TAG, "Switch camera");
     videoCapturer.switchCamera(null);
   }
 
   public void switchCamera() {
     executor.execute(new Runnable() {
       @Override
       public void run() {
         switchCameraInternal();
       }
     });
   }
 
   public void changeCaptureFormat(final int width, final int height, final int framerate) {
     executor.execute(new Runnable() {
       @Override
       public void run() {
         changeCaptureFormatInternal(width, height, framerate);
       }
     });
   }
 
   private void changeCaptureFormatInternal(int width, int height, int framerate) {
     if (!videoCallEnabled || isError || videoCapturer == null) {
-      Log.e(TAG, "Failed to change capture format. Video: " + videoCallEnabled + ". Error : "
-          + isError);
+      Log.e(TAG,
+          "Failed to change capture format. Video: " + videoCallEnabled + ". Error : " + isError);
       return;
     }
     Log.d(TAG, "changeCaptureFormat: " + width + "x" + height + "@" + framerate);
     videoSource.adaptOutputFormat(width, height, framerate);
   }
 
   // Implementation detail: observe ICE & stream changes and react accordingly.
   private class PCObserver implements PeerConnection.Observer {
     @Override
-    public void onIceCandidate(final IceCandidate candidate){
+    public void onIceCandidate(final IceCandidate candidate) {
       executor.execute(new Runnable() {
         @Override
         public void run() {
           events.onIceCandidate(candidate);
         }
       });
     }
 
     @Override
     public void onIceCandidatesRemoved(final IceCandidate[] candidates) {
       executor.execute(new Runnable() {
         @Override
         public void run() {
           events.onIceCandidatesRemoved(candidates);
         }
       });
     }
 
     @Override
-    public void onSignalingChange(
-        PeerConnection.SignalingState newState) {
+    public void onSignalingChange(PeerConnection.SignalingState newState) {
       Log.d(TAG, "SignalingState: " + newState);
     }
 
     @Override
-    public void onIceConnectionChange(
-        final PeerConnection.IceConnectionState newState) {
+    public void onIceConnectionChange(final PeerConnection.IceConnectionState newState) {
       executor.execute(new Runnable() {
         @Override
         public void run() {
           Log.d(TAG, "IceConnectionState: " + newState);
           if (newState == IceConnectionState.CONNECTED) {
             events.onIceConnected();
           } else if (newState == IceConnectionState.DISCONNECTED) {
             events.onIceDisconnected();
           } else if (newState == IceConnectionState.FAILED) {
             reportError("ICE connection failed.");
           }
         }
       });
     }
 
     @Override
-    public void onIceGatheringChange(
-      PeerConnection.IceGatheringState newState) {
+    public void onIceGatheringChange(PeerConnection.IceGatheringState newState) {
       Log.d(TAG, "IceGatheringState: " + newState);
     }
 
     @Override
     public void onIceConnectionReceivingChange(boolean receiving) {
       Log.d(TAG, "IceConnectionReceiving changed to " + receiving);
     }
 
     @Override
-    public void onAddStream(final MediaStream stream){
+    public void onAddStream(final MediaStream stream) {
       executor.execute(new Runnable() {
         @Override
         public void run() {
           if (peerConnection == null || isError) {
             return;
           }
           if (stream.audioTracks.size() > 1 || stream.videoTracks.size() > 1) {
             reportError("Weird-looking stream: " + stream);
             return;
           }
           if (stream.videoTracks.size() == 1) {
             remoteVideoTrack = stream.videoTracks.get(0);
             remoteVideoTrack.setEnabled(renderVideo);
             remoteVideoTrack.addRenderer(new VideoRenderer(remoteRender));
           }
         }
       });
     }
 
     @Override
-    public void onRemoveStream(final MediaStream stream){
+    public void onRemoveStream(final MediaStream stream) {
       executor.execute(new Runnable() {
         @Override
         public void run() {
           remoteVideoTrack = null;
         }
       });
     }
 
     @Override
     public void onDataChannel(final DataChannel dc) {
-      reportError("AppRTC doesn't use data channels, but got: " + dc.label()
-          + " anyway!");
+      reportError("AppRTC doesn't use data channels, but got: " + dc.label() + " anyway!");
     }
 
     @Override
     public void onRenegotiationNeeded() {
       // No need to do anything; AppRTC follows a pre-agreed-upon
       // signaling/negotiation protocol.
     }
   }
 
   // Implementation detail: handle offer creation/signaling and answer setting,
   // as well as adding remote ICE candidates once the answer SDP is set.
   private class SDPObserver implements SdpObserver {
     @Override
     public void onCreateSuccess(final SessionDescription origSdp) {
       if (localSdp != null) {
         reportError("Multiple SDP create.");
         return;
       }
       String sdpDescription = origSdp.description;
       if (preferIsac) {
         sdpDescription = preferCodec(sdpDescription, AUDIO_CODEC_ISAC, true);
       }
       if (videoCallEnabled) {
         sdpDescription = preferCodec(sdpDescription, preferredVideoCodec, false);
       }
-      final SessionDescription sdp = new SessionDescription(
-          origSdp.type, sdpDescription);
+      final SessionDescription sdp = new SessionDescription(origSdp.type, sdpDescription);
       localSdp = sdp;
       executor.execute(new Runnable() {
         @Override
         public void run() {
           if (peerConnection != null && !isError) {
             Log.d(TAG, "Set local SDP from " + sdp.type);
             peerConnection.setLocalDescription(sdpObserver, sdp);
           }
         }
       });
@@ skipping 43 matching lines @@
     public void onCreateFailure(final String error) {
       reportError("createSDP error: " + error);
     }
 
     @Override
     public void onSetFailure(final String error) {
       reportError("setSDP error: " + error);
     }
   }
 }