Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit c112be0d authored by James.cf Lin's avatar James.cf Lin
Browse files

[RCS] Enable RcsFeatureManager and update test case of enabling/Disabling UCE... 

[RCS] Enable RcsFeatureManager and update test case of enabling/Disabling UCE capability when RcsFeature created

Bug: 139260798
Test: atest RcsFeatureManagerTest; atest RcsFeatureConnection; atest FeatureConnectorTest; atest ImsPhoneTest; atest ImsPhoneCallTrackerTest
Change-Id: I1ad8e849f92ee46800ae4060fc1fcc8817638888
parent 994446c6

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());

    }

}