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

 /*
  * Copyright (C) 2020 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.app.ActivityManager;
 import android.app.UiAutomation;
 import android.app.role.RoleManager;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.content.ServiceConnection;
 import android.content.res.Configuration;
 import android.graphics.Color;
 import android.net.Uri;
 import android.os.AsyncTask;
 import android.os.IBinder;
 import android.os.UserHandle;
 import android.telecom.PhoneAccount;
 import android.telecom.PhoneAccountHandle;
 import android.telecom.TelecomManager;
 import android.telecom.cts.carmodetestapp.CtsCarModeInCallServiceControl;
 import android.telecom.cts.carmodetestapp.ICtsCarModeInCallServiceControl;
 import android.telecom.cts.carmodetestappselfmanaged.CtsCarModeInCallServiceControlSelfManaged;
 import android.telecom.cts.carmodetestapptwo.CtsCarModeInCallServiceControlTwo;
 import android.telecom.cts.thirdptydialer.CtsThirdPtyDialerInCallServiceControl;
 import android.telecom.cts.thirdptydialertwo.CtsThirdPtyDialerInCallServiceControlTwo;
 import android.telecom.cts.thirdptyincallservice.CtsThirdPartyInCallServiceControl;
 import android.telecom.cts.thirdptyincallservice.ICtsThirdPartyInCallServiceControl;
 import android.util.Log;

 import java.util.List;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.function.Consumer;

 public class SelfManagedConnectionTest extends BaseTelecomTestWithMockServices {
     private static final String TAG = "SelfManagedConnectionTest";
     private static final long TIMEOUT = 3000L;
     private static final String THIRD_PTY_CONTROL =
             CtsThirdPartyInCallServiceControl.CONTROL_INTERFACE_ACTION;
     private static final String CAR_MODE_CONTROL =
             "android.telecom.cts.carmodetestapp.ACTION_CAR_MODE_CONTROL";
     private static final ComponentName NON_UI_INCALLSERVICE = ComponentName.createRelative(
             CtsThirdPartyInCallServiceControl.class.getPackage().getName(),
             CtsThirdPartyInCallServiceControl.class.getName());
     // Default dialer that not support self-managed calls
     private static final String DEFAULT_DIALER_PKG_1 = CtsThirdPtyDialerInCallServiceControl.class
             .getPackage().getName();
     private static final ComponentName DEFAULT_DIALER_INCALLSERVICE_1 = ComponentName
             .createRelative(DEFAULT_DIALER_PKG_1,
                     CtsThirdPtyDialerInCallServiceControl.class.getName());
     // Default dialerhat support self-managed calls
     private static final String DEFAULT_DIALER_PKG_2 = CtsThirdPtyDialerInCallServiceControlTwo
             .class.getPackage().getName();
     private static final ComponentName DEFAULT_DIALER_INCALLSERVICE_2 = ComponentName
             .createRelative(DEFAULT_DIALER_PKG_2,
                     CtsThirdPtyDialerInCallServiceControlTwo.class.getName());
     private static final String CAR_DIALER_PKG_1 = CtsCarModeInCallServiceControl.class
             .getPackage().getName();
     private static final ComponentName CAR_DIALER_1 = ComponentName.createRelative(
             CAR_DIALER_PKG_1, CtsCarModeInCallServiceControl.class.getName());
     private static final String CAR_DIALER_PKG_2 = CtsCarModeInCallServiceControlTwo.class
             .getPackage().getName();
     private static final String CAR_SELF_MANAGED_PKG =
             CtsCarModeInCallServiceControlSelfManaged.class
                     .getPackage().getName();
     private static final ComponentName CAR_DIALER_2 = ComponentName.createRelative(
             CAR_DIALER_PKG_2, CtsCarModeInCallServiceControlTwo.class.getName());
     private static final ComponentName CAR_SELF_MANAGED_COMPONENT = ComponentName.createRelative(
             CAR_SELF_MANAGED_PKG, CtsCarModeInCallServiceControlSelfManaged.class.getName());

     private Uri TEST_ADDRESS = Uri.fromParts("tel", "6505551213", null);

     private static final PhoneAccountHandle TEST_CAR_SELF_MANAGED_HANDLE =
             new PhoneAccountHandle(
                     new ComponentName(CAR_SELF_MANAGED_PKG, TestUtils.SELF_MANAGED_COMPONENT),
                     TestUtils.SELF_MANAGED_ACCOUNT_ID_1);

     private static final PhoneAccount TEST_SELF_MANAGED_PHONE_ACCOUNT = PhoneAccount.builder(
                     TEST_CAR_SELF_MANAGED_HANDLE, TestUtils.SELF_MANAGED_ACCOUNT_LABEL)
             .setAddress(Uri.parse("sip:test@test.com"))
             .setSubscriptionAddress(Uri.parse("sip:test@test.com"))
             .setCapabilities(PhoneAccount.CAPABILITY_SELF_MANAGED
                     | PhoneAccount.CAPABILITY_SUPPORTS_VIDEO_CALLING
                     | PhoneAccount.CAPABILITY_VIDEO_CALLING)
             .setHighlightColor(Color.BLUE)
             .setShortDescription(TestUtils.SELF_MANAGED_ACCOUNT_LABEL)
             .addSupportedUriScheme(PhoneAccount.SCHEME_TEL)
             .addSupportedUriScheme(PhoneAccount.SCHEME_SIP)
             .setExtras(TestUtils.SELF_MANAGED_ACCOUNT_1_EXTRAS)
             .build();

     private RoleManager mRoleManager;
     private String mDefaultDialer;
     private UiAutomation mUiAutomation;
     private ICtsCarModeInCallServiceControl mCarModeIncallServiceControlOne;
     private ICtsCarModeInCallServiceControl mCarModeIncallServiceControlTwo;
     private ICtsCarModeInCallServiceControl mCarModeIncallServiceControlSelfManaged;

     private class TestServiceConnection implements ServiceConnection {
         private IBinder mService;
         private CountDownLatch mLatch = new CountDownLatch(1);
         private boolean mIsConnected;

         @Override
         public void onServiceConnected(ComponentName componentName, IBinder service) {
             Log.i(TAG, "Service Connected: " + componentName);
             mService = service;
             mIsConnected = true;
             mLatch.countDown();
         }

         @Override
         public void onServiceDisconnected(ComponentName componentName) {
             mService = null;
         }

         public IBinder getService() {
             return mService;
         }

         public boolean waitBind() {
             try {
                 mLatch.await(TIMEOUT, TimeUnit.MILLISECONDS);
                 return mIsConnected;
             } catch (InterruptedException e) {
                 return false;
             }
         }
     }

     @Override
     protected void setUp() throws Exception {
         if (!mShouldTestTelecom) {
             return;
         }
         super.setUp();
         NewOutgoingCallBroadcastReceiver.reset();
         mContext = getInstrumentation().getContext();
         mUiAutomation = getInstrumentation().getUiAutomation();
         if (mShouldTestTelecom) {
             mRoleManager = mContext.getSystemService(RoleManager.class);
             setupConnectionService(null, FLAG_ENABLE | FLAG_REGISTER);
             mTelecomManager.registerPhoneAccount(TestUtils.TEST_SELF_MANAGED_PHONE_ACCOUNT_4);
             mDefaultDialer = getDefaultDialer();
         }
     }

     @Override
     protected void tearDown() throws Exception {
         if (!mShouldTestTelecom) {
             return;
         }
         super.tearDown();

         disableAndVerifyCarMode(mCarModeIncallServiceControlOne, Configuration.UI_MODE_TYPE_NORMAL);
         disableAndVerifyCarMode(mCarModeIncallServiceControlTwo, Configuration.UI_MODE_TYPE_NORMAL);

         disconnectAllCallsAndVerify(mCarModeIncallServiceControlOne);
         disconnectAllCallsAndVerify(mCarModeIncallServiceControlTwo);

         CtsSelfManagedConnectionService connectionService =
                 CtsSelfManagedConnectionService.getConnectionService();
         if (connectionService != null) {
             connectionService.tearDown();
             mTelecomManager.unregisterPhoneAccount(TestUtils.TEST_SELF_MANAGED_HANDLE_4);
             assertTrue(setDefaultDialer(mDefaultDialer));
         }
     }

     /**
      * Test bind to non-UI in call services that support self-managed connections
      */
     public void testBindToSupportNonUiInCallService() throws Exception {
         if (!mShouldTestTelecom) {
             return;
         }
         TestServiceConnection controlConn = setUpControl(THIRD_PTY_CONTROL,
                 NON_UI_INCALLSERVICE);
         ICtsThirdPartyInCallServiceControl control = ICtsThirdPartyInCallServiceControl.Stub
                 .asInterface(controlConn.getService());
         control.resetLatchForServiceBound(true /* bind */);

         mUiAutomation.adoptShellPermissionIdentity("android.permission.CONTROL_INCALL_EXPERIENCE");
         SelfManagedConnection connection = placeAndVerifySelfManagedCall();
         control.checkBindStatus(true /* bindStatus */);
         assertTrue(control.checkBindStatus(true /* bindStatus */));
         connection.waitOnInCallServiceTrackingChanged();
         assertTrue(connection.isTracked());
         mUiAutomation.dropShellPermissionIdentity();

         connection.disconnectAndDestroy();
         assertIsInCall(false);
         mContext.unbindService(controlConn);
     }

     /**
      * Test bind to default dialer that support self-managed connections when device is not in car
      * mode
      */
     public void testBindToSupportDefaultDialerNoCarMode() throws Exception {
         if (!mShouldTestTelecom) {
             return;
         }
         TestServiceConnection controlConn = setUpControl(THIRD_PTY_CONTROL,
                 DEFAULT_DIALER_INCALLSERVICE_2);
         ICtsThirdPartyInCallServiceControl control = ICtsThirdPartyInCallServiceControl.Stub
                 .asInterface(controlConn.getService());
         TestUtils.setDefaultDialer(getInstrumentation(), DEFAULT_DIALER_PKG_2);
         control.resetLatchForServiceBound(true /* bind */);

         SelfManagedConnection connection = placeAndVerifySelfManagedCall();
         assertTrue(control.checkBindStatus(true /* bindStatus */));

         connection.waitOnInCallServiceTrackingChanged();
         assertTrue(connection.isAlternativeUiShowing());
         mUiAutomation.dropShellPermissionIdentity();

         connection.disconnectAndDestroy();
         assertIsInCall(false);
         mContext.unbindService(controlConn);
     }

     /**
      * Test not bind to default dialer that not support self-managed connections when device is not
      * in car mode
      */
     public void testNoBindToUnsupportDefaultDialerNoCarMode() throws Exception {
         if (!mShouldTestTelecom) {
             return;
         }
         TestServiceConnection controlConn = setUpControl(THIRD_PTY_CONTROL,
                 DEFAULT_DIALER_INCALLSERVICE_1);
         ICtsThirdPartyInCallServiceControl control = ICtsThirdPartyInCallServiceControl.Stub
                 .asInterface(controlConn.getService());
         assertTrue(setDefaultDialer(DEFAULT_DIALER_PKG_1));
         control.resetLatchForServiceBound(true /* bind */);

         SelfManagedConnection connection = placeAndVerifySelfManagedCall();
         assertFalse(control.checkBindStatus(true /* bindStatus */));

         connection.disconnectAndDestroy();
         assertIsInCall(false);
         mContext.unbindService(controlConn);
     }

     public void testEnterCarMode() throws Exception {
         if (!mShouldTestTelecom) {
             return;
         }
         TestServiceConnection controlConn = setUpControl(CAR_MODE_CONTROL,
                 CAR_DIALER_1);
         mCarModeIncallServiceControlOne = ICtsCarModeInCallServiceControl.Stub
                 .asInterface(controlConn.getService());
         mCarModeIncallServiceControlOne.reset();

         SelfManagedConnection connection = placeAndVerifySelfManagedCall();
         mUiAutomation.adoptShellPermissionIdentity(
                 "android.permission.ENTER_CAR_MODE_PRIORITIZED",
                 "android.permission.CONTROL_INCALL_EXPERIENCE");
         mCarModeIncallServiceControlOne.enableCarMode(1000);
         assertTrue(mCarModeIncallServiceControlOne.checkBindStatus(true /* bindStatus */));
         mCarModeIncallServiceControlOne.disableCarMode();
         mUiAutomation.dropShellPermissionIdentity();

         connection.disconnectAndDestroy();
         assertIsInCall(false);
         mContext.unbindService(controlConn);
     }

     /**
      * Test {@link TelecomManager#getOwnSelfManagedPhoneAccounts} works on packages with only the
      * {@link android.Manifest.permission#MANAGE_OWN_CALLS} permission.
      */
     public void testTelecomManagerGetSelfManagedPhoneAccountsForPackage() throws Exception {
         if (!mShouldTestTelecom) {
             return;
         }
         // bind to CarModeTestAppSelfManaged which only has the
         // {@link android.Manifest.permission#MANAGE_OWN_CALLS} permission
         TestServiceConnection control = setUpControl(CAR_MODE_CONTROL, CAR_SELF_MANAGED_COMPONENT);

         mCarModeIncallServiceControlSelfManaged =
                 ICtsCarModeInCallServiceControl.Stub
                         .asInterface(control.getService());

         mCarModeIncallServiceControlSelfManaged.reset();

         // register a self-managed phone account
         mCarModeIncallServiceControlSelfManaged.registerPhoneAccount(
                 TEST_SELF_MANAGED_PHONE_ACCOUNT);

         List<PhoneAccountHandle> pah =
                 mCarModeIncallServiceControlSelfManaged.getOwnSelfManagedPhoneAccounts();

         // assert that we can get all the self-managed phone accounts registered to
         // CarModeTestAppSelfManaged
         assertEquals(1, pah.size());
         assertTrue(pah.contains(TEST_CAR_SELF_MANAGED_HANDLE));

         mCarModeIncallServiceControlSelfManaged.unregisterPhoneAccount(
                 TEST_CAR_SELF_MANAGED_HANDLE);

         // unbind to CarModeTestAppSelfManaged
         mContext.unbindService(control);
     }

     public void testChangeCarModeApp() throws Exception {
         if (!mShouldTestTelecom) {
             return;
         }
         TestServiceConnection controlConn1 = setUpControl(CAR_MODE_CONTROL, CAR_DIALER_1);
         TestServiceConnection controlConn2 = setUpControl(CAR_MODE_CONTROL, CAR_DIALER_2);
         mCarModeIncallServiceControlOne = ICtsCarModeInCallServiceControl.Stub
                 .asInterface(controlConn1.getService());
         mCarModeIncallServiceControlTwo = ICtsCarModeInCallServiceControl.Stub
                 .asInterface(controlConn2.getService());
         mCarModeIncallServiceControlOne.reset();
         mCarModeIncallServiceControlTwo.reset();

         mUiAutomation.adoptShellPermissionIdentity(
                 "android.permission.ENTER_CAR_MODE_PRIORITIZED",
                 "android.permission.CONTROL_INCALL_EXPERIENCE");
         mCarModeIncallServiceControlOne.enableCarMode(999);

         SelfManagedConnection connection = placeAndVerifySelfManagedCall();
         assertTrue(mCarModeIncallServiceControlOne.checkBindStatus(true /* bindStatus */));
         mCarModeIncallServiceControlTwo.enableCarMode(1000);
         assertTrue(mCarModeIncallServiceControlOne.checkBindStatus(false /* bindStatus */));
         assertTrue(mCarModeIncallServiceControlTwo.checkBindStatus(true /* bindStatus */));

         mCarModeIncallServiceControlOne.disableCarMode();
         mCarModeIncallServiceControlTwo.disableCarMode();

         connection.disconnectAndDestroy();
         assertIsInCall(false);
         mUiAutomation.dropShellPermissionIdentity();
         mContext.unbindService(controlConn1);
         mContext.unbindService(controlConn2);
     }

     public void testExitCarMode() throws Exception {
         if (!mShouldTestTelecom) {
             return;
         }
         TestServiceConnection controlConn = setUpControl(CAR_MODE_CONTROL, CAR_DIALER_1);
         mCarModeIncallServiceControlOne = ICtsCarModeInCallServiceControl.Stub
                 .asInterface(controlConn.getService());
         mCarModeIncallServiceControlOne.reset();

         mUiAutomation.adoptShellPermissionIdentity(
                 "android.permission.ENTER_CAR_MODE_PRIORITIZED",
                 "android.permission.CONTROL_INCALL_EXPERIENCE");
         mCarModeIncallServiceControlOne.enableCarMode(1000);

         SelfManagedConnection connection = placeAndVerifySelfManagedCall();
         assertTrue(mCarModeIncallServiceControlOne.checkBindStatus(true /* bindStatus */));
         mCarModeIncallServiceControlOne.disableCarMode();
         assertTrue(mCarModeIncallServiceControlOne.checkBindStatus(false /* bindStatus */));
         mUiAutomation.dropShellPermissionIdentity();

         connection.disconnectAndDestroy();
         assertIsInCall(false);
         mContext.unbindService(controlConn);
     }

     private TestServiceConnection setUpControl(String action, ComponentName componentName) {
         Intent bindIntent = new Intent(action);
         bindIntent.setComponent(componentName);

         TestServiceConnection serviceConnection = new TestServiceConnection();
         mContext.bindService(bindIntent, serviceConnection, Context.BIND_AUTO_CREATE);
         if (!serviceConnection.waitBind()) {
             fail("fail bind to service");
         }
         return serviceConnection;
     }

     private boolean setDefaultDialer(String packageName) {
         mUiAutomation.adoptShellPermissionIdentity();
         try {
             CompletableFuture<Boolean> future = new CompletableFuture<>();
             Consumer<Boolean> callback = successful -> {
                 future.complete(successful);
             };

             mRoleManager.addRoleHolderAsUser(RoleManager.ROLE_DIALER, packageName, 0,
                     UserHandle.of(ActivityManager.getCurrentUser()), AsyncTask.THREAD_POOL_EXECUTOR,
                     callback);
             return future.get(TIMEOUT, TimeUnit.MILLISECONDS);
         } catch (InterruptedException | ExecutionException | TimeoutException e) {
             e.printStackTrace();
             return false;
         } finally {
             mUiAutomation.dropShellPermissionIdentity();
         }
     }

     private String getDefaultDialer() {
         mUiAutomation.adoptShellPermissionIdentity();
         String result = mRoleManager.getRoleHolders(RoleManager.ROLE_DIALER).get(0);
         mUiAutomation.dropShellPermissionIdentity();
         return result;
     }

     private SelfManagedConnection placeAndVerifySelfManagedCall() {
         TestUtils.addIncomingCall(getInstrumentation(), mTelecomManager,
                 TestUtils.TEST_SELF_MANAGED_HANDLE_4, TEST_ADDRESS);
         if (!CtsSelfManagedConnectionService.waitForBinding()) {
             fail("Could not bind to Self-Managed ConnectionService");
         }
         return TestUtils.waitForAndGetConnection(TEST_ADDRESS);
     }
 }
	/*
	* Copyright (C) 2020 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.app.ActivityManager;
	import android.app.UiAutomation;
	import android.app.role.RoleManager;
	import android.content.ComponentName;
	import android.content.Context;
	import android.content.Intent;
	import android.content.ServiceConnection;
	import android.content.res.Configuration;
	import android.graphics.Color;
	import android.net.Uri;
	import android.os.AsyncTask;
	import android.os.IBinder;
	import android.os.UserHandle;
	import android.telecom.PhoneAccount;
	import android.telecom.PhoneAccountHandle;
	import android.telecom.TelecomManager;
	import android.telecom.cts.carmodetestapp.CtsCarModeInCallServiceControl;
	import android.telecom.cts.carmodetestapp.ICtsCarModeInCallServiceControl;
	import android.telecom.cts.carmodetestappselfmanaged.CtsCarModeInCallServiceControlSelfManaged;
	import android.telecom.cts.carmodetestapptwo.CtsCarModeInCallServiceControlTwo;
	import android.telecom.cts.thirdptydialer.CtsThirdPtyDialerInCallServiceControl;
	import android.telecom.cts.thirdptydialertwo.CtsThirdPtyDialerInCallServiceControlTwo;
	import android.telecom.cts.thirdptyincallservice.CtsThirdPartyInCallServiceControl;
	import android.telecom.cts.thirdptyincallservice.ICtsThirdPartyInCallServiceControl;
	import android.util.Log;

	import java.util.List;
	import java.util.concurrent.CompletableFuture;
	import java.util.concurrent.CountDownLatch;
	import java.util.concurrent.ExecutionException;
	import java.util.concurrent.TimeUnit;
	import java.util.concurrent.TimeoutException;
	import java.util.function.Consumer;

	public class SelfManagedConnectionTest extends BaseTelecomTestWithMockServices {
	private static final String TAG = "SelfManagedConnectionTest";
	private static final long TIMEOUT = 3000L;
	private static final String THIRD_PTY_CONTROL =
	CtsThirdPartyInCallServiceControl.CONTROL_INTERFACE_ACTION;
	private static final String CAR_MODE_CONTROL =
	"android.telecom.cts.carmodetestapp.ACTION_CAR_MODE_CONTROL";
	private static final ComponentName NON_UI_INCALLSERVICE = ComponentName.createRelative(
	CtsThirdPartyInCallServiceControl.class.getPackage().getName(),
	CtsThirdPartyInCallServiceControl.class.getName());
	// Default dialer that not support self-managed calls
	private static final String DEFAULT_DIALER_PKG_1 = CtsThirdPtyDialerInCallServiceControl.class
	.getPackage().getName();
	private static final ComponentName DEFAULT_DIALER_INCALLSERVICE_1 = ComponentName
	.createRelative(DEFAULT_DIALER_PKG_1,
	CtsThirdPtyDialerInCallServiceControl.class.getName());
	// Default dialerhat support self-managed calls
	private static final String DEFAULT_DIALER_PKG_2 = CtsThirdPtyDialerInCallServiceControlTwo
	.class.getPackage().getName();
	private static final ComponentName DEFAULT_DIALER_INCALLSERVICE_2 = ComponentName
	.createRelative(DEFAULT_DIALER_PKG_2,
	CtsThirdPtyDialerInCallServiceControlTwo.class.getName());
	private static final String CAR_DIALER_PKG_1 = CtsCarModeInCallServiceControl.class
	.getPackage().getName();
	private static final ComponentName CAR_DIALER_1 = ComponentName.createRelative(
	CAR_DIALER_PKG_1, CtsCarModeInCallServiceControl.class.getName());
	private static final String CAR_DIALER_PKG_2 = CtsCarModeInCallServiceControlTwo.class
	.getPackage().getName();
	private static final String CAR_SELF_MANAGED_PKG =
	CtsCarModeInCallServiceControlSelfManaged.class
	.getPackage().getName();
	private static final ComponentName CAR_DIALER_2 = ComponentName.createRelative(
	CAR_DIALER_PKG_2, CtsCarModeInCallServiceControlTwo.class.getName());
	private static final ComponentName CAR_SELF_MANAGED_COMPONENT = ComponentName.createRelative(
	CAR_SELF_MANAGED_PKG, CtsCarModeInCallServiceControlSelfManaged.class.getName());

	private Uri TEST_ADDRESS = Uri.fromParts("tel", "6505551213", null);

	private static final PhoneAccountHandle TEST_CAR_SELF_MANAGED_HANDLE =
	new PhoneAccountHandle(
	new ComponentName(CAR_SELF_MANAGED_PKG, TestUtils.SELF_MANAGED_COMPONENT),
	TestUtils.SELF_MANAGED_ACCOUNT_ID_1);

	private static final PhoneAccount TEST_SELF_MANAGED_PHONE_ACCOUNT = PhoneAccount.builder(
	TEST_CAR_SELF_MANAGED_HANDLE, TestUtils.SELF_MANAGED_ACCOUNT_LABEL)
	.setAddress(Uri.parse("sip:test@test.com"))
	.setSubscriptionAddress(Uri.parse("sip:test@test.com"))
	.setCapabilities(PhoneAccount.CAPABILITY_SELF_MANAGED
	\| PhoneAccount.CAPABILITY_SUPPORTS_VIDEO_CALLING
	\| PhoneAccount.CAPABILITY_VIDEO_CALLING)
	.setHighlightColor(Color.BLUE)
	.setShortDescription(TestUtils.SELF_MANAGED_ACCOUNT_LABEL)
	.addSupportedUriScheme(PhoneAccount.SCHEME_TEL)
	.addSupportedUriScheme(PhoneAccount.SCHEME_SIP)
	.setExtras(TestUtils.SELF_MANAGED_ACCOUNT_1_EXTRAS)
	.build();

	private RoleManager mRoleManager;
	private String mDefaultDialer;
	private UiAutomation mUiAutomation;
	private ICtsCarModeInCallServiceControl mCarModeIncallServiceControlOne;
	private ICtsCarModeInCallServiceControl mCarModeIncallServiceControlTwo;
	private ICtsCarModeInCallServiceControl mCarModeIncallServiceControlSelfManaged;

	private class TestServiceConnection implements ServiceConnection {
	private IBinder mService;
	private CountDownLatch mLatch = new CountDownLatch(1);
	private boolean mIsConnected;

	@Override
	public void onServiceConnected(ComponentName componentName, IBinder service) {
	Log.i(TAG, "Service Connected: " + componentName);
	mService = service;
	mIsConnected = true;
	mLatch.countDown();
	}

	@Override
	public void onServiceDisconnected(ComponentName componentName) {
	mService = null;
	}

	public IBinder getService() {
	return mService;
	}

	public boolean waitBind() {
	try {
	mLatch.await(TIMEOUT, TimeUnit.MILLISECONDS);
	return mIsConnected;
	} catch (InterruptedException e) {
	return false;
	}
	}
	}

	@Override
	protected void setUp() throws Exception {
	if (!mShouldTestTelecom) {
	return;
	}
	super.setUp();
	NewOutgoingCallBroadcastReceiver.reset();
	mContext = getInstrumentation().getContext();
	mUiAutomation = getInstrumentation().getUiAutomation();
	if (mShouldTestTelecom) {
	mRoleManager = mContext.getSystemService(RoleManager.class);
	setupConnectionService(null, FLAG_ENABLE \| FLAG_REGISTER);
	mTelecomManager.registerPhoneAccount(TestUtils.TEST_SELF_MANAGED_PHONE_ACCOUNT_4);
	mDefaultDialer = getDefaultDialer();
	}
	}

	@Override
	protected void tearDown() throws Exception {
	if (!mShouldTestTelecom) {
	return;
	}
	super.tearDown();

	disableAndVerifyCarMode(mCarModeIncallServiceControlOne, Configuration.UI_MODE_TYPE_NORMAL);
	disableAndVerifyCarMode(mCarModeIncallServiceControlTwo, Configuration.UI_MODE_TYPE_NORMAL);

	disconnectAllCallsAndVerify(mCarModeIncallServiceControlOne);
	disconnectAllCallsAndVerify(mCarModeIncallServiceControlTwo);

	CtsSelfManagedConnectionService connectionService =
	CtsSelfManagedConnectionService.getConnectionService();
	if (connectionService != null) {
	connectionService.tearDown();
	mTelecomManager.unregisterPhoneAccount(TestUtils.TEST_SELF_MANAGED_HANDLE_4);
	assertTrue(setDefaultDialer(mDefaultDialer));
	}
	}

	/**
	* Test bind to non-UI in call services that support self-managed connections
	*/
	public void testBindToSupportNonUiInCallService() throws Exception {
	if (!mShouldTestTelecom) {
	return;
	}
	TestServiceConnection controlConn = setUpControl(THIRD_PTY_CONTROL,
	NON_UI_INCALLSERVICE);
	ICtsThirdPartyInCallServiceControl control = ICtsThirdPartyInCallServiceControl.Stub
	.asInterface(controlConn.getService());
	control.resetLatchForServiceBound(true /* bind */);

	mUiAutomation.adoptShellPermissionIdentity("android.permission.CONTROL_INCALL_EXPERIENCE");
	SelfManagedConnection connection = placeAndVerifySelfManagedCall();
	control.checkBindStatus(true /* bindStatus */);
	assertTrue(control.checkBindStatus(true /* bindStatus */));
	connection.waitOnInCallServiceTrackingChanged();
	assertTrue(connection.isTracked());
	mUiAutomation.dropShellPermissionIdentity();

	connection.disconnectAndDestroy();
	assertIsInCall(false);
	mContext.unbindService(controlConn);
	}

	/**
	* Test bind to default dialer that support self-managed connections when device is not in car
	* mode
	*/
	public void testBindToSupportDefaultDialerNoCarMode() throws Exception {
	if (!mShouldTestTelecom) {
	return;
	}
	TestServiceConnection controlConn = setUpControl(THIRD_PTY_CONTROL,
	DEFAULT_DIALER_INCALLSERVICE_2);
	ICtsThirdPartyInCallServiceControl control = ICtsThirdPartyInCallServiceControl.Stub
	.asInterface(controlConn.getService());
	TestUtils.setDefaultDialer(getInstrumentation(), DEFAULT_DIALER_PKG_2);
	control.resetLatchForServiceBound(true /* bind */);

	SelfManagedConnection connection = placeAndVerifySelfManagedCall();
	assertTrue(control.checkBindStatus(true /* bindStatus */));

	connection.waitOnInCallServiceTrackingChanged();
	assertTrue(connection.isAlternativeUiShowing());
	mUiAutomation.dropShellPermissionIdentity();

	connection.disconnectAndDestroy();
	assertIsInCall(false);
	mContext.unbindService(controlConn);
	}

	/**
	* Test not bind to default dialer that not support self-managed connections when device is not
	* in car mode
	*/
	public void testNoBindToUnsupportDefaultDialerNoCarMode() throws Exception {
	if (!mShouldTestTelecom) {
	return;
	}
	TestServiceConnection controlConn = setUpControl(THIRD_PTY_CONTROL,
	DEFAULT_DIALER_INCALLSERVICE_1);
	ICtsThirdPartyInCallServiceControl control = ICtsThirdPartyInCallServiceControl.Stub
	.asInterface(controlConn.getService());
	assertTrue(setDefaultDialer(DEFAULT_DIALER_PKG_1));
	control.resetLatchForServiceBound(true /* bind */);

	SelfManagedConnection connection = placeAndVerifySelfManagedCall();
	assertFalse(control.checkBindStatus(true /* bindStatus */));

	connection.disconnectAndDestroy();
	assertIsInCall(false);
	mContext.unbindService(controlConn);
	}

	public void testEnterCarMode() throws Exception {
	if (!mShouldTestTelecom) {
	return;
	}
	TestServiceConnection controlConn = setUpControl(CAR_MODE_CONTROL,
	CAR_DIALER_1);
	mCarModeIncallServiceControlOne = ICtsCarModeInCallServiceControl.Stub
	.asInterface(controlConn.getService());
	mCarModeIncallServiceControlOne.reset();

	SelfManagedConnection connection = placeAndVerifySelfManagedCall();
	mUiAutomation.adoptShellPermissionIdentity(
	"android.permission.ENTER_CAR_MODE_PRIORITIZED",
	"android.permission.CONTROL_INCALL_EXPERIENCE");
	mCarModeIncallServiceControlOne.enableCarMode(1000);
	assertTrue(mCarModeIncallServiceControlOne.checkBindStatus(true /* bindStatus */));
	mCarModeIncallServiceControlOne.disableCarMode();
	mUiAutomation.dropShellPermissionIdentity();

	connection.disconnectAndDestroy();
	assertIsInCall(false);
	mContext.unbindService(controlConn);
	}

	/**
	* Test {@link TelecomManager#getOwnSelfManagedPhoneAccounts} works on packages with only the
	* {@link android.Manifest.permission#MANAGE_OWN_CALLS} permission.
	*/
	public void testTelecomManagerGetSelfManagedPhoneAccountsForPackage() throws Exception {
	if (!mShouldTestTelecom) {
	return;
	}
	// bind to CarModeTestAppSelfManaged which only has the
	// {@link android.Manifest.permission#MANAGE_OWN_CALLS} permission
	TestServiceConnection control = setUpControl(CAR_MODE_CONTROL, CAR_SELF_MANAGED_COMPONENT);

	mCarModeIncallServiceControlSelfManaged =
	ICtsCarModeInCallServiceControl.Stub
	.asInterface(control.getService());

	mCarModeIncallServiceControlSelfManaged.reset();

	// register a self-managed phone account
	mCarModeIncallServiceControlSelfManaged.registerPhoneAccount(
	TEST_SELF_MANAGED_PHONE_ACCOUNT);

	List<PhoneAccountHandle> pah =
	mCarModeIncallServiceControlSelfManaged.getOwnSelfManagedPhoneAccounts();

	// assert that we can get all the self-managed phone accounts registered to
	// CarModeTestAppSelfManaged
	assertEquals(1, pah.size());
	assertTrue(pah.contains(TEST_CAR_SELF_MANAGED_HANDLE));

	mCarModeIncallServiceControlSelfManaged.unregisterPhoneAccount(
	TEST_CAR_SELF_MANAGED_HANDLE);

	// unbind to CarModeTestAppSelfManaged
	mContext.unbindService(control);
	}

	public void testChangeCarModeApp() throws Exception {
	if (!mShouldTestTelecom) {
	return;
	}
	TestServiceConnection controlConn1 = setUpControl(CAR_MODE_CONTROL, CAR_DIALER_1);
	TestServiceConnection controlConn2 = setUpControl(CAR_MODE_CONTROL, CAR_DIALER_2);
	mCarModeIncallServiceControlOne = ICtsCarModeInCallServiceControl.Stub
	.asInterface(controlConn1.getService());
	mCarModeIncallServiceControlTwo = ICtsCarModeInCallServiceControl.Stub
	.asInterface(controlConn2.getService());
	mCarModeIncallServiceControlOne.reset();
	mCarModeIncallServiceControlTwo.reset();

	mUiAutomation.adoptShellPermissionIdentity(
	"android.permission.ENTER_CAR_MODE_PRIORITIZED",
	"android.permission.CONTROL_INCALL_EXPERIENCE");
	mCarModeIncallServiceControlOne.enableCarMode(999);

	SelfManagedConnection connection = placeAndVerifySelfManagedCall();
	assertTrue(mCarModeIncallServiceControlOne.checkBindStatus(true /* bindStatus */));
	mCarModeIncallServiceControlTwo.enableCarMode(1000);
	assertTrue(mCarModeIncallServiceControlOne.checkBindStatus(false /* bindStatus */));
	assertTrue(mCarModeIncallServiceControlTwo.checkBindStatus(true /* bindStatus */));

	mCarModeIncallServiceControlOne.disableCarMode();
	mCarModeIncallServiceControlTwo.disableCarMode();

	connection.disconnectAndDestroy();
	assertIsInCall(false);
	mUiAutomation.dropShellPermissionIdentity();
	mContext.unbindService(controlConn1);
	mContext.unbindService(controlConn2);
	}

	public void testExitCarMode() throws Exception {
	if (!mShouldTestTelecom) {
	return;
	}
	TestServiceConnection controlConn = setUpControl(CAR_MODE_CONTROL, CAR_DIALER_1);
	mCarModeIncallServiceControlOne = ICtsCarModeInCallServiceControl.Stub
	.asInterface(controlConn.getService());
	mCarModeIncallServiceControlOne.reset();

	mUiAutomation.adoptShellPermissionIdentity(
	"android.permission.ENTER_CAR_MODE_PRIORITIZED",
	"android.permission.CONTROL_INCALL_EXPERIENCE");
	mCarModeIncallServiceControlOne.enableCarMode(1000);

	SelfManagedConnection connection = placeAndVerifySelfManagedCall();
	assertTrue(mCarModeIncallServiceControlOne.checkBindStatus(true /* bindStatus */));
	mCarModeIncallServiceControlOne.disableCarMode();
	assertTrue(mCarModeIncallServiceControlOne.checkBindStatus(false /* bindStatus */));
	mUiAutomation.dropShellPermissionIdentity();

	connection.disconnectAndDestroy();
	assertIsInCall(false);
	mContext.unbindService(controlConn);
	}

	private TestServiceConnection setUpControl(String action, ComponentName componentName) {
	Intent bindIntent = new Intent(action);
	bindIntent.setComponent(componentName);

	TestServiceConnection serviceConnection = new TestServiceConnection();
	mContext.bindService(bindIntent, serviceConnection, Context.BIND_AUTO_CREATE);
	if (!serviceConnection.waitBind()) {
	fail("fail bind to service");
	}
	return serviceConnection;
	}

	private boolean setDefaultDialer(String packageName) {
	mUiAutomation.adoptShellPermissionIdentity();
	try {
	CompletableFuture<Boolean> future = new CompletableFuture<>();
	Consumer<Boolean> callback = successful -> {
	future.complete(successful);
	};

	mRoleManager.addRoleHolderAsUser(RoleManager.ROLE_DIALER, packageName, 0,
	UserHandle.of(ActivityManager.getCurrentUser()), AsyncTask.THREAD_POOL_EXECUTOR,
	callback);
	return future.get(TIMEOUT, TimeUnit.MILLISECONDS);
	} catch (InterruptedException \| ExecutionException \| TimeoutException e) {
	e.printStackTrace();
	return false;
	} finally {
	mUiAutomation.dropShellPermissionIdentity();
	}
	}

	private String getDefaultDialer() {
	mUiAutomation.adoptShellPermissionIdentity();
	String result = mRoleManager.getRoleHolders(RoleManager.ROLE_DIALER).get(0);
	mUiAutomation.dropShellPermissionIdentity();
	return result;
	}

	private SelfManagedConnection placeAndVerifySelfManagedCall() {
	TestUtils.addIncomingCall(getInstrumentation(), mTelecomManager,
	TestUtils.TEST_SELF_MANAGED_HANDLE_4, TEST_ADDRESS);
	if (!CtsSelfManagedConnectionService.waitForBinding()) {
	fail("Could not bind to Self-Managed ConnectionService");
	}
	return TestUtils.waitForAndGetConnection(TEST_ADDRESS);
	}
	}