From b0071c56db7ce7a578d2e284bba6efead4f46fb6 Mon Sep 17 00:00:00 2001 From: burak-58 Date: Fri, 8 Dec 2023 09:56:58 +0300 Subject: [PATCH] add tests --- .../api/DefaultConferenceWebRTCListener.java | 25 +- .../api/DefaultWebRTCListener.java | 13 +- .../api/IWebRTCClient.java | 5 - .../api/IWebRTCListener.java | 6 - .../{core => api}/WebRTCClientBuilder.java | 10 +- .../{core => api}/WebRTCClientConfig.java | 9 +- .../core/ScreenCapturer.java | 242 --------------- .../core/WebRTCClient.java | 7 +- .../WebRTCClientTest.java | 4 +- .../DefaultConferenceWebRTCListenerTest.java | 214 +++++++++++++ .../api/DefaultDataChannelObserverTest.java | 55 ++++ .../api/DefaultWebRTCListenerTest.java | 198 ++++++++++++ .../api/WebRTCClientBuilderTest.java | 206 +++++++++++++ .../ConferenceActivityTest.java | 290 ++++++++++++++++++ .../RemoteParticipant.java | 95 ++++++ .../ScreenCaptureActivityTest.java | 135 ++++++++ .../SettingsActivityTest.java | 109 +++++++ .../basic/ConferenceActivity.java | 37 ++- .../basic/ScreenCaptureActivity.java | 7 +- .../main/res/layout/activity_screenshare.xml | 2 +- 20 files changed, 1373 insertions(+), 296 deletions(-) rename webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/{core => api}/WebRTCClientBuilder.java (94%) rename webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/{core => api}/WebRTCClientConfig.java (96%) delete mode 100644 webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/core/ScreenCapturer.java create mode 100644 webrtc-android-framework/src/test/java/io/antmedia/webrtcandroidframework/api/DefaultConferenceWebRTCListenerTest.java create mode 100644 webrtc-android-framework/src/test/java/io/antmedia/webrtcandroidframework/api/DefaultDataChannelObserverTest.java create mode 100644 webrtc-android-framework/src/test/java/io/antmedia/webrtcandroidframework/api/DefaultWebRTCListenerTest.java create mode 100644 webrtc-android-framework/src/test/java/io/antmedia/webrtcandroidframework/api/WebRTCClientBuilderTest.java create mode 100644 webrtc-android-sample-app/src/androidTest/java/io/antmedia/webrtc_android_sample_app/ConferenceActivityTest.java create mode 100644 webrtc-android-sample-app/src/androidTest/java/io/antmedia/webrtc_android_sample_app/RemoteParticipant.java create mode 100644 webrtc-android-sample-app/src/androidTest/java/io/antmedia/webrtc_android_sample_app/ScreenCaptureActivityTest.java create mode 100644 webrtc-android-sample-app/src/androidTest/java/io/antmedia/webrtc_android_sample_app/SettingsActivityTest.java diff --git a/webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/api/DefaultConferenceWebRTCListener.java b/webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/api/DefaultConferenceWebRTCListener.java index 51f337ce..c06b03c7 100644 --- a/webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/api/DefaultConferenceWebRTCListener.java +++ b/webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/api/DefaultConferenceWebRTCListener.java @@ -5,21 +5,16 @@ import android.util.Log; public class DefaultConferenceWebRTCListener extends DefaultWebRTCListener { - private String roomId; - private String streamId; + private final String roomId; + private final String streamId; - private boolean stoppedStream; private boolean playOnlyMode = false; - private boolean joined = false; - - private boolean videoCallEnabled = true; - private boolean audioCallEnabled = true; private boolean playMessageSent; - private int ROOM_INFO_POLLING_MILLIS = 5000; + private final int ROOM_INFO_POLLING_MILLIS = 5000; - private Handler handler = new Handler(); - private Runnable getRoomInfoRunnable = new Runnable() { + private final Handler handler = new Handler(); + private final Runnable getRoomInfoRunnable = new Runnable() { @Override public void run() { getRoomInfo(); @@ -57,7 +52,6 @@ public void onDisconnected() { public void onJoinedTheRoom(String streamId, String[] streams) { super.onJoinedTheRoom(streamId, streams); - if (!webRTCClient.isReconnectionInProgress() && !playOnlyMode) { publishStream(streamId); } @@ -66,7 +60,6 @@ public void onJoinedTheRoom(String streamId, String[] streams) { startPlaying(streams); } - joined = true; // start periodic polling of room info scheduleGetRoomInfo(); if (streams.length > 0) { @@ -79,12 +72,12 @@ public void onJoinedTheRoom(String streamId, String[] streams) { public void onLeftTheRoom(String roomId) { super.onLeftTheRoom(roomId); clearGetRoomInfoSchedule(); - joined = false; playMessageSent = false; } @Override public void onRoomInformation(String[] streams) { + super.onRoomInformation(streams); if (webRTCClient != null) { startPlaying(streams); } @@ -105,8 +98,8 @@ private void clearGetRoomInfoSchedule() { } public void publishStream(String streamId) { - if (playOnlyMode) { - webRTCClient.publish(streamId, "", videoCallEnabled, audioCallEnabled, "", "", + if (!playOnlyMode) { + webRTCClient.publish(streamId, "", webRTCClient.getConfig().videoCallEnabled, webRTCClient.getConfig().audioCallEnabled, "", "", streamId, roomId); } else { Log.i(getClass().getSimpleName(), "Play only mode. No publishing"); @@ -115,7 +108,7 @@ public void publishStream(String streamId) { private void startPlaying(String[] streams) { if (!playMessageSent) { - webRTCClient.play(roomId, "", streams, "", "", ""); + webRTCClient.play(roomId, streams); playMessageSent = true; } } diff --git a/webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/api/DefaultWebRTCListener.java b/webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/api/DefaultWebRTCListener.java index 41c2af15..840edcec 100644 --- a/webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/api/DefaultWebRTCListener.java +++ b/webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/api/DefaultWebRTCListener.java @@ -9,10 +9,8 @@ import de.tavendo.autobahn.WebSocket; import io.antmedia.webrtcandroidframework.core.StreamInfo; -import io.antmedia.webrtcandroidframework.core.WebRTCClientConfig; public class DefaultWebRTCListener implements IWebRTCListener { - private WebRTCClientConfig config; protected IWebRTCClient webRTCClient; public void setWebRTCClient(IWebRTCClient webRTCClient) { @@ -109,7 +107,7 @@ public void onNewVideoTrack(VideoTrack track) { String messageText = "New video track received"; callbackCalled(messageText); - for (SurfaceViewRenderer r : config.remoteVideoRenderers) { + for (SurfaceViewRenderer r : webRTCClient.getConfig().remoteVideoRenderers) { if (r.getTag() == null) { r.setTag(track); webRTCClient.setRendererForVideoTrack(r, track); @@ -122,7 +120,7 @@ public void onNewVideoTrack(VideoTrack track) { public void onVideoTrackEnded(VideoTrack track) { String messageText = "Video track ended"; callbackCalled(messageText); - for (SurfaceViewRenderer r : config.remoteVideoRenderers) { + for (SurfaceViewRenderer r : webRTCClient.getConfig().remoteVideoRenderers) { if (r.getTag() == track) { r.setTag(null); return; @@ -186,12 +184,7 @@ public void onSatatusUpdateFor(String streamId, boolean micStatus, boolean camer callbackCalled(messageText); } - @Override - public void setConfig(WebRTCClientConfig webRTCClientConfig) { - this.config = webRTCClientConfig; - } - - private void callbackCalled(String messageText) { + protected void callbackCalled(String messageText) { Log.d(DefaultWebRTCListener.class.getName(), messageText); } diff --git a/webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/api/IWebRTCClient.java b/webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/api/IWebRTCClient.java index 240577a4..03a8cfca 100644 --- a/webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/api/IWebRTCClient.java +++ b/webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/api/IWebRTCClient.java @@ -6,16 +6,11 @@ import org.webrtc.VideoTrack; import org.webrtc.audio.CustomWebRtcAudioRecord; -import io.antmedia.webrtcandroidframework.core.WebRTCClientBuilder; -import io.antmedia.webrtcandroidframework.core.WebRTCClientConfig; - /** * Created by karinca on 20.10.2017. */ public interface IWebRTCClient { - - enum StreamSource { SCREEN, diff --git a/webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/api/IWebRTCListener.java b/webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/api/IWebRTCListener.java index a626b459..997de423 100644 --- a/webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/api/IWebRTCListener.java +++ b/webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/api/IWebRTCListener.java @@ -6,7 +6,6 @@ import de.tavendo.autobahn.WebSocket; import io.antmedia.webrtcandroidframework.core.StreamInfo; -import io.antmedia.webrtcandroidframework.core.WebRTCClientConfig; /** * Created by karinca on 23.10.2017. @@ -165,11 +164,6 @@ public interface IWebRTCListener { */ void onSatatusUpdateFor(String streamId, boolean micStatus, boolean cameraStatus); - /* - * It's called in WebRTCClient constructor when config is set - */ - void setConfig(WebRTCClientConfig webRTCClientConfig); - /* * It's called in WebRTCClient constructor to set */ diff --git a/webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/core/WebRTCClientBuilder.java b/webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/api/WebRTCClientBuilder.java similarity index 94% rename from webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/core/WebRTCClientBuilder.java rename to webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/api/WebRTCClientBuilder.java index 1ccce926..d5e0035a 100644 --- a/webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/core/WebRTCClientBuilder.java +++ b/webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/api/WebRTCClientBuilder.java @@ -1,4 +1,4 @@ -package io.antmedia.webrtcandroidframework.core; +package io.antmedia.webrtcandroidframework.api; import android.app.Activity; @@ -7,8 +7,7 @@ import java.util.Arrays; -import io.antmedia.webrtcandroidframework.api.IDataChannelObserver; -import io.antmedia.webrtcandroidframework.api.IWebRTCListener; +import io.antmedia.webrtcandroidframework.core.WebRTCClient; public class WebRTCClientBuilder { @@ -19,7 +18,6 @@ public WebRTCClientBuilder() { } public WebRTCClient build() { - webRTCClientConfig.webRTCListener.setConfig(webRTCClientConfig); return new WebRTCClient(webRTCClientConfig); } @@ -142,4 +140,8 @@ public WebRTCClientBuilder setReconnectionEnabled(boolean b) { webRTCClientConfig.reconnectionEnabled = b; return this; } + + public WebRTCClientConfig getConfig() { + return webRTCClientConfig; + } } diff --git a/webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/core/WebRTCClientConfig.java b/webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/api/WebRTCClientConfig.java similarity index 96% rename from webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/core/WebRTCClientConfig.java rename to webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/api/WebRTCClientConfig.java index c69436c4..6dc3360e 100644 --- a/webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/core/WebRTCClientConfig.java +++ b/webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/api/WebRTCClientConfig.java @@ -1,6 +1,7 @@ -package io.antmedia.webrtcandroidframework.core; +package io.antmedia.webrtcandroidframework.api; import android.app.Activity; +import android.content.Intent; import android.media.projection.MediaProjection; import org.webrtc.RendererCommon; @@ -124,9 +125,9 @@ public class WebRTCClientConfig { public IDataChannelObserver dataChannelObserver = new DefaultDataChannelObserver(); - /* - * MediaProjectionManager for screencapture - */ + + public Intent mediaProjectionIntent; + public MediaProjection mediaProjection; public IWebRTCClient.StreamSource videoSource; public boolean customVideoCapturerEnabled; diff --git a/webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/core/ScreenCapturer.java b/webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/core/ScreenCapturer.java deleted file mode 100644 index 3fe652cd..00000000 --- a/webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/core/ScreenCapturer.java +++ /dev/null @@ -1,242 +0,0 @@ -/* - * Copyright 2016 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 io.antmedia.webrtcandroidframework.core; - -import android.content.Context; -import android.hardware.display.DisplayManager; -import android.hardware.display.VirtualDisplay; -import android.media.projection.MediaProjection; -import android.util.Log; -import android.view.Surface; - -import androidx.annotation.Nullable; - -import org.webrtc.CapturerObserver; -import org.webrtc.SurfaceTextureHelper; -import org.webrtc.ThreadUtils; -import org.webrtc.VideoCapturer; -import org.webrtc.VideoFrame; -import org.webrtc.VideoSink; - -public class ScreenCapturer implements VideoCapturer, VideoSink { - private static final int DISPLAY_FLAGS = - DisplayManager.VIRTUAL_DISPLAY_FLAG_PUBLIC | DisplayManager.VIRTUAL_DISPLAY_FLAG_PRESENTATION; - // DPI for VirtualDisplay, does not seem to matter for us. - public static final int VIRTUAL_DISPLAY_DPI = 400; - private int width; - private int height; - @Nullable private VirtualDisplay virtualDisplay; - @Nullable private SurfaceTextureHelper surfaceTextureHelper; - @Nullable private CapturerObserver capturerObserver; - private long numCapturedFrames; - @Nullable private MediaProjection mediaProjection; - private boolean isDisposed; - public int deviceRotation = 0; - private static final String TAG = ScreenCapturer.class.getSimpleName(); - private MediaProjection.Callback mediaProjectionCallback; - - public ScreenCapturer(MediaProjection mediaProjection, MediaProjection.Callback callback) { - this.mediaProjection = mediaProjection; - this.mediaProjectionCallback = callback; - } - - public boolean isDisposed() { - return isDisposed; - } - - private void checkNotDisposed() { - if (isDisposed) { - throw new RuntimeException("capturer is disposed."); - } - } - - @Nullable - public MediaProjection getMediaProjection() { - return mediaProjection; - } - - @Override - // TODO(bugs.webrtc.org/8491): Remove NoSynchronizedMethodCheck suppression. - @SuppressWarnings("NoSynchronizedMethodCheck") - public synchronized void initialize(final SurfaceTextureHelper surfaceTextureHelper, - final Context applicationContext, final CapturerObserver capturerObserver) { - checkNotDisposed(); - - if (capturerObserver == null) { - throw new RuntimeException("capturerObserver not set."); - } - this.capturerObserver = capturerObserver; - - if (surfaceTextureHelper == null) { - throw new RuntimeException("surfaceTextureHelper not set."); - } - this.surfaceTextureHelper = surfaceTextureHelper; - } - - public void setMediaProjection(@Nullable MediaProjection mediaProjection) { - this.mediaProjection = mediaProjection; - } - - @Override - // TODO(bugs.webrtc.org/8491): Remove NoSynchronizedMethodCheck suppression. - @SuppressWarnings("NoSynchronizedMethodCheck") - public synchronized void startCapture( - final int width, final int height, final int ignoredFramerate) { - checkNotDisposed(); - - this.width = width; - this.height = height; - - - // Let MediaProjection callback use the SurfaceTextureHelper thread. - mediaProjection.registerCallback(mediaProjectionCallback, surfaceTextureHelper.getHandler()); - - createVirtualDisplay(); - capturerObserver.onCapturerStarted(true); - surfaceTextureHelper.startListening(ScreenCapturer.this); - } - - @Override - // TODO(bugs.webrtc.org/8491): Remove NoSynchronizedMethodCheck suppression. - @SuppressWarnings("NoSynchronizedMethodCheck") - public synchronized void stopCapture() { - checkNotDisposed(); - ThreadUtils.invokeAtFrontUninterruptibly(surfaceTextureHelper.getHandler(), new Runnable() { - @Override - public void run() { - surfaceTextureHelper.stopListening(); - capturerObserver.onCapturerStopped(); - - if (virtualDisplay != null) { - virtualDisplay.release(); - virtualDisplay = null; - } - - if (mediaProjection != null) { - // Unregister the callback before stopping, otherwise the callback recursively - // calls this method. - mediaProjection.unregisterCallback(mediaProjectionCallback); - mediaProjection.stop(); - mediaProjection = null; - } - } - }); - } - - @Override - // TODO(bugs.webrtc.org/8491): Remove NoSynchronizedMethodCheck suppression. - @SuppressWarnings("NoSynchronizedMethodCheck") - public synchronized void dispose() { - Log.i(TAG, "ScreenCapturer is disposed"); - isDisposed = true; - } - - /** - * Changes output video format. This method can be used to scale the output - * video, or to change orientation when the captured screen is rotated for example. - * - * @param width new output video width - * @param height new output video height - * @param ignoredFramerate ignored - */ - @Override - // TODO(bugs.webrtc.org/8491): Remove NoSynchronizedMethodCheck suppression. - @SuppressWarnings("NoSynchronizedMethodCheck") - public synchronized void changeCaptureFormat( - final int width, final int height, final int ignoredFramerate) { - checkNotDisposed(); - - this.width = width; - this.height = height; - - if (virtualDisplay == null) { - // Capturer is stopped, the virtual display will be created in startCaptuer(). - return; - } - - // Create a new virtual display on the surfaceTextureHelper thread to avoid interference - // with frame processing, which happens on the same thread (we serialize events by running - // them on the same thread). - ThreadUtils.invokeAtFrontUninterruptibly(surfaceTextureHelper.getHandler(), new Runnable() { - @Override - public void run() { - virtualDisplay.release(); - createVirtualDisplay(); - } - }); - } - - private void createVirtualDisplay() { - surfaceTextureHelper.setTextureSize(width, height); - virtualDisplay = mediaProjection.createVirtualDisplay("WebRTC_ScreenCapture", width, height, - VIRTUAL_DISPLAY_DPI, DISPLAY_FLAGS, new Surface(surfaceTextureHelper.getSurfaceTexture()), - null /* callback */, null /* callback handler */); - } - - public void rotateScreen(int rotation) { - if (deviceRotation != rotation) { - Log.w("Rotation", "onFrame: " + rotation); - deviceRotation = rotation; - - if (deviceRotation == 0) { - virtualDisplay.resize(width, height, VIRTUAL_DISPLAY_DPI); - surfaceTextureHelper.setTextureSize(width, height); - } else if (deviceRotation == 180) { - // 180 degree is not supported by MediaProjection - } else { - virtualDisplay.resize(height, width, VIRTUAL_DISPLAY_DPI); - surfaceTextureHelper.setTextureSize(height, width); - } - } - } - - // This is called on the internal looper thread of {@Code SurfaceTextureHelper}. - @Override - public void onFrame(VideoFrame frame) { - numCapturedFrames++; - Log.v(TAG, "Frame received " + numCapturedFrames); - capturerObserver.onFrameCaptured(frame); - } - - @Override - public boolean isScreencast() { - return true; - } - - public long getNumCapturedFrames() { - return numCapturedFrames; - } - - - public void setVirtualDisplay(VirtualDisplay virtualDisplay) { - this.virtualDisplay = virtualDisplay; - } - - public void setSurfaceTextureHelper(SurfaceTextureHelper surfaceTextureHelper) { - this.surfaceTextureHelper = surfaceTextureHelper; - } - - public void setCapturerObserver(CapturerObserver capturerObserver) { - this.capturerObserver = capturerObserver; - } - - public void setWidth(int width) { - this.width = width; - } - - public void setHeight(int height) { - this.height = height; - } - - public MediaProjection.Callback getMediaProjectionCallback() { - return mediaProjectionCallback; - } -} diff --git a/webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/core/WebRTCClient.java b/webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/core/WebRTCClient.java index d8ecce7f..379ef1cd 100644 --- a/webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/core/WebRTCClient.java +++ b/webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/core/WebRTCClient.java @@ -43,6 +43,7 @@ import org.webrtc.RtpParameters; import org.webrtc.RtpReceiver; import org.webrtc.RtpSender; +import org.webrtc.ScreenCapturerAndroid; import org.webrtc.SdpObserver; import org.webrtc.SessionDescription; import org.webrtc.SoftwareVideoDecoderFactory; @@ -76,8 +77,8 @@ import javax.annotation.Nullable; -import io.antmedia.webrtcandroidframework.R; import io.antmedia.webrtcandroidframework.api.IWebRTCClient; +import io.antmedia.webrtcandroidframework.api.WebRTCClientConfig; import io.antmedia.webrtcandroidframework.apprtc.AppRTCAudioManager; import io.antmedia.webrtcandroidframework.websocket.AntMediaSignallingEvents; import io.antmedia.webrtcandroidframework.websocket.WebSocketHandler; @@ -278,7 +279,7 @@ else if (peerInfo.mode.equals(Mode.P2P)) { }; } - WebRTCClient(WebRTCClientConfig config) { + public WebRTCClient(WebRTCClientConfig config) { this.config = config; config.webRTCListener.setWebRTCClient(this); permissionsHandler = new PermissionsHandler(config.activity); @@ -696,7 +697,7 @@ public DisplayMetrics getDisplayMetrics() { } public @Nullable VideoCapturer createScreenCapturer() { - return new ScreenCapturer(config.mediaProjection, new MediaProjection.Callback() { + return new ScreenCapturerAndroid(config.mediaProjectionIntent, new MediaProjection.Callback() { @Override public void onStop() { reportError(getPublishStreamId(), USER_REVOKED_CAPTURE_SCREEN_PERMISSION); diff --git a/webrtc-android-framework/src/test/java/io/antmedia/webrtcandroidframework/WebRTCClientTest.java b/webrtc-android-framework/src/test/java/io/antmedia/webrtcandroidframework/WebRTCClientTest.java index f121477f..fed1f5a6 100644 --- a/webrtc-android-framework/src/test/java/io/antmedia/webrtcandroidframework/WebRTCClientTest.java +++ b/webrtc-android-framework/src/test/java/io/antmedia/webrtcandroidframework/WebRTCClientTest.java @@ -49,6 +49,7 @@ import org.webrtc.RtpReceiver; import org.webrtc.RtpSender; import org.webrtc.RtpTransceiver; +import org.webrtc.ScreenCapturerAndroid; import org.webrtc.SessionDescription; import org.webrtc.VideoCapturer; import org.webrtc.VideoTrack; @@ -68,7 +69,6 @@ import io.antmedia.webrtcandroidframework.apprtc.AppRTCAudioManager; import io.antmedia.webrtcandroidframework.core.PermissionsHandler; import io.antmedia.webrtcandroidframework.core.ProxyVideoSink; -import io.antmedia.webrtcandroidframework.core.ScreenCapturer; import io.antmedia.webrtcandroidframework.core.StreamInfo; import io.antmedia.webrtcandroidframework.core.WebRTCClient; import io.antmedia.webrtcandroidframework.websocket.WebSocketConstants; @@ -369,7 +369,7 @@ public void testCreateScreenCapturer() { webRTCClient.getConfig().mediaProjection = mock(MediaProjection.class); - ScreenCapturer screenCapturer = (ScreenCapturer) webRTCClient.createScreenCapturer(); + ScreenCapturerAndroid screenCapturer = (ScreenCapturerAndroid) webRTCClient.createScreenCapturer(); assertNotNull(screenCapturer); MediaProjection.Callback callback = Mockito.spy(screenCapturer.getMediaProjectionCallback()); diff --git a/webrtc-android-framework/src/test/java/io/antmedia/webrtcandroidframework/api/DefaultConferenceWebRTCListenerTest.java b/webrtc-android-framework/src/test/java/io/antmedia/webrtcandroidframework/api/DefaultConferenceWebRTCListenerTest.java new file mode 100644 index 00000000..dfe8c998 --- /dev/null +++ b/webrtc-android-framework/src/test/java/io/antmedia/webrtcandroidframework/api/DefaultConferenceWebRTCListenerTest.java @@ -0,0 +1,214 @@ +package io.antmedia.webrtcandroidframework.api; + +import static org.mockito.Matchers.anyBoolean; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.anyString; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.apache.commons.lang3.RandomStringUtils; +import org.junit.Before; +import org.junit.Test; +import org.mockito.MockitoAnnotations; +import org.webrtc.SurfaceViewRenderer; +import org.webrtc.VideoTrack; + +import java.util.ArrayList; + +import de.tavendo.autobahn.WebSocket; + +public class DefaultConferenceWebRTCListenerTest extends DefaultWebRTCListenerTest{ + private String roomId; + private String streamId; + + @Before + public void setUp() { + roomId = "roomId" + RandomStringUtils.randomNumeric(3); + streamId = "streamId" + RandomStringUtils.randomNumeric(3); + MockitoAnnotations.initMocks(this); + defaultWebRTCListener = spy(new DefaultConferenceWebRTCListener(roomId, streamId)); + defaultWebRTCListener.setWebRTCClient(mockWebRTCClient); + WebRTCClientConfig config = new WebRTCClientConfig(); + when(mockWebRTCClient.getConfig()).thenReturn(config); + } + + @Test + public void testOnDisconnected() { + defaultWebRTCListener.onDisconnected(); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnPublishFinished() { + defaultWebRTCListener.onPublishFinished("streamId"); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnPlayFinished() { + defaultWebRTCListener.onPlayFinished("streamId"); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnPublishStarted() { + defaultWebRTCListener.onPublishStarted("streamId"); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnPlayStarted() { + defaultWebRTCListener.onPlayStarted("streamId"); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testNoStreamExistsToPlay() { + defaultWebRTCListener.noStreamExistsToPlay("streamId"); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnError() { + defaultWebRTCListener.onError("description", "streamId"); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnSignalChannelClosed() { + defaultWebRTCListener.onSignalChannelClosed(WebSocket.WebSocketConnectionObserver.WebSocketCloseNotification.NORMAL, "streamId"); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testStreamIdInUse() { + defaultWebRTCListener.streamIdInUse("streamId"); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnIceConnected() { + defaultWebRTCListener.onIceConnected("streamId"); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnIceDisconnected() { + defaultWebRTCListener.onIceDisconnected("streamId"); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnTrackList() { + defaultWebRTCListener.onTrackList(new String[]{"track1", "track2"}); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnBitrateMeasurement() { + defaultWebRTCListener.onBitrateMeasurement("streamId", 100, 50, 50); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnStreamInfoList() { + defaultWebRTCListener.onStreamInfoList("streamId", new ArrayList<>()); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnNewVideoTrack() { + VideoTrack mockVideoTrack = mock(VideoTrack.class); + SurfaceViewRenderer mockSurfaceViewRenderer = mock(SurfaceViewRenderer.class); + + when(mockSurfaceViewRenderer.getTag()).thenReturn(null); + + mockWebRTCClient.getConfig().remoteVideoRenderers.add(mockSurfaceViewRenderer); + + + defaultWebRTCListener.onNewVideoTrack(mockVideoTrack); + + verify(mockSurfaceViewRenderer, times(1)).setTag(mockVideoTrack); + verify(mockWebRTCClient, times(1)).setRendererForVideoTrack(mockSurfaceViewRenderer, mockVideoTrack); + } + + @Test + public void testOnVideoTrackEnded() { + VideoTrack mockVideoTrack = mock(VideoTrack.class); + SurfaceViewRenderer mockSurfaceViewRenderer = mock(SurfaceViewRenderer.class); + + when(mockSurfaceViewRenderer.getTag()).thenReturn(mockVideoTrack); + + mockWebRTCClient.getConfig().remoteVideoRenderers.add(mockSurfaceViewRenderer); + + defaultWebRTCListener.onVideoTrackEnded(mockVideoTrack); + + verify(mockSurfaceViewRenderer, times(1)).setTag(null); + } + + @Test + public void testOnReconnectionAttempt() { + defaultWebRTCListener.onReconnectionAttempt("streamId"); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnJoinedTheRoom() { + String[] tracks = new String[]{"stream1", "stream2"}; + defaultWebRTCListener.onJoinedTheRoom(streamId, tracks); + verify(defaultWebRTCListener, times(2)).callbackCalled(anyString()); + + verify(mockWebRTCClient, times(1)).publish(eq(streamId), anyString(), + anyBoolean(), anyBoolean(), anyString(), anyString(), anyString(), eq(roomId)); + + verify(defaultWebRTCListener, times(1)).onTrackList(tracks); + + } + + @Test + public void testOnRoomInformation() { + String[] tracks = new String[]{"stream1", "stream2"}; + defaultWebRTCListener.onRoomInformation(tracks); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + verify(mockWebRTCClient, times(1)).play(eq(roomId), eq(tracks)); + } + + @Test + public void testOnLeftTheRoom() { + defaultWebRTCListener.onLeftTheRoom("roomId"); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnMutedFor() { + defaultWebRTCListener.onMutedFor("streamId"); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnUnmutedFor() { + defaultWebRTCListener.onUnmutedFor("streamId"); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnCameraTurnOnFor() { + defaultWebRTCListener.onCameraTurnOnFor("streamId"); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnCameraTurnOffFor() { + defaultWebRTCListener.onCameraTurnOffFor("streamId"); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnSatatusUpdateFor() { + defaultWebRTCListener.onSatatusUpdateFor("streamId", true, false); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } +} diff --git a/webrtc-android-framework/src/test/java/io/antmedia/webrtcandroidframework/api/DefaultDataChannelObserverTest.java b/webrtc-android-framework/src/test/java/io/antmedia/webrtcandroidframework/api/DefaultDataChannelObserverTest.java new file mode 100644 index 00000000..26bb30e0 --- /dev/null +++ b/webrtc-android-framework/src/test/java/io/antmedia/webrtcandroidframework/api/DefaultDataChannelObserverTest.java @@ -0,0 +1,55 @@ +package io.antmedia.webrtcandroidframework.api; + +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.webrtc.DataChannel; + +import java.nio.ByteBuffer; + +import static org.mockito.Mockito.*; + +public class DefaultDataChannelObserverTest { + + private DefaultDataChannelObserver defaultDataChannelObserver; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + defaultDataChannelObserver = spy(new DefaultDataChannelObserver()); + } + + @Test + public void testOnMessage() { + String message = "Test Message"; + ByteBuffer data = ByteBuffer.wrap(message.getBytes()); + DataChannel.Buffer mockBuffer = new DataChannel.Buffer(data, false); + defaultDataChannelObserver.onMessage(mockBuffer, "label"); + verify(defaultDataChannelObserver, times(1)).textMessageReceived(message); + } + + @Test + public void testToTextMessage() { + String message = "Test Message"; + ByteBuffer data = ByteBuffer.wrap(message.getBytes()); + DataChannel.Buffer mockBuffer = new DataChannel.Buffer(data, false); + String result = defaultDataChannelObserver.toTextMessage(mockBuffer); + assert result.equals(message); + } + + @Test + public void testOtherMethodsWithoutCallback() { + String message = "Test Message"; + ByteBuffer data = ByteBuffer.wrap(message.getBytes()); + DataChannel.Buffer mockBuffer = new DataChannel.Buffer(data, false); + defaultDataChannelObserver.onMessageSent(mockBuffer, true); + defaultDataChannelObserver.onMessageSent(mockBuffer, false); + + defaultDataChannelObserver.onBufferedAmountChange(100, "label"); + + defaultDataChannelObserver.onStateChange(DataChannel.State.OPEN, "label"); + //nothing for assertion + } + +} diff --git a/webrtc-android-framework/src/test/java/io/antmedia/webrtcandroidframework/api/DefaultWebRTCListenerTest.java b/webrtc-android-framework/src/test/java/io/antmedia/webrtcandroidframework/api/DefaultWebRTCListenerTest.java new file mode 100644 index 00000000..2d955b32 --- /dev/null +++ b/webrtc-android-framework/src/test/java/io/antmedia/webrtcandroidframework/api/DefaultWebRTCListenerTest.java @@ -0,0 +1,198 @@ +package io.antmedia.webrtcandroidframework.api; + +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.webrtc.SurfaceViewRenderer; +import org.webrtc.VideoTrack; +import de.tavendo.autobahn.WebSocket; + +import java.util.ArrayList; + +import static org.mockito.Mockito.*; + +public class DefaultWebRTCListenerTest { + + @Mock + IWebRTCClient mockWebRTCClient; + + DefaultWebRTCListener defaultWebRTCListener; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + defaultWebRTCListener = spy(new DefaultWebRTCListener()); + defaultWebRTCListener.setWebRTCClient(mockWebRTCClient); + WebRTCClientConfig config = new WebRTCClientConfig(); + when(mockWebRTCClient.getConfig()).thenReturn(config); + } + + @Test + public void testOnDisconnected() { + defaultWebRTCListener.onDisconnected(); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnPublishFinished() { + defaultWebRTCListener.onPublishFinished("streamId"); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnPlayFinished() { + defaultWebRTCListener.onPlayFinished("streamId"); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnPublishStarted() { + defaultWebRTCListener.onPublishStarted("streamId"); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnPlayStarted() { + defaultWebRTCListener.onPlayStarted("streamId"); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testNoStreamExistsToPlay() { + defaultWebRTCListener.noStreamExistsToPlay("streamId"); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnError() { + defaultWebRTCListener.onError("description", "streamId"); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnSignalChannelClosed() { + defaultWebRTCListener.onSignalChannelClosed(WebSocket.WebSocketConnectionObserver.WebSocketCloseNotification.NORMAL, "streamId"); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testStreamIdInUse() { + defaultWebRTCListener.streamIdInUse("streamId"); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnIceConnected() { + defaultWebRTCListener.onIceConnected("streamId"); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnIceDisconnected() { + defaultWebRTCListener.onIceDisconnected("streamId"); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnTrackList() { + defaultWebRTCListener.onTrackList(new String[]{"track1", "track2"}); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnBitrateMeasurement() { + defaultWebRTCListener.onBitrateMeasurement("streamId", 100, 50, 50); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnStreamInfoList() { + defaultWebRTCListener.onStreamInfoList("streamId", new ArrayList<>()); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnNewVideoTrack() { + VideoTrack mockVideoTrack = mock(VideoTrack.class); + SurfaceViewRenderer mockSurfaceViewRenderer = mock(SurfaceViewRenderer.class); + + when(mockSurfaceViewRenderer.getTag()).thenReturn(null); + + mockWebRTCClient.getConfig().remoteVideoRenderers.add(mockSurfaceViewRenderer); + + + defaultWebRTCListener.onNewVideoTrack(mockVideoTrack); + + verify(mockSurfaceViewRenderer, times(1)).setTag(mockVideoTrack); + verify(mockWebRTCClient, times(1)).setRendererForVideoTrack(mockSurfaceViewRenderer, mockVideoTrack); + } + + @Test + public void testOnVideoTrackEnded() { + VideoTrack mockVideoTrack = mock(VideoTrack.class); + SurfaceViewRenderer mockSurfaceViewRenderer = mock(SurfaceViewRenderer.class); + + when(mockSurfaceViewRenderer.getTag()).thenReturn(mockVideoTrack); + + mockWebRTCClient.getConfig().remoteVideoRenderers.add(mockSurfaceViewRenderer); + + defaultWebRTCListener.onVideoTrackEnded(mockVideoTrack); + + verify(mockSurfaceViewRenderer, times(1)).setTag(null); + } + + @Test + public void testOnReconnectionAttempt() { + defaultWebRTCListener.onReconnectionAttempt("streamId"); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnJoinedTheRoom() { + defaultWebRTCListener.onJoinedTheRoom("streamId", new String[]{"stream1", "stream2"}); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnRoomInformation() { + defaultWebRTCListener.onRoomInformation(new String[]{"stream1", "stream2"}); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnLeftTheRoom() { + defaultWebRTCListener.onLeftTheRoom("roomId"); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnMutedFor() { + defaultWebRTCListener.onMutedFor("streamId"); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnUnmutedFor() { + defaultWebRTCListener.onUnmutedFor("streamId"); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnCameraTurnOnFor() { + defaultWebRTCListener.onCameraTurnOnFor("streamId"); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnCameraTurnOffFor() { + defaultWebRTCListener.onCameraTurnOffFor("streamId"); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } + + @Test + public void testOnSatatusUpdateFor() { + defaultWebRTCListener.onSatatusUpdateFor("streamId", true, false); + verify(defaultWebRTCListener, times(1)).callbackCalled(anyString()); + } +} diff --git a/webrtc-android-framework/src/test/java/io/antmedia/webrtcandroidframework/api/WebRTCClientBuilderTest.java b/webrtc-android-framework/src/test/java/io/antmedia/webrtcandroidframework/api/WebRTCClientBuilderTest.java new file mode 100644 index 00000000..0d811be5 --- /dev/null +++ b/webrtc-android-framework/src/test/java/io/antmedia/webrtcandroidframework/api/WebRTCClientBuilderTest.java @@ -0,0 +1,206 @@ +package io.antmedia.webrtcandroidframework.api; + +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.webrtc.SurfaceViewRenderer; +import org.webrtc.RendererCommon; +import android.app.Activity; + +import java.util.Arrays; + +import static org.junit.Assert.*; +import static org.mockito.Mockito.*; + +import io.antmedia.webrtcandroidframework.core.WebRTCClient; + +public class WebRTCClientBuilderTest { + private WebRTCClientBuilder webRTCClientBuilder; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + webRTCClientBuilder = new WebRTCClientBuilder(); + } + + @Test + public void testBuild() { + Activity activity = mock(Activity.class); + when(activity.getMainLooper()).thenReturn(mock(android.os.Looper.class)); + webRTCClientBuilder.setActivity(activity); + WebRTCClient webRTCClient = webRTCClientBuilder.build(); + assertNotNull(webRTCClient); + assertEquals(webRTCClientBuilder.getConfig(), webRTCClient.getConfig()); + } + + @Test + public void testSetServerUrl() { + String serverUrl = "https://example.com"; + webRTCClientBuilder.setServerUrl(serverUrl); + assertEquals(serverUrl, webRTCClientBuilder.getConfig().serverUrl); + } + + @Test + public void testSetStreamId() { + String streamId = "stream123"; + webRTCClientBuilder.setStreamId(streamId); + assertEquals(streamId, webRTCClientBuilder.getConfig().streamId); + } + + // Repeat the above pattern for each setter method in WebRTCClientBuilder + + @Test + public void testAddRemoteVideoRenderer() { + SurfaceViewRenderer mockSurfaceViewRenderer = mock(SurfaceViewRenderer.class); + webRTCClientBuilder.addRemoteVideoRenderer(mockSurfaceViewRenderer); + assertTrue(webRTCClientBuilder.getConfig().remoteVideoRenderers.contains(mockSurfaceViewRenderer)); + } + + @Test + public void testSetWebRTCListener() { + IWebRTCListener mockWebRTCListener = mock(IWebRTCListener.class); + webRTCClientBuilder.setWebRTCListener(mockWebRTCListener); + assertEquals(mockWebRTCListener, webRTCClientBuilder.getConfig().webRTCListener); + } + + @Test + public void testSetDataChannelObserver() { + IDataChannelObserver mockDataChannelObserver = mock(IDataChannelObserver.class); + webRTCClientBuilder.setDataChannelObserver(mockDataChannelObserver); + assertEquals(mockDataChannelObserver, webRTCClientBuilder.getConfig().dataChannelObserver); + } + + @Test + public void testSetActivity() { + Activity mockActivity = mock(Activity.class); + webRTCClientBuilder.setActivity(mockActivity); + assertEquals(mockActivity, webRTCClientBuilder.getConfig().activity); + } + + @Test + public void testSetCustomVideoCapturerEnabled() { + boolean customVideoCapturerEnabled = true; + webRTCClientBuilder.setCustomVideoCapturerEnabled(customVideoCapturerEnabled); + assertEquals(customVideoCapturerEnabled, webRTCClientBuilder.getConfig().customVideoCapturerEnabled); + } + + @Test + public void testSetInitiateBeforeStream() { + boolean initiateBeforeStream = true; + webRTCClientBuilder.setInitiateBeforeStream(initiateBeforeStream); + assertEquals(initiateBeforeStream, webRTCClientBuilder.getConfig().initiateBeforeStream); + } + + @Test + public void testSetCustomAudioFeed() { + boolean customAudioFeed = true; + webRTCClientBuilder.setCustomAudioFeed(customAudioFeed); + assertEquals(customAudioFeed, webRTCClientBuilder.getConfig().customAudioFeed); + } + + @Test + public void testSetScalingType() { + RendererCommon.ScalingType scalingType = RendererCommon.ScalingType.SCALE_ASPECT_FIT; + webRTCClientBuilder.setScalingType(scalingType); + assertEquals(scalingType, webRTCClientBuilder.getConfig().scalingType); + } + + @Test + public void testSetStunServerUri() { + String stunServerUri = "stun:stun.example.com"; + webRTCClientBuilder.setStunServerUri(stunServerUri); + assertEquals(stunServerUri, webRTCClientBuilder.getConfig().stunServerUri); + } + + @Test + public void testSetReconnectionEnabled() { + boolean reconnectionEnabled = true; + webRTCClientBuilder.setReconnectionEnabled(reconnectionEnabled); + assertEquals(reconnectionEnabled, webRTCClientBuilder.getConfig().reconnectionEnabled); + } + + @Test + public void testSetToken() { + String token = "testToken"; + webRTCClientBuilder.setToken(token); + assertEquals(token, webRTCClientBuilder.getConfig().token); + } + + @Test + public void testSetVideoCallEnabled() { + boolean videoCallEnabled = true; + webRTCClientBuilder.setVideoCallEnabled(videoCallEnabled); + assertEquals(videoCallEnabled, webRTCClientBuilder.getConfig().videoCallEnabled); + } + + @Test + public void testSetAudioCallEnabled() { + boolean audioCallEnabled = true; + webRTCClientBuilder.setAudioCallEnabled(audioCallEnabled); + assertEquals(audioCallEnabled, webRTCClientBuilder.getConfig().audioCallEnabled); + } + + @Test + public void testSetDataChannelEnabled() { + boolean dataChannelEnabled = true; + webRTCClientBuilder.setDataChannelEnabled(dataChannelEnabled); + assertEquals(dataChannelEnabled, webRTCClientBuilder.getConfig().dataChannelEnabled); + } + + @Test + public void testSetVideoWidth() { + int videoWidth = 640; + webRTCClientBuilder.setVideoWidth(videoWidth); + assertEquals(videoWidth, webRTCClientBuilder.getConfig().videoWidth); + } + + @Test + public void testSetVideoHeight() { + int videoHeight = 480; + webRTCClientBuilder.setVideoHeight(videoHeight); + assertEquals(videoHeight, webRTCClientBuilder.getConfig().videoHeight); + } + + @Test + public void testSetVideoFps() { + int videoFps = 30; + webRTCClientBuilder.setVideoFps(videoFps); + assertEquals(videoFps, webRTCClientBuilder.getConfig().videoFps); + } + + @Test + public void testSetVideoStartBitrate() { + int videoStartBitrate = 500; + webRTCClientBuilder.setVideoStartBitrate(videoStartBitrate); + assertEquals(videoStartBitrate, webRTCClientBuilder.getConfig().videoStartBitrate); + } + + @Test + public void testSetVideoCodec() { + String videoCodec = "H.264"; + webRTCClientBuilder.setVideoCodec(videoCodec); + assertEquals(videoCodec, webRTCClientBuilder.getConfig().videoCodec); + } + + @Test + public void testSetAudioStartBitrate() { + int audioStartBitrate = 64; + webRTCClientBuilder.setAudioStartBitrate(audioStartBitrate); + assertEquals(audioStartBitrate, webRTCClientBuilder.getConfig().audioStartBitrate); + } + + @Test + public void testSetAudioCodec() { + String audioCodec = "Opus"; + webRTCClientBuilder.setAudioCodec(audioCodec); + assertEquals(audioCodec, webRTCClientBuilder.getConfig().audioCodec); + } + + @Test + public void testSetLocalVideoRenderer() { + SurfaceViewRenderer mockSurfaceViewRenderer = mock(SurfaceViewRenderer.class); + webRTCClientBuilder.setLocalVideoRenderer(mockSurfaceViewRenderer); + assertEquals(mockSurfaceViewRenderer, webRTCClientBuilder.getConfig().localVideoRenderer); + } +} diff --git a/webrtc-android-sample-app/src/androidTest/java/io/antmedia/webrtc_android_sample_app/ConferenceActivityTest.java b/webrtc-android-sample-app/src/androidTest/java/io/antmedia/webrtc_android_sample_app/ConferenceActivityTest.java new file mode 100644 index 00000000..b29d7e8f --- /dev/null +++ b/webrtc-android-sample-app/src/androidTest/java/io/antmedia/webrtc_android_sample_app/ConferenceActivityTest.java @@ -0,0 +1,290 @@ +package io.antmedia.webrtc_android_sample_app; + +import static androidx.test.espresso.Espresso.onView; +import static androidx.test.espresso.action.ViewActions.click; +import static androidx.test.espresso.assertion.ViewAssertions.matches; +import static androidx.test.espresso.matcher.ViewMatchers.withEffectiveVisibility; +import static androidx.test.espresso.matcher.ViewMatchers.withId; +import static androidx.test.espresso.matcher.ViewMatchers.withText; +import static androidx.test.platform.app.InstrumentationRegistry.getInstrumentation; +import static org.junit.Assert.assertNotNull; + +import android.app.Activity; +import android.content.Context; +import android.content.Intent; +import android.util.Log; + +import androidx.test.core.app.ActivityScenario; +import androidx.test.core.app.ApplicationProvider; +import androidx.test.espresso.IdlingRegistry; +import androidx.test.espresso.IdlingResource; +import androidx.test.espresso.assertion.ViewAssertions; +import androidx.test.espresso.matcher.ViewMatchers; +import androidx.test.ext.junit.rules.ActivityScenarioRule; +import androidx.test.ext.junit.runners.AndroidJUnit4; +import androidx.test.platform.app.InstrumentationRegistry; +import androidx.test.rule.GrantPermissionRule; + +import org.apache.commons.lang3.RandomStringUtils; +import org.junit.After; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.TestWatcher; +import org.junit.runner.Description; +import org.junit.runner.RunWith; + +import io.antmedia.webrtc_android_sample_app.basic.ConferenceActivity; +import io.antmedia.webrtc_android_sample_app.basic.SettingsActivity; +import io.antmedia.webrtcandroidframework.core.PermissionsHandler; + + +/** + * Instrumented test, which will execute on an Android device. + * + * @see Testing documentation + */ +@RunWith(AndroidJUnit4.class) +public class ConferenceActivityTest { + + //match + private static final String START_NOW_TEXT = "Start now"; + + private IdlingResource mIdlingResource; + + @Rule + public GrantPermissionRule permissionRule + = GrantPermissionRule.grant(PermissionsHandler.REQUIRED_EXTENDED_PERMISSIONS); + + @Rule + public ActivityScenarioRule activityScenarioRule = new ActivityScenarioRule<>(ConferenceActivity.class); + private String runningTest; + private String roomName; + + @Before + public void before() { + //try before method to make @Rule run properly + System.out.println("before test"); + + getInstrumentation().waitForIdleSync(); + + roomName = "room_" + RandomStringUtils.randomNumeric(3); + Context context = getInstrumentation().getTargetContext(); + SettingsActivity.changeRoomName(context, roomName); + } + + @After + public void after() { + System.out.println("after test"); + try { + Thread.sleep(10000); + } catch (InterruptedException e) { + throw new RuntimeException(e); + } + + } + + @Rule + public TestWatcher watchman= new TestWatcher() { + + @Override + protected void failed(Throwable e, Description description) { + Log.i("TestWatcher", "*** "+description + " failed!\n"); + } + + @Override + protected void succeeded(Description description) { + Log.i("TestWatcher", "*** "+description + " succeeded!\n"); + } + + protected void starting(Description description) { + Log.i("TestWatcher", "******\n*** "+description + " starting!\n"); + runningTest = description.toString(); + } + + protected void finished(Description description) { + Log.i("TestWatcher", "*** "+description + " finished!\n******\n"); + } + }; + + @Test + public void testJoinMultitrackRoom() { + activityScenarioRule.getScenario().onActivity(new ActivityScenario.ActivityAction() { + @Override + public void perform(ConferenceActivity activity) { + mIdlingResource = activity.getIdlingResource(); + IdlingRegistry.getInstance().register(mIdlingResource); + activity.sendBroadcast(new Intent(Intent.ACTION_CLOSE_SYSTEM_DIALOGS)); + } + }); + + onView(withId(R.id.join_conference_button)).check(matches(withText("Join Conference"))); + onView(withId(R.id.join_conference_button)).perform(click()); + + onView(withId(R.id.join_conference_button)).check(matches(withText("Leave"))); + try { + Thread.sleep(5000); + } catch (InterruptedException e) { + e.printStackTrace(); + } + + onView(withId(R.id.broadcasting_text_view)).check(ViewAssertions.matches(withEffectiveVisibility(ViewMatchers.Visibility.VISIBLE))); + + onView(withId(R.id.join_conference_button)).perform(click()); + + onView(withId(R.id.broadcasting_text_view)).check(ViewAssertions.matches(withEffectiveVisibility(ViewMatchers.Visibility.GONE))); + + IdlingRegistry.getInstance().unregister(mIdlingResource); + } + + + + @Test + public void testJoinWithExternalParticipant() { + activityScenarioRule.getScenario().onActivity(new ActivityScenario.ActivityAction() { + @Override + public void perform(ConferenceActivity activity) { + mIdlingResource = activity.getIdlingResource(); + IdlingRegistry.getInstance().register(mIdlingResource); + activity.sendBroadcast(new Intent(Intent.ACTION_CLOSE_SYSTEM_DIALOGS)); + } + }); + + onView(withId(R.id.join_conference_button)).check(matches(withText("Join Conference"))); + onView(withId(R.id.join_conference_button)).perform(click()); + + + RemoteParticipant participant = RemoteParticipant.addParticipant(roomName, runningTest); + + onView(withId(R.id.join_conference_button)).check(matches(withText("Leave"))); + + onView(withId(R.id.broadcasting_text_view)).check(ViewAssertions.matches(withEffectiveVisibility(ViewMatchers.Visibility.VISIBLE))); + + onView(withId(R.id.join_conference_button)).perform(click()); + + onView(withId(R.id.broadcasting_text_view)).check(ViewAssertions.matches(withEffectiveVisibility(ViewMatchers.Visibility.GONE))); + + participant.leave(); + IdlingRegistry.getInstance().unregister(mIdlingResource); + + } + + //@Test + public void testJoinWithoutVideo() { + activityScenarioRule.getScenario().onActivity(new ActivityScenario.ActivityAction() { + @Override + public void perform(ConferenceActivity activity) { + mIdlingResource = activity.getIdlingResource(); + IdlingRegistry.getInstance().register(mIdlingResource); + activity.sendBroadcast(new Intent(Intent.ACTION_CLOSE_SYSTEM_DIALOGS)); + } + }); + + onView(withId(R.id.control_audio_button)).check(matches(withText("Disable Audio"))); + onView(withId(R.id.control_audio_button)).perform(click()); + + onView(withId(R.id.control_video_button)).check(matches(withText("Disable Video"))); + onView(withId(R.id.control_video_button)).perform(click()); + + onView(withId(R.id.join_conference_button)).check(matches(withText("Join Conference"))); + onView(withId(R.id.join_conference_button)).perform(click()); + + RemoteParticipant participant = RemoteParticipant.addParticipant(roomName, runningTest); + + onView(withId(R.id.control_audio_button)).check(matches(withText("Enable Audio"))); + onView(withId(R.id.control_audio_button)).perform(click()); + + onView(withId(R.id.control_video_button)).check(matches(withText("Enable Video"))); + onView(withId(R.id.control_video_button)).perform(click()); + + onView(withId(R.id.join_conference_button)).check(matches(withText("Leave"))); + + onView(withId(R.id.broadcasting_text_view)).check(ViewAssertions.matches(withEffectiveVisibility(ViewMatchers.Visibility.VISIBLE))); + + onView(withId(R.id.join_conference_button)).perform(click()); + + onView(withId(R.id.broadcasting_text_view)).check(ViewAssertions.matches(withEffectiveVisibility(ViewMatchers.Visibility.GONE))); + + participant.leave(); + IdlingRegistry.getInstance().unregister(mIdlingResource); + + } + + + @Test + public void testJoinPlayOnlyAsFirstPerson() { + activityScenarioRule.getScenario().onActivity(new ActivityScenario.ActivityAction() { + @Override + public void perform(ConferenceActivity activity) { + mIdlingResource = activity.getIdlingResource(); + IdlingRegistry.getInstance().register(mIdlingResource); + activity.sendBroadcast(new Intent(Intent.ACTION_CLOSE_SYSTEM_DIALOGS)); + } + }); + + onView(withId(R.id.play_only_switch)).check(matches(withText("Play Only"))); + onView(withId(R.id.play_only_switch)).perform(click()); + + onView(withId(R.id.join_conference_button)).check(matches(withText("Join Conference"))); + onView(withId(R.id.join_conference_button)).perform(click()); + + RemoteParticipant participant = RemoteParticipant.addParticipant(roomName, runningTest); + + onView(withId(R.id.join_conference_button)).check(matches(withText("Leave"))); + + onView(withId(R.id.join_conference_button)).perform(click()); + + participant.leave(); + IdlingRegistry.getInstance().unregister(mIdlingResource); + + } + + @Test + public void testReconnect() { + final ConferenceActivity[] mactivity = new ConferenceActivity[1]; + activityScenarioRule.getScenario().onActivity(new ActivityScenario.ActivityAction() { + @Override + public void perform(ConferenceActivity activity) { + mIdlingResource = activity.getIdlingResource(); + IdlingRegistry.getInstance().register(mIdlingResource); + activity.sendBroadcast(new Intent(Intent.ACTION_CLOSE_SYSTEM_DIALOGS)); + mactivity[0] = activity; + } + }); + + onView(withId(R.id.join_conference_button)).check(matches(withText("Join Conference"))); + onView(withId(R.id.join_conference_button)).perform(click()); + + RemoteParticipant participant = RemoteParticipant.addParticipant(roomName, runningTest); + + onView(withId(R.id.join_conference_button)).check(matches(withText("Leave"))); + + onView(withId(R.id.broadcasting_text_view)).check(ViewAssertions.matches(withEffectiveVisibility(ViewMatchers.Visibility.VISIBLE))); + + + mactivity[0].changeWifiState(false); + + try { + Thread.sleep(3000); + } catch (InterruptedException e) { + throw new RuntimeException(e); + } + mactivity[0].changeWifiState(true); + + + + onView(withId(R.id.join_conference_button)).check(matches(withText("Leave"))); + + onView(withId(R.id.broadcasting_text_view)).check(ViewAssertions.matches(withEffectiveVisibility(ViewMatchers.Visibility.VISIBLE))); + + onView(withId(R.id.join_conference_button)).perform(click()); + + //onView(withId(R.id.broadcasting_text_view)).check(ViewAssertions.matches(withEffectiveVisibility(ViewMatchers.Visibility.GONE))); + + participant.leave(); + IdlingRegistry.getInstance().unregister(mIdlingResource); + + } + + +} diff --git a/webrtc-android-sample-app/src/androidTest/java/io/antmedia/webrtc_android_sample_app/RemoteParticipant.java b/webrtc-android-sample-app/src/androidTest/java/io/antmedia/webrtc_android_sample_app/RemoteParticipant.java new file mode 100644 index 00000000..f261e46c --- /dev/null +++ b/webrtc-android-sample-app/src/androidTest/java/io/antmedia/webrtc_android_sample_app/RemoteParticipant.java @@ -0,0 +1,95 @@ +package io.antmedia.webrtc_android_sample_app; + +import static org.junit.Assert.assertNotNull; + +import android.util.Log; + +import org.apache.commons.lang3.RandomStringUtils; + +import java.io.IOException; + +import okhttp3.Call; +import okhttp3.HttpUrl; +import okhttp3.OkHttpClient; +import okhttp3.Request; +import okhttp3.Response; + +class RemoteParticipant { + + NetworkClient client = new NetworkClient(); + String response = null; + String participantName = "p_"+ RandomStringUtils.randomNumeric(3); + + private String roomName; + private String runningTest; + + public RemoteParticipant(String roomName, String runningTest) { + this.roomName = roomName; + this.runningTest = runningTest; + } + + public class NetworkClient { + + private static final String REST_IP = "10.0.2.2"; + private static final int REST_PORT = 3030; + + private final OkHttpClient client = new OkHttpClient(); + + public String get(String path, String participantName) throws IOException { + HttpUrl httpUrl = new HttpUrl.Builder() + .scheme("http") + .host(REST_IP) + .port(REST_PORT) + .addPathSegment(path) + .addQueryParameter("room", roomName) + .addQueryParameter("test", runningTest) + .addQueryParameter("participant", participantName) + .build(); + + + Request request = new Request.Builder() + .url(httpUrl) + .header("Connection", "close") // <== solution, not declare in Interceptor + .build(); + + Call call = client.newCall(request); + Response response = call.execute(); + return response.body().string(); + } + } + + public void join() { + try { + response = client.get("create", participantName); + Log.i("RemoteParticipant", "create: " + response); + assertNotNull(response); + + response = client.get("join", participantName); + Log.i("RemoteParticipant", "join: " + response); + assertNotNull(response); + } catch (IOException e) { + throw new RuntimeException(e); + } + } + + public void leave() { + try { + response = client.get("leave", participantName); + Log.i("RemoteParticipant", "leave: " + response); + assertNotNull(response); + + response = client.get("delete", participantName); + Log.i("RemoteParticipant", "delete: " + response); + assertNotNull(response); + } catch (IOException e) { + throw new RuntimeException(e); + } + } + + public static RemoteParticipant addParticipant(String roomName, String runningTest) { + RemoteParticipant participant = new RemoteParticipant(roomName, runningTest); + participant.join(); + + return participant; + } +} \ No newline at end of file diff --git a/webrtc-android-sample-app/src/androidTest/java/io/antmedia/webrtc_android_sample_app/ScreenCaptureActivityTest.java b/webrtc-android-sample-app/src/androidTest/java/io/antmedia/webrtc_android_sample_app/ScreenCaptureActivityTest.java new file mode 100644 index 00000000..d0b904dd --- /dev/null +++ b/webrtc-android-sample-app/src/androidTest/java/io/antmedia/webrtc_android_sample_app/ScreenCaptureActivityTest.java @@ -0,0 +1,135 @@ +package io.antmedia.webrtc_android_sample_app; + +import static androidx.test.espresso.Espresso.onView; +import static androidx.test.espresso.action.ViewActions.click; +import static androidx.test.espresso.assertion.ViewAssertions.matches; +import static androidx.test.espresso.matcher.ViewMatchers.withEffectiveVisibility; +import static androidx.test.espresso.matcher.ViewMatchers.withId; +import static androidx.test.espresso.matcher.ViewMatchers.withText; +import static androidx.test.platform.app.InstrumentationRegistry.getInstrumentation; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; + +import android.content.Context; +import android.content.Intent; + +import androidx.test.core.app.ActivityScenario; +import androidx.test.core.app.ApplicationProvider; +import androidx.test.espresso.IdlingRegistry; +import androidx.test.espresso.IdlingResource; +import androidx.test.espresso.assertion.ViewAssertions; +import androidx.test.espresso.matcher.ViewMatchers; +import androidx.test.ext.junit.runners.AndroidJUnit4; +import androidx.test.rule.GrantPermissionRule; +import androidx.test.uiautomator.By; +import androidx.test.uiautomator.UiDevice; +import androidx.test.uiautomator.UiObject2; +import androidx.test.uiautomator.Until; + +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; + +import io.antmedia.webrtc_android_sample_app.basic.ScreenCaptureActivity; +import io.antmedia.webrtcandroidframework.core.PermissionsHandler; + +/** + * Instrumented test, which will execute on an Android device. + * + * @see Testing documentation + */ +@RunWith(AndroidJUnit4.class) +public class ScreenCaptureActivityTest { + + //match + private static final String START_NOW_TEXT = "Start now"; + + private IdlingResource mIdlingResource; + + @Rule + public GrantPermissionRule permissionRule + = GrantPermissionRule.grant(PermissionsHandler.REQUIRED_EXTENDED_PERMISSIONS); + + @Before + public void before() { + //try before method to make @Rule run properly + } + + @Test + public void useAppContext() { + // Context of the app under test. + Context appContext = getInstrumentation().getTargetContext(); + assertEquals("io.antmedia.webrtc_android_sample_app", appContext.getPackageName()); + } + + + /** + * This test should be in another method but cannot get the full logcat so it's moved here + */ + @Test + public void testPublishScreen() { + Intent intent = new Intent(ApplicationProvider.getApplicationContext(), ScreenCaptureActivity.class); + ActivityScenario scenario = ActivityScenario.launch(intent); + + + scenario.onActivity(new ActivityScenario.ActivityAction() { + + @Override + public void perform(ScreenCaptureActivity activity) { + mIdlingResource = activity.getIdlingResource(); + IdlingRegistry.getInstance().register(mIdlingResource); + activity.sendBroadcast(new Intent(Intent.ACTION_CLOSE_SYSTEM_DIALOGS)); + } + }); + + UiDevice device = UiDevice.getInstance(getInstrumentation()); + + onView(withId(R.id.rbScreen)).perform(click()); + UiObject2 button = device.wait(Until.findObject(By.text("Start now")), 100000); + assertNotNull(button); + button.click(); + + //this switch operation causes to crash so that it's added here as test + onView(withId(R.id.rbFront)).perform(click()); + onView(withId(R.id.rbScreen)).perform(click()); + + button = device.wait(Until.findObject(By.text("Start now")), 100000); + assertNotNull(button); + button.click(); + + onView(withId(R.id.start_streaming_button)).check(matches(withText("Start"))); + //Espresso.closeSoftKeyboard(); + onView(withId(R.id.start_streaming_button)).perform(click()); + + onView(withId(R.id.start_streaming_button)).check(matches(withText("Stop"))); + onView(withId(R.id.broadcasting_text_view)).check(ViewAssertions.matches(withEffectiveVisibility(ViewMatchers.Visibility.VISIBLE))); + + //2. stop stream and check that it's stopped + onView(withId(R.id.start_streaming_button)).perform(click()); + onView(withId(R.id.broadcasting_text_view)).check(ViewAssertions.matches(withEffectiveVisibility(ViewMatchers.Visibility.GONE))); + + + //Publish again without because it was failing + onView(withId(R.id.start_streaming_button)).check(matches(withText("Start"))); + + //FIXME: without this sleep, it's failing because onFinish event received but resources are not closed yet + try { + Thread.sleep(3000); + } catch (InterruptedException e) { + throw new RuntimeException(e); + } + onView(withId(R.id.start_streaming_button)).perform(click()); + + //Check it's publishing again + onView(withId(R.id.start_streaming_button)).check(matches(withText("Stop"))); + onView(withId(R.id.broadcasting_text_view)).check(ViewAssertions.matches(withEffectiveVisibility(ViewMatchers.Visibility.VISIBLE))); + + //Stop publishing + onView(withId(R.id.start_streaming_button)).perform(click()); + onView(withId(R.id.broadcasting_text_view)).check(ViewAssertions.matches(withEffectiveVisibility(ViewMatchers.Visibility.GONE))); + + + IdlingRegistry.getInstance().unregister(mIdlingResource); + } +} diff --git a/webrtc-android-sample-app/src/androidTest/java/io/antmedia/webrtc_android_sample_app/SettingsActivityTest.java b/webrtc-android-sample-app/src/androidTest/java/io/antmedia/webrtc_android_sample_app/SettingsActivityTest.java new file mode 100644 index 00000000..5d0eb1f5 --- /dev/null +++ b/webrtc-android-sample-app/src/androidTest/java/io/antmedia/webrtc_android_sample_app/SettingsActivityTest.java @@ -0,0 +1,109 @@ +package io.antmedia.webrtc_android_sample_app; + +import static androidx.test.espresso.Espresso.onView; +import static androidx.test.espresso.action.ViewActions.clearText; +import static androidx.test.espresso.action.ViewActions.click; +import static androidx.test.espresso.action.ViewActions.typeText; +import static androidx.test.espresso.assertion.ViewAssertions.matches; +import static androidx.test.espresso.matcher.ViewMatchers.withId; +import static androidx.test.espresso.matcher.ViewMatchers.withText; +import static androidx.test.platform.app.InstrumentationRegistry.getInstrumentation; +import static org.junit.Assert.assertEquals; +import static io.antmedia.webrtc_android_sample_app.basic.SettingsActivity.DEFAULT_WEBSOCKET_URL; + +import android.content.Context; +import android.content.Intent; +import android.content.SharedPreferences; + +import androidx.test.core.app.ActivityScenario; +import androidx.test.core.app.ApplicationProvider; +import androidx.test.espresso.Espresso; +import androidx.test.espresso.IdlingResource; +import androidx.test.ext.junit.runners.AndroidJUnit4; +import androidx.test.rule.GrantPermissionRule; +import androidx.test.uiautomator.UiDevice; + +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; + +import io.antmedia.webrtc_android_sample_app.basic.SettingsActivity; +import io.antmedia.webrtcandroidframework.core.PermissionsHandler; + +/** + * Instrumented test, which will execute on an Android device. + * + * @see Testing documentation + */ +@RunWith(AndroidJUnit4.class) +public class SettingsActivityTest { + + //match + private static final String START_NOW_TEXT = "Start now"; + + private IdlingResource mIdlingResource; + + @Rule + public GrantPermissionRule permissionRule + = GrantPermissionRule.grant(PermissionsHandler.REQUIRED_EXTENDED_PERMISSIONS); + + @Before + public void before() { + //try before method to make @Rule run properly + } + + @Test + public void useAppContext() { + // Context of the app under test. + Context appContext = getInstrumentation().getTargetContext(); + assertEquals("io.antmedia.webrtc_android_sample_app", appContext.getPackageName()); + } + + @Test + public void testSettingsActivity() { + Intent intent = new Intent(ApplicationProvider.getApplicationContext(), SettingsActivity.class); + ActivityScenario scenario = ActivityScenario.launch(intent); + + + scenario.onActivity(new ActivityScenario.ActivityAction() { + + @Override + public void perform(SettingsActivity activity) { + activity.sendBroadcast(new Intent(Intent.ACTION_CLOSE_SYSTEM_DIALOGS)); + } + }); + + UiDevice device = UiDevice.getInstance(getInstrumentation()); + + //if default value has changed, it fails. + onView(withId(R.id.server_address)).check(matches(withText(DEFAULT_WEBSOCKET_URL))); + + String websocketURL = "ws://example.com/WebRTCAppEE/websocket"; + onView(withId(R.id.server_address)).perform(clearText()); + onView(withId(R.id.server_address)).perform(typeText(websocketURL)); + Espresso.closeSoftKeyboard(); + onView(withId(R.id.save_button)).perform(click()); + + + + scenario.onActivity(new ActivityScenario.ActivityAction() { + + @Override + public void perform(SettingsActivity activity) { + SharedPreferences sharedPreferences = + android.preference.PreferenceManager.getDefaultSharedPreferences(activity /* Activity context */); + String url = sharedPreferences.getString(activity.getString(R.string.serverAddress), DEFAULT_WEBSOCKET_URL); + assertEquals(websocketURL, url); + + } + }); + + onView(withId(R.id.server_address)).perform(clearText()); + onView(withId(R.id.server_address)).perform(typeText(DEFAULT_WEBSOCKET_URL)); + Espresso.closeSoftKeyboard(); + onView(withId(R.id.save_button)).perform(click()); + + + } +} diff --git a/webrtc-android-sample-app/src/main/java/io/antmedia/webrtc_android_sample_app/basic/ConferenceActivity.java b/webrtc-android-sample-app/src/main/java/io/antmedia/webrtc_android_sample_app/basic/ConferenceActivity.java index f4f9c707..e62c0ef2 100644 --- a/webrtc-android-sample-app/src/main/java/io/antmedia/webrtc_android_sample_app/basic/ConferenceActivity.java +++ b/webrtc-android-sample-app/src/main/java/io/antmedia/webrtc_android_sample_app/basic/ConferenceActivity.java @@ -1,5 +1,7 @@ package io.antmedia.webrtc_android_sample_app.basic; +import android.content.Context; +import android.net.wifi.WifiManager; import android.os.Build; import android.os.Bundle; import android.util.Log; @@ -102,13 +104,34 @@ private IDataChannelObserver createDatachannelObserver() { @Override public void textMessageReceived(String messageText) { super.textMessageReceived(messageText); - Toast.makeText(ConferenceActivity.this, "Message received: " + messageText, Toast.LENGTH_SHORT).show(); + //Toast.makeText(ConferenceActivity.this, "Message received: " + messageText, Toast.LENGTH_SHORT).show(); } }; } private DefaultConferenceWebRTCListener createWebRTCListener(String roomId, String streamId) { - return new DefaultConferenceWebRTCListener(roomId, streamId); + return new DefaultConferenceWebRTCListener(roomId, streamId) { + + @Override + public void onJoinedTheRoom(String streamId, String[] streams) { + super.onJoinedTheRoom(streamId, streams); + decrementIdle(); + } + + @Override + public void onPublishStarted(String streamId) { + super.onPublishStarted(streamId); + broadcastingView.setVisibility(View.VISIBLE); + decrementIdle(); + } + + @Override + public void onPublishFinished(String streamId) { + super.onPublishFinished(streamId); + broadcastingView.setVisibility(View.GONE); + decrementIdle(); + } + }; } public void controlAudio(View view) { @@ -130,4 +153,14 @@ public void controlVideo(View view) { videoButton.setText("Disable Video"); } } + + + /** + * This method is used to change the state of the wifi for testing purposes + * @param state + */ + public void changeWifiState(boolean state) { + WifiManager wifiManager = (WifiManager) getApplicationContext().getSystemService(Context.WIFI_SERVICE); + wifiManager.setWifiEnabled(state); + } } diff --git a/webrtc-android-sample-app/src/main/java/io/antmedia/webrtc_android_sample_app/basic/ScreenCaptureActivity.java b/webrtc-android-sample-app/src/main/java/io/antmedia/webrtc_android_sample_app/basic/ScreenCaptureActivity.java index 151b69ac..cb6981b2 100644 --- a/webrtc-android-sample-app/src/main/java/io/antmedia/webrtc_android_sample_app/basic/ScreenCaptureActivity.java +++ b/webrtc-android-sample-app/src/main/java/io/antmedia/webrtc_android_sample_app/basic/ScreenCaptureActivity.java @@ -24,7 +24,7 @@ import io.antmedia.webrtcandroidframework.api.IDataChannelObserver; import io.antmedia.webrtcandroidframework.api.IWebRTCClient; import io.antmedia.webrtcandroidframework.api.IWebRTCListener; -import io.antmedia.webrtcandroidframework.core.WebRTCClientConfig; +import io.antmedia.webrtcandroidframework.api.WebRTCClientConfig; import android.media.projection.MediaProjection; import android.media.projection.MediaProjectionManager; @@ -79,6 +79,7 @@ else if(checkedId == R.id.rbRear) { .setActivity(this) .setWebRTCListener(createWebRTCListener()) .setDataChannelObserver(createDatachannelObserver()) + .setInitiateBeforeStream(true) .build(); View startStreamingButton = findViewById(R.id.start_streaming_button); @@ -151,6 +152,9 @@ public void onActivityResult(int requestCode, int resultCode, Intent data) if (requestCode != CAPTURE_PERMISSION_REQUEST_CODE) return; + WebRTCClientConfig config = webRTCClient.getConfig(); + config.mediaProjectionIntent = data; + // If the device version is v29 or higher, screen sharing will work service due to media projection policy. // Otherwise media projection will work without service if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q){ @@ -162,6 +166,7 @@ public void onActivityResult(int requestCode, int resultCode, Intent data) Intent serviceIntent = new Intent(this, MediaProjectionService.class); serviceIntent.putExtra(EXTRA_MEDIA_PROJECTION_DATA, data); startForegroundService(serviceIntent); + } else{ MediaProjection mediaProjection = mediaProjectionManager.getMediaProjection(resultCode, data); diff --git a/webrtc-android-sample-app/src/main/res/layout/activity_screenshare.xml b/webrtc-android-sample-app/src/main/res/layout/activity_screenshare.xml index 9cbf9a33..03ef3a52 100644 --- a/webrtc-android-sample-app/src/main/res/layout/activity_screenshare.xml +++ b/webrtc-android-sample-app/src/main/res/layout/activity_screenshare.xml @@ -61,7 +61,7 @@