android-16.0.0_r2/s

/*
 * 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.feature;

import static com.android.internal.telephony.flags.Flags.FLAG_SUPPORT_IMS_MMTEL_INTERFACE;

import android.annotation.CallbackExecutor;
import android.annotation.FlaggedApi;
import android.annotation.IntDef;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.annotation.SystemApi;
import android.os.Binder;
import android.os.Bundle;
import android.os.Message;
import android.os.RemoteException;
import android.os.ServiceSpecificException;
import android.telecom.TelecomManager;
import android.telephony.AccessNetworkConstants;
import android.telephony.ims.ImsCallProfile;
import android.telephony.ims.ImsCallSession;
import android.telephony.ims.ImsCallSessionListener;
import android.telephony.ims.ImsException;
import android.telephony.ims.ImsReasonInfo;
import android.telephony.ims.ImsService;
import android.telephony.ims.MediaQualityStatus;
import android.telephony.ims.MediaThreshold;
import android.telephony.ims.RtpHeaderExtensionType;
import android.telephony.ims.SrvccCall;
import android.telephony.ims.aidl.IImsCallSessionListener;
import android.telephony.ims.aidl.IImsCapabilityCallback;
import android.telephony.ims.aidl.IImsMmTelFeature;
import android.telephony.ims.aidl.IImsMmTelListener;
import android.telephony.ims.aidl.IImsSmsListener;
import android.telephony.ims.aidl.IImsTrafficSessionCallback;
import android.telephony.ims.aidl.ISrvccStartedCallback;
import android.telephony.ims.stub.ImsCallSessionImplBase;
import android.telephony.ims.stub.ImsEcbmImplBase;
import android.telephony.ims.stub.ImsMultiEndpointImplBase;
import android.telephony.ims.stub.ImsRegistrationImplBase;
import android.telephony.ims.stub.ImsSmsImplBase;
import android.telephony.ims.stub.ImsUtImplBase;
import android.util.ArraySet;
import android.util.Log;

import com.android.ims.internal.IImsCallSession;
import com.android.ims.internal.IImsEcbm;
import com.android.ims.internal.IImsMultiEndpoint;
import com.android.ims.internal.IImsUt;
import com.android.internal.telephony.util.TelephonyUtils;
import com.android.server.telecom.flags.Flags;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.ref.WeakReference;
import java.util.HashMap;
import java.util.List;
import java.util.Set;
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.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Consumer;
import java.util.function.Supplier;

/**
 * Base implementation for Voice and SMS (IR-92) and Video (IR-94) IMS support.
 *
 * Any class wishing to use MmTelFeature should extend this class and implement all methods that the
 * service supports.
 */
public class MmTelFeature extends ImsFeature {

    private static final String LOG_TAG = "MmTelFeature";
    private Executor mExecutor;
    private ImsSmsImplBase mSmsImpl;

    private HashMap<ImsTrafficSessionCallback, ImsTrafficSessionCallbackWrapper> mTrafficCallbacks =
            new HashMap<>();
    /**
     * Creates a new MmTelFeature using the Executor set in {@link ImsService#getExecutor}
     * @hide
     */
    @SystemApi
    public MmTelFeature() {
    }

    /**
     * Create a new MmTelFeature 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 MmTelFeature.
     * @hide
     */
    @SystemApi
    public MmTelFeature(@NonNull Executor executor) {
        super();
        mExecutor = executor;
    }

    private final IImsMmTelFeature mImsMMTelBinder = new IImsMmTelFeature.Stub() {

        @Override
        public void setListener(IImsMmTelListener l) {
            executeMethodAsyncNoException(() -> MmTelFeature.this.setListener(l), "setListener");
        }

        @Override
        public int getFeatureState() throws RemoteException {
            return executeMethodAsyncForResult(() -> MmTelFeature.this.getFeatureState(),
                    "getFeatureState");
        }

        @Override
        public ImsCallProfile createCallProfile(int callSessionType, int callType)
                throws RemoteException {
            return executeMethodAsyncForResult(() -> MmTelFeature.this.createCallProfile(
                    callSessionType, callType), "createCallProfile");
        }

        @Override
        public void changeOfferedRtpHeaderExtensionTypes(List<RtpHeaderExtensionType> types)
                throws RemoteException {
            executeMethodAsync(() -> MmTelFeature.this.changeOfferedRtpHeaderExtensionTypes(
                    new ArraySet<>(types)), "changeOfferedRtpHeaderExtensionTypes");
        }

        @Override
        public IImsCallSession createCallSession(ImsCallProfile profile) throws RemoteException {
            AtomicReference<RemoteException> exceptionRef = new AtomicReference<>();
            IImsCallSession result = executeMethodAsyncForResult(() -> {
                try {
                    return createCallSessionInterface(profile);
                } catch (RemoteException e) {
                    exceptionRef.set(e);
                    return null;
                }
            }, "createCallSession");

            if (exceptionRef.get() != null) {
                throw exceptionRef.get();
            }

            return result;
        }

        @Override
        public int shouldProcessCall(String[] numbers) {
            Integer result = executeMethodAsyncForResultNoException(() ->
                    MmTelFeature.this.shouldProcessCall(numbers), "shouldProcessCall");
            if (result != null) {
                return result.intValue();
            } else {
                return PROCESS_CALL_CSFB;
            }
        }

        @Override
        public IImsUt getUtInterface() throws RemoteException {
            AtomicReference<RemoteException> exceptionRef = new AtomicReference<>();
            IImsUt result = executeMethodAsyncForResult(() -> {
                try {
                    return MmTelFeature.this.getUtInterface();
                } catch (RemoteException e) {
                    exceptionRef.set(e);
                    return null;
                }
            }, "getUtInterface");

            if (exceptionRef.get() != null) {
                throw exceptionRef.get();
            }

            return result;
        }

        @Override
        public IImsEcbm getEcbmInterface() throws RemoteException {
            AtomicReference<RemoteException> exceptionRef = new AtomicReference<>();
            IImsEcbm result = executeMethodAsyncForResult(() -> {
                try {
                    return MmTelFeature.this.getEcbmInterface();
                } catch (RemoteException e) {
                    exceptionRef.set(e);
                    return null;
                }
            }, "getEcbmInterface");

            if (exceptionRef.get() != null) {
                throw exceptionRef.get();
            }

            return result;
        }

        @Override
        public void setUiTtyMode(int uiTtyMode, Message onCompleteMessage) throws RemoteException {
            executeMethodAsync(() -> MmTelFeature.this.setUiTtyMode(uiTtyMode, onCompleteMessage),
                    "setUiTtyMode");
        }

        @Override
        public IImsMultiEndpoint getMultiEndpointInterface() throws RemoteException {
            AtomicReference<RemoteException> exceptionRef = new AtomicReference<>();
            IImsMultiEndpoint result = executeMethodAsyncForResult(() -> {
                try {
                    return MmTelFeature.this.getMultiEndpointInterface();
                } catch (RemoteException e) {
                    exceptionRef.set(e);
                    return null;
                }
            }, "getMultiEndpointInterface");

            if (exceptionRef.get() != null) {
                throw exceptionRef.get();
            }

            return result;
        }

        @Override
        public int queryCapabilityStatus() {
            Integer result = executeMethodAsyncForResultNoException(() -> MmTelFeature.this
                    .queryCapabilityStatus().mCapabilities, "queryCapabilityStatus");

            if (result != null) {
                return result.intValue();
            } else {
                return 0;
            }
        }

        @Override
        public void addCapabilityCallback(IImsCapabilityCallback c) {
            executeMethodAsyncNoException(() -> MmTelFeature.this
                    .addCapabilityCallback(c), "addCapabilityCallback");
        }

        @Override
        public void removeCapabilityCallback(IImsCapabilityCallback c) {
            executeMethodAsyncNoException(() -> MmTelFeature.this
                    .removeCapabilityCallback(c), "removeCapabilityCallback");
        }

        @Override
        public void changeCapabilitiesConfiguration(CapabilityChangeRequest request,
                IImsCapabilityCallback c) {
            executeMethodAsyncNoException(() -> MmTelFeature.this
                            .requestChangeEnabledCapabilities(request, c),
                    "changeCapabilitiesConfiguration");
        }

        @Override
        public void queryCapabilityConfiguration(int capability, int radioTech,
                IImsCapabilityCallback c) {
            executeMethodAsyncNoException(() -> queryCapabilityConfigurationInternal(
                    capability, radioTech, c), "queryCapabilityConfiguration");
        }

        @Override
        public void setMediaQualityThreshold(@MediaQualityStatus.MediaSessionType int sessionType,
                MediaThreshold mediaThreshold) {
            if (mediaThreshold != null) {
                executeMethodAsyncNoException(() -> setMediaThreshold(sessionType, mediaThreshold),
                        "setMediaQualityThreshold");
            } else {
                executeMethodAsyncNoException(() -> clearMediaThreshold(sessionType),
                        "clearMediaQualityThreshold");
            }
        }

        @Override
        public MediaQualityStatus queryMediaQualityStatus(
                @MediaQualityStatus.MediaSessionType int sessionType)
                throws RemoteException {
            return executeMethodAsyncForResult(() -> MmTelFeature.this.queryMediaQualityStatus(
                    sessionType), "queryMediaQualityStatus");
        }

        @Override
        public void setSmsListener(IImsSmsListener l) {
            executeMethodAsyncNoException(() -> MmTelFeature.this.setSmsListener(l),
                    "setSmsListener", getImsSmsImpl().getExecutor());
        }

        @Override
        public void sendSms(int token, int messageRef, String format, String smsc, boolean retry,
                byte[] pdu) {
            executeMethodAsyncNoException(() -> MmTelFeature.this
                    .sendSms(token, messageRef, format, smsc, retry, pdu), "sendSms",
                    getImsSmsImpl().getExecutor());
        }

        @Override
        public void onMemoryAvailable(int token) {
            executeMethodAsyncNoException(() -> MmTelFeature.this
                    .onMemoryAvailable(token), "onMemoryAvailable", getImsSmsImpl().getExecutor());
        }

        @Override
        public void acknowledgeSms(int token, int messageRef, int result) {
            executeMethodAsyncNoException(() -> MmTelFeature.this
                    .acknowledgeSms(token, messageRef, result), "acknowledgeSms",
                    getImsSmsImpl().getExecutor());
        }

        @Override
        public void acknowledgeSmsWithPdu(int token, int messageRef, int result, byte[] pdu) {
            executeMethodAsyncNoException(() -> MmTelFeature.this
                    .acknowledgeSms(token, messageRef, result, pdu), "acknowledgeSms",
                    getImsSmsImpl().getExecutor());
        }

        @Override
        public void acknowledgeSmsReport(int token, int messageRef, int result) {
            executeMethodAsyncNoException(() -> MmTelFeature.this
                    .acknowledgeSmsReport(token, messageRef, result), "acknowledgeSmsReport",
                    getImsSmsImpl().getExecutor());
        }

        @Override
        public String getSmsFormat() {
            return executeMethodAsyncForResultNoException(() -> MmTelFeature.this
                    .getSmsFormat(), "getSmsFormat", getImsSmsImpl().getExecutor());
        }

        @Override
        public void onSmsReady() {
            executeMethodAsyncNoException(() -> MmTelFeature.this.onSmsReady(),
                    "onSmsReady", getImsSmsImpl().getExecutor());
        }

        @Override
        public void notifySrvccStarted(final ISrvccStartedCallback cb) {
            executeMethodAsyncNoException(
                    () -> MmTelFeature.this.notifySrvccStarted(
                            (profiles) -> {
                                try {
                                    cb.onSrvccCallNotified(profiles);
                                } catch (Exception e) {
                                    Log.e(LOG_TAG, "onSrvccCallNotified e=" + e);
                                }
                            }),
                    "notifySrvccStarted");
        }

        @Override
        public void notifySrvccCompleted() {
            executeMethodAsyncNoException(
                    () -> MmTelFeature.this.notifySrvccCompleted(), "notifySrvccCompleted");
        }

        @Override
        public void notifySrvccFailed() {
            executeMethodAsyncNoException(
                    () -> MmTelFeature.this.notifySrvccFailed(), "notifySrvccFailed");
        }

        @Override
        public void notifySrvccCanceled() {
            executeMethodAsyncNoException(
                    () -> MmTelFeature.this.notifySrvccCanceled(), "notifySrvccCanceled");
        }

        @Override
        public void setTerminalBasedCallWaitingStatus(boolean enabled) throws RemoteException {
            synchronized (mLock) {
                try {
                    MmTelFeature.this.setTerminalBasedCallWaitingStatus(enabled);
                } catch (ServiceSpecificException se) {
                    throw new ServiceSpecificException(se.errorCode, se.getMessage());
                } catch (Exception e) {
                    throw new RemoteException(e.getMessage());
                }
            }
        }

        // 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(LOG_TAG, "MmTelFeature Binder - " + errorLogName + " exception: "
                        + e.getMessage());
                throw new RemoteException(e.getMessage());
            }
        }

        private void executeMethodAsyncNoException(Runnable r, String errorLogName) {
            try {
                CompletableFuture.runAsync(
                        () -> TelephonyUtils.runWithCleanCallingIdentity(r), mExecutor).join();
            } catch (CancellationException | CompletionException e) {
                Log.w(LOG_TAG, "MmTelFeature Binder - " + errorLogName + " exception: "
                        + e.getMessage());
            }
        }

        private void executeMethodAsyncNoException(Runnable r, String errorLogName,
                Executor executor) {
            try {
                CompletableFuture.runAsync(
                        () -> TelephonyUtils.runWithCleanCallingIdentity(r), executor).join();
            } catch (CancellationException | CompletionException e) {
                Log.w(LOG_TAG, "MmTelFeature Binder - " + errorLogName + " exception: "
                        + 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(LOG_TAG, "MmTelFeature Binder - " + errorLogName + " exception: "
                        + e.getMessage());
                throw new RemoteException(e.getMessage());
            }
        }

        private <T> T executeMethodAsyncForResultNoException(Supplier<T> r,
                String errorLogName) {
            CompletableFuture<T> future = CompletableFuture.supplyAsync(
                    () -> TelephonyUtils.runWithCleanCallingIdentity(r), mExecutor);
            try {
                return future.get();
            } catch (ExecutionException | InterruptedException e) {
                Log.w(LOG_TAG, "MmTelFeature Binder - " + errorLogName + " exception: "
                        + e.getMessage());
                return null;
            }
        }

        private <T> T executeMethodAsyncForResultNoException(Supplier<T> r,
                String errorLogName, Executor executor) {
            CompletableFuture<T> future = CompletableFuture.supplyAsync(
                    () -> TelephonyUtils.runWithCleanCallingIdentity(r), executor);
            try {
                return future.get();
            } catch (ExecutionException | InterruptedException e) {
                Log.w(LOG_TAG, "MmTelFeature Binder - " + errorLogName + " exception: "
                        + e.getMessage());
                return null;
            }
        }
    };

    /**
     * Contains the capabilities defined and supported by a MmTelFeature in the form of a Bitmask.
     * The capabilities that are used in MmTelFeature are defined as
     * {@link MmTelCapabilities#CAPABILITY_TYPE_VOICE},
     * {@link MmTelCapabilities#CAPABILITY_TYPE_VIDEO},
     * {@link MmTelCapabilities#CAPABILITY_TYPE_UT},
     * {@link MmTelCapabilities#CAPABILITY_TYPE_SMS}, and
     * {@link MmTelCapabilities#CAPABILITY_TYPE_CALL_COMPOSER}.
     *
     * The capabilities of this MmTelFeature will be set by the framework.
     */
    public static class MmTelCapabilities extends Capabilities {

        /**
         * Create a new empty {@link MmTelCapabilities} instance.
         * @see #addCapabilities(int)
         * @see #removeCapabilities(int)
         * @hide
         */
        @SystemApi
        public MmTelCapabilities() {
            super();
        }

        /**@deprecated Use {@link MmTelCapabilities} to construct a new instance instead.
         * @hide
         */
        @Deprecated
        @SystemApi
        public MmTelCapabilities(Capabilities c) {
            mCapabilities = c.mCapabilities;
        }

        /**
         * Create a new {link @MmTelCapabilities} instance with the provided capabilities.
         * @param capabilities The capabilities that are supported for MmTel in the form of a
         *                     bitfield.
         * @hide
         */
        @SystemApi
        public MmTelCapabilities(@MmTelCapability int capabilities) {
            super(capabilities);
        }

        /** @hide */
        @IntDef(flag = true,
                value = {
                        CAPABILITY_TYPE_VOICE,
                        CAPABILITY_TYPE_VIDEO,
                        CAPABILITY_TYPE_UT,
                        CAPABILITY_TYPE_SMS,
                        CAPABILITY_TYPE_CALL_COMPOSER,
                        CAPABILITY_TYPE_CALL_COMPOSER_BUSINESS_ONLY
                })
        @Retention(RetentionPolicy.SOURCE)
        public @interface MmTelCapability {}

        /**
         * Undefined capability type for initialization
         * This is used to check the upper range of MmTel capability
         * @hide
         */
        public static final int CAPABILITY_TYPE_NONE = 0;

        /**
         * This MmTelFeature supports Voice calling (IR.92)
         */
        public static final int CAPABILITY_TYPE_VOICE = 1 << 0;

        /**
         * This MmTelFeature supports Video (IR.94)
         */
        public static final int CAPABILITY_TYPE_VIDEO = 1 << 1;

        /**
         * This MmTelFeature supports XCAP over Ut for supplementary services. (IR.92)
         */
        public static final int CAPABILITY_TYPE_UT = 1 << 2;

        /**
         * This MmTelFeature supports SMS (IR.92)
         */
        public static final int CAPABILITY_TYPE_SMS = 1 << 3;

        /**
         * This MmTelFeature supports Call Composer (section 2.4 of RC.20). This is the superset
         * Call Composer, meaning that all subset types of Call Composers must be enabled when this
         * capability is enabled
         */
        public static final int CAPABILITY_TYPE_CALL_COMPOSER = 1 << 4;


        /**
         * This MmTelFeature supports Business-only Call Composer. This is a subset of
         * {@code CAPABILITY_TYPE_CALL_COMPOSER} that only supports business related
         * information for calling (e.g. information to signal if the call is a business call) in
         * the SIP header.  When enabling {@code CAPABILITY_TYPE_CALL_COMPOSER}, the
         * {@code CAPABILITY_TYPE_CALL_COMPOSER_BUSINESS_ONLY} capability must also be enabled.
         */
        @FlaggedApi(Flags.FLAG_BUSINESS_CALL_COMPOSER)
        public static final int CAPABILITY_TYPE_CALL_COMPOSER_BUSINESS_ONLY = 1 << 5;

        /**
         * This is used to check the upper range of MmTel capability
         * @hide
         */
        public static final int CAPABILITY_TYPE_MAX =
                CAPABILITY_TYPE_CALL_COMPOSER_BUSINESS_ONLY + 1;

        /**
         * @hide
         */
        @Override
        @SystemApi
        public final void addCapabilities(@MmTelCapability int capabilities) {
            super.addCapabilities(capabilities);
        }

        /**
         * @hide
         */
        @Override
        @SystemApi
        public final void removeCapabilities(@MmTelCapability int capability) {
            super.removeCapabilities(capability);
        }

        /**
         * @param capabilities a bitmask of one or more capabilities.
         *
         * @return true if all queried capabilities are true, otherwise false.
         */
        @Override
        public final boolean isCapable(@MmTelCapability int capabilities) {
            return super.isCapable(capabilities);
        }

        /**
         * @hide
         */
        @NonNull
        @Override
        public String toString() {
            StringBuilder builder = new StringBuilder("MmTel Capabilities - [");
            builder.append("Voice: ");
            builder.append(isCapable(CAPABILITY_TYPE_VOICE));
            builder.append(" Video: ");
            builder.append(isCapable(CAPABILITY_TYPE_VIDEO));
            builder.append(" UT: ");
            builder.append(isCapable(CAPABILITY_TYPE_UT));
            builder.append(" SMS: ");
            builder.append(isCapable(CAPABILITY_TYPE_SMS));
            builder.append(" CALL_COMPOSER: ");
            builder.append(isCapable(CAPABILITY_TYPE_CALL_COMPOSER));
            builder.append(" BUSINESS_COMPOSER_ONLY: ");
            builder.append(isCapable(CAPABILITY_TYPE_CALL_COMPOSER_BUSINESS_ONLY));
            builder.append("]");
            return builder.toString();
        }
    }

    /**
     * Listener that the framework implements for communication from the MmTelFeature.
     * @hide
     */
    public static class Listener extends IImsMmTelListener.Stub {

        /**
         * Called when the IMS provider receives an incoming call.
         * @param c The {@link ImsCallSession} associated with the new call.
         * @param callId The call ID of the session of the new incoming call.
         * @param extras A bundle containing extra parameters related to the call. See
         * {@link #EXTRA_IS_UNKNOWN_CALL} and {@link #EXTRA_IS_USSD} above.
         * @return the listener to listen to the session events. An {@link ImsCallSession} can only
         *         hold one listener at a time. see {@link ImsCallSessionListener}.
         *         If this method returns {@code null}, then the call could not be placed.
         * @hide
         */
        @Override
        @Nullable
        public IImsCallSessionListener onIncomingCall(IImsCallSession c,
                String callId, Bundle extras) {
            return null;
        }

        /**
         * Called when the IMS provider implicitly rejects an incoming call during setup.
         * @param callProfile An {@link ImsCallProfile} with the call details.
         * @param reason The {@link ImsReasonInfo} reason for call rejection.
         * @hide
         */
        @Override
        public void onRejectedCall(ImsCallProfile callProfile, ImsReasonInfo reason) {

        }

        /**
         * Updates the Listener when the voice message count for IMS has changed.
         * @param count an integer representing the new message count.
         * @hide
         */
        @Override
        public void onVoiceMessageCountUpdate(int count) {

        }

        /**
         * Called to set the audio handler for this connection.
         * @param imsAudioHandler an {@link ImsAudioHandler} used to handle the audio
         *        for this IMS call.
         * @hide
         */
        @Override
        public void onAudioModeIsVoipChanged(int imsAudioHandler) {

        }

        /**
         * Called when the IMS triggers EPS fallback procedure.
         *
         * @param reason specifies the reason that causes EPS fallback.
         * @hide
         */
        @Override
        public void onTriggerEpsFallback(@EpsFallbackReason int reason) {

        }

        /**
         * Called when the IMS notifies the upcoming traffic type to the radio.
         *
         * @param token A nonce to identify the request
         * @param trafficType The {@link ImsTrafficType} type for IMS traffic.
         * @param accessNetworkType The {@link AccessNetworkConstants#RadioAccessNetworkType}
         *        type of the radio access network.
         * @param trafficDirection Indicates whether traffic is originated by mobile originated or
         *        mobile terminated use case eg. MO/MT call/SMS etc.
         * @param callback The callback to receive the result.
         * @hide
         */
        @Override
        public void onStartImsTrafficSession(int token,
                @ImsTrafficType int trafficType,
                @AccessNetworkConstants.RadioAccessNetworkType int accessNetworkType,
                @ImsTrafficDirection int trafficDirection,
                IImsTrafficSessionCallback callback) {

        }

        /**
         * Called when the IMS notifies the traffic type has been stopped.
         *
         * @param token A nonce registered with {@link #onStartImsTrafficSession}.
         * @param accessNetworkType The {@link AccessNetworkConstants#RadioAccessNetworkType}
         *        type of the radio access network.
         * @hide
         */
        @Override
        public void onModifyImsTrafficSession(int token,
                @AccessNetworkConstants.RadioAccessNetworkType int accessNetworkType) {

        }

        /**
         * Called when the IMS notifies the traffic type has been stopped.
         *
         * @param token A nonce registered with {@link #onStartImsTrafficSession}.
         * @hide
         */
        @Override
        public void onStopImsTrafficSession(int token) {

        }

        /**
         * Called when the IMS provider notifies {@link MediaQualityStatus}.
         *
         * @param status media quality status currently measured.
         * @hide
         */
        @Override
        public void onMediaQualityStatusChanged(MediaQualityStatus status) {

        }
    }

    /**
     * A wrapper class of {@link ImsTrafficSessionCallback}.
     * @hide
     */
    public static class ImsTrafficSessionCallbackWrapper {
        public static final int INVALID_TOKEN = -1;

        private static final int MAX_TOKEN = 0x10000;

        private static final AtomicInteger sTokenGenerator = new AtomicInteger();

        /** Callback to receive the response */
        private IImsTrafficSessionCallbackStub mCallback = null;
        /** Identifier to distinguish each IMS traffic request */
        private int mToken = INVALID_TOKEN;

        private ImsTrafficSessionCallback mImsTrafficSessionCallback;

        private ImsTrafficSessionCallbackWrapper(ImsTrafficSessionCallback callback) {
            mImsTrafficSessionCallback = callback;
        }

        /**
         * Updates the callback.
         *
         * The mToken should be kept since it is used to identify the traffic notified to the modem
         * until calling {@link MmtelFEature#stopImsTrafficSession}.
         */
        final void update(@NonNull @CallbackExecutor Executor executor) {
            if (executor == null) {
                throw new IllegalArgumentException(
                        "ImsTrafficSessionCallback Executor must be non-null");
            }

            if (mCallback == null) {
                // initial start of Ims traffic.
                mCallback = new IImsTrafficSessionCallbackStub(
                        mImsTrafficSessionCallback, executor);
                mToken = generateToken();
            } else {
                // handover between cellular and Wi-Fi
                mCallback.update(executor);
            }
        }

        /**
         * Using a static class and weak reference here to avoid memory leak caused by the
         * {@link IImsTrafficSessionCallback.Stub} callback retaining references to the outside
         * {@link ImsTrafficSessionCallback}.
         */
        private static class IImsTrafficSessionCallbackStub
                extends IImsTrafficSessionCallback.Stub {
            private WeakReference<ImsTrafficSessionCallback> mImsTrafficSessionCallbackWeakRef;
            private Executor mExecutor;

            IImsTrafficSessionCallbackStub(ImsTrafficSessionCallback imsTrafficCallback,
                    Executor executor) {
                mImsTrafficSessionCallbackWeakRef =
                        new WeakReference<ImsTrafficSessionCallback>(imsTrafficCallback);
                mExecutor = executor;
            }

            void update(Executor executor) {
                mExecutor = executor;
            }

            @Override
            public void onReady() {
                ImsTrafficSessionCallback callback = mImsTrafficSessionCallbackWeakRef.get();
                if (callback == null) return;

                Binder.withCleanCallingIdentity(
                        () -> mExecutor.execute(() -> callback.onReady()));
            }

            @Override
            public void onError(ConnectionFailureInfo info) {
                ImsTrafficSessionCallback callback = mImsTrafficSessionCallbackWeakRef.get();
                if (callback == null) return;

                Binder.withCleanCallingIdentity(
                        () -> mExecutor.execute(() -> callback.onError(info)));
            }
        }

        /**
         * Returns the callback binder.
         */
        final IImsTrafficSessionCallbackStub getCallbackBinder() {
            return mCallback;
        }

        /**
         * Returns the token.
         */
        final int getToken() {
            return mToken;
        }

        /**
         * Resets the members.
         * It's called by {@link MmTelFeature#stopImsTrafficSession}.
         */
        final void reset() {
            mCallback = null;
            mToken = INVALID_TOKEN;
        }

        private static int generateToken() {
            int token = sTokenGenerator.incrementAndGet();
            if (token == MAX_TOKEN) sTokenGenerator.set(0);
            return token;
        }
    }

    /**
     * To be returned by {@link #shouldProcessCall(String[])} when the ImsService should process the
     * outgoing call as IMS.
     * @hide
     */
    @SystemApi
    public static final int PROCESS_CALL_IMS = 0;
    /**
     * To be returned by {@link #shouldProcessCall(String[])} when the telephony framework should
     * not process the outgoing call as IMS and should instead use circuit switch.
     * @hide
     */
    @SystemApi
    public static final int PROCESS_CALL_CSFB = 1;

    /** @hide */
    @IntDef(flag = true,
            value = {
                    PROCESS_CALL_IMS,
                    PROCESS_CALL_CSFB
            })
    @Retention(RetentionPolicy.SOURCE)
    public @interface ProcessCallResult {}

    /**
     * If the flag is present and true, it indicates that the incoming call is for USSD.
     * <p>
     * This is an optional boolean flag.
     * @hide
     */
    @SystemApi
    public static final String EXTRA_IS_USSD = "android.telephony.ims.feature.extra.IS_USSD";

    /**
     * If this flag is present and true, this call is marked as an unknown dialing call instead
     * of an incoming call. An example of such a call is a call that is originated by sending
     * commands (like AT commands) directly to the modem without Android involvement or dialing
     * calls appearing over IMS when the modem does a silent redial from circuit-switched to IMS in
     * certain situations.
     * <p>
     * This is an optional boolean flag.
     * @hide
     */
    @SystemApi
    public static final String EXTRA_IS_UNKNOWN_CALL =
            "android.telephony.ims.feature.extra.IS_UNKNOWN_CALL";

    /** @hide */
    @IntDef(
        prefix = "AUDIO_HANDLER_",
        value = {
            AUDIO_HANDLER_ANDROID,
            AUDIO_HANDLER_BASEBAND
        })
    @Retention(RetentionPolicy.SOURCE)
    public @interface ImsAudioHandler {}

    /**
    * Audio Handler - Android
    * @hide
    */
    @SystemApi
    public static final int AUDIO_HANDLER_ANDROID = 0;

    /**
    * Audio Handler - Baseband
    * @hide
    */
    @SystemApi
    public static final int AUDIO_HANDLER_BASEBAND = 1;

    /** @hide */
    @Retention(RetentionPolicy.SOURCE)
    @IntDef(
        prefix = "EPS_FALLBACK_REASON_",
        value = {
            EPS_FALLBACK_REASON_INVALID,
            EPS_FALLBACK_REASON_NO_NETWORK_TRIGGER,
            EPS_FALLBACK_REASON_NO_NETWORK_RESPONSE,
        })
    public @interface EpsFallbackReason {}

    /**
     * Default value. Internal use only.
     * This value should not be used to trigger EPS fallback.
     * @hide
     */
    public static final int EPS_FALLBACK_REASON_INVALID = -1;

    /**
     * If the network only supports the EPS fallback in 5G NR SA for voice calling and the EPS
     * Fallback procedure by the network during the call setup is not triggered, UE initiated
     * fallback will be triggered with this reason. The modem shall locally release the 5G NR
     * SA RRC connection and acquire the LTE network and perform a tracking area update
     * procedure. After the EPS fallback procedure is completed, the call setup for voice will
     * be established if there is no problem.
     *
     * @hide
     */
    @FlaggedApi(FLAG_SUPPORT_IMS_MMTEL_INTERFACE)
    @SystemApi
    public static final int EPS_FALLBACK_REASON_NO_NETWORK_TRIGGER = 1;

    /**
     * If the UE doesn't receive any response for SIP INVITE within a certain timeout in 5G NR
     * SA for MO voice calling, the device determines that voice call is not available in 5G and
     * terminates all active SIP dialogs and SIP requests and enters IMS non-registered state.
     * In that case, UE initiated fallback will be triggered with this reason. The modem shall
     * reset modem's data buffer of IMS PDU to prevent the ghost call. After the EPS fallback
     * procedure is completed, VoLTE call could be tried if there is no problem.
     *
     * @hide
     */
    @FlaggedApi(FLAG_SUPPORT_IMS_MMTEL_INTERFACE)
    @SystemApi
    public static final int EPS_FALLBACK_REASON_NO_NETWORK_RESPONSE = 2;

    /** @hide */
    @Retention(RetentionPolicy.SOURCE)
    @IntDef(
        prefix = "IMS_TRAFFIC_TYPE_",
        value = {
            IMS_TRAFFIC_TYPE_NONE,
            IMS_TRAFFIC_TYPE_EMERGENCY,
            IMS_TRAFFIC_TYPE_EMERGENCY_SMS,
            IMS_TRAFFIC_TYPE_VOICE,
            IMS_TRAFFIC_TYPE_VIDEO,
            IMS_TRAFFIC_TYPE_SMS,
            IMS_TRAFFIC_TYPE_REGISTRATION,
            IMS_TRAFFIC_TYPE_UT_XCAP
        })
    public @interface ImsTrafficType {}

    /**
     * Default value for initialization. Internal use only.
     * @hide
     */
    public static final int IMS_TRAFFIC_TYPE_NONE = -1;
    /**
     * Emergency call
     * @hide
     */
    @FlaggedApi(FLAG_SUPPORT_IMS_MMTEL_INTERFACE)
    @SystemApi
    public static final int IMS_TRAFFIC_TYPE_EMERGENCY = 0;
    /**
     * Emergency SMS
     * @hide
     */
    @FlaggedApi(FLAG_SUPPORT_IMS_MMTEL_INTERFACE)
    @SystemApi
    public static final int IMS_TRAFFIC_TYPE_EMERGENCY_SMS = 1;
    /**
     * Voice call
     * @hide
     */
    @FlaggedApi(FLAG_SUPPORT_IMS_MMTEL_INTERFACE)
    @SystemApi
    public static final int IMS_TRAFFIC_TYPE_VOICE = 2;
    /**
     * Video call
     * @hide
     */
    @FlaggedApi(FLAG_SUPPORT_IMS_MMTEL_INTERFACE)
    @SystemApi
    public static final int IMS_TRAFFIC_TYPE_VIDEO = 3;
    /**
     * SMS over IMS
     * @hide
     */
    @FlaggedApi(FLAG_SUPPORT_IMS_MMTEL_INTERFACE)
    @SystemApi
    public static final int IMS_TRAFFIC_TYPE_SMS = 4;
    /**
     * IMS registration and subscription for reg event package (signaling)
     * @hide
     */
    @FlaggedApi(FLAG_SUPPORT_IMS_MMTEL_INTERFACE)
    @SystemApi
    public static final int IMS_TRAFFIC_TYPE_REGISTRATION = 5;
    /**
     * Ut/XCAP (XML Configuration Access Protocol)
     * @hide
     */
    @FlaggedApi(FLAG_SUPPORT_IMS_MMTEL_INTERFACE)
    @SystemApi
    public static final int IMS_TRAFFIC_TYPE_UT_XCAP = 6;

    /** @hide */
    @Retention(RetentionPolicy.SOURCE)
    @IntDef(
            prefix = { "IMS_TRAFFIC_DIRECTION_" },
            value = {IMS_TRAFFIC_DIRECTION_INCOMING, IMS_TRAFFIC_DIRECTION_OUTGOING})
    public @interface ImsTrafficDirection {}

    /**
     * Indicates that the traffic is an incoming traffic.
     * @hide
     */
    @FlaggedApi(FLAG_SUPPORT_IMS_MMTEL_INTERFACE)
    @SystemApi
    public static final int IMS_TRAFFIC_DIRECTION_INCOMING = 0;
    /**
     * Indicates that the traffic is an outgoing traffic.
     * @hide
     */
    @FlaggedApi(FLAG_SUPPORT_IMS_MMTEL_INTERFACE)
    @SystemApi
    public static final int IMS_TRAFFIC_DIRECTION_OUTGOING = 1;

    private IImsMmTelListener mListener;

    /**
     * @param listener A {@link Listener} used when the MmTelFeature receives an incoming call and
     *     notifies the framework.
     */
    private void setListener(IImsMmTelListener listener) {
        synchronized (mLock) {
            mListener = listener;
            if (mListener != null) {
                onFeatureReady();
            }
        }
    }

    /**
     * @return the listener associated with this MmTelFeature. May be null if it has not been set
     * by the framework yet.
     */
    private IImsMmTelListener getListener() {
        synchronized (mLock) {
            return mListener;
        }
    }

    /**
     * The current capability status that this MmTelFeature has defined is available. This
     * configuration will be used by the platform to figure out which capabilities are CURRENTLY
     * available to be used.
     *
     * Should be a subset of the capabilities that are enabled by the framework in
     * {@link #changeEnabledCapabilities}.
     * @return A copy of the current MmTelFeature capability status.
     * @hide
     */
    @Override
    @SystemApi
    public @NonNull final MmTelCapabilities queryCapabilityStatus() {
        return new MmTelCapabilities(super.queryCapabilityStatus());
    }

    /**
     * Notify the framework that the status of the Capabilities has changed. Even though the
     * MmTelFeature capability may be enabled by the framework, the status may be disabled due to
     * the feature being unavailable from the network.
     * @param c The current capability status of the MmTelFeature. If a capability is disabled, then
     * the status of that capability is disabled. This can happen if the network does not currently
     * support the capability that is enabled. A capability that is disabled by the framework (via
     * {@link #changeEnabledCapabilities}) should also show the status as disabled.
     * @hide
     */
    @SystemApi
    public final void notifyCapabilitiesStatusChanged(@NonNull MmTelCapabilities c) {
        if (c == null) {
            throw new IllegalArgumentException("MmTelCapabilities must be non-null!");
        }
        super.notifyCapabilitiesStatusChanged(c);
    }

    /**
     * Notify the framework that the measured media quality has crossed a threshold set by {@link
     * MmTelFeature#setMediaThreshold}
     *
     * @param status current media quality status measured.
     * @hide
     */
    @SystemApi
    public final void notifyMediaQualityStatusChanged(
            @NonNull MediaQualityStatus status) {
        if (status == null) {
            throw new IllegalArgumentException(
                    "MediaQualityStatus must be non-null!");
        }
        Log.i(LOG_TAG, "notifyMediaQualityStatusChanged " + status);
        IImsMmTelListener listener = getListener();
        if (listener == null) {
            throw new IllegalStateException("Session is not available.");
        }
        try {
            listener.onMediaQualityStatusChanged(status);
        } catch (RemoteException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * Notify the framework of an incoming call.
     * @param c The {@link ImsCallSessionImplBase} of the new incoming call.
     * @param extras A bundle containing extra parameters related to the call. See
     * {@link #EXTRA_IS_UNKNOWN_CALL} and {@link #EXTRA_IS_USSD} above.
     * @hide
     *
     * @deprecated use {@link #notifyIncomingCall(ImsCallSessionImplBase, String, Bundle)} instead
     */
    @Deprecated
    @SystemApi
    public final void notifyIncomingCall(@NonNull ImsCallSessionImplBase c,
            @NonNull Bundle extras) {
        if (c == null || extras == null) {
            throw new IllegalArgumentException("ImsCallSessionImplBase and Bundle can not be "
                    + "null.");
        }
        IImsMmTelListener listener = getListener();
        if (listener == null) {
            throw new IllegalStateException("Session is not available.");
        }
        try {
            c.setDefaultExecutor(MmTelFeature.this.mExecutor);
            listener.onIncomingCall(c.getServiceImpl(), null, extras);
        } catch (RemoteException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * Notify the framework of an incoming call.
     * @param c The {@link ImsCallSessionImplBase} of the new incoming call.
     * @param callId The call ID of the session of the new incoming call.
     * @param extras A bundle containing extra parameters related to the call. See
     * {@link #EXTRA_IS_UNKNOWN_CALL} and {@link #EXTRA_IS_USSD} above.
     * @return The listener used by the framework to listen to call session events created
     *         from the ImsService.
     *         If this method returns {@code null}, then the call could not be placed.
     * @hide
     */
    @SystemApi
    @Nullable
    public final ImsCallSessionListener notifyIncomingCall(
            @NonNull ImsCallSessionImplBase c, @NonNull String callId, @NonNull Bundle extras) {
        if (c == null || callId == null || extras == null) {
            throw new IllegalArgumentException("ImsCallSessionImplBase, callId, and Bundle can "
                    + "not be null.");
        }
        IImsMmTelListener listener = getListener();
        if (listener == null) {
            throw new IllegalStateException("Session is not available.");
        }
        try {
            c.setDefaultExecutor(MmTelFeature.this.mExecutor);
            IImsCallSessionListener isl =
                    listener.onIncomingCall(c.getServiceImpl(), callId, extras);
            if (isl != null) {
                ImsCallSessionListener iCSL = new ImsCallSessionListener(isl);
                iCSL.setDefaultExecutor(MmTelFeature.this.mExecutor);
                return iCSL;
            } else {
                return null;
            }
        } catch (RemoteException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * Notify the framework that a call has been implicitly rejected by this MmTelFeature
     * during call setup.
     * @param callProfile The {@link ImsCallProfile} IMS call profile with details.
     *        This can be null if no call information is available for the rejected call.
     * @param reason The {@link ImsReasonInfo} call rejection reason.
     * @hide
     */
    @SystemApi
    public final void notifyRejectedCall(@NonNull ImsCallProfile callProfile,
            @NonNull ImsReasonInfo reason) {
        if (callProfile == null || reason == null) {
            throw new IllegalArgumentException("ImsCallProfile and ImsReasonInfo must not be "
                    + "null.");
        }
        IImsMmTelListener listener = getListener();
        if (listener == null) {
            throw new IllegalStateException("Session is not available.");
        }
        try {
            listener.onRejectedCall(callProfile, reason);
        } catch (RemoteException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     *
     * @hide
     */
    public final void notifyIncomingCallSession(IImsCallSession c, Bundle extras) {
        IImsMmTelListener listener = getListener();
        if (listener == null) {
            throw new IllegalStateException("Session is not available.");
        }
        try {
            listener.onIncomingCall(c, null, extras);
        } catch (RemoteException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * Notify the framework of a change in the Voice Message count.
     * @link count the new Voice Message count.
     * @hide
     */
    @SystemApi
    public final void notifyVoiceMessageCountUpdate(int count) {
        IImsMmTelListener listener = getListener();
        if (listener == null) {
            throw new IllegalStateException("Session is not available.");
        }
        try {
            listener.onVoiceMessageCountUpdate(count);
        } catch (RemoteException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * Sets the audio handler for this connection. The vendor IMS stack will invoke this API
     * to inform Telephony/Telecom layers about which audio handlers i.e. either Android or Modem
     * shall be used for handling the IMS call audio.
     *
     * @param imsAudioHandler {@link MmTelFeature#ImsAudioHandler} used to handle the audio
     *        for this IMS call.
     * @hide
     */
    @SystemApi
    public final void setCallAudioHandler(@ImsAudioHandler int imsAudioHandler) {
        IImsMmTelListener listener = getListener();
        if (listener == null) {
            throw new IllegalStateException("Session is not available.");
        }
        try {
            listener.onAudioModeIsVoipChanged(imsAudioHandler);
        } catch (RemoteException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * Triggers the EPS fallback procedure.
     *
     * @param reason specifies the reason that EPS fallback was triggered.
     * @hide
     */
    @FlaggedApi(FLAG_SUPPORT_IMS_MMTEL_INTERFACE)
    @SystemApi
    public final void triggerEpsFallback(@EpsFallbackReason int reason) {
        IImsMmTelListener listener = getListener();
        if (listener == null) {
            throw new IllegalStateException("Session is not available.");
        }
        try {
            listener.onTriggerEpsFallback(reason);
        } catch (RemoteException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * Starts a new IMS traffic session with the framework.
     *
     * This API notifies the NAS and RRC layers of the modem that IMS traffic of type
     * {@link ImsTrafficType} is starting for the IMS session represented by a
     * {@link ImsTrafficSessionCallback}. The {@link ImsTrafficSessionCallback}
     * will notify the caller when IMS traffic is ready to start via the
     * {@link ImsTrafficSessionCallback#onReady()} callback. If there was an error starting
     * IMS traffic for the specified traffic type, {@link ImsTrafficSessionCallback#onError()} will
     * be called, which will also notify the caller of the reason of the failure.
     *
     * If there is a handover that changes the {@link AccessNetworkConstants#RadioAccessNetworkType}
     * of this IMS traffic session, then {@link #modifyImsTrafficSession} should be called. This is
     * used, for example, when a WiFi <-> cellular handover occurs.
     *
     * Once the IMS traffic session is finished, {@link #stopImsTrafficSession} must be called.
     *
     * Note: This API will be used to prioritize RF resources in case of DSDS. The service priority
     * is EMERGENCY > EMERGENCY SMS > VOICE > VIDEO > SMS > REGISTRATION > Ut/XCAP. RF
     * shall be prioritized to the subscription which handles the higher priority service.
     * When both subscriptions are handling the same type of service, then RF shall be
     * prioritized to the voice preferred sub.
     *
     * @param trafficType The {@link ImsTrafficType} type for IMS traffic.
     * @param accessNetworkType The {@link AccessNetworkConstants#RadioAccessNetworkType} type of
     *        the radio access network.
     * @param trafficDirection Indicates whether traffic is originated by mobile originated or
     *        mobile terminated use case eg. MO/MT call/SMS etc.
     * @param executor The Executor that will be used to call the {@link ImsTrafficSessionCallback}.
     * @param callback The session representing the IMS Session associated with a specific
     *        trafficType. This callback instance should only be used for the specified traffic type
     *        until {@link #stopImsTrafficSession} is called.
     *
     * @see modifyImsTrafficSession
     * @see stopImsTrafficSession
     *
     * @hide
     */
    @FlaggedApi(FLAG_SUPPORT_IMS_MMTEL_INTERFACE)
    @SystemApi
    public final void startImsTrafficSession(@ImsTrafficType int trafficType,
            @AccessNetworkConstants.RadioAccessNetworkType int accessNetworkType,
            @ImsTrafficDirection int trafficDirection,
            @NonNull Executor executor, @NonNull ImsTrafficSessionCallback callback) {
        IImsMmTelListener listener = getListener();
        if (listener == null) {
            throw new IllegalStateException("Session is not available.");
        }
        // TODO: retrieve from the callback list
        ImsTrafficSessionCallbackWrapper callbackWrapper = mTrafficCallbacks.get(callback);
        if (callbackWrapper == null) {
            callbackWrapper = new ImsTrafficSessionCallbackWrapper(callback);
            mTrafficCallbacks.put(callback, callbackWrapper);
        }
        try {
            callbackWrapper.update(executor);
            listener.onStartImsTrafficSession(callbackWrapper.getToken(),
                    trafficType, accessNetworkType, trafficDirection,
                    callbackWrapper.getCallbackBinder());
        } catch (RemoteException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * Modifies an existing IMS traffic session represented by the associated
     * {@link ImsTrafficSessionCallback}.
     *
     * The {@link ImsTrafficSessionCallback} will notify the caller when IMS traffic is ready to
     * start after modification using the {@link ImsTrafficSessionCallback#onReady()} callback.
     * If there was an error modifying IMS traffic for the new radio access network type type,
     * {@link ImsTrafficSessionCallback#onError()} will be called, which will also notify the
     * caller of the reason of the failure.
     *
     * @param accessNetworkType The {@link AccessNetworkConstants#RadioAccessNetworkType} type of
     *        the radio access network.
     * @param callback The callback registered with {@link #startImsTrafficSession}.
     *
     * @see startImsTrafficSession
     * @see stopImsTrafficSession
     *
     * @hide
     */
    @FlaggedApi(FLAG_SUPPORT_IMS_MMTEL_INTERFACE)
    @SystemApi
    public final void modifyImsTrafficSession(
            @AccessNetworkConstants.RadioAccessNetworkType int accessNetworkType,
            @NonNull ImsTrafficSessionCallback callback) {
        IImsMmTelListener listener = getListener();
        if (listener == null) {
            throw new IllegalStateException("Session is not available.");
        }
        ImsTrafficSessionCallbackWrapper callbackWrapper = mTrafficCallbacks.get(callback);
        if (callbackWrapper == null) {
            // should not reach here.
            throw new IllegalStateException("Unknown ImsTrafficSessionCallback instance.");
        }
        try {
            listener.onModifyImsTrafficSession(callbackWrapper.getToken(), accessNetworkType);
        } catch (RemoteException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * Notifies the framework that the IMS traffic session represented by the associated
     * {@link ImsTrafficSessionCallback} has ended.
     *
     * @param callback The callback registered with {@link #startImsTrafficSession}.
     *
     * @see startImsTrafficSession
     * @see modifyImsTrafficSession
     *
     * @hide
     */
    @FlaggedApi(FLAG_SUPPORT_IMS_MMTEL_INTERFACE)
    @SystemApi
    public final void stopImsTrafficSession(@NonNull ImsTrafficSessionCallback callback) {
        IImsMmTelListener listener = getListener();
        if (listener == null) {
            throw new IllegalStateException("Session is not available.");
        }
        ImsTrafficSessionCallbackWrapper callbackWrapper = mTrafficCallbacks.get(callback);
        if (callbackWrapper == null) {
            // should not reach here.
            throw new IllegalStateException("Unknown ImsTrafficSessionCallback instance.");
        }
        try {
            listener.onStopImsTrafficSession(callbackWrapper.getToken());
            callbackWrapper.reset();
            mTrafficCallbacks.remove(callback);
        } catch (RemoteException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * Provides the MmTelFeature with the ability to return the framework Capability Configuration
     * for a provided Capability. If the framework calls {@link #changeEnabledCapabilities} and
     * includes a capability A to enable or disable, this method should return the correct enabled
     * status for capability A.
     * @param capability The capability that we are querying the configuration for.
     * @return true if the capability is enabled, false otherwise.
     * @hide
     */
    @Override
    @SystemApi
    public boolean queryCapabilityConfiguration(@MmTelCapabilities.MmTelCapability int capability,
            @ImsRegistrationImplBase.ImsRegistrationTech int radioTech) {
        // Base implementation - Override to provide functionality
        return false;
    }

    /**
     * The MmTelFeature should override this method to handle the enabling/disabling of
     * MmTel Features, defined in {@link MmTelCapabilities.MmTelCapability}. The framework assumes
     * the {@link CapabilityChangeRequest} was processed successfully. If a subset of capabilities
     * could not be set to their new values,
     * {@link CapabilityCallbackProxy#onChangeCapabilityConfigurationError} must be called
     * individually for each capability whose processing resulted in an error.
     *
     * Enabling/Disabling a capability here indicates that the capability should be registered or
     * deregistered (depending on the capability change) and become available or unavailable to
     * the framework.
     * @hide
     */
    @Override
    @SystemApi
    public void changeEnabledCapabilities(@NonNull CapabilityChangeRequest request,
            @NonNull CapabilityCallbackProxy c) {
        // Base implementation, no-op
    }

    /**
     * Called by the framework to pass {@link MediaThreshold}. The MmTelFeature should override this
     * method to get Media quality threshold. This will pass the consolidated threshold values from
     * Telephony framework. IMS provider needs to monitor media quality of active call and notify
     * media quality {@link #notifyMediaQualityStatusChanged(MediaQualityStatus)} when the measured
     * media quality crosses at least one of {@link MediaThreshold} set by this.
     *
     * @param mediaSessionType media session type for this Threshold info.
     * @param mediaThreshold media threshold information
     * @hide
     */
    @SystemApi
    public void setMediaThreshold(
            @MediaQualityStatus.MediaSessionType int mediaSessionType,
            @NonNull MediaThreshold mediaThreshold) {
        // Base Implementation - Should be overridden.
        Log.d(LOG_TAG, "setMediaThreshold is not supported." + mediaThreshold);
    }

    /**
     * The MmTelFeature should override this method to clear Media quality thresholds that were
     * registered and stop media quality status updates.
     *
     * @param mediaSessionType media session type
     * @hide
     */
    @SystemApi
    public void clearMediaThreshold(@MediaQualityStatus.MediaSessionType int mediaSessionType) {
        // Base Implementation - Should be overridden.
        Log.d(LOG_TAG, "clearMediaThreshold is not supported." + mediaSessionType);
    }

    /**
     * IMS provider should override this method to return currently measured media quality status.
     *
     * <p/>
     * If media quality status is not yet measured after call is active, it needs to notify media
     * quality status {@link #notifyMediaQualityStatusChanged(MediaQualityStatus)} when the first
     * measurement is done.
     *
     * @param mediaSessionType media session type
     * @return Current media quality status. It could be null if media quality status is not
     *         measured yet or {@link MediaThreshold} was not set corresponding to the media session
     *         type.
     *
     * @hide
     */
    @SystemApi
    @Nullable
    public MediaQualityStatus queryMediaQualityStatus(
            @MediaQualityStatus.MediaSessionType int mediaSessionType) {
        // Base Implementation - Should be overridden.
        Log.d(LOG_TAG, "queryMediaQualityStatus is not supported." + mediaSessionType);
        return null;
    }

    /**
     * Creates a {@link ImsCallProfile} from the service capabilities & IMS registration state.
     *
     * @param callSessionType a service type that is specified in {@link ImsCallProfile}
     *        {@link ImsCallProfile#SERVICE_TYPE_NONE}
     *        {@link ImsCallProfile#SERVICE_TYPE_NORMAL}
     *        {@link ImsCallProfile#SERVICE_TYPE_EMERGENCY}
     * @param callType a call type that is specified in {@link ImsCallProfile}
     *        {@link ImsCallProfile#CALL_TYPE_VOICE}
     *        {@link ImsCallProfile#CALL_TYPE_VT}
     *        {@link ImsCallProfile#CALL_TYPE_VT_TX}
     *        {@link ImsCallProfile#CALL_TYPE_VT_RX}
     *        {@link ImsCallProfile#CALL_TYPE_VT_NODIR}
     *        {@link ImsCallProfile#CALL_TYPE_VS}
     *        {@link ImsCallProfile#CALL_TYPE_VS_TX}
     *        {@link ImsCallProfile#CALL_TYPE_VS_RX}
     * @return a {@link ImsCallProfile} object
     * @hide
     */
    @SystemApi
    public @Nullable ImsCallProfile createCallProfile(int callSessionType, int callType) {
        // Base Implementation - Should be overridden
        return null;
    }

    /**
     * Called by the framework to report a change to the RTP header extension types which should be
     * offered during SDP negotiation (see RFC8285 for more information).
     * <p>
     * The {@link ImsService} should report the RTP header extensions which were accepted during
     * SDP negotiation using {@link ImsCallProfile#setAcceptedRtpHeaderExtensionTypes(Set)}.
     *
     * @param extensionTypes The RTP header extensions the framework wishes to offer during
     *                       outgoing and incoming call setup.  An empty list indicates that there
     *                       are no framework defined RTP header extension types to offer.
     * @hide
     */
    @SystemApi
    public void changeOfferedRtpHeaderExtensionTypes(
            @NonNull Set<RtpHeaderExtensionType> extensionTypes) {
        // Base implementation - should be overridden if RTP header extension handling is supported.
    }

    /**
     * @hide
     */
    public IImsCallSession createCallSessionInterface(ImsCallProfile profile)
            throws RemoteException {
        ImsCallSessionImplBase s = MmTelFeature.this.createCallSession(profile);
        if (s != null) {
            s.setDefaultExecutor(mExecutor);
            return s.getServiceImpl();
        } else {
            return null;
        }
    }

    /**
     * Creates an {@link ImsCallSession} with the specified call profile.
     * Use other methods, if applicable, instead of interacting with
     * {@link ImsCallSession} directly.
     *
     * @param profile a call profile to make the call
     * @hide
     */
    @SystemApi
    public @Nullable ImsCallSessionImplBase createCallSession(@NonNull ImsCallProfile profile) {
        // Base Implementation - Should be overridden
        return null;
    }

    /**
     * Called by the framework to determine if the outgoing call, designated by the outgoing
     * {@link String}s, should be processed as an IMS call or CSFB call. If this method's
     * functionality is not overridden, the platform will process every call as IMS as long as the
     * MmTelFeature reports that the {@link MmTelCapabilities#CAPABILITY_TYPE_VOICE} capability is
     * available.
     * @param numbers An array of {@link String}s that will be used for placing the call. There can
     *         be multiple {@link String}s listed in the case when we want to place an outgoing
     *         call as a conference.
     * @return a {@link ProcessCallResult} to the framework, which will be used to determine if the
     *        call will be placed over IMS or via CSFB.
     * @hide
     */
    @SystemApi
    public @ProcessCallResult int shouldProcessCall(@NonNull String[] numbers) {
        return PROCESS_CALL_IMS;
    }

    /**
     *
     * @hide
     */
    protected IImsUt getUtInterface() throws RemoteException {
        ImsUtImplBase utImpl = getUt();
        if (utImpl != null) {
            utImpl.setDefaultExecutor(mExecutor);
            return utImpl.getInterface();
        } else {
            return null;
        }
    }

    /**
     * @hide
     */
    protected IImsEcbm getEcbmInterface() throws RemoteException {
        ImsEcbmImplBase ecbmImpl = getEcbm();
        if (ecbmImpl != null) {
            ecbmImpl.setDefaultExecutor(mExecutor);
            return ecbmImpl.getImsEcbm();
        } else {
            return null;
        }
    }

    /**
     * @hide
     */
    public IImsMultiEndpoint getMultiEndpointInterface() throws RemoteException {
        ImsMultiEndpointImplBase multiendpointImpl = getMultiEndpoint();
        if (multiendpointImpl != null) {
            multiendpointImpl.setDefaultExecutor(mExecutor);
            return multiendpointImpl.getIImsMultiEndpoint();
        } else {
            return null;
        }
    }

    /**
     * @hide
     */
    public @NonNull ImsSmsImplBase getImsSmsImpl() {
        synchronized (mLock) {
            if (mSmsImpl == null) {
                mSmsImpl = getSmsImplementation();
                mSmsImpl.setDefaultExecutor(mExecutor);
            }
            return mSmsImpl;
        }
    }

    /**
     * @return The {@link ImsUtImplBase} Ut interface implementation for the supplementary service
     * configuration.
     * @hide
     */
    @SystemApi
    public @NonNull ImsUtImplBase getUt() {
        // Base Implementation - Should be overridden
        return new ImsUtImplBase();
    }

    /**
     * @return The {@link ImsEcbmImplBase} Emergency call-back mode interface for emergency VoLTE
     * calls that support it.
     * @hide
     */
    @SystemApi
    public @NonNull ImsEcbmImplBase getEcbm() {
        // Base Implementation - Should be overridden
        return new ImsEcbmImplBase();
    }

    /**
     * @return The {@link ImsMultiEndpointImplBase} implementation for implementing Dialog event
     * package processing for multi-endpoint.
     * @hide
     */
    @SystemApi
    public @NonNull ImsMultiEndpointImplBase getMultiEndpoint() {
        // Base Implementation - Should be overridden
        return new ImsMultiEndpointImplBase();
    }

    /**
     * Sets the current UI TTY mode for the MmTelFeature.
     * @param mode An integer containing the new UI TTY Mode, can consist of
     *         {@link TelecomManager#TTY_MODE_OFF},
     *         {@link TelecomManager#TTY_MODE_FULL},
     *         {@link TelecomManager#TTY_MODE_HCO},
     *         {@link TelecomManager#TTY_MODE_VCO}
     * @param onCompleteMessage If non-null, this MmTelFeature should call this {@link Message} when
     *         the operation is complete by using the associated {@link android.os.Messenger} in
     *         {@link Message#replyTo}. For example:
     * {@code
     *     // Set UI TTY Mode and other operations...
     *     try {
     *         // Notify framework that the mode was changed.
     *         Messenger uiMessenger = onCompleteMessage.replyTo;
     *         uiMessenger.send(onCompleteMessage);
     *     } catch (RemoteException e) {
     *         // Remote side is dead
     *     }
     * }
     * @hide
     */
    @SystemApi
    public void setUiTtyMode(int mode, @Nullable Message onCompleteMessage) {
        // Base Implementation - Should be overridden
    }

    /**
     * Notifies the MmTelFeature of the enablement status of terminal based call waiting
     *
     * If the terminal based call waiting is provisioned,
     * IMS controls the enablement of terminal based call waiting which is defined
     * in 3GPP TS 24.615.
     *
     * @param enabled user setting controlling whether or not call waiting is enabled.
     *
     * @hide
     */
    @SystemApi
    public void setTerminalBasedCallWaitingStatus(boolean enabled) {
        // Base Implementation - Should be overridden by IMS service
        throw new ServiceSpecificException(ImsException.CODE_ERROR_UNSUPPORTED_OPERATION,
                "Not implemented on device.");
    }

    /**
     * Notifies the MmTelFeature that the network has initiated an SRVCC (Single radio voice
     * call continuity) for all IMS calls. When the network initiates an SRVCC, calls from
     * the LTE domain are handed over to the legacy circuit switched domain. The modem requires
     * knowledge of ongoing calls in the IMS domain in order to complete the SRVCC operation.
     * <p>
     * @param consumer The callback used to notify the framework of the list of IMS calls and their
     * state at the time of the SRVCC.
     *
     * @hide
     */
    @SystemApi
    public void notifySrvccStarted(@NonNull Consumer<List<SrvccCall>> consumer) {
        // Base Implementation - Should be overridden by IMS service
    }

    /**
     * Notifies the MmTelFeature that the SRVCC is completed and the calls have been moved
     * over to the circuit-switched domain.
     * {@link android.telephony.CarrierConfigManager.ImsVoice#KEY_SRVCC_TYPE_INT_ARRAY}
     * specifies the calls can be moved. Other calls will be disconnected.
     * <p>
     * The MmTelFeature may now release all resources related to the IMS calls.
     *
     * @hide
     */
    @SystemApi
    public void notifySrvccCompleted() {
        // Base Implementation - Should be overridden by IMS service
    }

    /**
     * Notifies the MmTelFeature that the SRVCC has failed.
     *
     * The handover can fail by encountering a failure at the radio level
     * or temporary MSC server internal errors in handover procedure.
     * Refer to 3GPP TS 23.216 section 8 Handover Failure.
     * <p>
     * IMS service will recover and continue calls over IMS.
     * Per TS 24.237 12.2.4.2, UE shall send SIP UPDATE request containing the reason-text
     * set to "failure to transition to CS domain".
     *
     * @hide
     */
    @SystemApi
    public void notifySrvccFailed() {
        // Base Implementation - Should be overridden by IMS service
    }

    /**
     * Notifies the MmTelFeature that the SRVCC has been canceled.
     *
     * Since the state of network can be changed, the network can decide to terminate
     * the handover procedure before its completion and to return to its state before the handover
     * procedure was triggered.
     * Refer to 3GPP TS 23.216 section 8.1.3 Handover Cancellation.
     *
     * <p>
     * IMS service will recover and continue calls over IMS.
     * Per TS 24.237 12.2.4.2, UE shall send SIP UPDATE request containing the reason-text
     * set to "handover canceled".
     *
     * @hide
     */
    @SystemApi
    public void notifySrvccCanceled() {
        // Base Implementation - Should be overridden by IMS service
    }

    private void setSmsListener(IImsSmsListener listener) {
        getImsSmsImpl().registerSmsListener(listener);
    }

    private void sendSms(int token, int messageRef, String format, String smsc, boolean isRetry,
            byte[] pdu) {
        getImsSmsImpl().sendSms(token, messageRef, format, smsc, isRetry, pdu);
    }

    private void onMemoryAvailable(int token) {
        getImsSmsImpl().onMemoryAvailable(token);
    }

    private void acknowledgeSms(int token, int messageRef,
            @ImsSmsImplBase.DeliverStatusResult int result) {
        getImsSmsImpl().acknowledgeSms(token, messageRef, result);
    }

    private void acknowledgeSms(int token, int messageRef,
            @ImsSmsImplBase.DeliverStatusResult int result, byte[] pdu) {
        getImsSmsImpl().acknowledgeSms(token, messageRef, result, pdu);
    }

    private void acknowledgeSmsReport(int token, int messageRef,
            @ImsSmsImplBase.StatusReportResult int result) {
        getImsSmsImpl().acknowledgeSmsReport(token, messageRef, result);
    }

    private void onSmsReady() {
        getImsSmsImpl().onReady();
    }

    /**
     * Must be overridden by IMS Provider to be able to support SMS over IMS. Otherwise a default
     * non-functional implementation is returned.
     *
     * @return an instance of {@link ImsSmsImplBase} which should be implemented by the IMS
     * Provider.
     * @hide
     */
    @SystemApi
    public @NonNull ImsSmsImplBase getSmsImplementation() {
        return new ImsSmsImplBase();
    }

    private String getSmsFormat() {
        return getImsSmsImpl().getSmsFormat();
    }

    /**
     * {@inheritDoc}
     * @hide
     */
    @Override
    @SystemApi
    public void onFeatureRemoved() {
        // Base Implementation - Should be overridden
    }

    /**
     * {@inheritDoc}
     * @hide
     */
    @Override
    @SystemApi
    public void onFeatureReady() {
        // Base Implementation - Should be overridden
    }

    /**
     * @hide
     */
    @Override
    public final IImsMmTelFeature getBinder() {
        return mImsMMTelBinder;
    }

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