diff options
Diffstat (limited to 'webrtc/examples/androidtests')
7 files changed, 699 insertions, 0 deletions
diff --git a/webrtc/examples/androidtests/AndroidManifest.xml b/webrtc/examples/androidtests/AndroidManifest.xml new file mode 100644 index 0000000000..f99f477a67 --- /dev/null +++ b/webrtc/examples/androidtests/AndroidManifest.xml @@ -0,0 +1,17 @@ +<?xml version="1.0" encoding="utf-8"?> +<manifest xmlns:android="http://schemas.android.com/apk/res/android" + package="org.appspot.apprtc.test" + android:versionCode="1" + android:versionName="1.0" > + + <uses-sdk android:minSdkVersion="13" android:targetSdkVersion="21" /> + + <instrumentation + android:name="android.test.InstrumentationTestRunner" + android:targetPackage="org.appspot.apprtc" /> + + <application> + <uses-library android:name="android.test.runner" /> + </application> + +</manifest>
\ No newline at end of file diff --git a/webrtc/examples/androidtests/README b/webrtc/examples/androidtests/README new file mode 100644 index 0000000000..d32fb560a2 --- /dev/null +++ b/webrtc/examples/androidtests/README @@ -0,0 +1,14 @@ +This directory contains an example unit test for Android AppRTCDemo. + +Example of building & using the app: + +- Build Android AppRTCDemo and AppRTCDemo unit test: +cd <path/to/webrtc>/src +ninja -C out/Debug AppRTCDemoTest + +- Install AppRTCDemo and AppRTCDemoTest: +adb install -r out/Debug/apks/AppRTCDemo.apk +adb install -r out/Debug/apks/AppRTCDemoTest.apk + +- Run unit tests: +adb shell am instrument -w org.appspot.apprtc.test/android.test.InstrumentationTestRunner
\ No newline at end of file diff --git a/webrtc/examples/androidtests/ant.properties b/webrtc/examples/androidtests/ant.properties new file mode 100644 index 0000000000..ec7d042885 --- /dev/null +++ b/webrtc/examples/androidtests/ant.properties @@ -0,0 +1,18 @@ +# This file is used to override default values used by the Ant build system. +# +# This file must be checked into Version Control Systems, as it is +# integral to the build system of your project. + +# This file is only used by the Ant script. + +# You can use this to override default values such as +# 'source.dir' for the location of your java source folder and +# 'out.dir' for the location of your output folder. + +# You can also use it define how the release builds are signed by declaring +# the following properties: +# 'key.store' for the location of your keystore and +# 'key.alias' for the name of the key to use. +# The password will be asked during the build when you use the 'release' target. + +tested.project.dir=../android diff --git a/webrtc/examples/androidtests/build.xml b/webrtc/examples/androidtests/build.xml new file mode 100644 index 0000000000..036759bd96 --- /dev/null +++ b/webrtc/examples/androidtests/build.xml @@ -0,0 +1,92 @@ +<?xml version="1.0" encoding="UTF-8"?> +<project name="AppRTCDemoTest" default="help"> + + <!-- The local.properties file is created and updated by the 'android' tool. + It contains the path to the SDK. It should *NOT* be checked into + Version Control Systems. --> + <property file="local.properties" /> + + <!-- The ant.properties file can be created by you. It is only edited by the + 'android' tool to add properties to it. + This is the place to change some Ant specific build properties. + Here are some properties you may want to change/update: + + source.dir + The name of the source directory. Default is 'src'. + out.dir + The name of the output directory. Default is 'bin'. + + For other overridable properties, look at the beginning of the rules + files in the SDK, at tools/ant/build.xml + + Properties related to the SDK location or the project target should + be updated using the 'android' tool with the 'update' action. + + This file is an integral part of the build system for your + application and should be checked into Version Control Systems. + + --> + <property file="ant.properties" /> + + <!-- if sdk.dir was not set from one of the property file, then + get it from the ANDROID_HOME env var. + This must be done before we load project.properties since + the proguard config can use sdk.dir --> + <property environment="env" /> + <condition property="sdk.dir" value="${env.ANDROID_SDK_ROOT}"> + <isset property="env.ANDROID_SDK_ROOT" /> + </condition> + + <!-- The project.properties file is created and updated by the 'android' + tool, as well as ADT. + + This contains project specific properties such as project target, and library + dependencies. Lower level build properties are stored in ant.properties + (or in .classpath for Eclipse projects). + + This file is an integral part of the build system for your + application and should be checked into Version Control Systems. --> + <loadproperties srcFile="project.properties" /> + + <!-- quick check on sdk.dir --> + <fail + message="sdk.dir is missing. Make sure to generate local.properties using 'android update project' or to inject it through the ANDROID_HOME environment variable." + unless="sdk.dir" + /> + + <!-- + Import per project custom build rules if present at the root of the project. + This is the place to put custom intermediary targets such as: + -pre-build + -pre-compile + -post-compile (This is typically used for code obfuscation. + Compiled code location: ${out.classes.absolute.dir} + If this is not done in place, override ${out.dex.input.absolute.dir}) + -post-package + -post-build + -pre-clean + --> + <import file="custom_rules.xml" optional="true" /> + + <!-- Import the actual build file. + + To customize existing targets, there are two options: + - Customize only one target: + - copy/paste the target into this file, *before* the + <import> task. + - customize it to your needs. + - Customize the whole content of build.xml + - copy/paste the content of the rules files (minus the top node) + into this file, replacing the <import> task. + - customize to your needs. + + *********************** + ****** IMPORTANT ****** + *********************** + In all cases you must update the value of version-tag below to read 'custom' instead of an integer, + in order to avoid having your file be overridden by tools such as "android update project" + --> + <!-- version-tag: 1 --> + <import file="${sdk.dir}/tools/ant/build.xml" /> + +</project> diff --git a/webrtc/examples/androidtests/project.properties b/webrtc/examples/androidtests/project.properties new file mode 100644 index 0000000000..a6ca533fe3 --- /dev/null +++ b/webrtc/examples/androidtests/project.properties @@ -0,0 +1,16 @@ +# This file is automatically generated by Android Tools. +# Do not modify this file -- YOUR CHANGES WILL BE ERASED! +# +# This file must be checked in Version Control Systems. +# +# To customize properties used by the Ant build system edit +# "ant.properties", and override values to adapt the script to your +# project structure. +# +# To enable ProGuard to shrink and obfuscate your code, uncomment this (available properties: sdk.dir, user.home): +#proguard.config=${sdk.dir}/tools/proguard/proguard-android.txt:proguard-project.txt + +# Project target. +target=android-22 + +java.compilerargs=-Xlint:all -Werror diff --git a/webrtc/examples/androidtests/src/org/appspot/apprtc/test/LooperExecutorTest.java b/webrtc/examples/androidtests/src/org/appspot/apprtc/test/LooperExecutorTest.java new file mode 100644 index 0000000000..29ccaefd05 --- /dev/null +++ b/webrtc/examples/androidtests/src/org/appspot/apprtc/test/LooperExecutorTest.java @@ -0,0 +1,67 @@ +/* + * Copyright 2015 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. + */ + +package org.appspot.apprtc.test; + +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.TimeUnit; + +import org.appspot.apprtc.util.LooperExecutor; + +import android.test.InstrumentationTestCase; +import android.util.Log; + +public class LooperExecutorTest extends InstrumentationTestCase { + private static final String TAG = "LooperTest"; + private static final int WAIT_TIMEOUT = 5000; + + public void testLooperExecutor() throws InterruptedException { + Log.d(TAG, "testLooperExecutor"); + final int counter[] = new int[1]; + final int expectedCounter = 10; + final CountDownLatch looperDone = new CountDownLatch(1); + + Runnable counterIncRunnable = new Runnable() { + @Override + public void run() { + counter[0]++; + Log.d(TAG, "Run " + counter[0]); + } + }; + LooperExecutor executor = new LooperExecutor(); + + // Try to execute a counter increment task before starting an executor. + executor.execute(counterIncRunnable); + + // Start the executor and run expected amount of counter increment task. + executor.requestStart(); + for (int i = 0; i < expectedCounter; i++) { + executor.execute(counterIncRunnable); + } + executor.execute(new Runnable() { + @Override + public void run() { + looperDone.countDown(); + } + }); + executor.requestStop(); + + // Try to execute a task after stopping the executor. + executor.execute(counterIncRunnable); + + // Wait for final looper task and make sure the counter increment task + // is executed expected amount of times. + looperDone.await(WAIT_TIMEOUT, TimeUnit.MILLISECONDS); + assertTrue (looperDone.getCount() == 0); + assertTrue (counter[0] == expectedCounter); + + Log.d(TAG, "testLooperExecutor done"); + } +} diff --git a/webrtc/examples/androidtests/src/org/appspot/apprtc/test/PeerConnectionClientTest.java b/webrtc/examples/androidtests/src/org/appspot/apprtc/test/PeerConnectionClientTest.java new file mode 100644 index 0000000000..5a5034b340 --- /dev/null +++ b/webrtc/examples/androidtests/src/org/appspot/apprtc/test/PeerConnectionClientTest.java @@ -0,0 +1,475 @@ +/* + * 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. + */ + +package org.appspot.apprtc.test; + +import java.util.LinkedList; +import java.util.List; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.TimeUnit; + +import org.appspot.apprtc.AppRTCClient.SignalingParameters; +import org.appspot.apprtc.PeerConnectionClient; +import org.appspot.apprtc.PeerConnectionClient.PeerConnectionEvents; +import org.appspot.apprtc.PeerConnectionClient.PeerConnectionParameters; +import org.appspot.apprtc.util.LooperExecutor; +import org.webrtc.EglBase; +import org.webrtc.IceCandidate; +import org.webrtc.MediaConstraints; +import org.webrtc.PeerConnection; +import org.webrtc.PeerConnectionFactory; +import org.webrtc.SessionDescription; +import org.webrtc.StatsReport; +import org.webrtc.VideoRenderer; + +import android.os.Build; +import android.test.InstrumentationTestCase; +import android.util.Log; + +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 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"; + private static final String VIDEO_CODEC_H264 = "H264"; + private static final int AUDIO_RUN_TIMEOUT = 1000; + private static final String LOCAL_RENDERER_NAME = "Local renderer"; + private static final String REMOTE_RENDERER_NAME = "Remote renderer"; + + // The peer connection client is assumed to be thread safe in itself; the + // reference is written by the test thread and read by worker threads. + private volatile PeerConnectionClient pcClient; + private volatile boolean loopback; + + // EGL context that can be used by hardware video decoders to decode to a texture. + private EglBase eglBase; + + // These are protected by their respective event objects. + private LooperExecutor signalingExecutor; + private boolean isClosed; + private boolean isIceConnected; + private SessionDescription localSdp; + private List<IceCandidate> iceCandidates = new LinkedList<IceCandidate>(); + private final Object localSdpEvent = new Object(); + private final Object iceCandidateEvent = new Object(); + private final Object iceConnectedEvent = new Object(); + private final Object closeEvent = new Object(); + + // Mock renderer implementation. + private static class MockRenderer implements VideoRenderer.Callbacks { + // These are protected by 'this' since we gets called from worker threads. + private String rendererName; + private boolean renderFrameCalled = false; + + // Thread-safe in itself. + private CountDownLatch doneRendering; + + public MockRenderer(int expectedFrames, String rendererName) { + this.rendererName = rendererName; + reset(expectedFrames); + } + + // 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()); + } 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 { + 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) { + 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 onIceConnected() { + Log.d(TAG, "ICE Connected"); + synchronized(iceConnectedEvent) { + isIceConnected = true; + iceConnectedEvent.notifyAll(); + } + } + + @Override + public void onIceDisconnected() { + Log.d(TAG, "ICE Disconnected"); + synchronized(iceConnectedEvent) { + isIceConnected = false; + iceConnectedEvent.notifyAll(); + } + } + + @Override + public void onPeerConnectionClosed() { + Log.d(TAG, "PeerConnection closed"); + synchronized(closeEvent) { + isClosed = true; + closeEvent.notifyAll(); + } + } + + @Override + public void onPeerConnectionError(String description) { + fail("PC Error: " + description); + } + + @Override + public void onPeerConnectionStatsReady(StatsReport[] reports) { + } + + // Helper wait functions. + 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) { + if (iceCandidates.size() == 0) { + iceCandidateEvent.wait(timeoutMs); + } + return (iceCandidates.size() > 0); + } + } + + 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) { + if (!isClosed) { + closeEvent.wait(timeoutMs); + } + return isClosed; + } + } + + PeerConnectionClient createPeerConnectionClient( + MockRenderer localRenderer, MockRenderer remoteRenderer, + PeerConnectionParameters peerConnectionParameters, boolean decodeToTexture) { + 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().getContext(), peerConnectionParameters, this); + client.createPeerConnection(decodeToTexture ? eglBase.getContext() : null, + localRenderer, remoteRenderer, signalingParameters); + client.createOffer(); + return client; + } + + private PeerConnectionParameters createParameters(boolean enableVideo, + String videoCodec) { + PeerConnectionParameters peerConnectionParameters = + new PeerConnectionParameters( + enableVideo, true, // videoCallEnabled, loopback. + 0, 0, 0, 0, videoCodec, true, // video codec parameters. + 0, "OPUS", false, true); // audio codec parameters. + return peerConnectionParameters; + } + + @Override + public void setUp() { + signalingExecutor = new LooperExecutor(); + signalingExecutor.requestStart(); + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) { + eglBase = new EglBase(); + } + } + + @Override + public void tearDown() { + signalingExecutor.requestStop(); + if (eglBase != null) { + eglBase.release(); + } + } + + 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), createParameters(true, VIDEO_CODEC_VP8), false); + + // 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)); + + // Check that local video frames were rendered. + assertTrue("Local video frames were not rendered.", + localRenderer.waitForFramesRendered(WAIT_TIMEOUT)); + + pcClient.close(); + 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); + + // 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); + 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.", + remoteRenderer.waitForFramesRendered(WAIT_TIMEOUT)); + } else { + // For audio just sleep for 1 sec. + // TODO(glaznev): check how we can detect that remote audio was rendered. + Thread.sleep(AUDIO_RUN_TIMEOUT); + } + + pcClient.close(); + assertTrue(waitForPeerConnectionClosed(WAIT_TIMEOUT)); + Log.d(TAG, "testLoopback done."); + } + + public void testLoopbackAudio() throws InterruptedException { + doLoopbackTest(createParameters(false, VIDEO_CODEC_VP8), false); + } + + public void testLoopbackVp8() throws InterruptedException { + doLoopbackTest(createParameters(true, VIDEO_CODEC_VP8), false); + } + + public void DISABLED_testLoopbackVp9() throws InterruptedException { + doLoopbackTest(createParameters(true, VIDEO_CODEC_VP9), false); + } + + public void testLoopbackH264() throws InterruptedException { + doLoopbackTest(createParameters(true, VIDEO_CODEC_H264), false); + } + + public void testLoopbackVp8DecodeToTexture() throws InterruptedException { + if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN_MR1) { + Log.i(TAG, "Decode to textures is not supported, requires EGL14."); + return; + } + + doLoopbackTest(createParameters(true, VIDEO_CODEC_VP8), true); + } + + public void DISABLED_testLoopbackVp9DecodeToTexture() throws InterruptedException { + if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN_MR1) { + Log.i(TAG, "Decode to textures is not supported, requires EGL14."); + return; + } + doLoopbackTest(createParameters(true, VIDEO_CODEC_VP9), true); + } + + public void testLoopbackH264DecodeToTexture() throws InterruptedException { + if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN_MR1) { + Log.i(TAG, "Decode to textures is not supported, requires EGL14."); + return; + } + doLoopbackTest(createParameters(true, VIDEO_CODEC_H264), true); + } + + // Checks if default front camera can be switched to back camera and then + // again to front camera. + 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, createParameters(true, VIDEO_CODEC_VP8), false); + + // 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); + 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)); + + for (int i = 0; i < CAMERA_SWITCH_ATTEMPTS; i++) { + // Try to switch camera + pcClient.switchCamera(); + + // Reset video renders and check that local and remote video frames + // were rendered after camera switch. + localRenderer.reset(EXPECTED_VIDEO_FRAMES); + remoteRenderer.reset(EXPECTED_VIDEO_FRAMES); + assertTrue("Local video frames were not rendered after camera switch.", + localRenderer.waitForFramesRendered(WAIT_TIMEOUT)); + assertTrue("Remote video frames were not rendered after camera switch.", + remoteRenderer.waitForFramesRendered(WAIT_TIMEOUT)); + } + pcClient.close(); + assertTrue(waitForPeerConnectionClosed(WAIT_TIMEOUT)); + Log.d(TAG, "testCameraSwitch done."); + } + + // Checks if video source can be restarted - simulate app goes to + // background and back to foreground. + public void testVideoSourceRestart() throws InterruptedException { + Log.d(TAG, "testVideoSourceRestart"); + 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, createParameters(true, VIDEO_CODEC_VP8), false); + + // 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); + 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)); + + // Stop and then start video source a few times. + for (int i = 0; i < VIDEO_RESTART_ATTEMPTS; i++) { + pcClient.stopVideoSource(); + Thread.sleep(VIDEO_RESTART_TIMEOUT); + pcClient.startVideoSource(); + + // Reset video renders and check that local and remote video frames + // were rendered after video restart. + localRenderer.reset(EXPECTED_VIDEO_FRAMES); + remoteRenderer.reset(EXPECTED_VIDEO_FRAMES); + assertTrue("Local video frames were not rendered after video restart.", + localRenderer.waitForFramesRendered(WAIT_TIMEOUT)); + assertTrue("Remote video frames were not rendered after video restart.", + remoteRenderer.waitForFramesRendered(WAIT_TIMEOUT)); + } + pcClient.close(); + assertTrue(waitForPeerConnectionClosed(WAIT_TIMEOUT)); + Log.d(TAG, "testVideoSourceRestart done."); + } + +} |