| /* |
| * Copyright (C) 2015 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License |
| */ |
| |
| package android.telecom.cts; |
| |
| import android.graphics.SurfaceTexture; |
| import android.telecom.Call; |
| import android.telecom.Connection; |
| import android.telecom.InCallService; |
| import android.telecom.VideoProfile; |
| import android.util.Log; |
| import android.view.Surface; |
| import android.view.TextureView; |
| |
| import static android.telecom.cts.TestUtils.shouldTestTelecom; |
| |
| /** |
| * Suites of tests that use {@link MockVideoProvider} and {@link MockVideoCallCallback} to verify |
| * the functionality of the video APIs. |
| * |
| * Note: You'll notice the use of {@code work}, and |
| * {@code doWorkAndWaitUntilConditionIsTrueOrTimeout} here. The problem is the |
| * {@link MockVideoProvider} is running using a Handler. To get it to emit mock data that is |
| * in sync with the setup operations performed on the handler, we'd need access to its handler. |
| * The handler of the {@link Connection.VideoProvider} is, however, not public. As a workaround |
| * we will call local methods on the MockVideoProvider. This means there is a chance the |
| * VideoProvider will emit the data we're interested in before the callbacks (on the handler) |
| * are even set up. Consequently, the callbacks we're depending on in our test may not get |
| * called. To compensate we will call the test methods on the provider repeatedly until we |
| * hear back via our callback. Suboptimal, but it works. |
| */ |
| public class VideoCallTest extends BaseTelecomTestWithMockServices { |
| @Override |
| protected void tearDown() throws Exception { |
| if (shouldTestTelecom(mContext)) { |
| cleanupAndVerifyUnbind(); |
| } |
| super.tearDown(); |
| } |
| |
| /** |
| * Tests ability to start a 2-way video call and retrieve its video state. |
| */ |
| public void testMakeTwoWayVideoCall() { |
| |
| placeAndVerifyCall(VideoProfile.STATE_BIDIRECTIONAL); |
| verifyConnectionForOutgoingCall(); |
| |
| final MockInCallService inCallService = mInCallCallbacks.getService(); |
| final Call call = inCallService.getLastCall(); |
| final MockConnection connection = mConnectionCallbacks.outgoingConnection; |
| |
| assertCallState(call, Call.STATE_ACTIVE); |
| assertVideoState(call, VideoProfile.STATE_BIDIRECTIONAL); |
| assertVideoCallbackRegistered(inCallService, call, true); |
| } |
| |
| /** |
| * Tests ability to start a 1-way video call and retrieve its video state. |
| */ |
| public void testMakeOneWayVideoCall() { |
| placeAndVerifyCall(VideoProfile.STATE_TX_ENABLED); |
| verifyConnectionForOutgoingCall(); |
| |
| final MockInCallService inCallService = mInCallCallbacks.getService(); |
| final Call call = inCallService.getLastCall(); |
| |
| assertVideoState(call, VideoProfile.STATE_TX_ENABLED); |
| assertVideoCallbackRegistered(inCallService, call, true); |
| } |
| |
| /** |
| * Tests ability to upgrade an audio-only call to a video call. |
| */ |
| public void testUpgradeToVideo() { |
| placeAndVerifyCall(VideoProfile.STATE_AUDIO_ONLY); |
| verifyConnectionForOutgoingCall(); |
| |
| final MockInCallService inCallService = mInCallCallbacks.getService(); |
| final Call call = inCallService.getLastCall(); |
| assertVideoState(call, VideoProfile.STATE_AUDIO_ONLY); |
| assertVideoCallbackRegistered(inCallService, call, true); |
| |
| // Send request to upgrade to video. |
| InCallService.VideoCall videoCall = call.getVideoCall(); |
| videoCall.sendSessionModifyRequest(new VideoProfile(VideoProfile.STATE_BIDIRECTIONAL)); |
| assertVideoState(call, VideoProfile.STATE_BIDIRECTIONAL); |
| assertResponseVideoProfileReceived(inCallService.getVideoCallCallback(call), |
| VideoProfile.STATE_BIDIRECTIONAL); |
| } |
| |
| /** |
| * Tests ability to receive a session modification request. |
| */ |
| public void testReceiveSessionModifyRequest() { |
| placeAndVerifyCall(VideoProfile.STATE_AUDIO_ONLY); |
| verifyConnectionForOutgoingCall(); |
| |
| final MockInCallService inCallService = mInCallCallbacks.getService(); |
| final Call call = inCallService.getLastCall(); |
| final MockConnection connection = mConnectionCallbacks.outgoingConnection; |
| assertVideoState(call, VideoProfile.STATE_AUDIO_ONLY); |
| assertVideoCallbackRegistered(inCallService, call, true); |
| |
| // Have the video profile mock reception of a request. |
| assertRequestVideoProfileReceived(inCallService.getVideoCallCallback(call), |
| VideoProfile.STATE_BIDIRECTIONAL, |
| new Work() { |
| @Override |
| public void doWork() { |
| connection.sendMockSessionModifyRequest( |
| new VideoProfile(VideoProfile.STATE_BIDIRECTIONAL)); |
| } |
| }); |
| } |
| |
| /** |
| * Tests ability to send a session modification response. |
| */ |
| public void testSendSessionModifyResponse() { |
| placeAndVerifyCall(VideoProfile.STATE_AUDIO_ONLY); |
| verifyConnectionForOutgoingCall(); |
| |
| final MockInCallService inCallService = mInCallCallbacks.getService(); |
| final Call call = inCallService.getLastCall(); |
| final MockConnection connection = mConnectionCallbacks.outgoingConnection; |
| final MockVideoProvider mockVideoProvider = connection.getMockVideoProvider(); |
| assertVideoState(call, VideoProfile.STATE_AUDIO_ONLY); |
| assertVideoCallbackRegistered(inCallService, call, true); |
| |
| InCallService.VideoCall videoCall = call.getVideoCall(); |
| videoCall.sendSessionModifyResponse(new VideoProfile(VideoProfile.STATE_BIDIRECTIONAL)); |
| assertSessionModifyResponse(mockVideoProvider, VideoProfile.STATE_BIDIRECTIONAL); |
| } |
| |
| /** |
| * Tests ability to start a video call, delaying the creation of the provider until after |
| * the call has been initiated (rather than immediately when the call is created). This more |
| * closely mimics the lifespan of a {@code VideoProvider} instance as it is reasonable to |
| * expect there will be some overhead associated with configuring the camera at the start of |
| * the call. |
| */ |
| public void testVideoCallDelayProvider() { |
| // Don't create video provider when call is created initially; we will do this later. |
| try { |
| MockConnectionService.setCreateVideoProvider(false); |
| placeAndVerifyCall(VideoProfile.STATE_BIDIRECTIONAL); |
| verifyConnectionForOutgoingCall(); |
| |
| final MockInCallService inCallService = mInCallCallbacks.getService(); |
| final Call call = inCallService.getLastCall(); |
| final MockConnection connection = mConnectionCallbacks.outgoingConnection; |
| |
| assertVideoState(call, VideoProfile.STATE_BIDIRECTIONAL); |
| // After initial connection creation there should not be a video provider or callbacks |
| // registered. |
| assertVideoCallbackRegistered(inCallService, call, false); |
| |
| // Trigger delayed creation of video provider and registration of callbacks and assert that |
| // it happened. |
| connection.createMockVideoProvider(); |
| assertVideoCallbackRegistered(inCallService, call, true); |
| |
| // Ensure video providers are created in the future. |
| } finally { |
| MockConnectionService.setCreateVideoProvider(true); |
| } |
| } |
| |
| |
| /** |
| * Tests ability to change the current camera. Ensures that the camera capabilities are sent |
| * back in response. |
| */ |
| public void testChangeCamera() { |
| placeAndVerifyCall(VideoProfile.STATE_BIDIRECTIONAL); |
| verifyConnectionForOutgoingCall(); |
| |
| final MockInCallService inCallService = mInCallCallbacks.getService(); |
| final Call call = inCallService.getLastCall(); |
| assertVideoCallbackRegistered(inCallService, call, true); |
| final InCallService.VideoCall videoCall = call.getVideoCall(); |
| |
| videoCall.setCamera(MockVideoProvider.CAMERA_FRONT); |
| assertCameraCapabilitiesReceived(inCallService.getVideoCallCallback(call), |
| MockVideoProvider.CAMERA_FRONT_DIMENSIONS); |
| |
| videoCall.setCamera(MockVideoProvider.CAMERA_BACK); |
| assertCameraCapabilitiesReceived(inCallService.getVideoCallCallback(call), |
| MockVideoProvider.CAMERA_BACK_DIMENSIONS); |
| } |
| |
| /** |
| * Tests ability to request the camera capabilities from the video provider. |
| */ |
| public void testRequestCameraCapabilities() { |
| placeAndVerifyCall(VideoProfile.STATE_BIDIRECTIONAL); |
| verifyConnectionForOutgoingCall(); |
| |
| final MockInCallService inCallService = mInCallCallbacks.getService(); |
| final Call call = inCallService.getLastCall(); |
| assertVideoCallbackRegistered(inCallService, call, true); |
| final InCallService.VideoCall videoCall = call.getVideoCall(); |
| |
| // First, set the camera. |
| videoCall.setCamera(MockVideoProvider.CAMERA_FRONT); |
| // Retrieve the camera capabilities that are automatically send when the camera is set -- |
| // ensures the cached value is cleared first. |
| inCallService.getVideoCallCallback(call).getCameraCapabilities(); |
| |
| // Now, request capabilities. |
| videoCall.requestCameraCapabilities(); |
| assertCameraCapabilitiesReceived(inCallService.getVideoCallCallback(call), |
| MockVideoProvider.CAMERA_FRONT_DIMENSIONS); |
| } |
| |
| /** |
| * Tests ability to request data usage from the video provider. |
| */ |
| public void testRequestDataUsage() { |
| placeAndVerifyCall(VideoProfile.STATE_BIDIRECTIONAL); |
| verifyConnectionForOutgoingCall(); |
| |
| final MockInCallService inCallService = mInCallCallbacks.getService(); |
| final Call call = inCallService.getLastCall(); |
| assertVideoCallbackRegistered(inCallService, call, true); |
| final InCallService.VideoCall videoCall = call.getVideoCall(); |
| |
| videoCall.requestCallDataUsage(); |
| assertCallDataUsageReceived(inCallService.getVideoCallCallback(call), |
| MockVideoProvider.DATA_USAGE); |
| } |
| |
| /** |
| * Tests ability to receive changes to the video quality from the video provider. |
| */ |
| public void testReceiveVideoQuality() { |
| placeAndVerifyCall(VideoProfile.STATE_BIDIRECTIONAL); |
| verifyConnectionForOutgoingCall(); |
| |
| final MockConnection connection = mConnectionCallbacks.outgoingConnection; |
| final MockInCallService inCallService = mInCallCallbacks.getService(); |
| final Call call = inCallService.getLastCall(); |
| assertVideoCallbackRegistered(inCallService, call, true); |
| |
| assertVideoQualityReceived(inCallService.getVideoCallCallback(call), |
| VideoProfile.QUALITY_HIGH, |
| new Work() { |
| @Override |
| public void doWork() { |
| connection |
| .sendMockVideoQuality(VideoProfile.QUALITY_HIGH); |
| } |
| }); |
| |
| assertVideoQualityReceived(inCallService.getVideoCallCallback(call), |
| VideoProfile.QUALITY_MEDIUM, |
| new Work() { |
| @Override |
| public void doWork() { |
| connection |
| .sendMockVideoQuality(VideoProfile.QUALITY_MEDIUM); |
| } |
| }); |
| } |
| |
| /** |
| * Tests ability to receive call session events from the video provider. |
| */ |
| public void testReceiveCallSessionEvent() { |
| placeAndVerifyCall(VideoProfile.STATE_BIDIRECTIONAL); |
| verifyConnectionForOutgoingCall(); |
| |
| final MockConnection connection = mConnectionCallbacks.outgoingConnection; |
| final MockInCallService inCallService = mInCallCallbacks.getService(); |
| final Call call = inCallService.getLastCall(); |
| assertVideoCallbackRegistered(inCallService, call, true); |
| |
| assertCallSessionEventReceived(inCallService.getVideoCallCallback(call), |
| Connection.VideoProvider.SESSION_EVENT_CAMERA_READY, |
| new Work() { |
| @Override |
| public void doWork() { |
| connection.sendMockCallSessionEvent( |
| Connection.VideoProvider.SESSION_EVENT_CAMERA_READY); |
| } |
| }); |
| } |
| |
| /** |
| * Tests ability to receive changes to the peer dimensions from the video provider. |
| */ |
| public void testReceivePeerDimensionChange() { |
| placeAndVerifyCall(VideoProfile.STATE_BIDIRECTIONAL); |
| verifyConnectionForOutgoingCall(); |
| |
| final MockConnection connection = mConnectionCallbacks.outgoingConnection; |
| final MockInCallService inCallService = mInCallCallbacks.getService(); |
| final Call call = inCallService.getLastCall(); |
| assertVideoCallbackRegistered(inCallService, call, true); |
| |
| assertPeerWidthChanged(inCallService.getVideoCallCallback(call), |
| MockVideoProvider.CAMERA_BACK_DIMENSIONS, |
| new Work() { |
| @Override |
| public void doWork() { |
| connection.sendMockPeerWidth(MockVideoProvider.CAMERA_BACK_DIMENSIONS); |
| } |
| }); |
| } |
| |
| /** |
| * Tests ability to set the device orientation via the provider. |
| */ |
| public void testSetDeviceOrientation() { |
| placeAndVerifyCall(VideoProfile.STATE_BIDIRECTIONAL); |
| verifyConnectionForOutgoingCall(); |
| |
| final MockConnection connection = mConnectionCallbacks.outgoingConnection; |
| final MockInCallService inCallService = mInCallCallbacks.getService(); |
| final Call call = inCallService.getLastCall(); |
| assertVideoCallbackRegistered(inCallService, call, true); |
| final MockVideoProvider mockVideoProvider = connection.getMockVideoProvider(); |
| final InCallService.VideoCall videoCall = call.getVideoCall(); |
| |
| // Set device orientation and ensure provider knows about it. |
| videoCall.setDeviceOrientation(90); |
| assertDeviceOrientationChanged(mockVideoProvider, 90); |
| } |
| |
| /** |
| * Tests ability to set the preview surface via the provider. |
| */ |
| public void testSetPreviewSurface() { |
| placeAndVerifyCall(VideoProfile.STATE_BIDIRECTIONAL); |
| verifyConnectionForOutgoingCall(); |
| |
| final MockConnection connection = mConnectionCallbacks.outgoingConnection; |
| final MockInCallService inCallService = mInCallCallbacks.getService(); |
| final Call call = inCallService.getLastCall(); |
| assertVideoCallbackRegistered(inCallService, call, true); |
| final MockVideoProvider mockVideoProvider = connection.getMockVideoProvider(); |
| final InCallService.VideoCall videoCall = call.getVideoCall(); |
| |
| Surface surface = new Surface(new SurfaceTexture(1)); |
| // Set a surface |
| videoCall.setPreviewSurface(surface); |
| assertPreviewSurfaceChanged(mockVideoProvider, true); |
| |
| // Clear the surface |
| videoCall.setPreviewSurface(null); |
| assertPreviewSurfaceChanged(mockVideoProvider, false); |
| } |
| |
| /** |
| * Tests ability to set the display surface via the provider. |
| */ |
| public void testSetDisplaySurface() { |
| placeAndVerifyCall(VideoProfile.STATE_BIDIRECTIONAL); |
| verifyConnectionForOutgoingCall(); |
| |
| final MockConnection connection = mConnectionCallbacks.outgoingConnection; |
| final MockInCallService inCallService = mInCallCallbacks.getService(); |
| final Call call = inCallService.getLastCall(); |
| assertVideoCallbackRegistered(inCallService, call, true); |
| final MockVideoProvider mockVideoProvider = connection.getMockVideoProvider(); |
| final InCallService.VideoCall videoCall = call.getVideoCall(); |
| |
| // Set a surface |
| Surface surface = new Surface(new SurfaceTexture(1)); |
| videoCall.setDisplaySurface(surface); |
| assertDisplaySurfaceChanged(mockVideoProvider, true); |
| |
| // Clear the surface |
| videoCall.setDisplaySurface(null); |
| assertDisplaySurfaceChanged(mockVideoProvider, false); |
| } |
| |
| /** |
| * Tests ability to set the camera zoom via the provider. |
| */ |
| public void testSetZoom() { |
| placeAndVerifyCall(VideoProfile.STATE_BIDIRECTIONAL); |
| verifyConnectionForOutgoingCall(); |
| |
| final MockConnection connection = mConnectionCallbacks.outgoingConnection; |
| final MockInCallService inCallService = mInCallCallbacks.getService(); |
| final Call call = inCallService.getLastCall(); |
| assertVideoCallbackRegistered(inCallService, call, true); |
| final MockVideoProvider mockVideoProvider = connection.getMockVideoProvider(); |
| final InCallService.VideoCall videoCall = call.getVideoCall(); |
| |
| videoCall.setZoom(0.0f); |
| assertZoomChanged(mockVideoProvider, 0.0f); |
| |
| videoCall.setZoom(10.0f); |
| assertZoomChanged(mockVideoProvider, 10.0f); |
| |
| call.disconnect(); |
| } |
| |
| /** |
| * Asserts that a call video state is as expected. |
| * |
| * @param call The call. |
| * @param videoState The expected video state. |
| */ |
| private void assertVideoState(final Call call, final int videoState) { |
| waitUntilConditionIsTrueOrTimeout( |
| new Condition() { |
| @Override |
| public Object expected() { |
| return videoState; |
| } |
| |
| @Override |
| public Object actual() { |
| return call.getDetails().getVideoState(); |
| } |
| }, |
| TestUtils.WAIT_FOR_STATE_CHANGE_TIMEOUT_MS, |
| "Call should be in videoState " + videoState |
| ); |
| } |
| |
| /** |
| * Asserts whether the InCallService has registered a video call back (and hence a video call) |
| * for a call. |
| * |
| * @param inCallService The incall service. |
| * @param call The call. |
| * @param isRegistered The expected registration state. |
| */ |
| private void assertVideoCallbackRegistered(final MockInCallService inCallService, |
| final Call call, final Boolean isRegistered) { |
| waitUntilConditionIsTrueOrTimeout( |
| new Condition() { |
| @Override |
| public Object expected() { |
| return isRegistered; |
| } |
| |
| @Override |
| public Object actual() { |
| return inCallService.isVideoCallbackRegistered(call); |
| } |
| }, |
| TestUtils.WAIT_FOR_STATE_CHANGE_TIMEOUT_MS, |
| "Video callback registration state should be " + isRegistered |
| ); |
| } |
| |
| /** |
| * Asserts whether the camera capabilities have changed to an expected value. Compares the |
| * camera height only (the {@link MockVideoProvider} sets height and width to be the same. |
| * |
| * @param videoCallCallback The video call callback. |
| * @param expectedCameraWidthHeight The expected width and height. |
| */ |
| private void assertCameraCapabilitiesReceived(final MockVideoCallCallback videoCallCallback, |
| final int expectedCameraWidthHeight) { |
| waitUntilConditionIsTrueOrTimeout( |
| new Condition() { |
| @Override |
| public Object expected() { |
| return expectedCameraWidthHeight; |
| } |
| |
| @Override |
| public Object actual() { |
| VideoProfile.CameraCapabilities cameraCapabilities = |
| videoCallCallback.getCameraCapabilities(); |
| return cameraCapabilities == null ? 0 : cameraCapabilities.getHeight(); |
| } |
| }, |
| TestUtils.WAIT_FOR_STATE_CHANGE_TIMEOUT_MS, |
| "Camera width and height should be " + expectedCameraWidthHeight |
| ); |
| } |
| |
| /** |
| * Asserts whether the call data usage has changed to the expected value. |
| * |
| * @param videoCallCallback The video call callback. |
| * @param expectedDataUsage The expected data usage. |
| */ |
| private void assertCallDataUsageReceived(final MockVideoCallCallback videoCallCallback, |
| final long expectedDataUsage) { |
| waitUntilConditionIsTrueOrTimeout( |
| new Condition() { |
| @Override |
| public Object expected() { |
| return expectedDataUsage; |
| } |
| |
| @Override |
| public Object actual() { |
| return videoCallCallback.getDataUsage(); |
| } |
| }, |
| TestUtils.WAIT_FOR_STATE_CHANGE_TIMEOUT_MS, |
| "Data usage should be " + expectedDataUsage |
| ); |
| } |
| |
| /** |
| * Asserts whether the video quality has changed to the expected value. |
| * |
| * @param videoCallCallback The video call callback. |
| * @param expectedVideoQuality The expected video quality. |
| * @param work The work to perform to have the provider emit the video quality. |
| */ |
| private void assertVideoQualityReceived(final MockVideoCallCallback videoCallCallback, |
| final int expectedVideoQuality, final Work work) { |
| doWorkAndWaitUntilConditionIsTrueOrTimeout( |
| work, |
| new Condition() { |
| @Override |
| public Object expected() { |
| return expectedVideoQuality; |
| } |
| |
| @Override |
| public Object actual() { |
| return videoCallCallback.getVideoQuality(); |
| } |
| }, |
| TestUtils.WAIT_FOR_STATE_CHANGE_TIMEOUT_MS, |
| "Video quality should be " + expectedVideoQuality |
| ); |
| } |
| |
| /** |
| * Asserts whether the call session event has changed to the expected value. |
| * |
| * @param videoCallCallback The video call callback. |
| * @param expectedEvent The expected event. |
| * @param work The work to be performed to send the call session event from the provider. |
| */ |
| private void assertCallSessionEventReceived(final MockVideoCallCallback videoCallCallback, |
| final int expectedEvent, final Work work) { |
| doWorkAndWaitUntilConditionIsTrueOrTimeout( |
| work, |
| new Condition() { |
| @Override |
| public Object expected() { |
| return expectedEvent; |
| } |
| |
| @Override |
| public Object actual() { |
| return videoCallCallback.getCallSessionEvent(); |
| } |
| }, |
| TestUtils.WAIT_FOR_STATE_CHANGE_TIMEOUT_MS, |
| "Call session event should be " + expectedEvent |
| ); |
| } |
| |
| /** |
| * Asserts whether the peer width has changed to the expected value. |
| * |
| * @param videoCallCallback The video call callback. |
| * @param expectedWidth The expected width. |
| * @param work The work to be performed to send the peer width from the provider. |
| */ |
| private void assertPeerWidthChanged(final MockVideoCallCallback videoCallCallback, |
| final int expectedWidth, final Work work) { |
| doWorkAndWaitUntilConditionIsTrueOrTimeout( |
| work, |
| new Condition() { |
| @Override |
| public Object expected() { |
| return expectedWidth; |
| } |
| |
| @Override |
| public Object actual() { |
| return videoCallCallback.getPeerWidth(); |
| } |
| }, |
| TestUtils.WAIT_FOR_STATE_CHANGE_TIMEOUT_MS, |
| "Peer width should be " + expectedWidth |
| ); |
| } |
| |
| /** |
| * Asserts whether the device orientation has changed to the expected value. |
| * |
| * @param mockVideoProvider The mock video provider. |
| * @param expected The expected device orientation. |
| */ |
| private void assertDeviceOrientationChanged(final MockVideoProvider mockVideoProvider, |
| final int expected) { |
| waitUntilConditionIsTrueOrTimeout( |
| new Condition() { |
| @Override |
| public Object expected() { |
| return expected; |
| } |
| |
| @Override |
| public Object actual() { |
| return mockVideoProvider.getDeviceOrientation(); |
| } |
| }, |
| TestUtils.WAIT_FOR_STATE_CHANGE_TIMEOUT_MS, |
| "Orientation should be " + expected |
| ); |
| } |
| |
| /** |
| * Asserts whether the preview surface has been set or not. |
| * |
| * @param mockVideoProvider The mock video provider. |
| * @param expected {@code true} if it is expected the preview surface is not null, {@code false} |
| * if it is expected the preview surface is null. |
| */ |
| private void assertPreviewSurfaceChanged(final MockVideoProvider mockVideoProvider, |
| final boolean expected) { |
| waitUntilConditionIsTrueOrTimeout( |
| new Condition() { |
| @Override |
| public Object expected() { |
| return expected; |
| } |
| |
| @Override |
| public Object actual() { |
| return mockVideoProvider.getPreviewSurface() != null; |
| } |
| }, |
| TestUtils.WAIT_FOR_STATE_CHANGE_TIMEOUT_MS, |
| "Preview should be set? " + expected |
| ); |
| } |
| |
| /** |
| * Asserts whether the display surface has been set or not. |
| * |
| * @param mockVideoProvider The mock video provider. |
| * @param expected {@code true} if it is expected the display surface is not null, {@code false} |
| * if it is expected the display surface is null. |
| */ |
| private void assertDisplaySurfaceChanged(final MockVideoProvider mockVideoProvider, |
| final boolean expected) { |
| waitUntilConditionIsTrueOrTimeout( |
| new Condition() { |
| @Override |
| public Object expected() { |
| return expected; |
| } |
| |
| @Override |
| public Object actual() { |
| return mockVideoProvider.getDisplaySurface() != null; |
| } |
| }, |
| TestUtils.WAIT_FOR_STATE_CHANGE_TIMEOUT_MS, |
| "Display should be set? " + expected |
| ); |
| } |
| |
| /** |
| * Asserts whether the zoom has changed to the expected value. Note: To make comparisons easier |
| * the floats are cast to ints, so ensure only whole values are used. |
| * |
| * @param mockVideoProvider The mock video provider. |
| * @param expected The expected zoom. |
| */ |
| private void assertZoomChanged(final MockVideoProvider mockVideoProvider, |
| final float expected) { |
| waitUntilConditionIsTrueOrTimeout( |
| new Condition() { |
| @Override |
| public Object expected() { |
| // Cast to int so we're not doing float equality |
| return (int)expected; |
| } |
| |
| @Override |
| public Object actual() { |
| // Cast to int so we're not doing float equality |
| return (int)mockVideoProvider.getZoom(); |
| } |
| }, |
| TestUtils.WAIT_FOR_STATE_CHANGE_TIMEOUT_MS, |
| "Zoom should be " + expected |
| ); |
| } |
| |
| /** |
| * Asserts whether a response video profile has been received |
| * |
| * @param videoCallCallback The video call callback. |
| * @param expected The expected video state. |
| */ |
| private void assertResponseVideoProfileReceived(final MockVideoCallCallback videoCallCallback, |
| final int expected) { |
| waitUntilConditionIsTrueOrTimeout( |
| new Condition() { |
| @Override |
| public Object expected() { |
| return expected; |
| } |
| |
| @Override |
| public Object actual() { |
| VideoProfile videoProfile = videoCallCallback.getResponseProfile(); |
| return videoProfile == null ? -1 : videoProfile.getVideoState(); |
| } |
| }, |
| TestUtils.WAIT_FOR_STATE_CHANGE_TIMEOUT_MS, |
| "Video state should be " + expected |
| ); |
| } |
| |
| /** |
| * Asserts whether a session modification request has been received. |
| * |
| * @param videoCallCallback The video call callback. |
| * @param expected The expected video state. |
| * @param work The work to be performed to cause the session modification request to be emit |
| * from the provider. |
| */ |
| private void assertRequestVideoProfileReceived(final MockVideoCallCallback videoCallCallback, |
| final int expected, final Work work) { |
| doWorkAndWaitUntilConditionIsTrueOrTimeout( |
| work, |
| new Condition() { |
| @Override |
| public Object expected() { |
| return expected; |
| } |
| |
| @Override |
| public Object actual() { |
| VideoProfile videoProfile = videoCallCallback.getRequestProfile(); |
| return videoProfile == null ? -1 : videoProfile.getVideoState(); |
| } |
| }, |
| TestUtils.WAIT_FOR_STATE_CHANGE_TIMEOUT_MS, |
| "Video state should be " + expected |
| ); |
| } |
| |
| /** |
| * Asserts whether the provider got a session modify response with the expected value. |
| * |
| * @param mockVideoProvider The mock video provider. |
| * @param expected The expected video state of the session modify response. |
| */ |
| private void assertSessionModifyResponse(final MockVideoProvider mockVideoProvider, |
| final int expected) { |
| waitUntilConditionIsTrueOrTimeout( |
| new Condition() { |
| @Override |
| public Object expected() { |
| return expected; |
| } |
| |
| @Override |
| public Object actual() { |
| VideoProfile responseProfile = mockVideoProvider.getSessionModifyResponse(); |
| return responseProfile == null ? -1 : responseProfile.getVideoState(); |
| } |
| }, |
| TestUtils.WAIT_FOR_STATE_CHANGE_TIMEOUT_MS, |
| "Session modify response video state should be " + expected |
| ); |
| } |
| } |
