android-13.0.0_r83/search

/*
 * Copyright (C) 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 android.telephony.ims.cts;

import android.app.Instrumentation;
import android.app.role.RoleManager;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.IBinder;
import android.telephony.cts.TelephonyUtils;
import android.telephony.cts.externalimsservice.ITestExternalImsService;
import android.telephony.cts.externalimsservice.TestExternalImsService;
import android.telephony.ims.feature.ImsFeature;
import android.telephony.ims.stub.ImsFeatureConfiguration;
import android.text.TextUtils;
import android.util.Log;
import android.util.SparseArray;

import androidx.test.platform.app.InstrumentationRegistry;

import com.android.compatibility.common.util.ShellIdentityUtils;

import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

/**
 * Connects The CTS test ImsService to the Telephony Framework.
 */
class ImsServiceConnector {

    private static final String TAG = "CtsImsServiceConnector";

    private static final String PACKAGE_NAME =
            InstrumentationRegistry.getInstrumentation().getTargetContext().getPackageName();
    private static final String EXTERNAL_PACKAGE_NAME =
            TestExternalImsService.class.getPackage().getName();

    private static final String COMMAND_BASE = "cmd phone ";
    private static final String COMMAND_SET_IMS_SERVICE = "ims set-ims-service ";
    private static final String COMMAND_GET_IMS_SERVICE = "ims get-ims-service ";
    private static final String COMMAND_CLEAR_SERVICE_OVERRIDE = "ims clear-ims-service-override";
    private static final String COMMAND_CARRIER_SERVICE_IDENTIFIER = "-c ";
    private static final String COMMAND_DEVICE_SERVICE_IDENTIFIER = "-d ";
    private static final String COMMAND_SLOT_IDENTIFIER = "-s ";
    private static final String COMMAND_FEATURE_IDENTIFIER = "-f ";
    private static final String COMMAND_ENABLE_IMS = "ims enable ";
    private static final String COMMAND_DISABLE_IMS = "ims disable ";
    private static final String COMMAND_SET_DEVICE_SINGLE_REGISTRATION_ENABLED =
            "src set-device-enabled ";
    private static final String COMMAND_GET_DEVICE_SINGLE_REGISTRATION_ENABLED =
            "src get-device-enabled";
    private static final String COMMAND_SET_CARRIER_SINGLE_REGISTRATION_ENABLED =
            "src set-carrier-enabled ";
    private static final String COMMAND_GET_CARRIER_SINGLE_REGISTRATION_ENABLED =
            "src get-carrier-enabled";
    private static final String COMMAND_REMOVE_EAB_CONTACT = "uce remove-eab-contact ";
    private static final String COMMAND_GET_UCE_ENABLED = "uce get-device-enabled";
    private static final String COMMAND_SET_UCE_ENABLED = "uce set-device-enabled ";
    private static final String COMMAND_REMOVE_UCE_REQUEST_DISALLOWED_STATUS =
            "uce remove-request-disallowed-status ";
    private static final String COMMAND_SET_CAPABILITY_REQUEST_TIMEOUT =
            "uce set-capabilities-request-timeout ";
    private static final String COMMAND_SET_TEST_MODE_ENABLED = "src set-test-enabled ";
    private static final String COMMAND_SET_D2D_ENABLED = "d2d set-device-support ";

    private boolean mIsTestTypeExecutor = false;

    public void setExecutorTestType(boolean type) {
        mIsTestTypeExecutor = type;
    }

    private class TestCarrierServiceConnection implements ServiceConnection {

        private final CountDownLatch mLatch;

        TestCarrierServiceConnection(CountDownLatch latch) {
            mLatch = latch;
        }

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            mCarrierService = ((TestImsService.LocalBinder) service).getService();
            mLatch.countDown();
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            mCarrierService = null;
        }
    }

    private class TestDeviceServiceConnection implements ServiceConnection {

        private final CountDownLatch mLatch;

        TestDeviceServiceConnection(CountDownLatch latch) {
            mLatch = latch;
        }

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            mExternalService = ITestExternalImsService.Stub.asInterface(service);
            mLatch.countDown();
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            mExternalService = null;
        }
    }

    public class Connection {

        private static final int CONNECTION_TYPE_IMS_SERVICE_DEVICE = 1;
        private static final int CONNECTION_TYPE_IMS_SERVICE_CARRIER = 2;
        private static final int CONNECTION_TYPE_DEFAULT_SMS_APP = 3;

        private boolean mIsServiceOverridden = false;
        private String mOrigMmTelServicePackage;
        private String mOrigRcsServicePackage;
        private String mOrigSmsPackage;
        private int mConnectionType;
        private int mSlotId;
        private SparseArray<String> mFeatureTypeToPackageOverrideMap = new SparseArray<>(2);
        Connection(int connectionType, int slotId) {
            mConnectionType = connectionType;
            mSlotId = slotId;
        }

        void clearPackage() throws Exception {
            mIsServiceOverridden = true;
            switch (mConnectionType) {
                case CONNECTION_TYPE_IMS_SERVICE_CARRIER: {
                    boolean unbindSent = setCarrierImsService("none");
                    if (unbindSent) waitForCarrierPackageUnbind();
                    break;
                }
                case CONNECTION_TYPE_IMS_SERVICE_DEVICE: {
                    boolean unbindSent = setDeviceImsService("");
                    if (unbindSent) waitForDevicePackageUnbind();
                    break;
                }
                case CONNECTION_TYPE_DEFAULT_SMS_APP: {
                    // We don't need to clear anything for default SMS app.
                    break;
                }
            }
        }

        void waitForCarrierPackageUnbind() {
            TestImsService carrierService = getCarrierService();
            if (carrierService == null) return;
            // First unbind the local services
            removeLocalCarrierServiceConnection();
            // Then wait for AOSP to unbind if there is still an active binding.
            boolean isBound = carrierService.isTelephonyBound();
            if (ImsUtils.VDBG) Log.i(TAG, "waitForCarrierPackageUnbind: isBound=" + isBound);
            if (isBound) {
                // Wait for telephony to unbind to local ImsService
                carrierService.waitForLatchCountdown(TestImsService.LATCH_ON_UNBIND);
            }
        }

        void waitForDevicePackageUnbind() throws Exception {
            // Wait until the ImsService unbinds
            ITestExternalImsService externalService = getExternalService();
            if (externalService == null) return;
            // First unbind the local services
            removeLocalExternalServiceConnection();
            // Then wait for AOSP to unbind if there is still an active binding.
            boolean isBound = externalService.isTelephonyBound();
            if (ImsUtils.VDBG) Log.i(TAG, "waitForDevicePackageUnbind: isBound=" + isBound);
            if (isBound) {
                // Wait for telephony to unbind to external ImsService
                externalService.waitForLatchCountdown(TestImsService.LATCH_ON_UNBIND);
            }
        }

        boolean overrideService(ImsFeatureConfiguration config) throws Exception {
            mIsServiceOverridden = true;
            switch (mConnectionType) {
                case CONNECTION_TYPE_IMS_SERVICE_CARRIER: {
                    return bindCarrierImsService(config, PACKAGE_NAME);
                }
                case CONNECTION_TYPE_IMS_SERVICE_DEVICE: {
                    return bindDeviceImsService(config, EXTERNAL_PACKAGE_NAME);
                }
                case CONNECTION_TYPE_DEFAULT_SMS_APP: {
                    return setDefaultSmsApp(PACKAGE_NAME);
                }
            }
            return false;
        }

        void restoreOriginalPackage() throws Exception {
            if (!mIsServiceOverridden) {
                return;
            }
            mIsServiceOverridden = false;

            if (mOrigRcsServicePackage == null) {
                mOrigRcsServicePackage = "";
            }

            if (mOrigMmTelServicePackage == null) {
                mOrigMmTelServicePackage = "";
            }

            switch (mConnectionType) {
                case CONNECTION_TYPE_IMS_SERVICE_CARRIER: {
                    clearCarrierImsServiceOverride();
                    break;
                }
                case CONNECTION_TYPE_IMS_SERVICE_DEVICE: {
                    setDeviceImsService(mOrigMmTelServicePackage, ImsFeature.FEATURE_MMTEL);
                    setDeviceImsService(mOrigRcsServicePackage, ImsFeature.FEATURE_RCS);
                    break;
                }
                case CONNECTION_TYPE_DEFAULT_SMS_APP: {
                    setDefaultSmsApp(mOrigSmsPackage);
                    break;
                }
            }
        }

        /**
         * @return true if the configuration set here still exists in telephony or false if it was
         * changed (due to something like a Phone process crash).
         */
        boolean checkConfigurationExists() throws Exception {
            boolean result = true;
            String mmTelPackage = mFeatureTypeToPackageOverrideMap.get(ImsFeature.FEATURE_MMTEL);
            String rcsPackage = mFeatureTypeToPackageOverrideMap.get(ImsFeature.FEATURE_RCS);
            switch (mConnectionType) {
                case CONNECTION_TYPE_IMS_SERVICE_CARRIER: {
                    result &= isPackageTheSame(mmTelPackage, getMmTelCarrierService());
                    result &= isPackageTheSame(rcsPackage, getRcsCarrierService());
                    break;
                }
                case CONNECTION_TYPE_IMS_SERVICE_DEVICE: {
                    result &= isPackageTheSame(mmTelPackage, getMmTelDeviceService());
                    result &= isPackageTheSame(rcsPackage, getRcsDeviceService());
                    break;
                }
                case CONNECTION_TYPE_DEFAULT_SMS_APP: {
                    break;
                }
            }
            return result;
        }

        private boolean isPackageTheSame(String pkgA, String pkgB) {
            if (TextUtils.isEmpty(pkgA) && TextUtils.isEmpty(pkgB)) {
                return true;
            }
            return TextUtils.equals(pkgA, pkgB);
        }

        private void storeOriginalPackage() throws Exception {
            switch (mConnectionType) {
                case CONNECTION_TYPE_IMS_SERVICE_CARRIER: {
                    mOrigMmTelServicePackage = getMmTelCarrierService();
                    mOrigRcsServicePackage = getRcsCarrierService();
                    break;
                }
                case CONNECTION_TYPE_IMS_SERVICE_DEVICE: {
                    mOrigMmTelServicePackage = getMmTelDeviceService();
                    mOrigRcsServicePackage = getRcsDeviceService();
                    break;
                }
                case CONNECTION_TYPE_DEFAULT_SMS_APP: {
                    mOrigSmsPackage = getDefaultSmsApp();
                    break;
                }
            }
        }

        private boolean setDeviceImsService(String packageName) throws Exception {
            mFeatureTypeToPackageOverrideMap.put(ImsFeature.FEATURE_MMTEL, packageName);
            mFeatureTypeToPackageOverrideMap.put(ImsFeature.FEATURE_RCS, packageName);
            String result = TelephonyUtils.executeShellCommand(mInstrumentation,
                    constructSetImsServiceOverrideCommand(false, packageName, new int[] {
                            ImsFeature.FEATURE_MMTEL, ImsFeature.FEATURE_RCS}));
            if (ImsUtils.VDBG) {
                Log.d(TAG, "setDeviceMmTelImsService result: " + result);
            }
            return "true".equals(result);
        }

        private boolean setCarrierImsService(String packageName) throws Exception {
            mFeatureTypeToPackageOverrideMap.put(ImsFeature.FEATURE_MMTEL, packageName);
            mFeatureTypeToPackageOverrideMap.put(ImsFeature.FEATURE_RCS, packageName);
            String result = TelephonyUtils.executeShellCommand(mInstrumentation,
                    constructSetImsServiceOverrideCommand(true, packageName, new int[] {
                            ImsFeature.FEATURE_EMERGENCY_MMTEL, ImsFeature.FEATURE_MMTEL,
                            ImsFeature.FEATURE_RCS}));
            if (ImsUtils.VDBG) {
                Log.d(TAG, "setCarrierMmTelImsService result: " + result);
            }
            return "true".equals(result);
        }

        private boolean setDeviceImsService(String packageName, int featureType) throws Exception {
            mFeatureTypeToPackageOverrideMap.put(featureType, packageName);
            String result = TelephonyUtils.executeShellCommand(mInstrumentation,
                    constructSetImsServiceOverrideCommand(false, packageName,
                            new int[]{featureType}));
            if (ImsUtils.VDBG) {
                Log.d(TAG, "setDeviceMmTelImsService result: " + result);
            }
            return "true".equals(result);
        }

        private boolean setCarrierImsService(String packageName, int featureType) throws Exception {
            mFeatureTypeToPackageOverrideMap.put(featureType, packageName);
            String result = TelephonyUtils.executeShellCommand(mInstrumentation,
                    constructSetImsServiceOverrideCommand(true, packageName,
                            new int[]{featureType}));
            if (ImsUtils.VDBG) {
                Log.d(TAG, "setCarrierMmTelImsService result: " + result);
            }
            return "true".equals(result);
        }

        private boolean clearCarrierImsServiceOverride() throws Exception {
            String result = TelephonyUtils.executeShellCommand(mInstrumentation,
                    constructClearCarrierImsServiceOverrideCommand());
            if (ImsUtils.VDBG) {
                Log.d(TAG, "clearCarrierImsServiceOverride result: " + result);
            }
            return "true".equals(result);
        }

        private boolean setDefaultSmsApp(String packageName) throws Exception {
            RoleManager roleManager = mInstrumentation.getContext()
                    .getSystemService(RoleManager.class);
            Boolean result;
            LinkedBlockingQueue<Boolean> queue = new LinkedBlockingQueue<>(1);
            if (TextUtils.isEmpty(packageName)) {
                ShellIdentityUtils.invokeMethodWithShellPermissionsNoReturn(roleManager,
                        (m) -> m.clearRoleHoldersAsUser(RoleManager.ROLE_SMS,
                                RoleManager.MANAGE_HOLDERS_FLAG_DONT_KILL_APP,
                                android.os.Process.myUserHandle(),
                                // Run on calling binder thread.
                                Runnable::run, queue::offer));
            } else {
                ShellIdentityUtils.invokeMethodWithShellPermissionsNoReturn(roleManager,
                        (m) -> m.addRoleHolderAsUser(RoleManager.ROLE_SMS, packageName, 0,
                                android.os.Process.myUserHandle(),
                                // Run on calling binder thread.
                                Runnable::run, queue::offer));
            }
            result = queue.poll(ImsUtils.TEST_TIMEOUT_MS, TimeUnit.MILLISECONDS);
            if (ImsUtils.VDBG) {
                Log.d(TAG, "setDefaultSmsApp result: " + result);
            }
            return result;
        }

        private String getDefaultSmsApp() throws Exception {
            RoleManager roleManager = mInstrumentation.getContext()
                    .getSystemService(RoleManager.class);
            List<String> result = ShellIdentityUtils.invokeMethodWithShellPermissions(roleManager,
                    (m) -> m.getRoleHolders(RoleManager.ROLE_SMS));
            if (ImsUtils.VDBG) {
                Log.d(TAG, "getDefaultSmsApp result: " + result);
            }
            if (result.isEmpty()) {
                // No default SMS app.
                return null;
            }
            // There should only be one default sms app
            return result.get(0);
        }

        private boolean bindCarrierImsService(ImsFeatureConfiguration config, String packageName)
                throws Exception {
            getCarrierService().setFeatureConfig(config);
            return setCarrierImsService(packageName) && getCarrierService().waitForLatchCountdown(
                            TestImsService.LATCH_FEATURES_READY);
        }

        private boolean bindDeviceImsService(ImsFeatureConfiguration config, String packageName)
                throws Exception {
            getExternalService().setFeatureConfig(config);
            return setDeviceImsService(packageName) && getExternalService().waitForLatchCountdown(
                    TestImsService.LATCH_FEATURES_READY);
        }

        private String getMmTelCarrierService() throws Exception {
            String result = TelephonyUtils.executeShellCommand(mInstrumentation,
                    constructGetImsServiceCommand(true, ImsFeature.FEATURE_MMTEL));
            if (ImsUtils.VDBG) {
                Log.d(TAG, "getMmTelCarrierService result: " + result);
            }
            return result;
        }

        private String getRcsCarrierService() throws Exception {
            String result = TelephonyUtils.executeShellCommand(mInstrumentation,
                    constructGetImsServiceCommand(true, ImsFeature.FEATURE_RCS));
            if (ImsUtils.VDBG) {
                Log.d(TAG, "getRcsCarrierService result: " + result);
            }
            return result;
        }

        private String getMmTelDeviceService() throws Exception {
            String result = TelephonyUtils.executeShellCommand(mInstrumentation,
                    constructGetImsServiceCommand(false, ImsFeature.FEATURE_MMTEL));
            if (ImsUtils.VDBG) {
                Log.d(TAG, "getMmTelDeviceService result: " + result);
            }
            return result;
        }

        private String getRcsDeviceService() throws Exception {
            String result = TelephonyUtils.executeShellCommand(mInstrumentation,
                    constructGetImsServiceCommand(false, ImsFeature.FEATURE_RCS));
            if (ImsUtils.VDBG) {
                Log.d(TAG, "getRcsDeviceService result: " + result);
            }
            return result;
        }

        private String constructSetImsServiceOverrideCommand(boolean isCarrierService,
                String packageName, int[] featureTypes) {
            return COMMAND_BASE + COMMAND_SET_IMS_SERVICE + COMMAND_SLOT_IDENTIFIER + mSlotId + " "
                    + (isCarrierService
                        ? COMMAND_CARRIER_SERVICE_IDENTIFIER : COMMAND_DEVICE_SERVICE_IDENTIFIER)
                    + COMMAND_FEATURE_IDENTIFIER + getFeatureTypesString(featureTypes) + " "
                    + packageName;
        }

        private String constructGetImsServiceCommand(boolean isCarrierService, int featureType) {
            return COMMAND_BASE + COMMAND_GET_IMS_SERVICE + COMMAND_SLOT_IDENTIFIER + mSlotId + " "
                    + (isCarrierService
                        ? COMMAND_CARRIER_SERVICE_IDENTIFIER : COMMAND_DEVICE_SERVICE_IDENTIFIER)
                    + COMMAND_FEATURE_IDENTIFIER + featureType;
        }

        private String constructClearCarrierImsServiceOverrideCommand() {
            return COMMAND_BASE + COMMAND_CLEAR_SERVICE_OVERRIDE + COMMAND_SLOT_IDENTIFIER
                    + mSlotId;
        }

        private String getFeatureTypesString(int[] featureTypes) {
            if (featureTypes.length == 0) return "";
            StringBuilder builder = new StringBuilder();
            builder.append(featureTypes[0]);
            for (int i = 1; i < featureTypes.length; i++) {
                builder.append(",");
                builder.append(featureTypes[i]);
            }
            return builder.toString();
        }
    }

    private Instrumentation mInstrumentation;

    private TestImsService mCarrierService;
    private TestCarrierServiceConnection mCarrierServiceConn;
    private ITestExternalImsService mExternalService;
    private TestDeviceServiceConnection mExternalServiceConn;

    private Connection mDeviceServiceConnection;
    private Connection mCarrierServiceConnection;
    private Connection mDefaultSmsAppConnection;

    ImsServiceConnector(Instrumentation instrumentation) {
        mInstrumentation = instrumentation;
    }

    void clearAllActiveImsServices(int slotId) throws Exception {
        mDeviceServiceConnection = new Connection(Connection.CONNECTION_TYPE_IMS_SERVICE_DEVICE,
                slotId);
        mDeviceServiceConnection.storeOriginalPackage();
        mDeviceServiceConnection.clearPackage();

        mCarrierServiceConnection = new Connection(Connection.CONNECTION_TYPE_IMS_SERVICE_CARRIER,
                slotId);
        mCarrierServiceConnection.storeOriginalPackage();
        mCarrierServiceConnection.clearPackage();

        mDefaultSmsAppConnection = new Connection(Connection.CONNECTION_TYPE_DEFAULT_SMS_APP,
                slotId);
        mDefaultSmsAppConnection.storeOriginalPackage();
        // No need to clear SMS App, only replace when necessary.
    }

    /**
     * Binds to the local implementation of ImsService but does not trigger ImsService bind from
     * telephony to allow additional configuration steps.
     * @return true if this request succeeded, false otherwise.
     */
    boolean connectCarrierImsServiceLocally() {
        if (!setupLocalCarrierImsService()) {
            Log.w(TAG, "connectCarrierImsService: couldn't set up service.");
            return false;
        }
        mCarrierService.resetState();
        if (mIsTestTypeExecutor) {
            mCarrierService.setExecutorTestType(mIsTestTypeExecutor);
            // reset the mIsTestTypeExecutor value
            mIsTestTypeExecutor = false;
        }
        return true;
    }

    /**
     * Trigger the telephony framework to bind to the local ImsService implementation.
     * @return true if this request succeeded, false otherwise.
     */
    boolean triggerFrameworkConnectionToCarrierImsService(
            ImsFeatureConfiguration config) throws Exception {
        return mCarrierServiceConnection.overrideService(config);
    }

    boolean connectCarrierImsService(ImsFeatureConfiguration config) throws Exception {
        if (!connectCarrierImsServiceLocally()) return false;
        return triggerFrameworkConnectionToCarrierImsService(config);
    }

    boolean connectDeviceImsService(ImsFeatureConfiguration config) throws Exception {
        if (!setupExternalImsService()) {
            Log.w(TAG, "connectDeviceImsService: couldn't set up service.");
            return false;
        }
        mExternalService.resetState();
        return mDeviceServiceConnection.overrideService(config);
    }

    boolean setDefaultSmsApp() throws Exception {
        return mDefaultSmsAppConnection.overrideService(null);
    }

    void restoreDefaultSmsApp() throws Exception {
        mDefaultSmsAppConnection.restoreOriginalPackage();
    }

    void disconnectCarrierImsService() throws Exception {
        mCarrierServiceConnection.clearPackage();
    }

    void disconnectDeviceImsService() throws Exception {
        mDeviceServiceConnection.clearPackage();
    }

    boolean isCarrierServiceStillConfigured() throws Exception {
        return mCarrierServiceConnection.checkConfigurationExists();
    }

    private boolean setupLocalCarrierImsService() {
        if (mCarrierService != null) {
            return true;
        }
        CountDownLatch latch = new CountDownLatch(1);
        mCarrierServiceConn = new TestCarrierServiceConnection(latch);
        mInstrumentation.getContext().bindService(new Intent(mInstrumentation.getContext(),
                        TestImsService.class), mCarrierServiceConn, Context.BIND_AUTO_CREATE);
        try {
            return latch.await(5000, TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            return false;
        }
    }

    private boolean setupExternalImsService() {
        if (mExternalService != null) {
            return true;
        }
        CountDownLatch latch = new CountDownLatch(1);
        mExternalServiceConn = new TestDeviceServiceConnection(latch);
        Intent deviceIntent = new Intent();
        deviceIntent.setComponent(new ComponentName(EXTERNAL_PACKAGE_NAME,
                TestExternalImsService.class.getName()));
        mInstrumentation.getContext().bindService(deviceIntent, mExternalServiceConn,
                Context.BIND_AUTO_CREATE);
        try {
            return latch.await(5000, TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            return false;
        }
    }

    void removeLocalCarrierServiceConnection() {
        if (mCarrierServiceConn != null) {
            mInstrumentation.getContext().unbindService(mCarrierServiceConn);
            mCarrierServiceConn = null;
            mCarrierService = null;
        }
    }

    void removeLocalExternalServiceConnection() {
        if (mExternalServiceConn != null) {
            mInstrumentation.getContext().unbindService(mExternalServiceConn);
            mExternalServiceConn = null;
            mExternalService = null;
        }
    }

    // Detect and disconnect all active services.
    void disconnectServices() throws Exception {
        // Remove local connections
        removeLocalCarrierServiceConnection();
        removeLocalExternalServiceConnection();
        mDeviceServiceConnection.restoreOriginalPackage();
        mCarrierServiceConnection.restoreOriginalPackage();
        mDefaultSmsAppConnection.restoreOriginalPackage();

        // Remove any overrides for single registration state
        setDeviceSingleRegistrationEnabled(null);
    }

    void enableImsService(int slot) throws Exception {
        TelephonyUtils.executeShellCommand(mInstrumentation, COMMAND_BASE + COMMAND_ENABLE_IMS
                + COMMAND_SLOT_IDENTIFIER + slot);
    }

    void disableImsService(int slot) throws Exception {
        TelephonyUtils.executeShellCommand(mInstrumentation, COMMAND_BASE + COMMAND_DISABLE_IMS
                + COMMAND_SLOT_IDENTIFIER + slot);
    }

    void setDeviceSingleRegistrationEnabled(Boolean enabled) throws Exception {
        TelephonyUtils.executeShellCommand(mInstrumentation, COMMAND_BASE
                + COMMAND_SET_DEVICE_SINGLE_REGISTRATION_ENABLED
                // if "null" is sent, it will remove override
                + (enabled != null ? enabled : "null"));
    }

    boolean getDeviceSingleRegistrationEnabled() throws Exception {
        return Boolean.parseBoolean(TelephonyUtils.executeShellCommand(mInstrumentation,
                COMMAND_BASE + COMMAND_GET_DEVICE_SINGLE_REGISTRATION_ENABLED));
    }

    boolean getCarrierSingleRegistrationEnabled() throws Exception {
        return Boolean.parseBoolean(TelephonyUtils.executeShellCommand(mInstrumentation,
                COMMAND_BASE + COMMAND_GET_CARRIER_SINGLE_REGISTRATION_ENABLED));
    }

    boolean getDeviceUceEnabled() throws Exception {
        return Boolean.parseBoolean(TelephonyUtils.executeShellCommand(mInstrumentation,
                COMMAND_BASE + COMMAND_GET_UCE_ENABLED));
    }

    void setDeviceUceEnabled(boolean isEnabled) throws Exception {
        TelephonyUtils.executeShellCommand(mInstrumentation,
                COMMAND_BASE + COMMAND_SET_UCE_ENABLED + isEnabled);
    }

    void removeEabContacts(int slotId, String phoneNum) throws Exception {
        StringBuilder cmdBuilder = new StringBuilder();
        cmdBuilder.append(COMMAND_BASE).append(COMMAND_REMOVE_EAB_CONTACT)
                .append(COMMAND_SLOT_IDENTIFIER).append(slotId).append(" ").append(phoneNum);
        TelephonyUtils.executeShellCommand(mInstrumentation, cmdBuilder.toString());
    }

    TestImsService getCarrierService() {
        return mCarrierService;
    }

    ITestExternalImsService getExternalService() {
        return mExternalService;
    }

    void setSingleRegistrationTestModeEnabled(boolean enabled) throws Exception {
        TelephonyUtils.executeShellCommand(mInstrumentation, COMMAND_BASE
                + COMMAND_SET_TEST_MODE_ENABLED  + (enabled ? "true" : "false"));
    }

    void removeUceRequestDisallowedStatus(int slotId) throws Exception {
        StringBuilder cmdBuilder = new StringBuilder();
        cmdBuilder.append(COMMAND_BASE).append(COMMAND_REMOVE_UCE_REQUEST_DISALLOWED_STATUS)
                .append(COMMAND_SLOT_IDENTIFIER).append(slotId);
        TelephonyUtils.executeShellCommand(mInstrumentation, cmdBuilder.toString());
    }

    void setCapabilitiesRequestTimeout(int slotId, long timeoutAfterMs) throws Exception {
        StringBuilder cmdBuilder = new StringBuilder();
        cmdBuilder.append(COMMAND_BASE).append(COMMAND_SET_CAPABILITY_REQUEST_TIMEOUT)
                .append(COMMAND_SLOT_IDENTIFIER).append(slotId).append(" ").append(timeoutAfterMs);
        TelephonyUtils.executeShellCommand(mInstrumentation, cmdBuilder.toString());
    }

    void setDeviceToDeviceCommunicationEnabled(boolean enabled) throws Exception {
        TelephonyUtils.executeShellCommand(mInstrumentation, COMMAND_BASE
                + COMMAND_SET_D2D_ENABLED  + (enabled ? "true" : "default"));
    }
}