tests/tests/telecom/src/android/telecom/cts/HandoverTest.java - platform/cts - Git at Google

 /*
  * Copyright (C) 2018 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 static android.telecom.cts.TestUtils.TEST_HANDOVER_DEST_PHONE_ACCOUNT_HANDLE;
 import static android.telecom.cts.TestUtils.TEST_HANDOVER_SRC_PHONE_ACCOUNT_HANDLE;
 import static android.telecom.cts.TestUtils.WAIT_FOR_STATE_CHANGE_TIMEOUT_MS;

 import android.net.Uri;
 import android.os.Bundle;
 import android.telecom.Call;
 import android.telecom.Connection;
 import android.telecom.ConnectionRequest;
 import android.telecom.PhoneAccountHandle;
 import android.telecom.TelecomManager;
 import android.telecom.VideoProfile;

 /**
  * Tests the Telecom handover APIs.
  */
 public class HandoverTest extends BaseTelecomTestWithMockServices {
     @Override
     protected void setUp() throws Exception {
         super.setUp();
         mContext = getInstrumentation().getContext();
         if (mShouldTestTelecom) {
             setupConnectionService(null, FLAG_REGISTER | FLAG_ENABLE);

             // Test handover source is a managed ConnectionService
             mTelecomManager.registerPhoneAccount(TestUtils.TEST_PHONE_ACCOUNT_HANDOVER_SRC);
             TestUtils.enablePhoneAccount(getInstrumentation(),
                     TestUtils.TEST_HANDOVER_SRC_PHONE_ACCOUNT_HANDLE);
             assertPhoneAccountEnabled(TestUtils.TEST_HANDOVER_SRC_PHONE_ACCOUNT_HANDLE);

             // Test handover destination is a self-managed ConnectionService.
             mTelecomManager.registerPhoneAccount(TestUtils.TEST_PHONE_ACCOUNT_HANDOVER_DEST);
         }

     }

     @Override
     protected void tearDown() throws Exception {
         CtsSelfManagedConnectionService connectionService =
                 CtsSelfManagedConnectionService.getConnectionService();
         if (connectionService != null) {
             connectionService.tearDown();
             mTelecomManager.unregisterPhoneAccount(
                     TestUtils.TEST_HANDOVER_SRC_PHONE_ACCOUNT_HANDLE);
             mTelecomManager.unregisterPhoneAccount(
                     TestUtils.TEST_HANDOVER_DEST_PHONE_ACCOUNT_HANDLE);
         }

         super.tearDown();
     }

     /**
      * Ensures a call handover cannot be initiated for a {@link android.telecom.PhoneAccount} which
      * does not declare {@link android.telecom.PhoneAccount#EXTRA_SUPPORTS_HANDOVER_FROM}.
      */
     public void testHandoverSourceFailed() {
         if (!mShouldTestTelecom) {
             return;
         }

         placeAndVerifyCall();
         Call call = mInCallCallbacks.getService().getLastCall();

         call.handoverTo(TestUtils.TEST_SELF_MANAGED_HANDLE_1, VideoProfile.STATE_BIDIRECTIONAL,
                 null);

         // Expect the handover failed callback to be called.
         mOnHandoverFailedCounter.waitForCount(WAIT_FOR_STATE_CHANGE_TIMEOUT_MS);
         Call callbackCall = (Call) mOnHandoverFailedCounter.getArgs(0)[0];
         int failureReason = (int) mOnHandoverFailedCounter.getArgs(0)[1];
         assertEquals(call, callbackCall);
         assertEquals(Call.Callback.HANDOVER_FAILURE_NOT_SUPPORTED, failureReason);

         call.disconnect();
     }

     /**
      * Ensures a call handover cannot be initiated to a {@link android.telecom.PhoneAccount} which
      * does not declare {@link android.telecom.PhoneAccount#EXTRA_SUPPORTS_HANDOVER_TO}.
      */
     public void testHandoverDestinationFailed() {
         if (!mShouldTestTelecom) {
             return;
         }
         startSourceCall();
         Call call = mInCallCallbacks.getService().getLastCall();

         // Now try to handover to an account which does not support handover.
         call.handoverTo(TestUtils.TEST_SELF_MANAGED_HANDLE_1, VideoProfile.STATE_BIDIRECTIONAL,
                 null);

         // Expect the handover failed callback to be called.
         mOnHandoverFailedCounter.waitForCount(WAIT_FOR_STATE_CHANGE_TIMEOUT_MS);
         Call callbackCall = (Call) mOnHandoverFailedCounter.getArgs(0)[0];
         int failureReason = (int) mOnHandoverFailedCounter.getArgs(0)[1];
         assertEquals(call, callbackCall);
         assertEquals(Call.Callback.HANDOVER_FAILURE_NOT_SUPPORTED, failureReason);

         call.disconnect();
     }

     /**
      * Ensures that when the source and destination both support handover that an outgoing handover
      * request will be successfully relayed.
      */
     public void testOutgoingHandoverRequestValid() {
         if (!mShouldTestTelecom) {
             return;
         }

         // Begin our source call on the CS which supports handover from it.
         startSourceCall();
         final Call call = mInCallCallbacks.getService().getLastCall();

         // Now try to handover to an account which does support handover to it.
         call.handoverTo(TestUtils.TEST_HANDOVER_DEST_PHONE_ACCOUNT_HANDLE,
                 VideoProfile.STATE_BIDIRECTIONAL, null);

         // Ensure Telecom bound to the self managed CS
         if (!CtsSelfManagedConnectionService.waitForBinding()) {
             fail("Could not bind to Self-Managed ConnectionService");
         }

         // Wait for binding to self managed CS and invocation of outgoing handover method.
         TestUtils.InvokeCounter counter =
                 CtsSelfManagedConnectionService.getConnectionService()
                         .getOnCreateOutgoingHandoverConnectionCounter();
         counter.waitForCount(WAIT_FOR_STATE_CHANGE_TIMEOUT_MS);

         SelfManagedConnection connection = TestUtils.waitForAndGetConnection(
                 call.getDetails().getHandle());

         // Verify the from handle is as expected.
         PhoneAccountHandle fromHandle = (PhoneAccountHandle) counter.getArgs(0)[0];
         assertEquals(TEST_HANDOVER_SRC_PHONE_ACCOUNT_HANDLE, fromHandle);
         // Verify the to handle is as expected.
         ConnectionRequest request = (ConnectionRequest) counter.getArgs(0)[1];
         assertEquals(TEST_HANDOVER_DEST_PHONE_ACCOUNT_HANDLE, request.getAccountHandle());

         completeHandoverAndVerify(call, connection);
     }

     /**
      * Tests use of the
      * {@link android.telecom.TelecomManager#acceptHandover(Uri, int, PhoneAccountHandle)} API on
      * the receiving side of the handover.
      */
     public void testIncomingHandoverRequestValid() {
         if (!mShouldTestTelecom) {
             return;
         }

         // Begin our source call on the CS which supports handover from it.
         startSourceCall();
         final Call call = mInCallCallbacks.getService().getLastCall();

         // Request to accept handover of that call to another app.
         mTelecomManager.acceptHandover(call.getDetails().getHandle(),
                 VideoProfile.STATE_BIDIRECTIONAL, TEST_HANDOVER_DEST_PHONE_ACCOUNT_HANDLE);

         // Ensure Telecom bound to the self managed CS
         if (!CtsSelfManagedConnectionService.waitForBinding()) {
             fail("Could not bind to Self-Managed ConnectionService");
         }

         // Wait for binding to self managed CS and invocation of incoming handover method.
         TestUtils.InvokeCounter counter =
                 CtsSelfManagedConnectionService.getConnectionService()
                         .getOnCreateIncomingHandoverConnectionCounter();
         counter.waitForCount(WAIT_FOR_STATE_CHANGE_TIMEOUT_MS);

         SelfManagedConnection connection = TestUtils.waitForAndGetConnection(
                 call.getDetails().getHandle());

         // Verify the from handle is as expected.
         PhoneAccountHandle fromHandle = (PhoneAccountHandle) counter.getArgs(0)[0];
         assertEquals(TEST_HANDOVER_SRC_PHONE_ACCOUNT_HANDLE, fromHandle);
         // Verify the to handle is as expected.
         ConnectionRequest request = (ConnectionRequest) counter.getArgs(0)[1];
         assertEquals(TEST_HANDOVER_DEST_PHONE_ACCOUNT_HANDLE, request.getAccountHandle());
         // The original call's address should match the address of the handover request.
         assertEquals(call.getDetails().getHandle(), request.getAddress());

         completeHandoverAndVerify(call, connection);
     }

     /**
      * Begins a call which will be the source of a handover.
      */
     private void startSourceCall() {
         // Ensure the ongoing account is on a PhoneAccount which supports handover from.
         Bundle extras = new Bundle();
         extras.putParcelable(TelecomManager.EXTRA_PHONE_ACCOUNT_HANDLE,
                 TEST_HANDOVER_SRC_PHONE_ACCOUNT_HANDLE);
         placeAndVerifyCall(extras);
         Connection connection = verifyConnectionForOutgoingCall();
         connection.setActive();
         Call call = mInCallCallbacks.getService().getLastCall();
         assertCallState(call, Call.STATE_ACTIVE);
     }

     /**
      * Complete the a call handover and verify that it was successfully reported.
      * @param call
      * @param connection
      */
     private void completeHandoverAndVerify(final Call call, SelfManagedConnection connection) {
         // Make the connection active, indicating that the user has accepted the handover.
         connection.setActive();

         // Expect the original call to have been informed of handover completion.
         mOnHandoverCompleteCounter.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS);
         assertTrue("mOnHandoverCompleteCounter is zero",
                 mOnHandoverCompleteCounter.getInvokeCount() >= 1);

         // Also expect the connection to be informed of handover completion.
         connection.getHandoverCompleteCounter().waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS);
         assertTrue("connection's handoverCompleteCounter is zero",
                 connection.getHandoverCompleteCounter().getInvokeCount() >= 1);

         // Now, we expect that the original connection will get disconnected.
         waitUntilConditionIsTrueOrTimeout(new Condition() {
                                               @Override
                                               public Object expected() {
                                                   return Call.STATE_DISCONNECTED;
                                               }
                                               @Override
                                               public Object actual() {
                                                   return call.getState();
                                               }
                                           },
                 WAIT_FOR_STATE_CHANGE_TIMEOUT_MS,
                 "Expected original call to be disconnected."
         );
     }
 }
	/*
	* Copyright (C) 2018 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 static android.telecom.cts.TestUtils.TEST_HANDOVER_DEST_PHONE_ACCOUNT_HANDLE;
	import static android.telecom.cts.TestUtils.TEST_HANDOVER_SRC_PHONE_ACCOUNT_HANDLE;
	import static android.telecom.cts.TestUtils.WAIT_FOR_STATE_CHANGE_TIMEOUT_MS;

	import android.net.Uri;
	import android.os.Bundle;
	import android.telecom.Call;
	import android.telecom.Connection;
	import android.telecom.ConnectionRequest;
	import android.telecom.PhoneAccountHandle;
	import android.telecom.TelecomManager;
	import android.telecom.VideoProfile;

	/**
	* Tests the Telecom handover APIs.
	*/
	public class HandoverTest extends BaseTelecomTestWithMockServices {
	@Override
	protected void setUp() throws Exception {
	super.setUp();
	mContext = getInstrumentation().getContext();
	if (mShouldTestTelecom) {
	setupConnectionService(null, FLAG_REGISTER \| FLAG_ENABLE);

	// Test handover source is a managed ConnectionService
	mTelecomManager.registerPhoneAccount(TestUtils.TEST_PHONE_ACCOUNT_HANDOVER_SRC);
	TestUtils.enablePhoneAccount(getInstrumentation(),
	TestUtils.TEST_HANDOVER_SRC_PHONE_ACCOUNT_HANDLE);
	assertPhoneAccountEnabled(TestUtils.TEST_HANDOVER_SRC_PHONE_ACCOUNT_HANDLE);

	// Test handover destination is a self-managed ConnectionService.
	mTelecomManager.registerPhoneAccount(TestUtils.TEST_PHONE_ACCOUNT_HANDOVER_DEST);
	}

	}

	@Override
	protected void tearDown() throws Exception {
	CtsSelfManagedConnectionService connectionService =
	CtsSelfManagedConnectionService.getConnectionService();
	if (connectionService != null) {
	connectionService.tearDown();
	mTelecomManager.unregisterPhoneAccount(
	TestUtils.TEST_HANDOVER_SRC_PHONE_ACCOUNT_HANDLE);
	mTelecomManager.unregisterPhoneAccount(
	TestUtils.TEST_HANDOVER_DEST_PHONE_ACCOUNT_HANDLE);
	}

	super.tearDown();
	}

	/**
	* Ensures a call handover cannot be initiated for a {@link android.telecom.PhoneAccount} which
	* does not declare {@link android.telecom.PhoneAccount#EXTRA_SUPPORTS_HANDOVER_FROM}.
	*/
	public void testHandoverSourceFailed() {
	if (!mShouldTestTelecom) {
	return;
	}

	placeAndVerifyCall();
	Call call = mInCallCallbacks.getService().getLastCall();

	call.handoverTo(TestUtils.TEST_SELF_MANAGED_HANDLE_1, VideoProfile.STATE_BIDIRECTIONAL,
	null);

	// Expect the handover failed callback to be called.
	mOnHandoverFailedCounter.waitForCount(WAIT_FOR_STATE_CHANGE_TIMEOUT_MS);
	Call callbackCall = (Call) mOnHandoverFailedCounter.getArgs(0)[0];
	int failureReason = (int) mOnHandoverFailedCounter.getArgs(0)[1];
	assertEquals(call, callbackCall);
	assertEquals(Call.Callback.HANDOVER_FAILURE_NOT_SUPPORTED, failureReason);

	call.disconnect();
	}

	/**
	* Ensures a call handover cannot be initiated to a {@link android.telecom.PhoneAccount} which
	* does not declare {@link android.telecom.PhoneAccount#EXTRA_SUPPORTS_HANDOVER_TO}.
	*/
	public void testHandoverDestinationFailed() {
	if (!mShouldTestTelecom) {
	return;
	}
	startSourceCall();
	Call call = mInCallCallbacks.getService().getLastCall();

	// Now try to handover to an account which does not support handover.
	call.handoverTo(TestUtils.TEST_SELF_MANAGED_HANDLE_1, VideoProfile.STATE_BIDIRECTIONAL,
	null);

	// Expect the handover failed callback to be called.
	mOnHandoverFailedCounter.waitForCount(WAIT_FOR_STATE_CHANGE_TIMEOUT_MS);
	Call callbackCall = (Call) mOnHandoverFailedCounter.getArgs(0)[0];
	int failureReason = (int) mOnHandoverFailedCounter.getArgs(0)[1];
	assertEquals(call, callbackCall);
	assertEquals(Call.Callback.HANDOVER_FAILURE_NOT_SUPPORTED, failureReason);

	call.disconnect();
	}

	/**
	* Ensures that when the source and destination both support handover that an outgoing handover
	* request will be successfully relayed.
	*/
	public void testOutgoingHandoverRequestValid() {
	if (!mShouldTestTelecom) {
	return;
	}

	// Begin our source call on the CS which supports handover from it.
	startSourceCall();
	final Call call = mInCallCallbacks.getService().getLastCall();

	// Now try to handover to an account which does support handover to it.
	call.handoverTo(TestUtils.TEST_HANDOVER_DEST_PHONE_ACCOUNT_HANDLE,
	VideoProfile.STATE_BIDIRECTIONAL, null);

	// Ensure Telecom bound to the self managed CS
	if (!CtsSelfManagedConnectionService.waitForBinding()) {
	fail("Could not bind to Self-Managed ConnectionService");
	}

	// Wait for binding to self managed CS and invocation of outgoing handover method.
	TestUtils.InvokeCounter counter =
	CtsSelfManagedConnectionService.getConnectionService()
	.getOnCreateOutgoingHandoverConnectionCounter();
	counter.waitForCount(WAIT_FOR_STATE_CHANGE_TIMEOUT_MS);

	SelfManagedConnection connection = TestUtils.waitForAndGetConnection(
	call.getDetails().getHandle());

	// Verify the from handle is as expected.
	PhoneAccountHandle fromHandle = (PhoneAccountHandle) counter.getArgs(0)[0];
	assertEquals(TEST_HANDOVER_SRC_PHONE_ACCOUNT_HANDLE, fromHandle);
	// Verify the to handle is as expected.
	ConnectionRequest request = (ConnectionRequest) counter.getArgs(0)[1];
	assertEquals(TEST_HANDOVER_DEST_PHONE_ACCOUNT_HANDLE, request.getAccountHandle());

	completeHandoverAndVerify(call, connection);
	}

	/**
	* Tests use of the
	* {@link android.telecom.TelecomManager#acceptHandover(Uri, int, PhoneAccountHandle)} API on
	* the receiving side of the handover.
	*/
	public void testIncomingHandoverRequestValid() {
	if (!mShouldTestTelecom) {
	return;
	}

	// Begin our source call on the CS which supports handover from it.
	startSourceCall();
	final Call call = mInCallCallbacks.getService().getLastCall();

	// Request to accept handover of that call to another app.
	mTelecomManager.acceptHandover(call.getDetails().getHandle(),
	VideoProfile.STATE_BIDIRECTIONAL, TEST_HANDOVER_DEST_PHONE_ACCOUNT_HANDLE);

	// Ensure Telecom bound to the self managed CS
	if (!CtsSelfManagedConnectionService.waitForBinding()) {
	fail("Could not bind to Self-Managed ConnectionService");
	}

	// Wait for binding to self managed CS and invocation of incoming handover method.
	TestUtils.InvokeCounter counter =
	CtsSelfManagedConnectionService.getConnectionService()
	.getOnCreateIncomingHandoverConnectionCounter();
	counter.waitForCount(WAIT_FOR_STATE_CHANGE_TIMEOUT_MS);

	SelfManagedConnection connection = TestUtils.waitForAndGetConnection(
	call.getDetails().getHandle());

	// Verify the from handle is as expected.
	PhoneAccountHandle fromHandle = (PhoneAccountHandle) counter.getArgs(0)[0];
	assertEquals(TEST_HANDOVER_SRC_PHONE_ACCOUNT_HANDLE, fromHandle);
	// Verify the to handle is as expected.
	ConnectionRequest request = (ConnectionRequest) counter.getArgs(0)[1];
	assertEquals(TEST_HANDOVER_DEST_PHONE_ACCOUNT_HANDLE, request.getAccountHandle());
	// The original call's address should match the address of the handover request.
	assertEquals(call.getDetails().getHandle(), request.getAddress());

	completeHandoverAndVerify(call, connection);
	}

	/**
	* Begins a call which will be the source of a handover.
	*/
	private void startSourceCall() {
	// Ensure the ongoing account is on a PhoneAccount which supports handover from.
	Bundle extras = new Bundle();
	extras.putParcelable(TelecomManager.EXTRA_PHONE_ACCOUNT_HANDLE,
	TEST_HANDOVER_SRC_PHONE_ACCOUNT_HANDLE);
	placeAndVerifyCall(extras);
	Connection connection = verifyConnectionForOutgoingCall();
	connection.setActive();
	Call call = mInCallCallbacks.getService().getLastCall();
	assertCallState(call, Call.STATE_ACTIVE);
	}

	/**
	* Complete the a call handover and verify that it was successfully reported.
	* @param call
	* @param connection
	*/
	private void completeHandoverAndVerify(final Call call, SelfManagedConnection connection) {
	// Make the connection active, indicating that the user has accepted the handover.
	connection.setActive();

	// Expect the original call to have been informed of handover completion.
	mOnHandoverCompleteCounter.waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS);
	assertTrue("mOnHandoverCompleteCounter is zero",
	mOnHandoverCompleteCounter.getInvokeCount() >= 1);

	// Also expect the connection to be informed of handover completion.
	connection.getHandoverCompleteCounter().waitForCount(1, WAIT_FOR_STATE_CHANGE_TIMEOUT_MS);
	assertTrue("connection's handoverCompleteCounter is zero",
	connection.getHandoverCompleteCounter().getInvokeCount() >= 1);

	// Now, we expect that the original connection will get disconnected.
	waitUntilConditionIsTrueOrTimeout(new Condition() {
	@Override
	public Object expected() {
	return Call.STATE_DISCONNECTED;
	}
	@Override
	public Object actual() {
	return call.getState();
	}
	},
	WAIT_FOR_STATE_CHANGE_TIMEOUT_MS,
	"Expected original call to be disconnected."
	);
	}
	}