Merge "Adds code to enforce size limits on simultaneous calling restrictions" into main (2245d5b7) · Commits · e / os / android_packages_services_Telecomm

src/com/android/server/telecom/PhoneAccountRegistrar.java

+41 −0

Original line number	Diff line number	Diff line
		@@ -85,6 +85,7 @@ import java.util.Iterator;
		import java.util.List;
		import java.util.Map;
		import java.util.Objects;
		import java.util.Set;
		import java.util.concurrent.ConcurrentHashMap;
		import java.util.concurrent.CopyOnWriteArrayList;
		import java.util.stream.Collectors;
		@@ -951,6 +952,9 @@ public class PhoneAccountRegistrar {
		enforceCharacterLimit(account);
		enforceIconSizeLimit(account);
		enforceMaxPhoneAccountLimit(account);
		if (mTelephonyFeatureFlags.simultaneousCallingIndications()) {
		enforceSimultaneousCallingRestrictionLimit(account);
		}
		addOrReplacePhoneAccount(account);
		}

		@@ -1078,6 +1082,43 @@ public class PhoneAccountRegistrar {
		}
		}

		/**
		* Enforce size limits on the simultaneous calling restriction of a PhoneAccount.
		* If a PhoneAccount has a simultaneous calling restriction on it, enforce the following: the
		* number of PhoneAccountHandles in the Set can not exceed the per app restriction on
		* PhoneAccounts registered and each PhoneAccountHandle's fields must not exceed the per field
		* character limit.
		* @param account The PhoneAccount to enforce simultaneous calling restrictions on.
		* @throws IllegalArgumentException if the PhoneAccount exceeds size limits.
		*/
		public void enforceSimultaneousCallingRestrictionLimit(@NonNull PhoneAccount account) {
		if (!account.hasSimultaneousCallingRestriction()) return;
		Set<PhoneAccountHandle> restrictions = account.getSimultaneousCallingRestriction();
		if (restrictions.size() > MAX_PHONE_ACCOUNT_REGISTRATIONS) {
		throw new IllegalArgumentException("Can not register a PhoneAccount with a number"
		+ "of simultaneous calling restrictions that is greater than "
		+ MAX_PHONE_ACCOUNT_REGISTRATIONS);
		}
		for (PhoneAccountHandle handle : restrictions) {
		ComponentName component = handle.getComponentName();
		if (component.getPackageName().length() > MAX_PHONE_ACCOUNT_FIELD_CHAR_LIMIT) {
		throw new IllegalArgumentException("A PhoneAccountHandle added as part of "
		+ "a simultaneous calling restriction has a package name that has exceeded "
		+ "the character limit of " + MAX_PHONE_ACCOUNT_FIELD_CHAR_LIMIT);
		}
		if (component.getClassName().length() > MAX_PHONE_ACCOUNT_FIELD_CHAR_LIMIT) {
		throw new IllegalArgumentException("A PhoneAccountHandle added as part of "
		+ "a simultaneous calling restriction has a class name that has exceeded "
		+ "the character limit of " + MAX_PHONE_ACCOUNT_FIELD_CHAR_LIMIT);
		}
		if (handle.getId().length() > MAX_PHONE_ACCOUNT_FIELD_CHAR_LIMIT) {
		throw new IllegalArgumentException("A PhoneAccountHandle added as part of "
		+ "a simultaneous calling restriction has an ID that has exceeded "
		+ "the character limit of " + MAX_PHONE_ACCOUNT_FIELD_CHAR_LIMIT);
		}
		}
		}

		/**
		* Enforce a character limit on all PA and PAH string or char-sequence fields.
		*

tests/src/com/android/server/telecom/tests/PhoneAccountRegistrarTest.java

+103 −0

Original line number	Diff line number	Diff line
		@@ -27,6 +27,7 @@ import static org.mockito.ArgumentMatchers.anyBoolean;
		import static org.mockito.ArgumentMatchers.anyInt;
		import static org.mockito.ArgumentMatchers.anyString;
		import static org.mockito.Mockito.clearInvocations;
		import static org.mockito.Mockito.doReturn;
		import static org.mockito.Mockito.mock;
		import static org.mockito.Mockito.never;
		import static org.mockito.Mockito.times;
		@@ -90,6 +91,7 @@ import java.io.OutputStream;
		import java.util.ArrayList;
		import java.util.Arrays;
		import java.util.Collection;
		import java.util.HashSet;
		import java.util.List;
		import java.util.Map;
		import java.util.Set;
		@@ -1624,6 +1626,107 @@ public class PhoneAccountRegistrarTest extends TelecomTestCase {
		}
		}

		/**
		* Ensure an IllegalArgumentException is thrown when adding too many PhoneAccountHandles to
		* a PhoneAccount.
		*/
		@Test
		public void testLimitOnSimultaneousCallingRestriction_tooManyElements() throws Exception {
		doReturn(true).when(mTelephonyFeatureFlags).simultaneousCallingIndications();
		mComponentContextFixture.addConnectionService(makeQuickConnectionServiceComponentName(),
		Mockito.mock(IConnectionService.class));
		Set<PhoneAccountHandle> tooManyElements = new HashSet<>(11);
		for (int i = 0; i < 11; i++) {
		tooManyElements.add(makeQuickAccountHandle(TEST_ID + i));
		}
		PhoneAccount tooManyRestrictionsPA = new PhoneAccount.Builder(
		makeQuickAccountHandle(TEST_ID), TEST_LABEL)
		.setSimultaneousCallingRestriction(tooManyElements)
		.build();
		try {
		mRegistrar.registerPhoneAccount(tooManyRestrictionsPA);
		fail("should have hit registrations exception in "
		+ "enforceSimultaneousCallingRestrictionLimit");
		} catch (IllegalArgumentException e) {
		// pass test
		}
		}

		/**
		* Ensure an IllegalArgumentException is thrown when adding a PhoneAccountHandle where the
		* package name field is too large.
		*/
		@Test
		public void testLimitOnSimultaneousCallingRestriction_InvalidPackageName() throws Exception {
		doReturn(true).when(mTelephonyFeatureFlags).simultaneousCallingIndications();
		mComponentContextFixture.addConnectionService(makeQuickConnectionServiceComponentName(),
		Mockito.mock(IConnectionService.class));
		Set<PhoneAccountHandle> invalidElement = new HashSet<>(1);
		invalidElement.add(new PhoneAccountHandle(new ComponentName(INVALID_STR, "Class"),
		TEST_ID));
		PhoneAccount invalidRestrictionPA = new PhoneAccount.Builder(
		makeQuickAccountHandle(TEST_ID), TEST_LABEL)
		.setSimultaneousCallingRestriction(invalidElement)
		.build();
		try {
		mRegistrar.registerPhoneAccount(invalidRestrictionPA);
		fail("should have hit package name size limit exception in "
		+ "enforceSimultaneousCallingRestrictionLimit");
		} catch (IllegalArgumentException e) {
		// pass test
		}
		}

		/**
		* Ensure an IllegalArgumentException is thrown when adding a PhoneAccountHandle where the
		* class name field is too large.
		*/
		@Test
		public void testLimitOnSimultaneousCallingRestriction_InvalidClassName() throws Exception {
		doReturn(true).when(mTelephonyFeatureFlags).simultaneousCallingIndications();
		mComponentContextFixture.addConnectionService(makeQuickConnectionServiceComponentName(),
		Mockito.mock(IConnectionService.class));
		Set<PhoneAccountHandle> invalidElement = new HashSet<>(1);
		invalidElement.add(new PhoneAccountHandle(new ComponentName("pkg", INVALID_STR),
		TEST_ID));
		PhoneAccount invalidRestrictionPA = new PhoneAccount.Builder(
		makeQuickAccountHandle(TEST_ID), TEST_LABEL)
		.setSimultaneousCallingRestriction(invalidElement)
		.build();
		try {
		mRegistrar.registerPhoneAccount(invalidRestrictionPA);
		fail("should have hit class name size limit exception in "
		+ "enforceSimultaneousCallingRestrictionLimit");
		} catch (IllegalArgumentException e) {
		// pass test
		}
		}

		/**
		* Ensure an IllegalArgumentException is thrown when adding a PhoneAccountHandle where the
		* ID field is too large.
		*/
		@Test
		public void testLimitOnSimultaneousCallingRestriction_InvalidIdSize() throws Exception {
		doReturn(true).when(mTelephonyFeatureFlags).simultaneousCallingIndications();
		mComponentContextFixture.addConnectionService(makeQuickConnectionServiceComponentName(),
		Mockito.mock(IConnectionService.class));
		Set<PhoneAccountHandle> invalidIdElement = new HashSet<>(1);
		invalidIdElement.add(new PhoneAccountHandle(makeQuickConnectionServiceComponentName(),
		INVALID_STR));
		PhoneAccount invalidRestrictionPA = new PhoneAccount.Builder(
		makeQuickAccountHandle(TEST_ID), TEST_LABEL)
		.setSimultaneousCallingRestriction(invalidIdElement)
		.build();
		try {
		mRegistrar.registerPhoneAccount(invalidRestrictionPA);
		fail("should have hit ID size limit exception in "
		+ "enforceSimultaneousCallingRestrictionLimit");
		} catch (IllegalArgumentException e) {
		// pass test
		}
		}

		/**
		* Ensure an IllegalArgumentException is thrown when adding an address over the limit
		*/