src/com/android/phone/ImsProvisioningController.java

/*
 * Copyright (C) 2021 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.phone;

import static android.telephony.ims.ImsRcsManager.CAPABILITY_TYPE_OPTIONS_UCE;
import static android.telephony.ims.ImsRcsManager.CAPABILITY_TYPE_PRESENCE_UCE;
import static android.telephony.ims.ProvisioningManager.KEY_EAB_PROVISIONING_STATUS;
import static android.telephony.ims.ProvisioningManager.KEY_VOICE_OVER_WIFI_ENABLED_OVERRIDE;
import static android.telephony.ims.ProvisioningManager.KEY_VOLTE_PROVISIONING_STATUS;
import static android.telephony.ims.ProvisioningManager.KEY_VT_PROVISIONING_STATUS;
import static android.telephony.ims.ProvisioningManager.PROVISIONING_VALUE_DISABLED;
import static android.telephony.ims.ProvisioningManager.PROVISIONING_VALUE_ENABLED;
import static android.telephony.ims.feature.ImsFeature.FEATURE_MMTEL;
import static android.telephony.ims.feature.ImsFeature.FEATURE_RCS;
import static android.telephony.ims.feature.MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_CALL_COMPOSER;
import static android.telephony.ims.feature.MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_SMS;
import static android.telephony.ims.feature.MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_UT;
import static android.telephony.ims.feature.MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VIDEO;
import static android.telephony.ims.feature.MmTelFeature.MmTelCapabilities.CAPABILITY_TYPE_VOICE;
import static android.telephony.ims.stub.ImsRegistrationImplBase.REGISTRATION_TECH_CROSS_SIM;
import static android.telephony.ims.stub.ImsRegistrationImplBase.REGISTRATION_TECH_IWLAN;
import static android.telephony.ims.stub.ImsRegistrationImplBase.REGISTRATION_TECH_LTE;
import static android.telephony.ims.stub.ImsRegistrationImplBase.REGISTRATION_TECH_MAX;
import static android.telephony.ims.stub.ImsRegistrationImplBase.REGISTRATION_TECH_NONE;
import static android.telephony.ims.stub.ImsRegistrationImplBase.REGISTRATION_TECH_NR;

import android.annotation.Nullable;
import android.content.Context;
import android.os.AsyncResult;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;
import android.os.PersistableBundle;
import android.os.RemoteCallbackList;
import android.os.RemoteException;
import android.telephony.CarrierConfigManager;
import android.telephony.CarrierConfigManager.Ims;
import android.telephony.SubscriptionManager;
import android.telephony.TelephonyRegistryManager;
import android.telephony.ims.ProvisioningManager;
import android.telephony.ims.aidl.IFeatureProvisioningCallback;
import android.telephony.ims.aidl.IImsConfig;
import android.telephony.ims.feature.MmTelFeature.MmTelCapabilities;
import android.telephony.ims.feature.RcsFeature.RcsImsCapabilities;
import android.telephony.ims.stub.ImsConfigImplBase;
import android.telephony.ims.stub.ImsRegistrationImplBase;
import android.util.SparseArray;

import com.android.ims.FeatureConnector;
import com.android.ims.ImsConfig;
import com.android.ims.ImsException;
import com.android.ims.ImsManager;
import com.android.ims.RcsFeatureManager;
import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.telephony.PhoneConfigurationManager;
import com.android.internal.telephony.util.HandlerExecutor;
import com.android.telephony.Rlog;

import java.util.Arrays;
import java.util.Map;
import java.util.concurrent.Executor;

/**
 * Provides APIs for MMTEL and RCS provisioning status. This class handles provisioning status and
 * notifies the status changing for each capability
 * {{@link MmTelCapabilities.MmTelCapability} for MMTel services}
 * {{@link RcsImsCapabilities.RcsImsCapabilityFlag} for RCS services}
 */
public class ImsProvisioningController {
    private static final String TAG = "ImsProvisioningController";
    private static final int INVALID_VALUE = -1;

    private static final int EVENT_SUB_CHANGED = 1;
    private static final int EVENT_PROVISIONING_CAPABILITY_CHANGED = 2;
    @VisibleForTesting
    protected static final int EVENT_MULTI_SIM_CONFIGURATION_CHANGE = 3;

    // Provisioning Keys that are handled via AOSP cache and not sent to the ImsService
    private static final int[] LOCAL_IMS_CONFIG_KEYS = {
            KEY_VOLTE_PROVISIONING_STATUS,
            KEY_VT_PROVISIONING_STATUS,
            KEY_VOICE_OVER_WIFI_ENABLED_OVERRIDE,
            KEY_EAB_PROVISIONING_STATUS
    };
    private static final int[] LOCAL_RADIO_TECHS = {
            REGISTRATION_TECH_LTE,
            REGISTRATION_TECH_IWLAN,
            REGISTRATION_TECH_CROSS_SIM,
            REGISTRATION_TECH_NR
    };

    private static final int MMTEL_CAPABILITY_MIN = MmTelCapabilities.CAPABILITY_TYPE_NONE;
    private static final int MMTEL_CAPABILITY_MAX = MmTelCapabilities.CAPABILITY_TYPE_MAX;

    private static final int RCS_CAPABILITY_MIN = RcsImsCapabilities.CAPABILITY_TYPE_NONE;
    private static final int RCS_CAPABILITY_MAX = RcsImsCapabilities.CAPABILITY_TYPE_MAX;

    private static final int[] LOCAL_MMTEL_CAPABILITY = {
            CAPABILITY_TYPE_VOICE,
            CAPABILITY_TYPE_VIDEO,
            CAPABILITY_TYPE_UT,
            CAPABILITY_TYPE_SMS,
            CAPABILITY_TYPE_CALL_COMPOSER
    };

    /**
     * map the MmTelCapabilities.MmTelCapability and
     * CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_VOICE_INT
     * CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_VIDEO_INT
     * CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_UT_INT
     * CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_SMS_INT
     * CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_CALL_COMPOSER_INT
     */
    private static final Map<Integer, String> KEYS_MMTEL_CAPABILITY = Map.of(
            CAPABILITY_TYPE_VOICE, Ims.KEY_CAPABILITY_TYPE_VOICE_INT_ARRAY,
            CAPABILITY_TYPE_VIDEO, Ims.KEY_CAPABILITY_TYPE_VIDEO_INT_ARRAY,
            CAPABILITY_TYPE_UT, Ims.KEY_CAPABILITY_TYPE_UT_INT_ARRAY,
            CAPABILITY_TYPE_SMS, Ims.KEY_CAPABILITY_TYPE_SMS_INT_ARRAY,
            CAPABILITY_TYPE_CALL_COMPOSER, Ims.KEY_CAPABILITY_TYPE_CALL_COMPOSER_INT_ARRAY
    );

    /**
     * map the RcsImsCapabilities.RcsImsCapabilityFlag and
     * CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_OPTIONS_UCE
     * CarrierConfigManager.Ims.KEY_CAPABILITY_TYPE_PRESENCE_UCE
     */
    private static final Map<Integer, String> KEYS_RCS_CAPABILITY = Map.of(
            CAPABILITY_TYPE_OPTIONS_UCE, Ims.KEY_CAPABILITY_TYPE_OPTIONS_UCE_INT_ARRAY,
            CAPABILITY_TYPE_PRESENCE_UCE, Ims.KEY_CAPABILITY_TYPE_PRESENCE_UCE_INT_ARRAY
    );

    /**
     * Create a FeatureConnector for this class to use to connect to an ImsManager.
     */
    @VisibleForTesting
    public interface MmTelFeatureConnector {
        /**
         * Create a FeatureConnector for this class to use to connect to an ImsManager.
         * @param listener will receive ImsManager instance.
         * @param executor that the Listener callbacks will be called on.
         * @return A FeatureConnector
         */
        FeatureConnector<ImsManager> create(Context context, int slotId,
                String logPrefix, FeatureConnector.Listener<ImsManager> listener,
                Executor executor);
    }

    /**
     * Create a FeatureConnector for this class to use to connect to an RcsFeatureManager.
     */
    @VisibleForTesting
    public interface RcsFeatureConnector {
        /**
         * Create a FeatureConnector for this class to use to connect to an RcsFeatureManager.
         * @param listener will receive RcsFeatureManager instance.
         * @param executor that the Listener callbacks will be called on.
         * @return A FeatureConnector
         */
        FeatureConnector<RcsFeatureManager> create(Context context, int slotId,
                FeatureConnector.Listener<RcsFeatureManager> listener,
                Executor executor, String logPrefix);
    }

    private static ImsProvisioningController sInstance;

    private final PhoneGlobals mApp;
    private final Handler mHandler;
    private final CarrierConfigManager mCarrierConfigManager;
    private final SubscriptionManager mSubscriptionManager;
    private final TelephonyRegistryManager mTelephonyRegistryManager;
    private final MmTelFeatureConnector mMmTelFeatureConnector;
    private final RcsFeatureConnector mRcsFeatureConnector;

    // maps a slotId to a list of MmTelFeatureListeners
    private final SparseArray<MmTelFeatureListener> mMmTelFeatureListenersSlotMap =
            new SparseArray<>();
    // maps a slotId to a list of RcsFeatureListeners
    private final SparseArray<RcsFeatureListener> mRcsFeatureListenersSlotMap =
            new SparseArray<>();
    // map a slotId to a list of ProvisioningCallbackManager
    private final SparseArray<ProvisioningCallbackManager> mProvisioningCallbackManagersSlotMap =
            new SparseArray<>();
    private final ImsProvisioningLoader mImsProvisioningLoader;

    private int mNumSlot;

    /**
     * This class contains the provisioning status to notify changes.
     * {{@link MmTelCapabilities.MmTelCapability} for MMTel services}
     * {{@link android.telephony.ims.ImsRcsManager.RcsImsCapabilityFlag} for RCS services}
     * {{@link ImsRegistrationImplBase.ImsRegistrationTech} for Registration tech}
     */
    private static final class FeatureProvisioningData {
        public final int mCapability;
        public final int mTech;
        public final boolean mProvisioned;
        public final boolean mIsMmTel;

        FeatureProvisioningData(int capability, int tech, boolean provisioned, boolean isMmTel) {
            mCapability = capability;
            mTech = tech;
            mProvisioned = provisioned;
            mIsMmTel = isMmTel;
        }
    }

    private final class MessageHandler extends Handler {
        private static final String LOG_PREFIX = "Handler";
        MessageHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case EVENT_SUB_CHANGED:
                    onSubscriptionsChanged();
                    break;
                case EVENT_PROVISIONING_CAPABILITY_CHANGED:
                    try {
                        mProvisioningCallbackManagersSlotMap.get(msg.arg1)
                                .notifyProvisioningCapabilityChanged(
                                        (FeatureProvisioningData) msg.obj);
                    } catch (NullPointerException e) {
                        logw(LOG_PREFIX, msg.arg1,
                                "can not find callback manager message" + msg.what);
                    }
                    break;
                case EVENT_MULTI_SIM_CONFIGURATION_CHANGE:
                    int activeModemCount = (int) ((AsyncResult) msg.obj).result;
                    onMultiSimConfigChanged(activeModemCount);
                    break;
                default:
                    log("unknown message " + msg);
                    break;
            }
        }
    }

    private final SubscriptionManager.OnSubscriptionsChangedListener mSubChangedListener =
            new SubscriptionManager.OnSubscriptionsChangedListener() {
                @Override
                public void onSubscriptionsChanged() {
                    if (!mHandler.hasMessages(EVENT_SUB_CHANGED)) {
                        mHandler.sendEmptyMessage(EVENT_SUB_CHANGED);
                    }
                }
            };

    private final class ProvisioningCallbackManager {
        private static final String LOG_PREFIX = "ProvisioningCallbackManager";
        private RemoteCallbackList<IFeatureProvisioningCallback> mIFeatureProvisioningCallbackList;
        private int mSubId;
        private int mSlotId;

        ProvisioningCallbackManager(int slotId) {
            mIFeatureProvisioningCallbackList =
                    new RemoteCallbackList<IFeatureProvisioningCallback>();
            mSlotId = slotId;
            mSubId = getSubId(slotId);
            log(LOG_PREFIX, mSlotId, "ProvisioningCallbackManager create");
        }

        public void clear() {
            log(LOG_PREFIX, mSlotId, "ProvisioningCallbackManager clear ");

            mIFeatureProvisioningCallbackList.kill();

            // All registered callbacks are unregistered, and the list is disabled
            // need to create again
            mIFeatureProvisioningCallbackList =
                    new RemoteCallbackList<IFeatureProvisioningCallback>();
        }

        public void registerCallback(IFeatureProvisioningCallback localCallback) {
            if (!mIFeatureProvisioningCallbackList.register(localCallback, (Object) mSubId)) {
                log(LOG_PREFIX, mSlotId, "registration callback fail");
            }
        }

        public void unregisterCallback(IFeatureProvisioningCallback localCallback) {
            mIFeatureProvisioningCallbackList.unregister(localCallback);
        }

        public void setSubId(int subId) {
            if (mSubId == subId) {
                log(LOG_PREFIX, mSlotId, "subId is not changed ");
                return;
            }

            mSubId = subId;
            mSlotId = getSlotId(subId);

            // subId changed means the registered callbacks are not available.
            clear();
        }

        public boolean hasCallblacks() {
            int size = mIFeatureProvisioningCallbackList.beginBroadcast();
            mIFeatureProvisioningCallbackList.finishBroadcast();

            return (size > 0);
        }

        public void notifyProvisioningCapabilityChanged(FeatureProvisioningData data) {
            int size = mIFeatureProvisioningCallbackList.beginBroadcast();
            for (int index = 0; index < size; index++) {
                try {
                    IFeatureProvisioningCallback imsFeatureProvisioningCallback =
                            mIFeatureProvisioningCallbackList.getBroadcastItem(index);

                    // MMTEL
                    if (data.mIsMmTel
                            && Arrays.stream(LOCAL_MMTEL_CAPABILITY)
                            .anyMatch(value -> value == data.mCapability)) {
                        imsFeatureProvisioningCallback.onFeatureProvisioningChanged(
                                data.mCapability, data.mTech, data.mProvisioned);
                        logi(LOG_PREFIX, mSlotId, "notifyProvisioningCapabilityChanged : "
                                + "onFeatureProvisioningChanged"
                                + " capability " + data.mCapability
                                + " tech "  + data.mTech
                                + " isProvisioned " + data.mProvisioned);
                    } else if (data.mCapability == CAPABILITY_TYPE_PRESENCE_UCE) {
                        imsFeatureProvisioningCallback.onRcsFeatureProvisioningChanged(
                                data.mCapability, data.mTech, data.mProvisioned);
                        logi(LOG_PREFIX, mSlotId, "notifyProvisioningCapabilityChanged : "
                                + "onRcsFeatureProvisioningChanged"
                                + " capability " + data.mCapability
                                + " tech "  + data.mTech
                                + " isProvisioned " + data.mProvisioned);
                    } else {
                        loge(LOG_PREFIX, mSlotId, "notifyProvisioningCapabilityChanged : "
                                + "unknown capability "
                                + data.mCapability);
                    }
                } catch (RemoteException e) {
                    loge(LOG_PREFIX, mSlotId,
                            "notifyProvisioningChanged: callback #" + index + " failed");
                }
            }
            mIFeatureProvisioningCallbackList.finishBroadcast();
        }
    }

    private final class MmTelFeatureListener implements FeatureConnector.Listener<ImsManager> {
        private static final String LOG_PREFIX = "MmTelFeatureListener";
        private FeatureConnector<ImsManager> mConnector;
        private ImsManager mImsManager;
        private boolean mReady = false;
        // stores whether the initial provisioning key value should be notified to ImsService
        private boolean mRequiredNotify = false;
        private int mSubId;
        private int mSlotId;

        MmTelFeatureListener(int slotId) {
            log(LOG_PREFIX, slotId, "created");

            mSlotId = slotId;
            mSubId = getSubId(slotId);
            mConnector = mMmTelFeatureConnector.create(
                    mApp, slotId, TAG, this, new HandlerExecutor(mHandler));
            mConnector.connect();
        }

        public void setSubId(int subId) {
            if (mRequiredNotify && mReady) {
                mRequiredNotify = false;
                setInitialProvisioningKeys(subId);
            }
            if (mSubId == subId) {
                log(LOG_PREFIX, mSlotId, "subId is not changed");
                return;
            }

            mSubId = subId;
            mSlotId = getSlotId(subId);
        }

        public void destroy() {
            log("destroy");
            mConnector.disconnect();
            mConnector = null;
            mReady = false;
            mImsManager = null;
        }

        public @Nullable ImsManager getImsManager() {
            return mImsManager;
        }

        @Override
        public void connectionReady(ImsManager manager, int subId) {
            log(LOG_PREFIX, mSlotId, "connection ready");
            mReady = true;
            mImsManager = manager;

            onMmTelAvailable();
        }

        @Override
        public void connectionUnavailable(int reason) {
            log(LOG_PREFIX, mSlotId, "connection unavailable " + reason);

            mReady = false;
            mImsManager = null;

            // keep the callback for other reason
            if (reason == FeatureConnector.UNAVAILABLE_REASON_IMS_UNSUPPORTED) {
                onMmTelUnavailable();
            }
        }

        public int setProvisioningValue(int key, int value) {
            int retVal = ImsConfigImplBase.CONFIG_RESULT_FAILED;

            if (!mReady) {
                loge(LOG_PREFIX, mSlotId, "service is Unavailable");
                return retVal;
            }
            try {
                // getConfigInterface() will return not null or throw the ImsException
                // need not null checking
                ImsConfig imsConfig = getImsConfig(mImsManager);
                retVal = imsConfig.setConfig(key, value);
                log(LOG_PREFIX, mSlotId, "setConfig called with key " + key + " value " + value);
            } catch (ImsException e) {
                logw(LOG_PREFIX, mSlotId,
                        "setConfig operation failed for key =" + key
                        + ", value =" + value + ". Exception:" + e.getMessage());
            }
            return retVal;
        }

        public int getProvisioningValue(int key) {
            if (!mReady) {
                loge(LOG_PREFIX, mSlotId, "service is Unavailable");
                return INVALID_VALUE;
            }

            int retValue = INVALID_VALUE;
            try {
                // getConfigInterface() will return not null or throw the ImsException
                // need not null checking
                ImsConfig imsConfig = getImsConfig(mImsManager);
                retValue = imsConfig.getConfigInt(key);
            } catch (ImsException e) {
                logw(LOG_PREFIX, mSlotId,
                        "getConfig operation failed for key =" + key
                        + ", value =" + retValue + ". Exception:" + e.getMessage());
            }
            return retValue;
        }

        public void onMmTelAvailable() {
            log(LOG_PREFIX, mSlotId, "onMmTelAvailable");

            if (isValidSubId(mSubId)) {
                mRequiredNotify = false;

                // notify provisioning key value to ImsService
                setInitialProvisioningKeys(mSubId);
            } else {
                // wait until subId is valid
                mRequiredNotify = true;
            }
        }

        public void onMmTelUnavailable() {
            log(LOG_PREFIX, mSlotId, "onMmTelUnavailable");

            try {
                // delete all callbacks reference from ProvisioningManager
                mProvisioningCallbackManagersSlotMap.get(getSlotId(mSubId)).clear();
            } catch (NullPointerException e) {
                logw(LOG_PREFIX, getSlotId(mSubId), "can not find callback manager to clear");
            }
        }

        private void setInitialProvisioningKeys(int subId) {
            boolean required;
            int value = ImsProvisioningLoader.STATUS_NOT_SET;

            // updating KEY_VOLTE_PROVISIONING_STATUS
            try {
                required = isImsProvisioningRequiredForCapability(subId, CAPABILITY_TYPE_VOICE,
                        REGISTRATION_TECH_LTE);
            } catch (IllegalArgumentException e) {
                logw("setInitialProvisioningKeys: KEY_VOLTE_PROVISIONING_STATUS failed for"
                        + " subId=" + subId + ", exception: " + e.getMessage());
                return;
            }

            log(LOG_PREFIX, mSlotId,
                    "setInitialProvisioningKeys provisioning required(voice, lte) " + required);
            if (required) {
                value = mImsProvisioningLoader.getProvisioningStatus(subId, FEATURE_MMTEL,
                        CAPABILITY_TYPE_VOICE, REGISTRATION_TECH_LTE);
                if (value != ImsProvisioningLoader.STATUS_NOT_SET) {
                    value = (value == ImsProvisioningLoader.STATUS_PROVISIONED)
                            ? PROVISIONING_VALUE_ENABLED : PROVISIONING_VALUE_DISABLED;
                    setProvisioningValue(KEY_VOLTE_PROVISIONING_STATUS, value);
                }
            }

            // updating KEY_VT_PROVISIONING_STATUS
            try {
                required = isImsProvisioningRequiredForCapability(subId, CAPABILITY_TYPE_VIDEO,
                        REGISTRATION_TECH_LTE);
            } catch (IllegalArgumentException e) {
                logw("setInitialProvisioningKeys: KEY_VT_PROVISIONING_STATUS failed for"
                        + " subId=" + subId + ", exception: " + e.getMessage());
                return;
            }

            log(LOG_PREFIX, mSlotId,
                    "setInitialProvisioningKeys provisioning required(video, lte) " + required);
            if (required) {
                value = mImsProvisioningLoader.getProvisioningStatus(subId, FEATURE_MMTEL,
                        CAPABILITY_TYPE_VIDEO, REGISTRATION_TECH_LTE);
                if (value != ImsProvisioningLoader.STATUS_NOT_SET) {
                    value = (value == ImsProvisioningLoader.STATUS_PROVISIONED)
                            ? PROVISIONING_VALUE_ENABLED : PROVISIONING_VALUE_DISABLED;
                    setProvisioningValue(KEY_VT_PROVISIONING_STATUS, value);
                }
            }

            // updating KEY_VOICE_OVER_WIFI_ENABLED_OVERRIDE
            try {
                required = isImsProvisioningRequiredForCapability(subId, CAPABILITY_TYPE_VOICE,
                        REGISTRATION_TECH_IWLAN);
            } catch (IllegalArgumentException e) {
                logw("setInitialProvisioningKeys: KEY_VOICE_OVER_WIFI_ENABLED_OVERRIDE failed"
                        + " for subId=" + subId + ", exception: " + e.getMessage());
                return;
            }

            log(LOG_PREFIX, mSlotId,
                    "setInitialProvisioningKeys provisioning required(voice, iwlan) " + required);
            if (required) {
                value = mImsProvisioningLoader.getProvisioningStatus(subId, FEATURE_MMTEL,
                        CAPABILITY_TYPE_VOICE, REGISTRATION_TECH_IWLAN);
                if (value != ImsProvisioningLoader.STATUS_NOT_SET) {
                    value = (value == ImsProvisioningLoader.STATUS_PROVISIONED)
                            ? PROVISIONING_VALUE_ENABLED : PROVISIONING_VALUE_DISABLED;
                    setProvisioningValue(KEY_VOICE_OVER_WIFI_ENABLED_OVERRIDE, value);
                }
            }
        }
    }

    private final class RcsFeatureListener implements FeatureConnector.Listener<RcsFeatureManager> {
        private static final String LOG_PREFIX = "RcsFeatureListener";
        private FeatureConnector<RcsFeatureManager> mConnector;
        private RcsFeatureManager mRcsFeatureManager;
        private boolean mReady = false;
        // stores whether the initial provisioning key value should be notified to ImsService
        private boolean mRequiredNotify = false;
        private int mSubId;
        private int mSlotId;

        RcsFeatureListener(int slotId) {
            log(LOG_PREFIX, slotId, "created");

            mSlotId = slotId;
            mSubId = getSubId(slotId);
            mConnector = mRcsFeatureConnector.create(
                    mApp, slotId, this, new HandlerExecutor(mHandler), TAG);
            mConnector.connect();
        }

        public void setSubId(int subId) {
            if (mRequiredNotify && mReady) {
                mRequiredNotify = false;
                setInitialProvisioningKeys(subId);
            }
            if (mSubId == subId) {
                log(LOG_PREFIX, mSlotId, "subId is not changed");
                return;
            }

            mSubId = subId;
            mSlotId = getSlotId(subId);
        }

        public void destroy() {
            log(LOG_PREFIX, mSlotId, "destroy");
            mConnector.disconnect();
            mConnector = null;
            mReady = false;
            mRcsFeatureManager = null;
        }

        @Override
        public void connectionReady(RcsFeatureManager manager, int subId) {
            log(LOG_PREFIX, mSlotId, "connection ready");
            mReady = true;
            mRcsFeatureManager = manager;

            onRcsAvailable();
        }

        @Override
        public void connectionUnavailable(int reason) {
            log(LOG_PREFIX, mSlotId, "connection unavailable");
            mReady = false;
            mRcsFeatureManager = null;

            // keep the callback for other reason
            if (reason == FeatureConnector.UNAVAILABLE_REASON_IMS_UNSUPPORTED) {
                onRcsUnavailable();
            }
        }

        public int setProvisioningValue(int key, int value) {
            int retVal = ImsConfigImplBase.CONFIG_RESULT_FAILED;

            if (!mReady) {
                loge(LOG_PREFIX, mSlotId, "service is Unavailable");
                return retVal;
            }

            try {
                // getConfigInterface() will return not null or throw the ImsException
                // need not null checking
                ImsConfig imsConfig = getImsConfig(mRcsFeatureManager.getConfig());
                retVal = imsConfig.setConfig(key, value);
                log(LOG_PREFIX, mSlotId, "setConfig called with key " + key + " value " + value);
            } catch (ImsException e) {
                logw(LOG_PREFIX, mSlotId,
                        "setConfig operation failed for key =" + key
                        + ", value =" + value + ". Exception:" + e.getMessage());
            }
            return retVal;
        }

        public int getProvisioningValue(int key) {
            if (!mReady) {
                loge(LOG_PREFIX, mSlotId, "service is Unavailable");
                return INVALID_VALUE;
            }

            int retValue = INVALID_VALUE;
            try {
                // getConfigInterface() will return not null or throw the ImsException
                // need not null checking
                ImsConfig imsConfig = getImsConfig(mRcsFeatureManager.getConfig());
                retValue = imsConfig.getConfigInt(key);
            } catch (ImsException e) {
                logw(LOG_PREFIX, mSlotId,
                        "getConfig operation failed for key =" + key
                        + ", value =" + retValue + ". Exception:" + e.getMessage());
            }
            return retValue;
        }

        public boolean isConnectionReady() {
            return mReady;
        }

        public void onRcsAvailable() {
            log(LOG_PREFIX, mSlotId, "onRcsAvailable");

            if (isValidSubId(mSubId)) {
                mRequiredNotify = false;

                // notify provisioning key value to ImsService
                setInitialProvisioningKeys(mSubId);
            } else {
                // wait until subId is valid
                mRequiredNotify = true;
            }
        }

        public void onRcsUnavailable() {
            log(LOG_PREFIX, mSlotId, "onRcsUnavailable");

            try {
                // delete all callbacks reference from ProvisioningManager
                mProvisioningCallbackManagersSlotMap.get(getSlotId(mSubId)).clear();
            } catch (NullPointerException e) {
                logw(LOG_PREFIX, getSlotId(mSubId), "can not find callback manager to clear");
            }
        }

        private void setInitialProvisioningKeys(int subId) {
            boolean required;
            int value = ImsProvisioningLoader.STATUS_NOT_SET;

            // KEY_EAB_PROVISIONING_STATUS
            int capability = CAPABILITY_TYPE_PRESENCE_UCE;
            // Assume that all radio techs have the same provisioning value
            int tech = REGISTRATION_TECH_LTE;

            try {
                required = isRcsProvisioningRequiredForCapability(subId, capability, tech);
            } catch (IllegalArgumentException e) {
                logw("setInitialProvisioningKeys: KEY_EAB_PROVISIONING_STATUS failed for"
                        + " subId=" + subId + ", exception: " + e.getMessage());
                return;
            }

            if (required) {
                value = mImsProvisioningLoader.getProvisioningStatus(subId, FEATURE_RCS,
                        capability, tech);
                if (value != ImsProvisioningLoader.STATUS_NOT_SET) {
                    value = (value == ImsProvisioningLoader.STATUS_PROVISIONED)
                            ? PROVISIONING_VALUE_ENABLED : PROVISIONING_VALUE_DISABLED;
                    setProvisioningValue(KEY_EAB_PROVISIONING_STATUS, value);
                }
            }
        }
    }

    /**
     * Do NOT use this directly, instead use {@link #getInstance()}.
     */
    @VisibleForTesting
    public ImsProvisioningController(PhoneGlobals app, int numSlot, Looper looper,
            MmTelFeatureConnector mmTelFeatureConnector, RcsFeatureConnector rcsFeatureConnector,
            ImsProvisioningLoader imsProvisioningLoader) {
        log("ImsProvisioningController");
        mApp = app;
        mNumSlot = numSlot;
        mHandler = new MessageHandler(looper);
        mMmTelFeatureConnector = mmTelFeatureConnector;
        mRcsFeatureConnector = rcsFeatureConnector;
        mCarrierConfigManager = mApp.getSystemService(CarrierConfigManager.class);
        mSubscriptionManager = mApp.getSystemService(SubscriptionManager.class);
        mTelephonyRegistryManager = mApp.getSystemService(TelephonyRegistryManager.class);
        mTelephonyRegistryManager.addOnSubscriptionsChangedListener(
                mSubChangedListener, mSubChangedListener.getHandlerExecutor());
        mImsProvisioningLoader = imsProvisioningLoader;

        PhoneConfigurationManager.registerForMultiSimConfigChange(mHandler,
                EVENT_MULTI_SIM_CONFIGURATION_CHANGE, null);

        initialize(numSlot);
    }

    private void initialize(int numSlot) {
        for (int i = 0; i < numSlot; i++) {
            MmTelFeatureListener m = new MmTelFeatureListener(i);
            mMmTelFeatureListenersSlotMap.put(i, m);

            RcsFeatureListener r = new RcsFeatureListener(i);
            mRcsFeatureListenersSlotMap.put(i, r);

            ProvisioningCallbackManager p = new ProvisioningCallbackManager(i);
            mProvisioningCallbackManagersSlotMap.put(i, p);
        }
    }

    private void onMultiSimConfigChanged(int newNumSlot) {
        log("onMultiSimConfigChanged: NumSlot " + mNumSlot + " newNumSlot " + newNumSlot);

        if (mNumSlot < newNumSlot) {
            for (int i = mNumSlot; i < newNumSlot; i++) {
                MmTelFeatureListener m = new MmTelFeatureListener(i);
                mMmTelFeatureListenersSlotMap.put(i, m);

                RcsFeatureListener r = new RcsFeatureListener(i);
                mRcsFeatureListenersSlotMap.put(i, r);

                ProvisioningCallbackManager p = new ProvisioningCallbackManager(i);
                mProvisioningCallbackManagersSlotMap.put(i, p);
            }
        } else if (mNumSlot > newNumSlot) {
            for (int i = (mNumSlot - 1); i > (newNumSlot - 1); i--) {
                MmTelFeatureListener m = mMmTelFeatureListenersSlotMap.get(i);
                mMmTelFeatureListenersSlotMap.remove(i);
                m.destroy();

                RcsFeatureListener r = mRcsFeatureListenersSlotMap.get(i);
                mRcsFeatureListenersSlotMap.remove(i);
                r.destroy();

                ProvisioningCallbackManager p = mProvisioningCallbackManagersSlotMap.get(i);
                mProvisioningCallbackManagersSlotMap.remove(i);
                p.clear();
            }
        }

        mNumSlot = newNumSlot;
    }

    /**
     * destroy the instance
     */
    @VisibleForTesting
    public void destroy() {
        log("destroy");

        mHandler.getLooper().quit();

        mTelephonyRegistryManager.removeOnSubscriptionsChangedListener(mSubChangedListener);

        for (int i = 0; i < mMmTelFeatureListenersSlotMap.size(); i++) {
            mMmTelFeatureListenersSlotMap.get(i).destroy();
        }
        mMmTelFeatureListenersSlotMap.clear();

        for (int i = 0; i < mRcsFeatureListenersSlotMap.size(); i++) {
            mRcsFeatureListenersSlotMap.get(i).destroy();
        }
        mRcsFeatureListenersSlotMap.clear();

        for (int i = 0; i < mProvisioningCallbackManagersSlotMap.size(); i++) {
            mProvisioningCallbackManagersSlotMap.get(i).clear();
        }
    }

    /**
     * create an instance
     */
    @VisibleForTesting
    public static ImsProvisioningController make(PhoneGlobals app, int numSlot) {
        synchronized (ImsProvisioningController.class) {
            if (sInstance == null) {
                Rlog.i(TAG, "ImsProvisioningController created");
                HandlerThread handlerThread = new HandlerThread(TAG);
                handlerThread.start();
                sInstance = new ImsProvisioningController(app, numSlot, handlerThread.getLooper(),
                        ImsManager::getConnector, RcsFeatureManager::getConnector,
                        new ImsProvisioningLoader(app));
            }
        }
        return sInstance;
    }

    /**
     * Gets a ImsProvisioningController instance
     */
    @VisibleForTesting
    public static ImsProvisioningController getInstance() {
        synchronized (ImsProvisioningController.class) {
            return sInstance;
        }
    }

    /**
     * Register IFeatureProvisioningCallback from ProvisioningManager
     */

    @VisibleForTesting
    public void addFeatureProvisioningChangedCallback(int subId,
            IFeatureProvisioningCallback callback) {
        if (callback == null) {
            throw new IllegalArgumentException("provisioning callback can't be null");
        }
        int slotId = getSlotId(subId);
        if (slotId < 0 || slotId >= mNumSlot) {
            throw new IllegalArgumentException("subscription id is not available");
        }

        try {
            mProvisioningCallbackManagersSlotMap.get(slotId).registerCallback(callback);
            log("Feature Provisioning Callback registered.");
        } catch (NullPointerException e) {
            logw("can not access callback manager to add callback");
        }
    }

    /**
     * Remove IFeatureProvisioningCallback
     */
    @VisibleForTesting
    public void removeFeatureProvisioningChangedCallback(int subId,
            IFeatureProvisioningCallback callback) {
        if (callback == null) {
            throw new IllegalArgumentException("provisioning callback can't be null");
        }

        int slotId = getSlotId(subId);
        if (slotId < 0 || slotId >= mNumSlot) {
            throw new IllegalArgumentException("subscription id is not available");
        }

        try {
            mProvisioningCallbackManagersSlotMap.get(slotId).unregisterCallback(callback);
            log("Feature Provisioning Callback removed.");
        } catch (NullPointerException e) {
            logw("can not access callback manager to remove callback");
        }
    }

    /**
     * return the boolean whether MmTel capability is required provisioning or not
     */
    @VisibleForTesting
    public boolean isImsProvisioningRequiredForCapability(int subId, int capability, int tech) {
        // check subId
        int slotId = getSlotId(subId);
        if (slotId <= SubscriptionManager.INVALID_SIM_SLOT_INDEX || slotId >= mNumSlot) {
            loge("Fail to retrieve slotId from subId");
            throw new IllegalArgumentException("subscribe id is invalid");
        }

        // check valid capability
        if (!(MMTEL_CAPABILITY_MIN < capability && capability < MMTEL_CAPABILITY_MAX)) {
            throw new IllegalArgumentException("MmTel capability '" + capability + "' is invalid");
        }

        // check valid radio tech
        if (!(REGISTRATION_TECH_NONE < tech && tech < REGISTRATION_TECH_MAX)) {
            log("Ims not matched radio tech " + tech);
            throw new IllegalArgumentException("Registration technology '" + tech + "' is invalid");
        }

        // check new carrier config first KEY_MMTEL_REQUIRES_PROVISIONING_BUNDLE
        boolean retVal = isProvisioningRequired(subId, capability, tech, /*isMmTel*/true);

        // if that returns false, check deprecated carrier config
        // KEY_CARRIER_VOLTE_PROVISIONING_REQUIRED_BOOL, KEY_CARRIER_UT_PROVISIONING_REQUIRED_BOOL
        if (!retVal && (capability == CAPABILITY_TYPE_VOICE
                || capability == CAPABILITY_TYPE_VIDEO
                || capability == CAPABILITY_TYPE_UT)) {
            String key = CarrierConfigManager.KEY_CARRIER_VOLTE_PROVISIONING_REQUIRED_BOOL;
            if (capability == CAPABILITY_TYPE_UT) {
                key = CarrierConfigManager.KEY_CARRIER_UT_PROVISIONING_REQUIRED_BOOL;
            }

            PersistableBundle imsCarrierConfigs = mCarrierConfigManager.getConfigForSubId(subId);
            if (imsCarrierConfigs != null) {
                retVal = imsCarrierConfigs.getBoolean(key);
            } else {
                retVal = CarrierConfigManager.getDefaultConfig().getBoolean(key);
            }
        }

        log("isImsProvisioningRequiredForCapability capability " + capability
                + " tech " + tech + " return value " + retVal);

        return retVal;
    }

    /**
     * return the boolean whether RCS capability is required provisioning or not
     */
    @VisibleForTesting
    public boolean isRcsProvisioningRequiredForCapability(int subId, int capability, int tech) {
        // check slotId and Phone object
        int slotId = getSlotId(subId);
        if (slotId <= SubscriptionManager.INVALID_SIM_SLOT_INDEX || slotId >= mNumSlot) {
            loge("Fail to retrieve slotId from subId");
            throw new IllegalArgumentException("subscribe id is invalid");
        }

        // check valid capability
        if (!(RCS_CAPABILITY_MIN < capability && capability < RCS_CAPABILITY_MAX)) {
            throw new IllegalArgumentException("Rcs capability '" + capability + "' is invalid");
        }

        // check valid radio tech
        if (!(REGISTRATION_TECH_NONE < tech && tech < REGISTRATION_TECH_MAX)) {
            log("Rcs not matched radio tech " + tech);
            throw new IllegalArgumentException("Registration technology '" + tech + "' is invalid");
        }

        // check new carrier config first KEY_RCS_REQUIRES_PROVISIONING_BUNDLE
        boolean retVal = isProvisioningRequired(subId, capability, tech, /*isMmTel*/false);

        // if that returns false, check deprecated carrier config
        // KEY_CARRIER_RCS_PROVISIONING_REQUIRED_BOOL
        if (!retVal) {
            PersistableBundle imsCarrierConfigs = mCarrierConfigManager.getConfigForSubId(subId);
            if (imsCarrierConfigs != null) {
                retVal = imsCarrierConfigs.getBoolean(
                        CarrierConfigManager.KEY_CARRIER_RCS_PROVISIONING_REQUIRED_BOOL);
            } else {
                retVal = CarrierConfigManager.getDefaultConfig().getBoolean(
                        CarrierConfigManager.KEY_CARRIER_RCS_PROVISIONING_REQUIRED_BOOL);
            }
        }

        log("isRcsProvisioningRequiredForCapability capability " + capability
                + " tech " + tech + " return value " + retVal);

        return retVal;
    }

    /**
     * return the provisioning status for MmTel capability in specific radio tech
     */
    @VisibleForTesting
    public boolean getImsProvisioningStatusForCapability(int subId, int capability, int tech) {
        boolean mmTelProvisioned = isImsProvisioningRequiredForCapability(subId, capability, tech);
        if (!mmTelProvisioned) { // provisioning not required
            log("getImsProvisioningStatusForCapability : not required "
                    + " capability " + capability + " tech " + tech);
            return true;
        }

        // read value from ImsProvisioningLoader
        int result = mImsProvisioningLoader.getProvisioningStatus(subId, FEATURE_MMTEL,
                capability, tech);
        if (result == ImsProvisioningLoader.STATUS_NOT_SET) {
            // not set means initial value
            // read data from vendor ImsService and store that in ImsProvisioningLoader
            result = getValueFromImsService(subId, capability, tech);
            mmTelProvisioned = getBoolValue(result);
            if (result != ProvisioningManager.PROVISIONING_RESULT_UNKNOWN) {
                setAndNotifyMmTelProvisioningValue(subId, capability, tech, mmTelProvisioned);
            }
        } else {
            mmTelProvisioned = getBoolValue(result);
        }

        log("getImsProvisioningStatusForCapability : "
                + " capability " + capability
                + " tech " + tech
                + " result " + mmTelProvisioned);
        return mmTelProvisioned;
    }

    /**
     * set MmTel provisioning status in specific tech
     */
    @VisibleForTesting
    public void setImsProvisioningStatusForCapability(int subId, int capability, int tech,
            boolean isProvisioned) {
        boolean mmTelProvisioned = isImsProvisioningRequiredForCapability(subId, capability, tech);
        if (!mmTelProvisioned) { // provisioning not required
            log("setImsProvisioningStatusForCapability : not required "
                    + " capability " + capability + " tech " + tech);
            return;
        }

        // write value to ImsProvisioningLoader
        boolean isChanged = setAndNotifyMmTelProvisioningValue(subId, capability, tech,
                isProvisioned);
        if (!isChanged) {
            log("status not changed mmtel capability " + capability + " tech " + tech);
            return;
        }

        int slotId = getSlotId(subId);
        // find matched key from capability and tech
        int value = getIntValue(isProvisioned);
        int key = getKeyFromCapability(capability, tech);
        if (key != INVALID_VALUE) {
            log("setImsProvisioningStatusForCapability : matched key " + key);
            try {
                // set key and value to vendor ImsService for MmTel
                mMmTelFeatureListenersSlotMap.get(slotId).setProvisioningValue(key, value);
            } catch (NullPointerException e) {
                loge("can not access MmTelFeatureListener with capability " + capability);
            }
        }
    }

    /**
     * return the provisioning status for RCS capability in specific radio tech
     */
    @VisibleForTesting
    public boolean getRcsProvisioningStatusForCapability(int subId, int capability, int tech) {
        boolean rcsProvisioned = isRcsProvisioningRequiredForCapability(subId, capability, tech);
        if (!rcsProvisioned) { // provisioning not required
            log("getRcsProvisioningStatusForCapability : not required"
                    + " capability " + capability + " tech " + tech);
            return true;
        }

        // read data from ImsProvisioningLoader
        int result = mImsProvisioningLoader.getProvisioningStatus(subId, FEATURE_RCS,
                capability, tech);
        if (result == ImsProvisioningLoader.STATUS_NOT_SET) {
            // not set means initial value
            // read data from vendor ImsService and store that in ImsProvisioningLoader
            result = getRcsValueFromImsService(subId, capability);
            rcsProvisioned = getBoolValue(result);
            if (result != ProvisioningManager.PROVISIONING_RESULT_UNKNOWN) {
                setAndNotifyRcsProvisioningValueForAllTech(subId, capability, rcsProvisioned);
            }
        } else {
            rcsProvisioned = getBoolValue(result);
        }

        log("getRcsProvisioningStatusForCapability : "
                + " capability " + capability
                + " tech " + tech
                + " result " + rcsProvisioned);
        return rcsProvisioned;
    }

    /**
     * set RCS provisioning status in specific tech
     */
    @VisibleForTesting
    public void setRcsProvisioningStatusForCapability(int subId, int capability, int tech,
            boolean isProvisioned) {
        boolean rcsProvisioned = isRcsProvisioningRequiredForCapability(subId, capability, tech);
        if (!rcsProvisioned) { // provisioning not required
            log("set rcs provisioning status but not required");
            return;
        }

        // write status using ImsProvisioningLoader
        boolean isChanged = setAndNotifyRcsProvisioningValue(subId, capability, tech,
                isProvisioned);
        if (!isChanged) {
            log("status not changed rcs capability " + capability + " tech " + tech);
            return;
        }

        int slotId = getSlotId(subId);
        int key =  ProvisioningManager.KEY_EAB_PROVISIONING_STATUS;
        int value = getIntValue(isProvisioned);
        try {
            // On some older devices, EAB is managed on the MmTel ImsService when the RCS
            // ImsService is not configured. If there is no RCS ImsService defined, fallback to
            // MmTel. In the rare case that we hit a race condition where the RCS ImsService has
            // crashed or has not come up yet, the value will be synchronized via
            // setInitialProvisioningKeys().
            if (mRcsFeatureListenersSlotMap.get(slotId).isConnectionReady()) {
                mRcsFeatureListenersSlotMap.get(slotId).setProvisioningValue(key, value);
            }

            // EAB provisioning status should be updated to both the Rcs and MmTel ImsService,
            // because the provisioning callback is listening to only MmTel provisioning key
            // changes.
            mMmTelFeatureListenersSlotMap.get(slotId).setProvisioningValue(key, value);
        } catch (NullPointerException e) {
            loge("can not access RcsFeatureListener with capability " + capability);
        }
    }

    /**
     * set RCS provisioning status in specific key and value
     * @param key integer key, defined as one of
     * {@link ProvisioningManager#KEY_VOLTE_PROVISIONING_STATUS}
     * {@link ProvisioningManager#KEY_VT_PROVISIONING_STATUS}
     * {@link ProvisioningManager#KEY_VOICE_OVER_WIFI_ENABLED_OVERRIDE}
     * {@link ProvisioningManager#KEY_EAB_PROVISIONING_STATUS}
     * @param value in Integer format.
     * @return the result of setting the configuration value, defined as one of
     * {@link ImsConfigImplBase#CONFIG_RESULT_FAILED} or
     * {@link ImsConfigImplBase#CONFIG_RESULT_SUCCESS} or
     */
    @VisibleForTesting
    public int setProvisioningValue(int subId, int key, int value) {
        log("setProvisioningValue");

        int retVal = ImsConfigImplBase.CONFIG_RESULT_FAILED;
        // check key value
        if (!Arrays.stream(LOCAL_IMS_CONFIG_KEYS).anyMatch(keyValue -> keyValue == key)) {
            log("not matched key " + key);
            return ImsConfigImplBase.CONFIG_RESULT_UNKNOWN;
        }

        // check subId
        int slotId = getSlotId(subId);
        if (slotId <= SubscriptionManager.INVALID_SIM_SLOT_INDEX || slotId >= mNumSlot) {
            loge("Fail to retrieve slotId from subId");
            return ImsConfigImplBase.CONFIG_RESULT_FAILED;
        }

        try {
            // set key and value to vendor ImsService for MmTel
            // EAB provisioning status should be updated to both the Rcs and MmTel ImsService,
            // because the provisioning callback is listening to only MmTel provisioning key
            // changes.
            retVal = mMmTelFeatureListenersSlotMap.get(slotId).setProvisioningValue(key, value);

            // If the  Rcs ImsService is not available, the EAB provisioning status will be written
            // to the MmTel ImsService for backwards compatibility. In the rare case that this is
            // hit due to RCS ImsService temporarily unavailable, the value will be synchronized
            // via setInitialProvisioningKeys() when the RCS ImsService comes back up.
            if (key == KEY_EAB_PROVISIONING_STATUS
                    && mRcsFeatureListenersSlotMap.get(slotId).isConnectionReady()) {
                // set key and value to vendor ImsService for RCS and use retVal from RCS if
                // related to EAB when possible.
                retVal = mRcsFeatureListenersSlotMap.get(slotId).setProvisioningValue(key, value);
            }
        } catch (NullPointerException e) {
            loge("can not access FeatureListener to set provisioning value");
            return ImsConfigImplBase.CONFIG_RESULT_FAILED;
        }

        // update and notify provisioning status changed capability and tech from key
        updateCapabilityTechFromKey(subId, key, value);

        return retVal;
    }

    /**
     * get RCS provisioning status in specific key and value
     * @param key integer key, defined as one of
     * {@link ProvisioningManager#KEY_VOLTE_PROVISIONING_STATUS}
     * {@link ProvisioningManager#KEY_VT_PROVISIONING_STATUS}
     * {@link ProvisioningManager#KEY_VOICE_OVER_WIFI_ENABLED_OVERRIDE}
     * {@link ProvisioningManager#KEY_EAB_PROVISIONING_STATUS}
     * @return the result of setting the configuration value, defined as one of
     * {@link ImsConfigImplBase#CONFIG_RESULT_FAILED} or
     * {@link ImsConfigImplBase#CONFIG_RESULT_SUCCESS} or
     * {@link ImsConfigImplBase#CONFIG_RESULT_UNKNOWN}
     */
    @VisibleForTesting
    public int getProvisioningValue(int subId, int key) {
        // check key value
        if (!Arrays.stream(LOCAL_IMS_CONFIG_KEYS).anyMatch(keyValue -> keyValue == key)) {
            log("not matched key " + key);
            return ImsConfigImplBase.CONFIG_RESULT_UNKNOWN;
        }

        // check subId
        int slotId = getSlotId(subId);
        if (slotId <= SubscriptionManager.INVALID_SIM_SLOT_INDEX || slotId >= mNumSlot) {
            loge("Fail to retrieve slotId from subId");
            return ImsConfigImplBase.CONFIG_RESULT_UNKNOWN;
        }

        // check data from ImsProvisioningLoader
        int capability = getCapabilityFromKey(key);
        int tech = getTechFromKey(key);
        int result;
        if (capability != INVALID_VALUE && tech != INVALID_VALUE) {
            if (key == KEY_EAB_PROVISIONING_STATUS) {
                result = mImsProvisioningLoader.getProvisioningStatus(subId, FEATURE_RCS,
                        capability, tech);
            } else {
                result = mImsProvisioningLoader.getProvisioningStatus(subId, FEATURE_MMTEL,
                        capability, tech);
            }
            if (result != ImsProvisioningLoader.STATUS_NOT_SET) {
                log("getProvisioningValue from loader : key " + key + " result " + result);
                return result;
            }
        }

        // get data from ImsService, update it in ImsProvisioningLoader
        if (key == KEY_EAB_PROVISIONING_STATUS) {
            result = getRcsValueFromImsService(subId, capability);
            if (result == ImsConfigImplBase.CONFIG_RESULT_UNKNOWN) {
                logw("getProvisioningValue : fail to get data from ImsService capability"
                        + capability);
                return result;
            }
            log("getProvisioningValue from vendor : key " + key + " result " + result);

            setAndNotifyRcsProvisioningValueForAllTech(subId, capability, getBoolValue(result));
            return result;
        } else {
            result = getValueFromImsService(subId, capability, tech);
            if (result == ImsConfigImplBase.CONFIG_RESULT_UNKNOWN) {
                logw("getProvisioningValue : fail to get data from ImsService capability"
                        + capability);
                return result;
            }
            log("getProvisioningValue from vendor : key " + key + " result " + result);

            setAndNotifyMmTelProvisioningValue(subId, capability, tech, getBoolValue(result));
            return result;
        }
    }

    /**
     * get the handler
     */
    @VisibleForTesting
    public Handler getHandler() {
        return mHandler;
    }

    private boolean isProvisioningRequired(int subId, int capability, int tech, boolean isMmTel) {
        int[] techArray;
        techArray = getTechsFromCarrierConfig(subId, capability, isMmTel);
        if (techArray == null) {
            logw("isProvisioningRequired : getTechsFromCarrierConfig failed");
            // not exist in CarrierConfig that means provisioning is not required
            return false;
        }

        // compare with carrier config
        if (Arrays.stream(techArray).anyMatch(keyValue -> keyValue == tech)) {
            // existing same tech means provisioning required
            return true;
        }

        log("isProvisioningRequired : not matched capability " + capability + " tech " + tech);
        return false;
    }

    private int[] getTechsFromCarrierConfig(int subId, int capability, boolean isMmTel) {
        String featureKey;
        String capabilityKey;
        if (isMmTel) {
            featureKey = CarrierConfigManager.Ims.KEY_MMTEL_REQUIRES_PROVISIONING_BUNDLE;
            capabilityKey = KEYS_MMTEL_CAPABILITY.get(capability);
        } else {
            featureKey = CarrierConfigManager.Ims.KEY_RCS_REQUIRES_PROVISIONING_BUNDLE;
            capabilityKey = KEYS_RCS_CAPABILITY.get(capability);
        }

        if (capabilityKey != null) {
            PersistableBundle imsCarrierConfigs = mCarrierConfigManager.getConfigForSubId(subId);
            if (imsCarrierConfigs == null) {
                log("getTechsFromCarrierConfig : imsCarrierConfigs null");
                return null;
            }

            PersistableBundle provisioningBundle =
                    imsCarrierConfigs.getPersistableBundle(featureKey);
            if (provisioningBundle == null) {
                log("getTechsFromCarrierConfig : provisioningBundle null");
                return null;
            }

            return provisioningBundle.getIntArray(capabilityKey);
        }

        return null;
    }

    private int getValueFromImsService(int subId, int capability, int tech) {
        int config = ImsConfigImplBase.CONFIG_RESULT_UNKNOWN;

        // operation is based on capability
        switch (capability) {
            case CAPABILITY_TYPE_VOICE:
                int item = (tech == ImsRegistrationImplBase.REGISTRATION_TECH_IWLAN)
                        ? ProvisioningManager.KEY_VOICE_OVER_WIFI_ENABLED_OVERRIDE
                        : ProvisioningManager.KEY_VOLTE_PROVISIONING_STATUS;
                // read data from vendor ImsService
                config = mMmTelFeatureListenersSlotMap.get(getSlotId(subId))
                        .getProvisioningValue(item);
                break;
            case CAPABILITY_TYPE_VIDEO:
                // read data from vendor ImsService
                config = mMmTelFeatureListenersSlotMap.get(getSlotId(subId))
                        .getProvisioningValue(ProvisioningManager.KEY_VT_PROVISIONING_STATUS);
                break;
            default:
                log("Capability " + capability + " has been provisioning");
                break;
        }

        return config;
    }

    private int getRcsValueFromImsService(int subId, int capability) {
        int config = ImsConfigImplBase.CONFIG_RESULT_UNKNOWN;
        int slotId = getSlotId(subId);

        if (capability != CAPABILITY_TYPE_PRESENCE_UCE) {
            log("Capability " + capability + " has been provisioning");
            return config;
        }
        try {
            if (mRcsFeatureListenersSlotMap.get(slotId).isConnectionReady()) {
                config = mRcsFeatureListenersSlotMap.get(slotId)
                        .getProvisioningValue(ProvisioningManager.KEY_EAB_PROVISIONING_STATUS);
            } else {
                log("Rcs ImsService is not available, "
                        + "EAB provisioning status should be read from MmTel ImsService");
                config = mMmTelFeatureListenersSlotMap.get(slotId)
                        .getProvisioningValue(ProvisioningManager.KEY_EAB_PROVISIONING_STATUS);
            }
        } catch (NullPointerException e) {
            logw("can not access FeatureListener : " + e.getMessage());
        }

        return config;
    }

    private void onSubscriptionsChanged() {
        for (int index = 0; index < mMmTelFeatureListenersSlotMap.size(); index++) {
            MmTelFeatureListener m = mMmTelFeatureListenersSlotMap.get(index);
            m.setSubId(getSubId(index));
        }
        for (int index = 0; index < mRcsFeatureListenersSlotMap.size(); index++) {
            RcsFeatureListener r = mRcsFeatureListenersSlotMap.get(index);
            r.setSubId(getSubId(index));
        }
        for (int index = 0; index < mProvisioningCallbackManagersSlotMap.size(); index++) {
            ProvisioningCallbackManager m = mProvisioningCallbackManagersSlotMap.get(index);
            m.setSubId(getSubId(index));
        }
    }

    private void  updateCapabilityTechFromKey(int subId, int key, int value) {
        boolean isProvisioned = getBoolValue(value);
        int capability = getCapabilityFromKey(key);
        int tech = getTechFromKey(key);

        if (capability == INVALID_VALUE || tech == INVALID_VALUE) {
            logw("updateCapabilityTechFromKey : unknown key " + key);
            return;
        }

        if (key == KEY_VOLTE_PROVISIONING_STATUS
                || key == KEY_VT_PROVISIONING_STATUS
                || key == KEY_VOICE_OVER_WIFI_ENABLED_OVERRIDE) {
            setAndNotifyMmTelProvisioningValue(subId, capability, tech, isProvisioned);
        }
        if (key == KEY_EAB_PROVISIONING_STATUS) {
            setAndNotifyRcsProvisioningValueForAllTech(subId, capability, isProvisioned);
        }
    }

    private int getCapabilityFromKey(int key) {
        int capability;
        switch (key) {
            case ProvisioningManager.KEY_VOLTE_PROVISIONING_STATUS:
                // intentional fallthrough
            case ProvisioningManager.KEY_VOICE_OVER_WIFI_ENABLED_OVERRIDE:
                capability = CAPABILITY_TYPE_VOICE;
                break;
            case ProvisioningManager.KEY_VT_PROVISIONING_STATUS:
                capability = CAPABILITY_TYPE_VIDEO;
                break;
            case ProvisioningManager.KEY_EAB_PROVISIONING_STATUS:
                // default CAPABILITY_TYPE_PRESENCE_UCE used for KEY_EAB_PROVISIONING_STATUS
                capability = CAPABILITY_TYPE_PRESENCE_UCE;
                break;
            default:
                capability = INVALID_VALUE;
                break;
        }
        return capability;
    }

    private int getTechFromKey(int key) {
        int tech;
        switch (key) {
            case ProvisioningManager.KEY_VOICE_OVER_WIFI_ENABLED_OVERRIDE:
                tech = ImsRegistrationImplBase.REGISTRATION_TECH_IWLAN;
                break;
            case ProvisioningManager.KEY_VOLTE_PROVISIONING_STATUS:
                // intentional fallthrough
            case ProvisioningManager.KEY_VT_PROVISIONING_STATUS:
                // intentional fallthrough
            case ProvisioningManager.KEY_EAB_PROVISIONING_STATUS:
                tech = ImsRegistrationImplBase.REGISTRATION_TECH_LTE;
                break;
            default:
                tech = INVALID_VALUE;
                break;
        }
        return tech;
    }

    private int getKeyFromCapability(int capability, int tech) {
        int key = INVALID_VALUE;
        if (capability == CAPABILITY_TYPE_VOICE && tech == REGISTRATION_TECH_IWLAN) {
            key = ProvisioningManager.KEY_VOICE_OVER_WIFI_ENABLED_OVERRIDE;
        } else if (capability == CAPABILITY_TYPE_VOICE && tech == REGISTRATION_TECH_LTE) {
            key = ProvisioningManager.KEY_VOLTE_PROVISIONING_STATUS;
        } else if (capability == CAPABILITY_TYPE_VIDEO && tech == REGISTRATION_TECH_LTE) {
            key = ProvisioningManager.KEY_VT_PROVISIONING_STATUS;
        }

        return key;
    }

    protected int getSubId(int slotId) {
        final int[] subIds = mSubscriptionManager.getSubscriptionIds(slotId);
        int subId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
        if (subIds != null && subIds.length >= 1) {
            subId = subIds[0];
        }

        return subId;
    }

    protected int getSlotId(int subId) {
        return mSubscriptionManager.getPhoneId(subId);
    }

    protected ImsConfig getImsConfig(ImsManager imsManager) throws ImsException {
        return imsManager.getConfigInterface();
    }

    protected ImsConfig getImsConfig(IImsConfig iImsConfig) {
        return new ImsConfig(iImsConfig);
    }

    private int getIntValue(boolean isProvisioned) {
        return isProvisioned ? ProvisioningManager.PROVISIONING_VALUE_ENABLED
                : ProvisioningManager.PROVISIONING_VALUE_DISABLED;
    }

    private boolean getBoolValue(int value) {
        return value == ProvisioningManager.PROVISIONING_VALUE_ENABLED ? true : false;
    }

    private boolean setAndNotifyMmTelProvisioningValue(int subId, int capability, int tech,
            boolean isProvisioned) {
        boolean changed = mImsProvisioningLoader.setProvisioningStatus(subId, FEATURE_MMTEL,
                capability, tech, isProvisioned);
        // notify MmTel capability changed
        if (changed) {
            mHandler.sendMessage(mHandler.obtainMessage(EVENT_PROVISIONING_CAPABILITY_CHANGED,
                    getSlotId(subId), 0, (Object) new FeatureProvisioningData(
                            capability, tech, isProvisioned, /*isMmTel*/true)));
        }

        return changed;
    }

    private boolean setAndNotifyRcsProvisioningValue(int subId, int capability, int tech,
            boolean isProvisioned) {
        boolean isChanged = mImsProvisioningLoader.setProvisioningStatus(subId, FEATURE_RCS,
                capability, tech, isProvisioned);

        if (isChanged) {
            int slotId = getSlotId(subId);

            // notify RCS capability changed
            mHandler.sendMessage(mHandler.obtainMessage(EVENT_PROVISIONING_CAPABILITY_CHANGED,
                    slotId, 0, (Object) new FeatureProvisioningData(
                            capability, tech, isProvisioned, /*isMmtel*/false)));
        }

        return isChanged;
    }

    private boolean setAndNotifyRcsProvisioningValueForAllTech(int subId, int capability,
            boolean isProvisioned) {
        boolean isChanged = false;

        for (int tech : LOCAL_RADIO_TECHS) {
            isChanged |= setAndNotifyRcsProvisioningValue(subId, capability, tech, isProvisioned);
        }

        return isChanged;
    }

    protected boolean isValidSubId(int subId) {
        int slotId = getSlotId(subId);
        if (slotId <= SubscriptionManager.INVALID_SIM_SLOT_INDEX || slotId >= mNumSlot) {
            return false;
        }

        return true;
    }

    private void log(String s) {
        Rlog.d(TAG, s);
    }

    private void log(String prefix, int slotId, String s) {
        Rlog.d(TAG, prefix + "[" + slotId + "] " + s);
    }

    private void logi(String prefix, int slotId, String s) {
        Rlog.i(TAG, prefix + "[" + slotId + "] " + s);
    }

    private void logw(String s) {
        Rlog.w(TAG, s);
    }

    private void logw(String prefix, int slotId, String s) {
        Rlog.w(TAG, prefix + "[" + slotId + "] " + s);
    }

    private void loge(String s) {
        Rlog.e(TAG, s);
    }

    private void loge(String prefix, int slotId, String s) {
        Rlog.e(TAG, prefix + "[" + slotId + "] " + s);
    }
}