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

import android.annotation.IntDef;
import android.annotation.NonNull;
import android.annotation.SystemApi;
import android.content.Context;
import android.os.PersistableBundle;
import android.os.RemoteException;
import android.telephony.ims.ImsService;
import android.telephony.ims.ProvisioningManager;
import android.telephony.ims.RcsClientConfiguration;
import android.telephony.ims.RcsConfig;
import android.telephony.ims.aidl.IImsConfig;
import android.telephony.ims.aidl.IImsConfigCallback;
import android.telephony.ims.aidl.IRcsConfigCallback;
import android.util.Log;

import com.android.ims.ImsConfig;
import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.telephony.util.RemoteCallbackListExt;
import com.android.internal.telephony.util.TelephonyUtils;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.ref.WeakReference;
import java.util.Arrays;
import java.util.HashMap;
import java.util.concurrent.CancellationException;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Supplier;


/**
 * Controls the modification of IMS specific configurations. For more information on the supported
 * IMS configuration constants, see {@link ImsConfig}.
 *
 * The inner class {@link ImsConfigStub} implements methods of IImsConfig AIDL interface.
 * The IImsConfig AIDL interface is called by ImsConfig, which may exist in many other processes.
 * ImsConfigImpl access to the configuration parameters may be arbitrarily slow, especially in
 * during initialization, or times when a lot of configuration parameters are being set/get
 * (such as during boot up or SIM card change). By providing a cache in ImsConfigStub, we can speed
 * up access to these configuration parameters, so a query to the ImsConfigImpl does not have to be
 * performed every time.
 * @hide
 */
@SystemApi
public class ImsConfigImplBase {

    private static final String TAG = "ImsConfigImplBase";

    /**
     * Implements the IImsConfig AIDL interface, which is called by potentially many processes
     * in order to get/set configuration parameters.
     *
     * It holds an object of ImsConfigImplBase class which is usually extended by ImsConfigImpl
     * with actual implementations from vendors. This class caches provisioned values from
     * ImsConfigImpl layer because queries through ImsConfigImpl can be slow. When query goes in,
     * it first checks cache layer. If missed, it will call the vendor implementation of
     * ImsConfigImplBase API.
     * and cache the return value if the set succeeds.
     *
     * Provides APIs to get/set the IMS service feature/capability/parameters.
     * The config items include:
     * 1) Items provisioned by the operator.
     * 2) Items configured by user. Mainly service feature class.
     *
     * @hide
     */
    @VisibleForTesting
    static public class ImsConfigStub extends IImsConfig.Stub {
        WeakReference<ImsConfigImplBase> mImsConfigImplBaseWeakReference;
        private HashMap<Integer, Integer> mProvisionedIntValue = new HashMap<>();
        private HashMap<Integer, String> mProvisionedStringValue = new HashMap<>();
        private final Object mLock = new Object();
        private Executor mExecutor;

        @VisibleForTesting
        public ImsConfigStub(ImsConfigImplBase imsConfigImplBase, Executor executor) {
            mExecutor = executor;
            mImsConfigImplBaseWeakReference =
                    new WeakReference<ImsConfigImplBase>(imsConfigImplBase);
        }

        @Override
        public void addImsConfigCallback(IImsConfigCallback c) throws RemoteException {
            AtomicReference<RemoteException> exceptionRef = new AtomicReference<>();
            executeMethodAsync(()-> {
                try {
                    getImsConfigImpl().addImsConfigCallback(c);
                } catch (RemoteException e) {
                    exceptionRef.set(e);
                }
            }, "addImsConfigCallback");

            if (exceptionRef.get() != null) {
                Log.d(TAG, "ImsConfigImplBase Exception addImsConfigCallback");
                throw exceptionRef.get();
            }
        }

        @Override
        public void removeImsConfigCallback(IImsConfigCallback c) throws RemoteException {
            AtomicReference<RemoteException> exceptionRef = new AtomicReference<>();
            executeMethodAsync(()-> {
                try {
                    getImsConfigImpl().removeImsConfigCallback(c);
                } catch (RemoteException e) {
                    exceptionRef.set(e);
                }
            }, "removeImsConfigCallback");

            if (exceptionRef.get() != null) {
                Log.d(TAG, "ImsConfigImplBase Exception removeImsConfigCallback");
                throw exceptionRef.get();
            }
        }

        /**
         * Gets the value for ims service/capabilities parameters. It first checks its local cache,
         * if missed, it will call ImsConfigImplBase.getConfigInt.
         * Synchronous blocking call.
         *
         * @param item integer key
         * @return value in Integer format or {@link #CONFIG_RESULT_UNKNOWN} if
         * unavailable.
         */
        @Override
        public int getConfigInt(int item) throws RemoteException {
            AtomicReference<RemoteException> exceptionRef = new AtomicReference<>();
            int retVal = executeMethodAsyncForResult(()-> {
                int returnVal = ImsConfig.OperationStatusConstants.UNKNOWN;
                synchronized (mLock) {
                    if (mProvisionedIntValue.containsKey(item)) {
                        return mProvisionedIntValue.get(item);
                    } else {
                        try {
                            returnVal = getImsConfigImpl().getConfigInt(item);
                            if (returnVal != ImsConfig.OperationStatusConstants.UNKNOWN) {
                                mProvisionedIntValue.put(item, returnVal);
                            }
                        } catch (RemoteException e) {
                            exceptionRef.set(e);
                            return returnVal;
                        }
                    }
                }
                return returnVal;
            }, "getConfigInt");

            if (exceptionRef.get() != null) {
                Log.d(TAG, "ImsConfigImplBase Exception getConfigString");
                throw exceptionRef.get();
            }

            return retVal;
        }

        /**
         * Gets the value for ims service/capabilities parameters. It first checks its local cache,
         * if missed, it will call #ImsConfigImplBase.getConfigString.
         * Synchronous blocking call.
         *
         * @param item integer key
         * @return value in String format.
         */
        @Override
        public String getConfigString(int item) throws RemoteException {
            AtomicReference<RemoteException> exceptionRef = new AtomicReference<>();
            String retVal = executeMethodAsyncForResult(()-> {
                String returnVal = null;
                synchronized (mLock) {
                    if (mProvisionedStringValue.containsKey(item)) {
                        returnVal = mProvisionedStringValue.get(item);
                    } else {
                        try {
                            returnVal = getImsConfigImpl().getConfigString(item);
                            if (returnVal != null) {
                                mProvisionedStringValue.put(item, returnVal);
                            }
                        } catch (RemoteException e) {
                            exceptionRef.set(e);
                            return returnVal;
                        }
                    }
                }
                return returnVal;
            }, "getConfigString");

            if (exceptionRef.get() != null) {
                Log.d(TAG, "ImsConfigImplBase Exception getConfigString");
                throw exceptionRef.get();
            }

            return retVal;
        }

        /**
         * Sets the value for IMS service/capabilities parameters by the operator device
         * management entity. It sets the config item value in the provisioned storage
         * from which the main value is derived, and write it into local cache.
         * Synchronous blocking call.
         *
         * @param item integer key
         * @param value in Integer format.
         * @return the result of setting the configuration value, defined as either
         * {@link #CONFIG_RESULT_FAILED} or {@link #CONFIG_RESULT_SUCCESS}.
         */
        @Override
        public int setConfigInt(int item, int value) throws RemoteException {
            AtomicReference<RemoteException> exceptionRef = new AtomicReference<>();
            int retVal = executeMethodAsyncForResult(()-> {
                int returnVal = ImsConfig.OperationStatusConstants.UNKNOWN;
                try {
                    synchronized (mLock) {
                        mProvisionedIntValue.remove(item);
                        returnVal = getImsConfigImpl().setConfig(item, value);
                        if (returnVal == ImsConfig.OperationStatusConstants.SUCCESS) {
                            mProvisionedIntValue.put(item, value);
                        } else {
                            Log.d(TAG, "Set provision value of " + item
                                    + " to " + value + " failed with error code " + returnVal);
                        }
                    }
                    notifyImsConfigChanged(item, value);
                    return returnVal;
                } catch (RemoteException e) {
                    exceptionRef.set(e);
                    return returnVal;
                }
            }, "setConfigInt");

            if (exceptionRef.get() != null) {
                Log.d(TAG, "ImsConfigImplBase Exception setConfigInt");
                throw exceptionRef.get();
            }

            return retVal;
        }

        /**
         * Sets the value for IMS service/capabilities parameters by the operator device
         * management entity. It sets the config item value in the provisioned storage
         * from which the main value is derived, and write it into local cache.
         * Synchronous blocking call.
         *
         * @param item as defined in com.android.ims.ImsConfig#ConfigConstants.
         * @param value in String format.
         * @return the result of setting the configuration value, defined as either
         * {@link #CONFIG_RESULT_FAILED} or {@link #CONFIG_RESULT_SUCCESS}.
         */
        @Override
        public int setConfigString(int item, String value)
                throws RemoteException {
            AtomicReference<RemoteException> exceptionRef = new AtomicReference<>();
            int retVal = executeMethodAsyncForResult(()-> {
                int returnVal = ImsConfig.OperationStatusConstants.UNKNOWN;
                try {
                    synchronized (mLock) {
                        mProvisionedStringValue.remove(item);
                        returnVal = getImsConfigImpl().setConfig(item, value);
                        if (returnVal == ImsConfig.OperationStatusConstants.SUCCESS) {
                            mProvisionedStringValue.put(item, value);
                        }
                    }
                    notifyImsConfigChanged(item, value);
                    return returnVal;
                } catch (RemoteException e) {
                    exceptionRef.set(e);
                    return returnVal;
                }
            }, "setConfigString");

            if (exceptionRef.get() != null) {
                Log.d(TAG, "ImsConfigImplBase Exception setConfigInt");
                throw exceptionRef.get();
            }

            return retVal;
        }

        @Override
        public void updateImsCarrierConfigs(PersistableBundle bundle) throws RemoteException {
            AtomicReference<RemoteException> exceptionRef = new AtomicReference<>();
            executeMethodAsync(()-> {
                try {
                    getImsConfigImpl().updateImsCarrierConfigs(bundle);
                } catch (RemoteException e) {
                    exceptionRef.set(e);
                }
            }, "updateImsCarrierConfigs");

            if (exceptionRef.get() != null) {
                Log.d(TAG, "ImsConfigImplBase Exception updateImsCarrierConfigs");
                throw exceptionRef.get();
            }
        }

        private ImsConfigImplBase getImsConfigImpl() throws RemoteException {
            ImsConfigImplBase ref = mImsConfigImplBaseWeakReference.get();
            if (ref == null) {
                throw new RemoteException("Fail to get ImsConfigImpl");
            } else {
                return ref;
            }
        }

        @Override
        public void notifyRcsAutoConfigurationReceived(byte[] config, boolean isCompressed)
                throws RemoteException {
            AtomicReference<RemoteException> exceptionRef = new AtomicReference<>();
            executeMethodAsync(()-> {
                try {
                    getImsConfigImpl().onNotifyRcsAutoConfigurationReceived(config, isCompressed);
                } catch (RemoteException e) {
                    exceptionRef.set(e);
                }
            }, "notifyRcsAutoConfigurationReceived");

            if (exceptionRef.get() != null) {
                Log.d(TAG, "ImsConfigImplBase Exception notifyRcsAutoConfigurationReceived");
                throw exceptionRef.get();
            }
        }

        @Override
        public void notifyRcsAutoConfigurationRemoved()
                throws RemoteException {
            AtomicReference<RemoteException> exceptionRef = new AtomicReference<>();
            executeMethodAsync(()-> {
                try {
                    getImsConfigImpl().onNotifyRcsAutoConfigurationRemoved();
                } catch (RemoteException e) {
                    exceptionRef.set(e);
                }
            }, "notifyRcsAutoConfigurationRemoved");

            if (exceptionRef.get() != null) {
                Log.d(TAG, "ImsConfigImplBase Exception notifyRcsAutoConfigurationRemoved");
                throw exceptionRef.get();
            }
        }

        private void notifyImsConfigChanged(int item, int value) throws RemoteException {
            getImsConfigImpl().notifyConfigChanged(item, value);
        }

        private void notifyImsConfigChanged(int item, String value) throws RemoteException {
            getImsConfigImpl().notifyConfigChanged(item, value);
        }

        protected void updateCachedValue(int item, int value) {
            synchronized (mLock) {
                mProvisionedIntValue.put(item, value);
            }
        }

        protected void updateCachedValue(int item, String value) {
            synchronized (mLock) {
                mProvisionedStringValue.put(item, value);
            }
        }

        @Override
        public void addRcsConfigCallback(IRcsConfigCallback c) throws RemoteException {
            AtomicReference<RemoteException> exceptionRef = new AtomicReference<>();
            executeMethodAsync(()-> {
                try {
                    getImsConfigImpl().addRcsConfigCallback(c);
                } catch (RemoteException e) {
                    exceptionRef.set(e);
                }
            }, "addRcsConfigCallback");

            if (exceptionRef.get() != null) {
                Log.d(TAG, "ImsConfigImplBase Exception addRcsConfigCallback");
                throw exceptionRef.get();
            }
        }

        @Override
        public void removeRcsConfigCallback(IRcsConfigCallback c) throws RemoteException {
            AtomicReference<RemoteException> exceptionRef = new AtomicReference<>();
            executeMethodAsync(()-> {
                try {
                    getImsConfigImpl().removeRcsConfigCallback(c);
                } catch (RemoteException e) {
                    exceptionRef.set(e);
                }
            }, "removeRcsConfigCallback");

            if (exceptionRef.get() != null) {
                Log.d(TAG, "ImsConfigImplBase Exception removeRcsConfigCallback");
                throw exceptionRef.get();
            }
        }

        @Override
        public void triggerRcsReconfiguration() throws RemoteException {
            AtomicReference<RemoteException> exceptionRef = new AtomicReference<>();
            executeMethodAsync(()-> {
                try {
                    getImsConfigImpl().triggerAutoConfiguration();
                } catch (RemoteException e) {
                    exceptionRef.set(e);
                }
            }, "triggerRcsReconfiguration");

            if (exceptionRef.get() != null) {
                Log.d(TAG, "ImsConfigImplBase Exception triggerRcsReconfiguration");
                throw exceptionRef.get();
            }
        }

        @Override
        public void setRcsClientConfiguration(RcsClientConfiguration rcc) throws RemoteException {
            AtomicReference<RemoteException> exceptionRef = new AtomicReference<>();
            executeMethodAsync(()-> {
                try {
                    getImsConfigImpl().setRcsClientConfiguration(rcc);
                } catch (RemoteException e) {
                    exceptionRef.set(e);
                }
            }, "setRcsClientConfiguration");

            if (exceptionRef.get() != null) {
                Log.d(TAG, "ImsConfigImplBase Exception setRcsClientConfiguration");
                throw exceptionRef.get();
            }
        }

        @Override
        public void notifyIntImsConfigChanged(int item, int value) throws RemoteException {
            AtomicReference<RemoteException> exceptionRef = new AtomicReference<>();
            executeMethodAsync(()-> {
                try {
                    notifyImsConfigChanged(item, value);
                } catch (RemoteException e) {
                    exceptionRef.set(e);
                }
            }, "notifyIntImsConfigChanged");

            if (exceptionRef.get() != null) {
                Log.d(TAG, "ImsConfigImplBase Exception notifyIntImsConfigChanged");
                throw exceptionRef.get();
            }
        }

        @Override
        public void notifyStringImsConfigChanged(int item, String value) throws RemoteException {
            AtomicReference<RemoteException> exceptionRef = new AtomicReference<>();
            executeMethodAsync(()-> {
                try {
                    notifyImsConfigChanged(item, value);
                } catch (RemoteException e) {
                    exceptionRef.set(e);
                }
            }, "notifyStringImsConfigChanged");

            if (exceptionRef.get() != null) {
                Log.d(TAG, "ImsConfigImplBase Exception notifyStringImsConfigChanged");
                throw exceptionRef.get();
            }
        }

        /**
         * Clear cached configuration value.
         */
        public void clearCachedValue() {
            Log.i(TAG, "clearCachedValue");
            synchronized (mLock) {
                mProvisionedIntValue.clear();
                mProvisionedStringValue.clear();
            }
        }

        // Call the methods with a clean calling identity on the executor and wait indefinitely for
        // the future to return.
        private void executeMethodAsync(Runnable r, String errorLogName) throws RemoteException {
            try {
                CompletableFuture.runAsync(
                        () -> TelephonyUtils.runWithCleanCallingIdentity(r), mExecutor).join();
            } catch (CancellationException | CompletionException e) {
                Log.w(TAG, "ImsConfigImplBase Binder - " + errorLogName + " exception: "
                        + e.getMessage());
                throw new RemoteException(e.getMessage());
            }
        }

        private <T> T executeMethodAsyncForResult(Supplier<T> r,
                String errorLogName) throws RemoteException {
            CompletableFuture<T> future = CompletableFuture.supplyAsync(
                    () -> TelephonyUtils.runWithCleanCallingIdentity(r), mExecutor);
            try {
                return future.get();
            } catch (ExecutionException | InterruptedException e) {
                Log.w(TAG, "ImsConfigImplBase Binder - " + errorLogName + " exception: "
                        + e.getMessage());
                throw new RemoteException(e.getMessage());
            }
        }
    }

    /**
     * The configuration requested resulted in an unknown result. This may happen if the
     * IMS configurations are unavailable.
     */
    public static final int CONFIG_RESULT_UNKNOWN = ProvisioningManager.PROVISIONING_RESULT_UNKNOWN;

    /**
     * Setting the configuration value completed.
     */
    public static final int CONFIG_RESULT_SUCCESS = 0;
    /**
     * Setting the configuration value failed.
     */
    public static final int CONFIG_RESULT_FAILED =  1;

    /**
     * @hide
     */
    @Retention(RetentionPolicy.SOURCE)
    @IntDef(prefix = "CONFIG_RESULT_", value = {
            CONFIG_RESULT_SUCCESS,
            CONFIG_RESULT_FAILED
    })
    public @interface SetConfigResult {}

    private final RemoteCallbackListExt<IImsConfigCallback> mCallbacks =
            new RemoteCallbackListExt<>();
    private final RemoteCallbackListExt<IRcsConfigCallback> mRcsCallbacks =
            new RemoteCallbackListExt<>();
    private byte[] mRcsConfigData;
    private final Object mRcsConfigDataLock = new Object();
    ImsConfigStub mImsConfigStub;

    /**
     * Create an ImsConfig using the Executor specified for methods being called by the
     * framework.
     * @param executor The executor for the framework to use when executing the methods overridden
     * by the implementation of ImsConfig.
     */
    public ImsConfigImplBase(@NonNull Executor executor) {
        mImsConfigStub = new ImsConfigStub(this, executor);
    }

    /**
     * @hide
     */
    public ImsConfigImplBase(@NonNull Context context) {
        mImsConfigStub = new ImsConfigStub(this, null);
    }

    /**
     * Create an ImsConfig using the Executor defined in {@link ImsService#getExecutor}
     */
    public ImsConfigImplBase() {
        mImsConfigStub = new ImsConfigStub(this, null);
    }

    /**
     * Adds a {@link android.telephony.ims.ProvisioningManager.Callback} to the list of callbacks
     * notified when a value in the configuration changes.
     * @param c callback to add.
     */
    private void addImsConfigCallback(IImsConfigCallback c) {
        mCallbacks.register(c);
    }
    /**
     * Removes a {@link android.telephony.ims.ProvisioningManager.Callback} to the list of callbacks
     * notified when a value in the configuration changes.
     * @param c callback to remove.
     */
    private void removeImsConfigCallback(IImsConfigCallback c) {
        mCallbacks.unregister(c);
    }

    /**
     * @param item
     * @param value
     */
    private final void notifyConfigChanged(int item, int value) {
        // can be null in testing
        if (mCallbacks == null) {
            return;
        }
        synchronized (mCallbacks) {
            mCallbacks.broadcastAction(c -> {
                try {
                    c.onIntConfigChanged(item, value);
                } catch (RemoteException e) {
                    Log.w(TAG, "notifyConfigChanged(int): dead binder in notify, skipping.");
                }
            });
        }
    }

    private void notifyConfigChanged(int item, String value) {
        // can be null in testing
        if (mCallbacks == null) {
            return;
        }
        synchronized (mCallbacks) {
            mCallbacks.broadcastAction(c -> {
                try {
                    c.onStringConfigChanged(item, value);
                } catch (RemoteException e) {
                    Log.w(TAG, "notifyConfigChanged(string): dead binder in notify, skipping.");
                }
            });
        }
    }

    private void addRcsConfigCallback(IRcsConfigCallback c) {
        mRcsCallbacks.register(c);

        // This is used to avoid calling the binder out of the synchronized scope.
        byte[] cloneRcsConfigData;
        synchronized (mRcsConfigDataLock) {
            if (mRcsConfigData == null) {
                return;
            }
            cloneRcsConfigData = mRcsConfigData.clone();
        }

        try {
            c.onConfigurationChanged(cloneRcsConfigData);
        } catch (RemoteException e) {
            Log.w(TAG, "dead binder to call onConfigurationChanged, skipping.");
        }
    }

    private void removeRcsConfigCallback(IRcsConfigCallback c) {
        mRcsCallbacks.unregister(c);
    }

    private void onNotifyRcsAutoConfigurationReceived(byte[] config, boolean isCompressed) {
        // cache uncompressed config
        final byte[] rcsConfigData = isCompressed ? RcsConfig.decompressGzip(config) : config;

        synchronized (mRcsConfigDataLock) {
            if (Arrays.equals(mRcsConfigData, config)) {
                return;
            }
            mRcsConfigData = rcsConfigData;
        }

        // can be null in testing
        if (mRcsCallbacks != null) {
            synchronized (mRcsCallbacks) {
                mRcsCallbacks.broadcastAction(c -> {
                    try {
                        // config is cloned here so modifications to the config passed to the
                        // vendor do not accidentally modify the cache.
                        c.onConfigurationChanged(rcsConfigData.clone());
                    } catch (RemoteException e) {
                        Log.w(TAG, "dead binder in notifyRcsAutoConfigurationReceived, skipping.");
                    }
                });
            }
        }
        notifyRcsAutoConfigurationReceived(config, isCompressed);
    }

    private void onNotifyRcsAutoConfigurationRemoved() {
        synchronized (mRcsConfigDataLock) {
            mRcsConfigData = null;
        }
        if (mRcsCallbacks != null) {
            synchronized (mRcsCallbacks) {
                mRcsCallbacks.broadcastAction(c -> {
                    try {
                        c.onConfigurationReset();
                    } catch (RemoteException e) {
                        Log.w(TAG, "dead binder in notifyRcsAutoConfigurationRemoved, skipping.");
                    }
                });
            }
        }
        notifyRcsAutoConfigurationRemoved();
    }

    /**
     * @hide
     */
    public IImsConfig getIImsConfig() { return mImsConfigStub; }

    /**
     * Updates provisioning value and notifies the framework of the change.
     * Doesn't call {@link #setConfig(int,int)} and assumes the result succeeded.
     * This should only be used when the IMS implementer implicitly changed provisioned values.
     *
     * @param item an integer key.
     * @param value in Integer format.
     */
    public final void notifyProvisionedValueChanged(int item, int value) {
        mImsConfigStub.updateCachedValue(item, value);

        try {
            mImsConfigStub.notifyImsConfigChanged(item, value);
        } catch (RemoteException e) {
            Log.w(TAG, "notifyProvisionedValueChanged(int): Framework connection is dead.");
        }
    }

    /**
     * Updates provisioning value and notifies the framework of the change.
     * Doesn't call {@link #setConfig(int,String)} and assumes the result succeeded.
     * This should only be used when the IMS implementer implicitly changed provisioned values.
     *
     * @param item an integer key.
     * @param value in String format.
     */
    public final void notifyProvisionedValueChanged(int item, String value) {
        mImsConfigStub.updateCachedValue(item, value);

        try {
            mImsConfigStub.notifyImsConfigChanged(item, value);
        } catch (RemoteException e) {
            Log.w(TAG, "notifyProvisionedValueChanged(string): Framework connection is dead.");
        }
    }

    /**
     * The framework has received an RCS autoconfiguration XML file for provisioning.
     *
     * @param config The XML file to be read, if not compressed, it should be in ASCII/UTF8 format.
     * @param isCompressed The XML file is compressed in gzip format and must be decompressed
     *         before being read.
     *
     */
    public void notifyRcsAutoConfigurationReceived(@NonNull byte[] config, boolean isCompressed) {
    }

    /**
     * The RCS autoconfiguration XML file is removed or invalid.
     */
    public void notifyRcsAutoConfigurationRemoved() {
    }

    /**
     * Sets the configuration value for this ImsService.
     *
     * @param item an integer key.
     * @param value an integer containing the configuration value.
     * @return the result of setting the configuration value.
     */
    public @SetConfigResult int setConfig(int item, int value) {
        // Base Implementation - To be overridden.
        return CONFIG_RESULT_FAILED;
    }

    /**
     * Sets the configuration value for this ImsService.
     *
     * @param item an integer key.
     * @param value a String containing the new configuration value.
     * @return Result of setting the configuration value.
     */
    public @SetConfigResult int setConfig(int item, String value) {
        // Base Implementation - To be overridden.
        return CONFIG_RESULT_FAILED;
    }

    /**
     * Gets the currently stored value configuration value from the ImsService for {@code item}.
     *
     * @param item an integer key.
     * @return configuration value, stored in integer format or {@link #CONFIG_RESULT_UNKNOWN} if
     * unavailable.
     */
    public int getConfigInt(int item) {
        // Base Implementation - To be overridden.
        return CONFIG_RESULT_UNKNOWN;
    }

    /**
     * Gets the currently stored value configuration value from the ImsService for {@code item}.
     *
     * @param item an integer key.
     * @return configuration value, stored in String format or {@code null} if unavailable.
     */
    public String getConfigString(int item) {
        // Base Implementation - To be overridden.
        return null;
    }

    /**
     * @hide
     */
    public void updateImsCarrierConfigs(PersistableBundle bundle) {
        // Base Implementation - Should be overridden
    }

    /**
     * Default messaging application parameters are sent to the ACS client
     * using this interface.
     * @param rcc RCS client configuration {@link RcsClientConfiguration}
     */
    public void setRcsClientConfiguration(@NonNull RcsClientConfiguration rcc) {
        // Base Implementation - Should be overridden
    }

    /**
     * Reconfiguration triggered by the RCS application. Most likely cause
     * is the 403 forbidden to a SIP/HTTP request
     */
    public void triggerAutoConfiguration() {
        // Base Implementation - Should be overridden
    }

    /**
     * Errors during autoconfiguration connection setup are notified by the
     * ACS client using this interface.
     * @param errorCode HTTP error received during connection setup.
     * @param errorString reason phrase received with the error
     */
    public final void notifyAutoConfigurationErrorReceived(int errorCode,
            @NonNull String errorString) {
        // can be null in testing
        if (mRcsCallbacks == null) {
            return;
        }
        synchronized (mRcsCallbacks) {
            mRcsCallbacks.broadcastAction(c -> {
                try {
                    c.onAutoConfigurationErrorReceived(errorCode, errorString);
                } catch (RemoteException e) {
                    Log.w(TAG, "dead binder in notifyAutoConfigurationErrorReceived, skipping.");
                }
            });
        }
    }

    /**
     * Notifies application that pre-provisioning config is received.
     *
     * <p>Some carriers using ACS (auto configuration server) may send a carrier-specific
     * pre-provisioning configuration XML if the user has not been provisioned for RCS
     * services yet. When such provisioning XML is received, ACS client must call this
     * method to notify the application with the XML.
     *
     * @param configXml the pre-provisioning config in carrier specified format.
     */
    public final void notifyPreProvisioningReceived(@NonNull byte[] configXml) {
        // can be null in testing
        if (mRcsCallbacks == null) {
            return;
        }
        synchronized (mRcsCallbacks) {
            mRcsCallbacks.broadcastAction(c -> {
                try {
                    c.onPreProvisioningReceived(configXml);
                } catch (RemoteException e) {
                    Log.w(TAG, "dead binder in notifyPreProvisioningReceived, skipping.");
                }
            });
        }
    }

    /**
     * Set default Executor from ImsService.
     * @param executor The default executor for the framework to use when executing the methods
     * overridden by the implementation of ImsConfig.
     * @hide
     */
    public final void setDefaultExecutor(@NonNull Executor executor) {
        if (mImsConfigStub.mExecutor == null) {
            mImsConfigStub.mExecutor = executor;
        }
    }

    /**
     * Clear all cached config data. This will be called when the config data is no longer valid
     * such as when the SIM was removed.
     * @hide
     */
    public final void clearConfigurationCache() {
        mImsConfigStub.clearCachedValue();

        synchronized (mRcsConfigDataLock) {
            mRcsConfigData = null;
        }
    }
}