Format all Java in WebRTC.

webrtc/examples/androidtests/src/org/appspot/apprtc/test/PeerConnectionClientTest.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 19 matching lines @@
 import org.webrtc.StatsReport;
 import org.webrtc.VideoRenderer;
 
 import java.util.LinkedList;
 import java.util.List;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
 
-public class PeerConnectionClientTest extends InstrumentationTestCase
-    implements PeerConnectionEvents {
+public class PeerConnectionClientTest
+    extends InstrumentationTestCase implements PeerConnectionEvents {
   private static final String TAG = "RTCClientTest";
   private static final int ICE_CONNECTION_WAIT_TIMEOUT = 10000;
   private static final int WAIT_TIMEOUT = 7000;
   private static final int CAMERA_SWITCH_ATTEMPTS = 3;
   private static final int VIDEO_RESTART_ATTEMPTS = 3;
   private static final int CAPTURE_FORMAT_CHANGE_ATTEMPTS = 3;
   private static final int VIDEO_RESTART_TIMEOUT = 500;
   private static final int EXPECTED_VIDEO_FRAMES = 10;
   private static final String VIDEO_CODEC_VP8 = "VP8";
   private static final String VIDEO_CODEC_VP9 = "VP9";
@@ skipping 44 matching lines @@
     // Resets render to wait for new amount of video frames.
     public synchronized void reset(int expectedFrames) {
       renderFrameCalled = false;
       doneRendering = new CountDownLatch(expectedFrames);
     }
 
     @Override
     public synchronized void renderFrame(VideoRenderer.I420Frame frame) {
       if (!renderFrameCalled) {
         if (rendererName != null) {
-          Log.d(TAG, rendererName + " render frame: "
-              + frame.rotatedWidth() + " x " + frame.rotatedHeight());
+          Log.d(TAG, rendererName + " render frame: " + frame.rotatedWidth() + " x "
+                  + frame.rotatedHeight());
         } else {
           Log.d(TAG, "Render frame: " + frame.rotatedWidth() + " x " + frame.rotatedHeight());
         }
       }
       renderFrameCalled = true;
       VideoRenderer.renderFrameDone(frame);
       doneRendering.countDown();
     }
 
-
     // This method shouldn't hold any locks or touch member variables since it
     // blocks.
-    public boolean waitForFramesRendered(int timeoutMs)
-        throws InterruptedException {
+    public boolean waitForFramesRendered(int timeoutMs) throws InterruptedException {
       doneRendering.await(timeoutMs, TimeUnit.MILLISECONDS);
       return (doneRendering.getCount() <= 0);
     }
   }
 
   // Peer connection events implementation.
   @Override
   public void onLocalDescription(SessionDescription sdp) {
     Log.d(TAG, "LocalSDP type: " + sdp.type);
     synchronized (localSdpEvent) {
       localSdp = sdp;
       localSdpEvent.notifyAll();
     }
   }
 
   @Override
   public void onIceCandidate(final IceCandidate candidate) {
-    synchronized(iceCandidateEvent) {
+    synchronized (iceCandidateEvent) {
       Log.d(TAG, "IceCandidate #" + iceCandidates.size() + " : " + candidate.toString());
       if (loopback) {
         // Loopback local ICE candidate in a separate thread to avoid adding
         // remote ICE candidate in a local ICE candidate callback.
         signalingExecutor.execute(new Runnable() {
           @Override
           public void run() {
             pcClient.addRemoteIceCandidate(candidate);
           }
         });
       }
       iceCandidates.add(candidate);
       iceCandidateEvent.notifyAll();
     }
   }
 
   @Override
   public void onIceCandidatesRemoved(final IceCandidate[] candidates) {
     // TODO(honghaiz): Add this for tests.
   }
 
   @Override
   public void onIceConnected() {
     Log.d(TAG, "ICE Connected");
-    synchronized(iceConnectedEvent) {
+    synchronized (iceConnectedEvent) {
       isIceConnected = true;
       iceConnectedEvent.notifyAll();
     }
   }
 
   @Override
   public void onIceDisconnected() {
     Log.d(TAG, "ICE Disconnected");
-    synchronized(iceConnectedEvent) {
+    synchronized (iceConnectedEvent) {
       isIceConnected = false;
       iceConnectedEvent.notifyAll();
     }
   }
 
   @Override
   public void onPeerConnectionClosed() {
     Log.d(TAG, "PeerConnection closed");
-    synchronized(closeEvent) {
+    synchronized (closeEvent) {
       isClosed = true;
       closeEvent.notifyAll();
     }
   }
 
   @Override
   public void onPeerConnectionError(String description) {
     fail("PC Error: " + description);
   }
 
   @Override
-  public void onPeerConnectionStatsReady(StatsReport[] reports) {
-  }
+  public void onPeerConnectionStatsReady(StatsReport[] reports) {}
 
   // Helper wait functions.
-  private boolean waitForLocalSDP(int timeoutMs)
-      throws InterruptedException {
-    synchronized(localSdpEvent) {
+  private boolean waitForLocalSDP(int timeoutMs) throws InterruptedException {
+    synchronized (localSdpEvent) {
       if (localSdp == null) {
         localSdpEvent.wait(timeoutMs);
       }
       return (localSdp != null);
     }
   }
 
-  private boolean waitForIceCandidates(int timeoutMs)
-      throws InterruptedException {
-    synchronized(iceCandidateEvent) {
+  private boolean waitForIceCandidates(int timeoutMs) throws InterruptedException {
+    synchronized (iceCandidateEvent) {
       if (iceCandidates.size() == 0) {
         iceCandidateEvent.wait(timeoutMs);
       }
       return (iceCandidates.size() > 0);
     }
   }
 
-  private boolean waitForIceConnected(int timeoutMs)
-      throws InterruptedException {
-    synchronized(iceConnectedEvent) {
+  private boolean waitForIceConnected(int timeoutMs) throws InterruptedException {
+    synchronized (iceConnectedEvent) {
       if (!isIceConnected) {
         iceConnectedEvent.wait(timeoutMs);
       }
       if (!isIceConnected) {
         Log.e(TAG, "ICE connection failure");
       }
 
       return isIceConnected;
     }
   }
 
-  private boolean waitForPeerConnectionClosed(int timeoutMs)
-      throws InterruptedException {
-    synchronized(closeEvent) {
+  private boolean waitForPeerConnectionClosed(int timeoutMs) throws InterruptedException {
+    synchronized (closeEvent) {
       if (!isClosed) {
         closeEvent.wait(timeoutMs);
       }
       return isClosed;
     }
   }
 
-  PeerConnectionClient createPeerConnectionClient(
-      MockRenderer localRenderer, MockRenderer remoteRenderer,
-      PeerConnectionParameters peerConnectionParameters, EglBase.Context eglContext) {
-    List<PeerConnection.IceServer> iceServers =
-        new LinkedList<PeerConnection.IceServer>();
-    SignalingParameters signalingParameters = new SignalingParameters(
-        iceServers, true, // iceServers, initiator.
-        null, null, null, // clientId, wssUrl, wssPostUrl.
-        null, null); // offerSdp, iceCandidates.
+  PeerConnectionClient createPeerConnectionClient(MockRenderer localRenderer,
+      MockRenderer remoteRenderer, PeerConnectionParameters peerConnectionParameters,
+      EglBase.Context eglContext) {
+    List<PeerConnection.IceServer> iceServers = new LinkedList<PeerConnection.IceServer>();
+    SignalingParameters signalingParameters =
+        new SignalingParameters(iceServers, true, // iceServers, initiator.
+            null, null, null, // clientId, wssUrl, wssPostUrl.
+            null, null); // offerSdp, iceCandidates.
 
     PeerConnectionClient client = PeerConnectionClient.getInstance();
     PeerConnectionFactory.Options options = new PeerConnectionFactory.Options();
     options.networkIgnoreMask = 0;
     options.disableNetworkMonitor = true;
     client.setPeerConnectionFactoryOptions(options);
     client.createPeerConnectionFactory(
         getInstrumentation().getTargetContext(), peerConnectionParameters, this);
     client.createPeerConnection(eglContext, localRenderer, remoteRenderer, signalingParameters);
     client.createOffer();
     return client;
   }
 
   private PeerConnectionParameters createParametersForAudioCall() {
     PeerConnectionParameters peerConnectionParameters =
-        new PeerConnectionParameters(
-            false, /* videoCallEnabled */
+        new PeerConnectionParameters(false, /* videoCallEnabled */
             true, /* loopback */
             false, /* tracing */
             // Video codec parameters.
             true, /* useCamera2 */
             0, /* videoWidth */
             0, /* videoHeight */
             0, /* videoFps */
             0, /* videoStartBitrate */
             "", /* videoCodec */
             true, /* videoCodecHwAcceleration */
             false, /* captureToToTexture */
             // Audio codec parameters.
             0, /* audioStartBitrate */
             "OPUS", /* audioCodec */
             false, /* noAudioProcessing */
             false, /* aecDump */
-            false /* useOpenSLES */,
-            false /* disableBuiltInAEC */,
-            false /* disableBuiltInAGC */,
-            false /* disableBuiltInNS */,
-            false /* enableLevelControl */);
+            false /* useOpenSLES */, false /* disableBuiltInAEC */, false /* disableBuiltInAGC */,
+            false /* disableBuiltInNS */, false /* enableLevelControl */);
     return peerConnectionParameters;
   }
 
   private PeerConnectionParameters createParametersForVideoCall(
       String videoCodec, boolean captureToTexture) {
-    final boolean useCamera2 = captureToTexture
-        && Camera2Enumerator.isSupported(getInstrumentation().getTargetContext());
+    final boolean useCamera2 =
+        captureToTexture && Camera2Enumerator.isSupported(getInstrumentation().getTargetContext());
 
     PeerConnectionParameters peerConnectionParameters =
-        new PeerConnectionParameters(
-            true, /* videoCallEnabled */
+        new PeerConnectionParameters(true, /* videoCallEnabled */
             true, /* loopback */
             false, /* tracing */
             // Video codec parameters.
             useCamera2, /* useCamera2 */
             0, /* videoWidth */
             0, /* videoHeight */
             0, /* videoFps */
             0, /* videoStartBitrate */
             videoCodec, /* videoCodec */
             true, /* videoCodecHwAcceleration */
             captureToTexture, /* captureToToTexture */
             // Audio codec parameters.
             0, /* audioStartBitrate */
             "OPUS", /* audioCodec */
             false, /* noAudioProcessing */
             false, /* aecDump */
-            false /* useOpenSLES */,
-            false /* disableBuiltInAEC */,
-            false /* disableBuiltInAGC */,
-            false /* disableBuiltInNS */,
-            false /* enableLevelControl */);
+            false /* useOpenSLES */, false /* disableBuiltInAEC */, false /* disableBuiltInAGC */,
+            false /* disableBuiltInNS */, false /* enableLevelControl */);
     return peerConnectionParameters;
   }
 
   @Override
   public void setUp() {
     signalingExecutor = Executors.newSingleThreadExecutor();
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
       eglBase = EglBase.create();
     }
   }
 
   @Override
   public void tearDown() {
     signalingExecutor.shutdown();
     if (eglBase != null) {
       eglBase.release();
     }
   }
 
   @SmallTest
-  public void testSetLocalOfferMakesVideoFlowLocally()
-      throws InterruptedException {
+  public void testSetLocalOfferMakesVideoFlowLocally() throws InterruptedException {
     Log.d(TAG, "testSetLocalOfferMakesVideoFlowLocally");
     MockRenderer localRenderer = new MockRenderer(EXPECTED_VIDEO_FRAMES, LOCAL_RENDERER_NAME);
-    pcClient = createPeerConnectionClient(
-        localRenderer, new MockRenderer(0, null),
+    pcClient = createPeerConnectionClient(localRenderer, new MockRenderer(0, null),
         createParametersForVideoCall(VIDEO_CODEC_VP8, false), null);
 
     // Wait for local SDP and ice candidates set events.
     assertTrue("Local SDP was not set.", waitForLocalSDP(WAIT_TIMEOUT));
-    assertTrue("ICE candidates were not generated.",
-        waitForIceCandidates(WAIT_TIMEOUT));
+    assertTrue("ICE candidates were not generated.", waitForIceCandidates(WAIT_TIMEOUT));
 
     // Check that local video frames were rendered.
-    assertTrue("Local video frames were not rendered.",
-        localRenderer.waitForFramesRendered(WAIT_TIMEOUT));
+    assertTrue(
+        "Local video frames were not rendered.", localRenderer.waitForFramesRendered(WAIT_TIMEOUT));
 
     pcClient.close();
-    assertTrue("PeerConnection close event was not received.",
-        waitForPeerConnectionClosed(WAIT_TIMEOUT));
+    assertTrue(
+        "PeerConnection close event was not received.", waitForPeerConnectionClosed(WAIT_TIMEOUT));
     Log.d(TAG, "testSetLocalOfferMakesVideoFlowLocally Done.");
   }
 
   private void doLoopbackTest(PeerConnectionParameters parameters, boolean decodeToTexure)
       throws InterruptedException {
     loopback = true;
     MockRenderer localRenderer = null;
     MockRenderer remoteRenderer = null;
     if (parameters.videoCallEnabled) {
       Log.d(TAG, "testLoopback for video " + parameters.videoCodec);
       localRenderer = new MockRenderer(EXPECTED_VIDEO_FRAMES, LOCAL_RENDERER_NAME);
       remoteRenderer = new MockRenderer(EXPECTED_VIDEO_FRAMES, REMOTE_RENDERER_NAME);
     } else {
       Log.d(TAG, "testLoopback for audio.");
     }
     pcClient = createPeerConnectionClient(localRenderer, remoteRenderer, parameters,
         decodeToTexure ? eglBase.getEglBaseContext() : null);
 
     // Wait for local SDP, rename it to answer and set as remote SDP.
     assertTrue("Local SDP was not set.", waitForLocalSDP(WAIT_TIMEOUT));
     SessionDescription remoteSdp = new SessionDescription(
-        SessionDescription.Type.fromCanonicalForm("answer"),
-        localSdp.description);
+        SessionDescription.Type.fromCanonicalForm("answer"), localSdp.description);
     pcClient.setRemoteDescription(remoteSdp);
 
     // Wait for ICE connection.
     assertTrue("ICE connection failure.", waitForIceConnected(ICE_CONNECTION_WAIT_TIMEOUT));
 
     if (parameters.videoCallEnabled) {
       // Check that local and remote video frames were rendered.
       assertTrue("Local video frames were not rendered.",
           localRenderer.waitForFramesRendered(WAIT_TIMEOUT));
       assertTrue("Remote video frames were not rendered.",
@@ skipping 91 matching lines @@
     // Wait for local SDP, rename it to answer and set as remote SDP.
     assertTrue("Local SDP was not set.", waitForLocalSDP(WAIT_TIMEOUT));
 
     // Release the EGL context used for creating the PeerConnectionClient.
     // Since createPeerConnectionClient is asynchronous, we must wait for the local
     // SessionDescription.
     eglBase.release();
     eglBase = null;
 
     SessionDescription remoteSdp = new SessionDescription(
-        SessionDescription.Type.fromCanonicalForm("answer"),
-        localSdp.description);
+        SessionDescription.Type.fromCanonicalForm("answer"), localSdp.description);
     pcClient.setRemoteDescription(remoteSdp);
 
     // Wait for ICE connection.
     assertTrue("ICE connection failure.", waitForIceConnected(ICE_CONNECTION_WAIT_TIMEOUT));
     // Check that local and remote video frames were rendered.
-    assertTrue("Local video frames were not rendered.",
-        localRenderer.waitForFramesRendered(WAIT_TIMEOUT));
+    assertTrue(
+        "Local video frames were not rendered.", localRenderer.waitForFramesRendered(WAIT_TIMEOUT));
     assertTrue("Remote video frames were not rendered.",
         remoteRenderer.waitForFramesRendered(WAIT_TIMEOUT));
 
     pcClient.close();
     assertTrue(waitForPeerConnectionClosed(WAIT_TIMEOUT));
     Log.d(TAG, "testLoopback done.");
   }
 
   @SmallTest
   public void testLoopbackH264CaptureToTexture() throws InterruptedException {
     if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT) {
       Log.i(TAG, "Encode to textures is not supported. Requires KITKAT");
       return;
     }
     // TODO(perkj): If we can always capture to textures, there is no need to check if the
     // hardware encoder supports to encode from a texture.
     if (!MediaCodecVideoEncoder.isH264HwSupportedUsingTextures()) {
       Log.i(TAG, "H264 encode to textures is not supported.");
       return;
     }
     doLoopbackTest(createParametersForVideoCall(VIDEO_CODEC_H264, true), true);
   }
 
-
   // Checks if default front camera can be switched to back camera and then
   // again to front camera.
   @SmallTest
   public void testCameraSwitch() throws InterruptedException {
     Log.d(TAG, "testCameraSwitch");
     loopback = true;
 
     MockRenderer localRenderer = new MockRenderer(EXPECTED_VIDEO_FRAMES, LOCAL_RENDERER_NAME);
     MockRenderer remoteRenderer = new MockRenderer(EXPECTED_VIDEO_FRAMES, REMOTE_RENDERER_NAME);
 
     pcClient = createPeerConnectionClient(
         localRenderer, remoteRenderer, createParametersForVideoCall(VIDEO_CODEC_VP8, false), null);
 
     // Wait for local SDP, rename it to answer and set as remote SDP.
     assertTrue("Local SDP was not set.", waitForLocalSDP(WAIT_TIMEOUT));
     SessionDescription remoteSdp = new SessionDescription(
-        SessionDescription.Type.fromCanonicalForm("answer"),
-        localSdp.description);
+        SessionDescription.Type.fromCanonicalForm("answer"), localSdp.description);
     pcClient.setRemoteDescription(remoteSdp);
 
     // Wait for ICE connection.
     assertTrue("ICE connection failure.", waitForIceConnected(ICE_CONNECTION_WAIT_TIMEOUT));
 
     // Check that local and remote video frames were rendered.
     assertTrue("Local video frames were not rendered before camera switch.",
         localRenderer.waitForFramesRendered(WAIT_TIMEOUT));
     assertTrue("Remote video frames were not rendered before camera switch.",
         remoteRenderer.waitForFramesRendered(WAIT_TIMEOUT));
@@ skipping 25 matching lines @@
 
     MockRenderer localRenderer = new MockRenderer(EXPECTED_VIDEO_FRAMES, LOCAL_RENDERER_NAME);
     MockRenderer remoteRenderer = new MockRenderer(EXPECTED_VIDEO_FRAMES, REMOTE_RENDERER_NAME);
 
     pcClient = createPeerConnectionClient(
         localRenderer, remoteRenderer, createParametersForVideoCall(VIDEO_CODEC_VP8, false), null);
 
     // Wait for local SDP, rename it to answer and set as remote SDP.
     assertTrue("Local SDP was not set.", waitForLocalSDP(WAIT_TIMEOUT));
     SessionDescription remoteSdp = new SessionDescription(
-        SessionDescription.Type.fromCanonicalForm("answer"),
-        localSdp.description);
+        SessionDescription.Type.fromCanonicalForm("answer"), localSdp.description);
     pcClient.setRemoteDescription(remoteSdp);
 
     // Wait for ICE connection.
     assertTrue("ICE connection failure.", waitForIceConnected(ICE_CONNECTION_WAIT_TIMEOUT));
 
     // Check that local and remote video frames were rendered.
     assertTrue("Local video frames were not rendered before video restart.",
         localRenderer.waitForFramesRendered(WAIT_TIMEOUT));
     assertTrue("Remote video frames were not rendered before video restart.",
         remoteRenderer.waitForFramesRendered(WAIT_TIMEOUT));
@@ skipping 26 matching lines @@
 
     MockRenderer localRenderer = new MockRenderer(EXPECTED_VIDEO_FRAMES, LOCAL_RENDERER_NAME);
     MockRenderer remoteRenderer = new MockRenderer(EXPECTED_VIDEO_FRAMES, REMOTE_RENDERER_NAME);
 
     pcClient = createPeerConnectionClient(
         localRenderer, remoteRenderer, createParametersForVideoCall(VIDEO_CODEC_VP8, false), null);
 
     // Wait for local SDP, rename it to answer and set as remote SDP.
     assertTrue("Local SDP was not set.", waitForLocalSDP(WAIT_TIMEOUT));
     SessionDescription remoteSdp = new SessionDescription(
-        SessionDescription.Type.fromCanonicalForm("answer"),
-        localSdp.description);
+        SessionDescription.Type.fromCanonicalForm("answer"), localSdp.description);
     pcClient.setRemoteDescription(remoteSdp);
 
     // Wait for ICE connection.
     assertTrue("ICE connection failure.", waitForIceConnected(ICE_CONNECTION_WAIT_TIMEOUT));
 
     // Check that local and remote video frames were rendered.
     assertTrue("Local video frames were not rendered before camera resolution change.",
         localRenderer.waitForFramesRendered(WAIT_TIMEOUT));
     assertTrue("Remote video frames were not rendered before camera resolution change.",
         remoteRenderer.waitForFramesRendered(WAIT_TIMEOUT));
@@ skipping 13 matching lines @@
       assertTrue("Local video frames were not rendered after capture format change.",
           localRenderer.waitForFramesRendered(WAIT_TIMEOUT));
       assertTrue("Remote video frames were not rendered after capture format change.",
           remoteRenderer.waitForFramesRendered(WAIT_TIMEOUT));
     }
 
     pcClient.close();
     assertTrue(waitForPeerConnectionClosed(WAIT_TIMEOUT));
     Log.d(TAG, "testCaptureFormatChange done.");
   }
-
 }