xref: /aosp14/frameworks/base/telephony/java/android/telephony/ims/ImsCallSessionListener.java

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

import android.annotation.IntRange;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.annotation.SystemApi;
import android.os.RemoteException;
import android.telephony.Annotation;
import android.telephony.CallQuality;
import android.telephony.ServiceState;
import android.telephony.ims.aidl.IImsCallSessionListener;
import android.telephony.ims.stub.ImsCallSessionImplBase;
import android.telephony.ims.stub.ImsCallSessionImplBase.MediaStreamDirection;
import android.telephony.ims.stub.ImsCallSessionImplBase.MediaStreamType;
import android.util.Log;

import com.android.ims.internal.IImsCallSession;

import java.util.ArrayList;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.Executor;

/**
 * Listener interface for notifying the Framework's {@link ImsCallSession} for updates to an ongoing
 * IMS call.
 *
 * @hide
 */
// DO NOT remove or change the existing APIs, only add new ones to this implementation or you
// will break other implementations of ImsCallSessionListener maintained by other ImsServices.
// TODO: APIs in here do not conform to API guidelines yet. This can be changed if
// ImsCallSessionListenerConverter is also changed.
@SystemApi
public class ImsCallSessionListener {
    private static final String TAG = "ImsCallSessionListener";
    private final IImsCallSessionListener mListener;
    private Executor mExecutor = null;

    /** @hide */
    public ImsCallSessionListener(IImsCallSessionListener l) {
        mListener = l;
    }

    /**
     * Called when the network first begins to establish the call session and is now connecting
     * to the remote party. This must be called once after {@link ImsCallSessionImplBase#start} and
     * before any other method on this listener.  After this is called,
     * {@link #callSessionProgressing(ImsStreamMediaProfile)} must be called to communicate any
     * further updates.
     * <p/>
     * Once this is called, {@link #callSessionTerminated} must be called
     * to end the call session.  In the event that the session failed before the remote party
     * was contacted, {@link #callSessionInitiatingFailed} must be called.
     *
     * @param profile the associated {@link ImsCallProfile}.
     */
    public void callSessionInitiating(@NonNull ImsCallProfile profile) {
        try {
            mListener.callSessionInitiating(profile);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * The IMS call session establishment has failed while initiating.
     *
     * @param reasonInfo {@link ImsReasonInfo} detailing the reason of the IMS call session
     * establishment failure.
     */
    public void callSessionInitiatingFailed(@NonNull ImsReasonInfo reasonInfo) {
        try {
            mListener.callSessionInitiatingFailed(reasonInfo);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * Called after the network has contacted the remote party and the call state should move to
     * ALERTING.
     *
     * @param profile the associated {@link ImsCallProfile}.
     */
    public void callSessionProgressing(ImsStreamMediaProfile profile) {
        try {
            mListener.callSessionProgressing(profile);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * Called once the outgoing IMS call session has been begun between the local and remote party.
     * The call state should move to ACTIVE.
     *
     * @param profile the associated {@link ImsCallProfile}.
     */
    public void callSessionInitiated(ImsCallProfile profile) {
        try {
            mListener.callSessionInitiated(profile);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * The IMS call session establishment has failed.
     *
     * @param reasonInfo {@link ImsReasonInfo} detailing the reason of the IMS call session
     * establishment failure.
     * @deprecated {@link #callSessionInitiated(ImsCallProfile)} is called immediately after
     * the session is first started which meant that there was no time in which a call to this
     * method was technically valid.  This method is replaced starting Android S in favor of
     * {@link #callSessionInitiatingFailed(ImsReasonInfo)}.
     */
    @Deprecated
    public void callSessionInitiatedFailed(ImsReasonInfo reasonInfo) {
        try {
            mListener.callSessionInitiatedFailed(reasonInfo);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * The IMS call session has been terminated.
     *
     * @param reasonInfo {@link ImsReasonInfo} detailing the reason of the session termination.
     */
    public void callSessionTerminated(ImsReasonInfo reasonInfo) {
        try {
            mListener.callSessionTerminated(reasonInfo);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * The IMS call session has started the process of holding the call. If it fails,
     * {@link #callSessionHoldFailed(ImsReasonInfo)} should be called.
     *
     * If the IMS call session is resumed, call {@link #callSessionResumed(ImsCallProfile)}.
     *
     * @param profile The associated {@link ImsCallProfile} of the call session that has been put
     * on hold.
     */
    public void callSessionHeld(ImsCallProfile profile) {
        try {
            mListener.callSessionHeld(profile);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * The IMS call session has failed to be held.
     *
     * @param reasonInfo {@link ImsReasonInfo} detailing the reason of the session hold failure.
     */
    public void callSessionHoldFailed(ImsReasonInfo reasonInfo) {
        try {
            mListener.callSessionHoldFailed(reasonInfo);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * This IMS Call session has been put on hold by the remote party.
     *
     * @param profile The {@link ImsCallProfile} associated with this IMS call session.
     */
    public void callSessionHoldReceived(ImsCallProfile profile) {
        try {
            mListener.callSessionHoldReceived(profile);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * The IMS call session has started the process of resuming the call. If the process of resuming
     * the call fails, call {@link #callSessionResumeFailed(ImsReasonInfo)}.
     *
     * @param profile The {@link ImsCallProfile} associated with this IMS call session.
     */
    public void callSessionResumed(ImsCallProfile profile) {
        try {
            mListener.callSessionResumed(profile);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * The IMS call session resume has failed.
     *
     * @param reasonInfo {@link ImsReasonInfo} containing the detailed reason of the session resume
     * failure.
     */
    public void callSessionResumeFailed(ImsReasonInfo reasonInfo) {
        try {
            mListener.callSessionResumeFailed(reasonInfo);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * The remote party has resumed this IMS call session.
     *
     * @param profile {@link ImsCallProfile} associated with the IMS call session.
     */
    public void callSessionResumeReceived(ImsCallProfile profile) {
        try {
            mListener.callSessionResumeReceived(profile);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * The IMS call session merge has been started.  At this point, the {@code newSession}
     * represents the IMS call session which represents the new merged conference and has been
     * initiated to the IMS conference server.
     *
     * @param newSession the {@link ImsCallSessionImplBase} that represents the merged active & held
     * sessions.
     * @param profile The {@link ImsCallProfile} associated with this IMS call session.
     */
    public void callSessionMergeStarted(ImsCallSessionImplBase newSession, ImsCallProfile profile)
    {
        try {
            if (newSession != null && mExecutor != null) {
                newSession.setDefaultExecutor(mExecutor);
            }
            mListener.callSessionMergeStarted(newSession != null ?
                            newSession.getServiceImpl() : null, profile);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * Compatibility method for older implementations.
     * See {@link #callSessionMergeStarted(ImsCallSessionImplBase, ImsCallProfile)}.
     *
     * @hide
     */
    public void callSessionMergeStarted(IImsCallSession newSession, ImsCallProfile profile)
    {
        try {
            mListener.callSessionMergeStarted(newSession, profile);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * The session merge is successful and the merged {@link ImsCallSession} is active.
     *
     * @param newSession the new {@link ImsCallSessionImplBase}
     *                  that represents the conference IMS call
     * session.
     */
    public void callSessionMergeComplete(ImsCallSessionImplBase newSession) {
        try {
            if (newSession != null && mExecutor != null) {
                newSession.setDefaultExecutor(mExecutor);
            }
            mListener.callSessionMergeComplete(newSession != null ?
                    newSession.getServiceImpl() : null);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * Compatibility method for older implementations of ImsService.
     *
     * See {@link #callSessionMergeComplete(ImsCallSessionImplBase)}}.
     *
     * @hide
     */
    public void callSessionMergeComplete(IImsCallSession newSession) {
        try {
            mListener.callSessionMergeComplete(newSession);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * The IMS call session merge has failed.
     *
     * @param reasonInfo {@link ImsReasonInfo} contining the reason for the call merge failure.
     */
    public void callSessionMergeFailed(ImsReasonInfo reasonInfo) {
        try {
            mListener.callSessionMergeFailed(reasonInfo);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * The IMS call session profile has been updated. Does not include holding or resuming a call.
     *
     * @param profile The {@link ImsCallProfile} associated with the updated IMS call session.
     */
    public void callSessionUpdated(ImsCallProfile profile) {
        try {
            mListener.callSessionUpdated(profile);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * The IMS call session profile update has failed.
     *
     * @param reasonInfo {@link ImsReasonInfo} containing a reason for the session update failure.
     */
    public void callSessionUpdateFailed(ImsReasonInfo reasonInfo) {
        try {
            mListener.callSessionUpdateFailed(reasonInfo);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * The IMS call session profile has received an update from the remote user.
     *
     * @param profile The new {@link ImsCallProfile} associated with the update.
     */
    public void callSessionUpdateReceived(ImsCallProfile profile) {
        try {
            mListener.callSessionUpdateReceived(profile);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * Called when the session has been extended to a conference session.
     *
     * If the conference extension fails, call
     * {@link #callSessionConferenceExtendFailed(ImsReasonInfo)}.
     *
     * @param newSession the session object that is extended to the conference from the active
     * IMS Call session.
     * @param profile The {@link ImsCallProfile} associated with the IMS call session.
     */
    public void callSessionConferenceExtended(ImsCallSessionImplBase newSession,
            ImsCallProfile profile) {
        try {
            if (newSession != null && mExecutor != null) {
                newSession.setDefaultExecutor(mExecutor);
            }
            mListener.callSessionConferenceExtended(
                    newSession != null ? newSession.getServiceImpl() : null, profile);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * Compatibility method to interface with older versions of ImsService.
     * See {@link #callSessionConferenceExtended(ImsCallSessionImplBase, ImsCallProfile)}.
     *
     * @hide
     */
    public void callSessionConferenceExtended(IImsCallSession newSession, ImsCallProfile profile) {
        try {
            mListener.callSessionConferenceExtended(newSession, profile);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * The previous conference extension has failed.
     *
     * @param reasonInfo {@link ImsReasonInfo} containing the detailed reason of the conference
     * extension failure.
     */
    public void callSessionConferenceExtendFailed(ImsReasonInfo reasonInfo) {
        try {
            mListener.callSessionConferenceExtendFailed(reasonInfo);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * A conference extension has been received received from the remote party.
     *
     * @param newSession An {@link ImsCallSessionImplBase}
     *                   representing the extended IMS call session.
     * @param profile The {@link ImsCallProfile} associated with the new IMS call session.
     */
    public void callSessionConferenceExtendReceived(ImsCallSessionImplBase newSession,
            ImsCallProfile profile) {
        try {
            if (newSession != null && mExecutor != null) {
                newSession.setDefaultExecutor(mExecutor);
            }
            mListener.callSessionConferenceExtendReceived(newSession != null
                    ? newSession.getServiceImpl() : null, profile);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * Compatibility method to interface with older versions of ImsService.
     * See {@link #callSessionConferenceExtendReceived(ImsCallSessionImplBase, ImsCallProfile)}.
     *
     * @hide
     */
    public void callSessionConferenceExtendReceived(IImsCallSession newSession,
            ImsCallProfile profile) {
        try {
            mListener.callSessionConferenceExtendReceived(newSession, profile);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * The request to invite participants to the conference has been delivered to the conference
     * server.
     */
    public void callSessionInviteParticipantsRequestDelivered() {
        try {
            mListener.callSessionInviteParticipantsRequestDelivered();
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * The previous request to invite participants to the conference (see
     * {@link #callSessionInviteParticipantsRequestDelivered()}) has failed.
     *
     * @param reasonInfo {@link ImsReasonInfo} detailing the reason forthe conference invitation
     * failure.
     */
    public void callSessionInviteParticipantsRequestFailed(ImsReasonInfo reasonInfo)
    {
        try {
            mListener.callSessionInviteParticipantsRequestFailed(reasonInfo);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * The request to remove participants from the conference has been delivered to the conference
     * server.
     */
    public void callSessionRemoveParticipantsRequestDelivered() {
        try {
            mListener.callSessionRemoveParticipantsRequestDelivered();
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * The previous request to remove participants from the conference (see
     * {@link #callSessionRemoveParticipantsRequestDelivered()}) has failed.
     *
     * @param reasonInfo {@link ImsReasonInfo} detailing the reason for the conference removal
     * failure.
     */
    public void callSessionRemoveParticipantsRequestFailed(ImsReasonInfo reasonInfo)
    {
        try {
            mListener.callSessionInviteParticipantsRequestFailed(reasonInfo);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * The IMS call session's conference state has changed.
     *
     * @param state The new {@link ImsConferenceState} associated with the conference.
     */
    public void callSessionConferenceStateUpdated(ImsConferenceState state) {
        try {
            mListener.callSessionConferenceStateUpdated(state);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * The IMS call session has received a Ussd message.
     *
     * @param mode The mode of the USSD message, either
     * {@link ImsCallSessionImplBase#USSD_MODE_NOTIFY} or
     * {@link ImsCallSessionImplBase#USSD_MODE_REQUEST}.
     * @param ussdMessage The USSD message.
     */
    public void callSessionUssdMessageReceived(int mode, String ussdMessage)
    {
        try {
            mListener.callSessionUssdMessageReceived(mode, ussdMessage);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * An {@link ImsCallSession} may potentially handover from one radio
     * technology to another.
     *
     * @param srcAccessTech The source radio access technology; one of the access technology
     * constants defined in {@link android.telephony.ServiceState}. For example
     * {@link android.telephony.ServiceState#RIL_RADIO_TECHNOLOGY_LTE}.
     * @param targetAccessTech The target radio access technology; one of the access technology
     * constants defined in {@link android.telephony.ServiceState}. For example
     * {@link android.telephony.ServiceState#RIL_RADIO_TECHNOLOGY_LTE}.
     * @deprecated Uses hidden constants for radio access technology, use
     * {@link #onMayHandover(int, int)} instead.
     */
    @Deprecated
    public void callSessionMayHandover(int srcAccessTech, int targetAccessTech) {
        // Use new API internally.
        onMayHandover(ServiceState.rilRadioTechnologyToNetworkType(srcAccessTech),
                ServiceState.rilRadioTechnologyToNetworkType(targetAccessTech));
    }

    /**
     * Notify the framework that the associated {@link ImsCallSession} may handover from one network
     * type to another.
     *
     * @param srcNetworkType The source network type.
     * @param targetNetworkType The target network type.
     */
    public void onMayHandover(@Annotation.NetworkType int srcNetworkType,
            @Annotation.NetworkType int targetNetworkType) {
        try {
            mListener.callSessionMayHandover(srcNetworkType, targetNetworkType);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * The IMS call session's access technology has changed.
     *
     * @param srcAccessTech original access technology, defined in
     * {@link android.telephony.ServiceState}.
     * @param targetAccessTech new access technology, defined in
     * {@link android.telephony.ServiceState}.
     * @param reasonInfo The {@link ImsReasonInfo} associated with this handover.
     * @deprecated Uses hidden radio access technology constants, use
     * {@link #onHandover(int, int, ImsReasonInfo)} instead.
     */
    @Deprecated
    public void callSessionHandover(int srcAccessTech, int targetAccessTech,
            ImsReasonInfo reasonInfo) {
        // Use new API internally.
        onHandover(ServiceState.rilRadioTechnologyToNetworkType(srcAccessTech),
                ServiceState.rilRadioTechnologyToNetworkType(targetAccessTech), reasonInfo);
    }

    /**
     * Notify the framework that the associated {@link ImsCallSession} has handed over from one
     * network type to another.
     *
     * @param srcNetworkType original network type.
     * @param targetNetworkType target network type after handover..
     * @param reasonInfo An optional {@link ImsReasonInfo} associated with this handover.
     */
    public void onHandover(@Annotation.NetworkType int srcNetworkType,
            @Annotation.NetworkType int targetNetworkType, @Nullable ImsReasonInfo reasonInfo) {
        try {
            mListener.callSessionHandover(srcNetworkType, targetNetworkType, reasonInfo);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * The IMS call session's access technology change has failed..
     *
     * @param srcAccessTech original access technology
     * @param targetAccessTech new access technology
     * @param reasonInfo An {@link ImsReasonInfo} detailing the reason for the failure.
     * @deprecated Uses hidden radio access technology constants, use
     * {@link #onHandoverFailed(int, int, ImsReasonInfo)} instead
     */
    @Deprecated
    public void callSessionHandoverFailed(int srcAccessTech, int targetAccessTech,
            ImsReasonInfo reasonInfo) {
        // Use new API internally.
        onHandoverFailed(ServiceState.rilRadioTechnologyToNetworkType(srcAccessTech),
                ServiceState.rilRadioTechnologyToNetworkType(targetAccessTech), reasonInfo);
    }

    /**
     * The IMS call session's access technology change has failed..
     *
     * @param srcNetworkType original network type.
     * @param targetNetworkType target network type that the handover failed for.
     * @param reasonInfo An {@link ImsReasonInfo} detailing the reason for the failure.
     */
    public void onHandoverFailed(@Annotation.NetworkType int srcNetworkType,
            @Annotation.NetworkType int targetNetworkType, @NonNull ImsReasonInfo reasonInfo) {
        try {
            mListener.callSessionHandoverFailed(srcNetworkType, targetNetworkType, reasonInfo);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * The TTY mode has been changed by the remote party.
     *
     * @param mode one of the following: -
     *             {@link com.android.internal.telephony.Phone#TTY_MODE_OFF} -
     *             {@link com.android.internal.telephony.Phone#TTY_MODE_FULL} -
     *             {@link com.android.internal.telephony.Phone#TTY_MODE_HCO} -
     *             {@link com.android.internal.telephony.Phone#TTY_MODE_VCO}
     */
    public void callSessionTtyModeReceived(int mode) {
        try {
            mListener.callSessionTtyModeReceived(mode);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * The multiparty state has been changed for this {@code ImsCallSession}.
     *
     * @param isMultiParty {@code true} if the session became multiparty, {@code false} otherwise.
     */
    public void callSessionMultipartyStateChanged(boolean isMultiParty) {
        try {
            mListener.callSessionMultipartyStateChanged(isMultiParty);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * Supplementary service information has been received for the current IMS call session.
     *
     * @param suppSrvNotification The {@link ImsSuppServiceNotification} containing the change.
     */
    public void callSessionSuppServiceReceived(ImsSuppServiceNotification suppSrvNotification)
    {
        try {
            mListener.callSessionSuppServiceReceived(suppSrvNotification);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * An RTT modify request has been received from the remote party.
     *
     * @param callProfile An {@link ImsCallProfile} with the updated attributes
     */
    public void callSessionRttModifyRequestReceived(ImsCallProfile callProfile)
    {
        try {
            mListener.callSessionRttModifyRequestReceived(callProfile);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * An RTT modify response has been received.
     *
     * @param status the received response for RTT modify request.
     */
    public void callSessionRttModifyResponseReceived(int status) {
        try {
            mListener.callSessionRttModifyResponseReceived(status);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * An RTT message has been received from the remote party.
     *
     * @param rttMessage The RTT message that has been received.
     */
    public void callSessionRttMessageReceived(String rttMessage) {
        try {
            mListener.callSessionRttMessageReceived(rttMessage);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * While in call, there has been a change in RTT audio indicator.
     *
     * @param profile updated ImsStreamMediaProfile
     */
    public void callSessionRttAudioIndicatorChanged(@NonNull ImsStreamMediaProfile profile) {
        try {
            mListener.callSessionRttAudioIndicatorChanged(profile);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * The call quality has changed.
     *
     * @param callQuality The new call quality
     */
    public void callQualityChanged(@NonNull CallQuality callQuality) {
        try {
            mListener.callQualityChanged(callQuality);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * The {@link ImsService} calls this method to inform the framework of a DTMF digit which was
     * received from the network.
     * <p>
     * According to <a href="http://tools.ietf.org/html/rfc2833">RFC 2833 sec 3.10</a>,
     * event 0 ~ 9 maps to decimal value 0 ~ 9, '*' to 10, '#' to 11, event 'A' ~ 'D' to 12 ~ 15.
     * <p>
     * <em>Note:</em> Alpha DTMF digits are converted from lower-case to upper-case.
     *
     * @param dtmf The DTMF digit received, '0'-'9', *, #, A, B, C, or D.
     * @throws IllegalArgumentException If an invalid DTMF character is provided.
     */
    public void callSessionDtmfReceived(char dtmf) {
        if (!(dtmf >= '0' && dtmf <= '9'
                || dtmf >= 'A' && dtmf <= 'D'
                || dtmf >= 'a' && dtmf <= 'd'
                || dtmf == '*'
                || dtmf == '#')) {
            throw new IllegalArgumentException("DTMF digit must be 0-9, *, #, A, B, C, D");
        }
        try {
            mListener.callSessionDtmfReceived(Character.toUpperCase(dtmf));
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * The {@link ImsService} calls this method to inform the framework of RTP header extension data
     * which was received from the network.
     * <p>
     * The set of {@link RtpHeaderExtension} data are identified by local identifiers which were
     * negotiated during SDP signalling.  See RFC8285,
     * {@link ImsCallProfile#getAcceptedRtpHeaderExtensionTypes()} and
     * {@link RtpHeaderExtensionType} for more information.
     * <p>
     * By specification, the RTP header extension is an unacknowledged transmission and there is no
     * guarantee that the header extension will be delivered by the network to the other end of the
     * call.
     *
     * @param extensions The RTP header extension data received.
     */
    public void callSessionRtpHeaderExtensionsReceived(
            @NonNull Set<RtpHeaderExtension> extensions) {
        Objects.requireNonNull(extensions, "extensions are required.");
        try {
            mListener.callSessionRtpHeaderExtensionsReceived(
                    new ArrayList<RtpHeaderExtension>(extensions));
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * Notifies the result of transfer request.
     * @hide
     */
    public void callSessionTransferred() {
        try {
            mListener.callSessionTransferred();
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * Notifies the result of transfer request.
     *
     * @param reasonInfo {@link ImsReasonInfo} containing a reason for the
     * session transfer failure
     * @hide
     */
    public void callSessionTransferFailed(ImsReasonInfo reasonInfo) {
        try {
            mListener.callSessionTransferFailed(reasonInfo);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * Access Network Bitrate Recommendation Query (ANBRQ), see 3GPP TS 26.114.
     * This API triggers radio to send ANBRQ message to the access network to query the
     * desired bitrate.
     *
     * @param mediaType {@link ImsCallSessionImplBase.MediaStreamType} is used to identify
     *        media stream such as audio or video.
     * @param direction {@link ImsCallSessionImplBase.MediaStreamDirection} of this packet
     *        stream (e.g. uplink or downlink).
     * @param bitsPerSecond This value is the bitrate requested by the other party UE through
     *        RTP CMR, RTCPAPP or TMMBR, and ImsStack converts this value to the MAC bitrate
     *        (defined in TS36.321, range: 0 ~ 8000 kbit/s).
     * @hide
     */
    public final void callSessionSendAnbrQuery(@MediaStreamType int mediaType,
                @MediaStreamDirection int direction, @IntRange(from = 0) int bitsPerSecond) {
        Log.d(TAG, "callSessionSendAnbrQuery in imscallsessonListener");
        try {
            mListener.callSessionSendAnbrQuery(mediaType, direction, bitsPerSecond);
        } catch (RemoteException e) {
            e.rethrowFromSystemServer();
        }
    }

    /**
     * Set default Executor from ImsService.
     * @param executor The default executor to use when executing the methods by the vendor
     *                 implementation of {@link ImsCallSessionImplBase} for conference call.
     *                 This executor is dedicated to set vendor CallSessionImpl
     *                 only when conference call is established.
     * @hide
     */
    public final void setDefaultExecutor(@NonNull Executor executor) {
        if (mExecutor == null) {
            mExecutor = executor;
        }
    }
}