Merge "[RCS] Add getRcsManager method in ImsPhone for phone process to access... (f65a10b7) · Commits · e / os / android_frameworks_opt_telephony

src/java/com/android/internal/telephony/imsphone/ImsPhone.java

+14 −2

Original line number	Diff line number	Diff line
		@@ -372,6 +372,11 @@ public class ImsPhone extends ImsPhoneBase {
		mRcsManagerConnector.disconnect();
		mRcsManagerConnector = null;
		}

		if (mRcsManager != null) {
		mRcsManager.release();
		mRcsManager = null;
		}
		}

		private BroadcastReceiver mCarrierConfigChangedReceiver = new BroadcastReceiver() {
		@@ -416,18 +421,19 @@ public class ImsPhone extends ImsPhoneBase {

		@Override
		public RcsFeatureManager getFeatureManager() {
		logd("Create RcsFeatureManager instance");
		return new RcsFeatureManager(mContext, mPhoneId);
		}

		@Override
		public void connectionReady(RcsFeatureManager manager) throws ImsException {
		logd("RcsFeatureManager is ready");
		logi("RcsFeatureManager is ready");
		mRcsManager = manager;
		}

		@Override
		public void connectionUnavailable() {
		logd("RcsFeatureManager is unavailable");
		logi("RcsFeatureManager is unavailable");
		mRcsManager = null;
		}
		};
		@@ -437,6 +443,10 @@ public class ImsPhone extends ImsPhoneBase {
		mRcsManagerConnector.connect();
		}

		public RcsFeatureManager getRcsManager() {
		return mRcsManager;
		}

		@UnsupportedAppUsage
		@Override
		public ServiceState getServiceState() {
		@@ -1657,6 +1667,8 @@ public class ImsPhone extends ImsPhoneBase {
		if (DBG) logd("EVENT_CARRIER_CONFIG_CHANGED");
		if (mRcsManager == null) {
		initRcsFeatureManager();
		} else {
		mRcsManager.updateCapabilities();
		}
		break;

tests/telephonytests/src/com/android/internal/telephony/ims/MmTelFeatureConnectionTest.java

+2 −2

Original line number	Diff line number	Diff line
		@@ -34,7 +34,7 @@ import android.telephony.SubscriptionInfo;
		import android.telephony.SubscriptionManager;
		import android.test.suitebuilder.annotation.SmallTest;

		import com.android.ims.MmTelFeatureConnection;
		import com.android.ims.ImsCallbackAdapterManager;
		import com.android.internal.telephony.TelephonyTest;

		import org.junit.After;
		@@ -55,7 +55,7 @@ public class MmTelFeatureConnectionTest extends TelephonyTest {
		}

		private class CallbackManagerTest extends
		MmTelFeatureConnection.CallbackAdapterManager<TestCallback> {
		ImsCallbackAdapterManager<TestCallback> {

		List<TestCallback> mCallbacks = new ArrayList<>();

tests/telephonytests/src/com/android/internal/telephony/ims/RcsFeatureConnectionTest.java

+52 −34

Original line number	Diff line number	Diff line
		@@ -19,13 +19,17 @@ package com.android.internal.telephony.ims;
		import junit.framework.AssertionFailedError;

		import static org.junit.Assert.assertNotNull;
		import static org.mockito.Matchers.any;
		import static org.mockito.Matchers.anyInt;
		import static org.mockito.Mockito.doReturn;
		import static org.mockito.Mockito.mock;
		import static org.mockito.Mockito.spy;
		import static org.mockito.Mockito.verify;
		import static org.mockito.Mockito.when;

		import android.content.Context;
		import android.content.pm.PackageManager;
		import android.net.Uri;
		import android.os.IBinder;
		import android.os.RemoteException;
		import android.telephony.SubscriptionManager;
		import android.telephony.ims.RcsContactUceCapability;
		@@ -118,11 +122,7 @@ public class RcsFeatureConnectionTest extends TelephonyTest {
		private int mPhoneId;
		private SubscriptionManager mSubscriptionManager;
		private RcsFeatureConnection mRcsFeatureConnection;

		@Mock
		RcsFeatureConnection.RcsFeatureManagerProxy mRcsFeatureManagerProxy;
		@Mock
		RcsFeatureConnection.IRcsFeatureUpdate mCallback;
		@Mock private RcsFeatureConnection.IRcsFeatureUpdate mCallback;

		@Before
		public void setUp() throws Exception {
		@@ -151,8 +151,6 @@ public class RcsFeatureConnectionTest extends TelephonyTest {
		@Test
		@SmallTest
		public void testServiceIsReady() {
		// RCS UCE is supported by carrier
		setRcsUceIsSupportedByCarrier(true);
		try {
		mRcsFeatureConnection.checkServiceIsReady();
		} catch (RemoteException e) {
		@@ -160,35 +158,12 @@ public class RcsFeatureConnectionTest extends TelephonyTest {
		}
		}

		/**
		* Test that RcsFeatureConnection is not ready when RCS UCE is not supported carrier.
		*/
		@Test
		@SmallTest
		public void testServiceIsNotSupportedByCarrier() {
		// RCS UCE feature is NOT supported by carrier
		setRcsUceIsSupportedByCarrier(false);
		try {
		mRcsFeatureConnection.checkServiceIsReady();
		throw new AssertionFailedError("Exception in testServiceIsNotSupportedByCarrier");
		} catch (RemoteException e) {
		//expected result
		}
		}

		private void setRcsUceIsSupportedByCarrier(boolean isSupported) {
		when(mRcsFeatureManagerProxy.isRcsUceSupportedByCarrier(mContext, 0))
		.thenReturn(isSupported);
		RcsFeatureConnection.setRcsFeatureManagerProxy(mRcsFeatureManagerProxy);
		}

		/**
		* Test that service is not ready after IMS feature is removed.
		*/
		@Test
		@SmallTest
		public void testImsFeatureRemoved() {
		setRcsUceIsSupportedByCarrier(true);
		IImsServiceFeatureCallback imsServiceCallback = mRcsFeatureConnection.getListener();
		try {
		imsServiceCallback.imsFeatureRemoved(0, ImsFeature.FEATURE_RCS);
		@@ -205,7 +180,6 @@ public class RcsFeatureConnectionTest extends TelephonyTest {
		@Test
		@SmallTest
		public void testImsStatusIsUnavailable() {
		setRcsUceIsSupportedByCarrier(true);
		IImsServiceFeatureCallback imsServiceCallback = mRcsFeatureConnection.getListener();
		try {
		imsServiceCallback.imsStatusChanged(0, ImsFeature.FEATURE_RCS,
		@@ -223,7 +197,6 @@ public class RcsFeatureConnectionTest extends TelephonyTest {
		@Test
		@SmallTest
		public void testImsStatusUnavailableOnDifferentSlot() {
		setRcsUceIsSupportedByCarrier(true);
		IImsServiceFeatureCallback imsServiceCallback = mRcsFeatureConnection.getListener();
		try {
		imsServiceCallback.imsFeatureRemoved(1, ImsFeature.FEATURE_RCS);
		@@ -239,7 +212,6 @@ public class RcsFeatureConnectionTest extends TelephonyTest {
		@Test
		@SmallTest
		public void testImsStatusUnavailableOnDifferentFeature() {
		setRcsUceIsSupportedByCarrier(true);
		IImsServiceFeatureCallback imsServiceCallback = mRcsFeatureConnection.getListener();
		try {
		imsServiceCallback.imsFeatureRemoved(1, ImsFeature.FEATURE_MMTEL);
		@@ -270,4 +242,50 @@ public class RcsFeatureConnectionTest extends TelephonyTest {
		ImsFeature.STATE_READY);
		verify(mCallback).notifyStateChanged();
		}

		@Test
		@SmallTest
		public void testCapabilityStatusQuery() throws Exception {
		RcsFeatureConnection featureConnection = spy(mRcsFeatureConnection);
		IImsRcsFeature imsRcsFeature = mock(IImsRcsFeature.class);

		doReturn(true).when(featureConnection).isBinderReady();
		doReturn(imsRcsFeature).when(featureConnection).getServiceInterface(any(IBinder.class));

		featureConnection.queryCapabilityStatus();

		// Verify the IImsRcsFeature.queryCapabilityStatus API will call be called
		verify(imsRcsFeature).queryCapabilityStatus();
		}

		@Test
		@SmallTest
		public void testCabapilityCallbackRegistered() throws Exception {
		RcsFeatureConnection featureConnection = spy(mRcsFeatureConnection);
		IImsRcsFeature imsRcsFeature = mock(IImsRcsFeature.class);

		doReturn(true).when(featureConnection).isBinderReady();
		doReturn(imsRcsFeature).when(featureConnection).getServiceInterface(any(IBinder.class));

		// Verify the callback will be registered by the api IImsRcsFeature.addCapabilityCallback
		featureConnection.addCapabilityCallback(any());
		verify(imsRcsFeature).addCapabilityCallback(any());

		// Verify the callback will be removed by the api IImsRcsFeature.removeCapabilityCallback
		featureConnection.removeCapabilityCallback(any());
		verify(imsRcsFeature).removeCapabilityCallback(any());
		}

		@Test
		@SmallTest
		public void testCabapilityConfigurationQuery() throws Exception {
		RcsFeatureConnection featureConnection = spy(mRcsFeatureConnection);
		IImsRcsFeature imsRcsFeature = mock(IImsRcsFeature.class);

		doReturn(true).when(featureConnection).isBinderReady();
		doReturn(imsRcsFeature).when(featureConnection).getServiceInterface(any(IBinder.class));

		featureConnection.queryCapabilityConfiguration(anyInt(), anyInt(), any());
		verify(imsRcsFeature).queryCapabilityConfiguration(anyInt(), anyInt(), any());
		}
		}

tests/telephonytests/src/com/android/internal/telephony/ims/RcsFeatureManagerTest.java

+74 −10

Original line number	Diff line number	Diff line
		@@ -21,8 +21,13 @@ import junit.framework.AssertionFailedError;
		import static org.junit.Assert.assertEquals;
		import static org.junit.Assert.assertFalse;
		import static org.junit.Assert.assertTrue;
		import static org.mockito.ArgumentMatchers.any;
		import static org.mockito.ArgumentMatchers.anyInt;
		import static org.mockito.Matchers.eq;
		import static org.mockito.Mockito.anyObject;
		import static org.mockito.Mockito.doAnswer;
		import static org.mockito.Mockito.doReturn;
		import static org.mockito.Mockito.times;
		import static org.mockito.Mockito.verify;
		import static org.mockito.Mockito.when;

		@@ -30,11 +35,14 @@ import android.content.pm.PackageManager;
		import android.os.PersistableBundle;
		import android.os.RemoteException;
		import android.telephony.CarrierConfigManager;
		import android.telephony.ims.aidl.IImsCapabilityCallback;
		import android.telephony.ims.feature.RcsFeature.RcsImsCapabilities;
		import android.test.suitebuilder.annotation.SmallTest;

		import com.android.ims.ImsException;
		import com.android.ims.RcsFeatureConnection;
		import com.android.ims.RcsFeatureManager;
		import com.android.ims.RcsFeatureManager.RcsCapabilityCallbackManager;
		import com.android.internal.telephony.TelephonyTest;

		import org.junit.After;
		@@ -47,12 +55,10 @@ public class RcsFeatureManagerTest extends TelephonyTest {
		private int mPhoneId;
		private PersistableBundle mCarrierConfigBundle;
		private RcsFeatureManager mRcsFeatureManager;
		@Mock
		RcsFeatureConnection mRcsFeatureConnection;
		@Mock
		RcsFeatureConnection.IRcsFeatureUpdate mStatusCallback;
		@Mock
		RcsFeatureManager.SubscriptionManagerProxy mSubscriptionManagerProxy;
		@Mock RcsFeatureConnection mRcsFeatureConnection;
		@Mock RcsFeatureConnection.IRcsFeatureUpdate mStatusCallback;
		@Mock RcsCapabilityCallbackManager mCapabilityCallbackManager;
		@Mock RcsFeatureManager.SubscriptionManagerProxy mSubscriptionManagerProxy;

		@Before
		public void setUp() throws Exception {
		@@ -68,6 +74,7 @@ public class RcsFeatureManagerTest extends TelephonyTest {

		mRcsFeatureManager = new RcsFeatureManager(mContext, mPhoneId);
		mRcsFeatureManager.mRcsFeatureConnection = mRcsFeatureConnection;
		mRcsFeatureManager.mCapabilityCallbackManager = mCapabilityCallbackManager;
		}

		@After
		@@ -100,7 +107,7 @@ public class RcsFeatureManagerTest extends TelephonyTest {
		}

		/**
		* Test ImsFeature status can be add/remove successfully
		* Test ImsFeature status can be added and removed successfully
		*/
		@Test
		@SmallTest
		@@ -121,16 +128,73 @@ public class RcsFeatureManagerTest extends TelephonyTest {
		assertEquals(0, currentSize);
		}

		/**
		* Test IImsCapabilityCallback can be registered and unregistered
		*/
		@Test
		@SmallTest
		public void testImsCapabilityCallbackRegistered() throws Exception {
		// Verify ImsCapabilityCallback can be registered
		mRcsFeatureManager.registerRcsAvailabilityCallback(anyObject());
		verify(mCapabilityCallbackManager).addCallbackForSubscription(anyObject(), anyInt());

		// Verify ImsCapabilityCallback can be unregistered
		mRcsFeatureManager.unregisterRcsAvailabilityCallback(anyObject());
		verify(mCapabilityCallbackManager).removeCallbackForSubscription(anyObject(), anyInt());
		}

		@Test
		@SmallTest
		public void testIsCapableQuery() throws Exception {
		// Verify the result is true if OPTIONS is capable
		boolean result = callIsCapable(RcsImsCapabilities.CAPABILITY_TYPE_OPTIONS_UCE, true);
		assertTrue(result);

		// Verify the result is false if OPTIONS is incapable
		result = callIsCapable(RcsImsCapabilities.CAPABILITY_TYPE_OPTIONS_UCE, false);
		assertFalse(result);
		}

		private boolean callIsCapable(int capability, boolean enabled) throws Exception {
		doAnswer(invocation -> {
		IImsCapabilityCallback cb = (IImsCapabilityCallback) invocation.getArguments()[2];
		cb.onQueryCapabilityConfiguration(capability, 1, enabled);
		return null;
		}).when(mRcsFeatureConnection).queryCapabilityConfiguration(
		eq(capability), anyInt(), any());

		return mRcsFeatureManager.isCapable(capability, 1);
		}

		@Test
		@SmallTest
		public void testIsAvailableQuery() throws Exception {
		final int capabilityOptions = RcsImsCapabilities.CAPABILITY_TYPE_OPTIONS_UCE;
		final int capabilityPresence = RcsImsCapabilities.CAPABILITY_TYPE_PRESENCE_UCE;

		when(mRcsFeatureConnection.queryCapabilityStatus()).thenReturn(capabilityOptions);
		boolean result = mRcsFeatureManager.isAvailable(capabilityOptions);
		assertTrue(result);

		when(mRcsFeatureConnection.queryCapabilityStatus()).thenReturn(capabilityPresence);
		result = mRcsFeatureManager.isAvailable(capabilityPresence);
		assertTrue(result);

		result = mRcsFeatureManager.isAvailable(capabilityOptions);
		assertFalse(result);
		}

		@Test
		@SmallTest
		public void testChangeEnabledCapabilities() {
		// RCS UCE supported by carrier
		setIsSupportedByCarrier(true, true);
		// change enable UCE capability
		mRcsFeatureManager.changeEnabledCapabilitiesAfterRcsFeatureCreated();
		// update UCE capability
		mRcsFeatureManager.updateCapabilities();
		try {
		// verify the request "changeEnabledCapabilities" will be called
		verify(mRcsFeatureConnection).changeEnabledCapabilities(anyObject(), anyObject());
		verify(mRcsFeatureConnection, times(2)).changeEnabledCapabilities(anyObject(),
		anyObject());
		} catch (RemoteException e) {
		throw new AssertionFailedError("testChangeEnabledCapabilities: " + e);
		}