Merge "[RCS] Enable RcsFeatureManager and update test case of... (a52d13b1) · Commits · e / os / android_frameworks_opt_telephony

src/java/com/android/internal/telephony/ImsSmsDispatcher.java

+14 −3

Original line number	Diff line number	Diff line
		@@ -33,6 +33,7 @@ import android.telephony.ims.stub.ImsSmsImplBase;
		import android.telephony.ims.stub.ImsSmsImplBase.SendStatusResult;
		import android.util.Pair;

		import com.android.ims.FeatureConnector;
		import com.android.ims.ImsException;
		import com.android.ims.ImsManager;
		import com.android.internal.annotations.VisibleForTesting;
		@@ -62,7 +63,7 @@ public class ImsSmsDispatcher extends SMSDispatcher {
		private volatile boolean mIsSmsCapable;
		private volatile boolean mIsImsServiceUp;
		private volatile boolean mIsRegistered;
		private final ImsManager.Connector mImsManagerConnector;
		private final FeatureConnector<ImsManager> mImsManagerConnector;
		/** Telephony metrics instance for logging metrics event */
		private TelephonyMetrics mMetrics = TelephonyMetrics.getInstance();

		@@ -233,8 +234,18 @@ public class ImsSmsDispatcher extends SMSDispatcher {
		public ImsSmsDispatcher(Phone phone, SmsDispatchersController smsDispatchersController) {
		super(phone, smsDispatchersController);

		mImsManagerConnector = new ImsManager.Connector(mContext, mPhone.getPhoneId(),
		new ImsManager.Connector.Listener() {
		mImsManagerConnector = new FeatureConnector<ImsManager>(mContext, mPhone.getPhoneId(),
		new FeatureConnector.Listener<ImsManager>() {
		@Override
		public boolean isSupported() {
		return ImsManager.isImsSupportedOnDevice(mContext);
		}

		@Override
		public ImsManager getFeatureManager() {
		return ImsManager.getInstance(mContext, phone.getPhoneId());
		}

		@Override
		public void connectionReady(ImsManager manager) throws ImsException {
		Rlog.d(TAG, "ImsManager: connection ready.");

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

+36 −0

Original line number	Diff line number	Diff line
		@@ -75,11 +75,13 @@ import android.telephony.ims.ImsReasonInfo;
		import android.telephony.ims.ImsSsInfo;
		import android.text.TextUtils;

		import com.android.ims.FeatureConnector;
		import com.android.ims.ImsEcbm;
		import com.android.ims.ImsEcbmStateListener;
		import com.android.ims.ImsException;
		import com.android.ims.ImsManager;
		import com.android.ims.ImsUtInterface;
		import com.android.ims.RcsFeatureManager;
		import com.android.internal.annotations.VisibleForTesting;
		import com.android.internal.telephony.Call;
		import com.android.internal.telephony.CallForwardInfo;
		@@ -197,6 +199,9 @@ public class ImsPhone extends ImsPhoneBase {
		@UnsupportedAppUsage
		private ServiceState mSS = new ServiceState();

		private RcsFeatureManager mRcsManager;
		private final FeatureConnector<RcsFeatureManager> mRcsManagerConnector;

		// To redial silently through GSM or CDMA when dialing through IMS fails
		private String mLastDialString;

		@@ -309,6 +314,35 @@ public class ImsPhone extends ImsPhoneBase {
		mDefaultPhone.registerForServiceStateChanged(this, EVENT_SERVICE_STATE_CHANGED, null);
		// Force initial roaming state update later, on EVENT_CARRIER_CONFIG_CHANGED.
		// Settings provider or CarrierConfig may not be loaded now.

		mRcsManagerConnector = new FeatureConnector<RcsFeatureManager>(mContext, mPhoneId,
		new FeatureConnector.Listener<RcsFeatureManager>() {
		@Override
		public boolean isSupported() {
		if (!ImsManager.isImsSupportedOnDevice(mContext)) {
		return false;
		}
		if (!RcsFeatureManager.isRcsUceSupportedByCarrier(mContext, mPhoneId)) {
		return false;
		}
		return true;
		}

		@Override
		public RcsFeatureManager getFeatureManager() {
		return new RcsFeatureManager(mContext, mPhoneId);
		}

		@Override
		public void connectionReady(RcsFeatureManager manager) throws ImsException {
		mRcsManager = manager;
		}

		@Override
		public void connectionUnavailable() {
		}
		}, mContext.getMainExecutor(), "ImsPhone");
		mRcsManagerConnector.connect();
		}

		//todo: get rid of this function. It is not needed since parentPhone obj never changes
		@@ -331,6 +365,8 @@ public class ImsPhone extends ImsPhoneBase {
		}
		mDefaultPhone.unregisterForServiceStateChanged(this);
		}

		mRcsManagerConnector.disconnect();
		}

		@UnsupportedAppUsage

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

+16 −4

Original line number	Diff line number	Diff line
		@@ -72,6 +72,7 @@ import android.util.ArrayMap;
		import android.util.Log;
		import android.util.Pair;

		import com.android.ims.FeatureConnector;
		import com.android.ims.ImsCall;
		import com.android.ims.ImsConfig;
		import com.android.ims.ImsConfigListener;
		@@ -526,7 +527,7 @@ public class ImsPhoneCallTracker extends CallTracker implements ImsPullCall {
		return PhoneNumberUtils.isEmergencyNumber(string);
		};

		private final ImsManager.Connector mImsManagerConnector;
		private final FeatureConnector<ImsManager> mImsManagerConnector;

		//***** Events

		@@ -561,8 +562,19 @@ public class ImsPhoneCallTracker extends CallTracker implements ImsPullCall {
		mVtDataUsageUidSnapshot = new NetworkStats(currentTime, 1);

		// Allow the executor to be specified for testing.
		mImsManagerConnector = new ImsManager.Connector(phone.getContext(), phone.getPhoneId(),
		new ImsManager.Connector.Listener() {
		mImsManagerConnector = new FeatureConnector<ImsManager>(
		phone.getContext(), phone.getPhoneId(),
		new FeatureConnector.Listener<ImsManager>() {
		@Override
		public boolean isSupported() {
		return ImsManager.isImsSupportedOnDevice(phone.getContext());
		}

		@Override
		public ImsManager getFeatureManager() {
		return ImsManager.getInstance(phone.getContext(), phone.getPhoneId());
		}

		@Override
		public void connectionReady(ImsManager manager) throws ImsException {
		mImsManager = manager;
		@@ -600,7 +612,7 @@ public class ImsPhoneCallTracker extends CallTracker implements ImsPullCall {
		* Test-only method used to set the ImsService retry timeout.
		*/
		@VisibleForTesting
		public void setRetryTimeout(ImsManager.Connector.RetryTimeout retryTimeout) {
		public void setRetryTimeout(FeatureConnector.RetryTimeout retryTimeout) {
		mImsManagerConnector.mRetryTimeout = retryTimeout;
		}

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

+18 −17

Original line number	Diff line number	Diff line
		@@ -55,8 +55,8 @@ public class FeatureConnectionTest extends TelephonyTest {
		private class TestFeatureConnection extends FeatureConnection {
		private Integer mFeatureState = ImsFeature.STATE_READY;

		public boolean ImsFeatureCreatedCalled = false;
		public boolean ImsFeatureRemovedCalled = false;
		public boolean isFeatureCreatedCalled = false;
		public boolean isFeatureRemovedCalled = false;
		public int mNewStatus = ImsFeature.STATE_UNAVAILABLE;

		TestFeatureConnection(Context context, int slotId, int featureType) {
		@@ -73,12 +73,12 @@ public class FeatureConnectionTest extends TelephonyTest {

		@Override
		protected void handleImsFeatureCreatedCallback(int slotId, int feature) {
		ImsFeatureCreatedCalled = true;
		isFeatureCreatedCalled = true;
		}

		@Override
		protected void handleImsFeatureRemovedCallback(int slotId, int feature) {
		ImsFeatureRemovedCalled = true;
		isFeatureRemovedCalled = true;
		}

		@Override
		@@ -97,7 +97,7 @@ public class FeatureConnectionTest extends TelephonyTest {
		};

		private int mPhoneId;
		private TestFeatureConnection mFeatureConnection;
		private TestFeatureConnection mTestFeatureConnection;
		@Mock IBinder mBinder;

		@Before
		@@ -108,9 +108,10 @@ public class FeatureConnectionTest extends TelephonyTest {
		doReturn(null).when(mContext).getMainLooper();
		doReturn(true).when(mPackageManager).hasSystemFeature(PackageManager.FEATURE_TELEPHONY_IMS);

		mFeatureConnection = new TestFeatureConnection(mContext, mPhoneId, ImsFeature.FEATURE_RCS);
		mFeatureConnection.mExecutor = mSimpleExecutor;
		mFeatureConnection.setBinder(mBinder);
		mTestFeatureConnection = new TestFeatureConnection(
		mContext, mPhoneId, ImsFeature.FEATURE_RCS);
		mTestFeatureConnection.mExecutor = mSimpleExecutor;
		mTestFeatureConnection.setBinder(mBinder);
		}

		@After
		@@ -125,10 +126,10 @@ public class FeatureConnectionTest extends TelephonyTest {
		@SmallTest
		public void testServiceIsReady() {
		when(mBinder.isBinderAlive()).thenReturn(true);
		mFeatureConnection.setFeatureState(ImsFeature.STATE_READY);
		mTestFeatureConnection.setFeatureState(ImsFeature.STATE_READY);

		try {
		mFeatureConnection.checkServiceIsReady();
		mTestFeatureConnection.checkServiceIsReady();
		} catch (RemoteException e) {
		throw new AssertionFailedError("Exception in testServiceIsReady: " + e);
		}
		@@ -144,7 +145,7 @@ public class FeatureConnectionTest extends TelephonyTest {
		when(mBinder.isBinderAlive()).thenReturn(false);

		try {
		mFeatureConnection.checkServiceIsReady();
		mTestFeatureConnection.checkServiceIsReady();
		throw new AssertionFailedError("testServiceIsNotReady: binder isn't alive");
		} catch (RemoteException e) {
		// expected result
		@@ -152,10 +153,10 @@ public class FeatureConnectionTest extends TelephonyTest {

		// IMS feature status is unavailable
		when(mBinder.isBinderAlive()).thenReturn(true);
		mFeatureConnection.setFeatureState(ImsFeature.STATE_UNAVAILABLE);
		mTestFeatureConnection.setFeatureState(ImsFeature.STATE_UNAVAILABLE);

		try {
		mFeatureConnection.checkServiceIsReady();
		mTestFeatureConnection.checkServiceIsReady();
		throw new AssertionFailedError("testServiceIsNotReady: status unavailable");
		} catch (RemoteException e) {
		// expected result
		@@ -168,25 +169,25 @@ public class FeatureConnectionTest extends TelephonyTest {
		@Test
		@SmallTest
		public void testListenerCallback() {
		IImsServiceFeatureCallback featureCallback = mFeatureConnection.getListener();
		IImsServiceFeatureCallback featureCallback = mTestFeatureConnection.getListener();

		try {
		featureCallback.imsFeatureCreated(anyInt(), anyInt());
		assertTrue(mFeatureConnection.ImsFeatureCreatedCalled);
		assertTrue(mTestFeatureConnection.isFeatureCreatedCalled);
		} catch (RemoteException e) {
		throw new AssertionFailedError("testListenerCallback(Created): " + e);
		}

		try {
		featureCallback.imsFeatureRemoved(anyInt(), anyInt());
		assertTrue(mFeatureConnection.ImsFeatureRemovedCalled);
		assertTrue(mTestFeatureConnection.isFeatureRemovedCalled);
		} catch (RemoteException e) {
		throw new AssertionFailedError("testListenerCallback(Removed): " + e);
		}

		try {
		featureCallback.imsStatusChanged(anyInt(), anyInt(), ImsFeature.STATE_READY);
		assertEquals(mFeatureConnection.mNewStatus, ImsFeature.STATE_READY);
		assertEquals(mTestFeatureConnection.mNewStatus, ImsFeature.STATE_READY);
		} catch (RemoteException e) {
		throw new AssertionFailedError("testListenerCallback(Changed): " + e);
		}

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

0 → 100644

+148 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2019 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 com.android.internal.telephony.ims;

		import junit.framework.AssertionFailedError;

		import static org.mockito.ArgumentMatchers.anyObject;
		import static org.mockito.Mockito.never;
		import static org.mockito.Mockito.reset;
		import static org.mockito.Mockito.verify;
		import static org.mockito.Mockito.when;

		import android.os.HandlerThread;
		import android.os.Looper;
		import android.telephony.ims.feature.ImsFeature;
		import android.test.suitebuilder.annotation.SmallTest;

		import com.android.ims.FeatureConnector;
		import com.android.ims.ImsException;
		import com.android.ims.ImsManager;
		import com.android.internal.telephony.TelephonyTest;

		import org.junit.After;
		import org.junit.Before;
		import org.junit.Test;
		import org.mockito.Mock;

		import java.util.concurrent.Executor;

		public class FeatureConnectorTest extends TelephonyTest {

		private Executor mExecutor = new Executor() {
		@Override
		public void execute(Runnable r) {
		r.run();
		}
		};

		private HandlerThread mHandlerThread;
		private FeatureConnector<ImsManager> mFeatureConnector;
		@Mock
		ImsManager mImsManager;
		@Mock
		FeatureConnector.Listener<ImsManager> mListener;
		@Mock
		FeatureConnector.RetryTimeout mRetryTimeout;

		@Before
		public void setUp() throws Exception {
		super.setUp("FeatureConnectorTest");
		if (Looper.myLooper() == null) {
		Looper.prepare();
		}

		int phoneId = mPhone.getPhoneId();
		mHandlerThread = new HandlerThread("ConnectorHandlerThread");
		mHandlerThread.start();

		mFeatureConnector = new FeatureConnector<ImsManager>(mContext, phoneId,
		mListener, mExecutor, mHandlerThread.getLooper());
		mFeatureConnector.mListener = mListener;
		}

		@After
		public void tearDown() throws Exception {
		mHandlerThread.quit();
		super.tearDown();
		}

		@Test
		@SmallTest
		public void testConnect() {
		// ImsManager is supported on device
		when(mListener.isSupported()).thenReturn(true);
		when(mListener.getFeatureManager()).thenReturn(mImsManager);

		mFeatureConnector.connect();
		waitForHandlerAction(mFeatureConnector, 1000);

		// Verify that mListener will retrieve feature manager
		verify(mListener).getFeatureManager();

		reset(mListener);

		// ImsManager is NOT supported on device
		when(mListener.isSupported()).thenReturn(false);
		when(mListener.getFeatureManager()).thenReturn(mImsManager);

		mFeatureConnector.connect();
		waitForHandlerAction(mFeatureConnector, 1000);

		// Verify that mListener won't retrieve feature manager
		verify(mListener, never()).getFeatureManager();
		}

		@Test
		@SmallTest
		public void testDisconnect() {
		// Verify mListener will call connectionUnavailable if disconnect() is called.
		mFeatureConnector.disconnect();
		verify(mListener).connectionUnavailable();
		}

		@Test
		@SmallTest
		public void testNotifyStateChanged() {
		try {
		mFeatureConnector.mManager = mImsManager;
		when(mImsManager.getImsServiceState()).thenReturn(ImsFeature.STATE_READY);
		// Trigger status changed
		mFeatureConnector.mNotifyStatusChangedCallback.notifyStateChanged();
		// Verify NotifyReady is called
		verify(mListener).connectionReady(anyObject());
		} catch (ImsException e) {
		throw new AssertionFailedError("Exception in testNotifyStateChanged: " + e);
		}
		}

		@Test
		@SmallTest
		public void testRetryGetImsService() {
		mFeatureConnector.mManager = mImsManager;
		mFeatureConnector.mRetryTimeout = mRetryTimeout;

		when(mRetryTimeout.get()).thenReturn(1);
		when(mListener.getFeatureManager()).thenReturn(mImsManager);

		mFeatureConnector.retryGetImsService();
		waitForHandlerAction(mFeatureConnector, 2000);

		// Verify removeNotifyStatusChangedCallback will be called if ImsManager is not null.
		verify(mImsManager).removeNotifyStatusChangedCallback(anyObject());
		}
		}