xref: /frameworks/base/telephony/java/android/telephony/ims/stub/ImsCallSessionImplBase.java

/*
 * Copyright (C) 2017 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License
 */

package android.telephony.ims.stub;

import android.annotation.NonNull;
import android.annotation.SystemApi;
import android.os.Message;
import android.os.RemoteException;
import android.telephony.ims.ImsCallProfile;
import android.telephony.ims.ImsCallSession;
import android.telephony.ims.ImsCallSessionListener;
import android.telephony.ims.ImsReasonInfo;
import android.telephony.ims.ImsStreamMediaProfile;
import android.telephony.ims.ImsVideoCallProvider;
import android.telephony.ims.RtpHeaderExtension;
import android.telephony.ims.RtpHeaderExtensionType;
import android.telephony.ims.aidl.IImsCallSessionListener;
import android.util.ArraySet;
import android.util.Log;

import com.android.ims.internal.IImsCallSession;
import com.android.ims.internal.IImsVideoCallProvider;
import com.android.internal.telephony.util.TelephonyUtils;

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.function.Supplier;

/**
 * Base implementation of IImsCallSession, which implements stub versions of the methods available.
 *
 * Override the methods that your implementation of ImsCallSession supports.
 *
 * @hide
 */
@SystemApi
// DO NOT remove or change the existing APIs, only add new ones to this Base implementation or you
// will break other implementations of ImsCallSession maintained by other ImsServices.
public class ImsCallSessionImplBase implements AutoCloseable {

    private static final String LOG_TAG = "ImsCallSessionImplBase";
    /**
     * Notify USSD Mode.
     */
    public static final int USSD_MODE_NOTIFY = 0;
    /**
     * Request USSD Mode
     */
    public static final int USSD_MODE_REQUEST = 1;

    /**
     * Defines IMS call session state.
     */
    public static class State {
        public static final int IDLE = 0;
        public static final int INITIATED = 1;
        public static final int NEGOTIATING = 2;
        public static final int ESTABLISHING = 3;
        public static final int ESTABLISHED = 4;

        public static final int RENEGOTIATING = 5;
        public static final int REESTABLISHING = 6;

        public static final int TERMINATING = 7;
        public static final int TERMINATED = 8;

        public static final int INVALID = (-1);

        /**
         * Converts the state to string.
         */
        public static String toString(int state) {
            switch (state) {
                case IDLE:
                    return "IDLE";
                case INITIATED:
                    return "INITIATED";
                case NEGOTIATING:
                    return "NEGOTIATING";
                case ESTABLISHING:
                    return "ESTABLISHING";
                case ESTABLISHED:
                    return "ESTABLISHED";
                case RENEGOTIATING:
                    return "RENEGOTIATING";
                case REESTABLISHING:
                    return "REESTABLISHING";
                case TERMINATING:
                    return "TERMINATING";
                case TERMINATED:
                    return "TERMINATED";
                default:
                    return "UNKNOWN";
            }
        }

        /**
         * @hide
         */
        private State() {
        }
    }

    private Executor mExecutor = Runnable::run;

    // Non-final for injection by tests
    private IImsCallSession mServiceImpl = new IImsCallSession.Stub() {
        @Override
        public void close() {
            executeMethodAsync(() -> ImsCallSessionImplBase.this.close(), "close");
        }

        @Override
        public String getCallId() {
            return executeMethodAsyncForResult(() -> ImsCallSessionImplBase.this.getCallId(),
                    "getCallId");
        }

        @Override
        public ImsCallProfile getCallProfile() {
            return executeMethodAsyncForResult(() -> ImsCallSessionImplBase.this.getCallProfile(),
                    "getCallProfile");
        }

        @Override
        public ImsCallProfile getLocalCallProfile() {
            return executeMethodAsyncForResult(() -> ImsCallSessionImplBase.this
                    .getLocalCallProfile(), "getLocalCallProfile");
        }

        @Override
        public ImsCallProfile getRemoteCallProfile() {
            return executeMethodAsyncForResult(() -> ImsCallSessionImplBase.this
                    .getRemoteCallProfile(), "getRemoteCallProfile");
        }

        @Override
        public String getProperty(String name) {
            return executeMethodAsyncForResult(() -> ImsCallSessionImplBase.this.getProperty(name),
                    "getProperty");
        }

        @Override
        public int getState() {
            return executeMethodAsyncForResult(() -> ImsCallSessionImplBase.this.getState(),
                    "getState");
        }

        @Override
        public boolean isInCall() {
            return executeMethodAsyncForResult(() -> ImsCallSessionImplBase.this.isInCall(),
                    "isInCall");
        }

        @Override
        public void setListener(IImsCallSessionListener listener) {
            executeMethodAsync(() -> ImsCallSessionImplBase.this.setListener(
                    new ImsCallSessionListener(listener)), "setListener");
        }

        @Override
        public void setMute(boolean muted) {
            executeMethodAsync(() -> ImsCallSessionImplBase.this.setMute(muted), "setMute");
        }

        @Override
        public void start(String callee, ImsCallProfile profile) {
            executeMethodAsync(() -> ImsCallSessionImplBase.this.start(callee, profile), "start");
        }

        @Override
        public void startConference(String[] participants, ImsCallProfile profile) throws
                RemoteException {
            executeMethodAsync(() -> ImsCallSessionImplBase.this.startConference(participants,
                    profile), "startConference");
        }

        @Override
        public void accept(int callType, ImsStreamMediaProfile profile) {
            executeMethodAsync(() -> ImsCallSessionImplBase.this.accept(callType, profile),
                    "accept");
        }

        @Override
        public void deflect(String deflectNumber) {
            executeMethodAsync(() -> ImsCallSessionImplBase.this.deflect(deflectNumber),
                    "deflect");
        }

        @Override
        public void reject(int reason) {
            executeMethodAsync(() -> ImsCallSessionImplBase.this.reject(reason), "reject");
        }

        @Override
        public void transfer(@NonNull String number, boolean isConfirmationRequired) {
            executeMethodAsync(() -> ImsCallSessionImplBase.this.transfer(number,
                    isConfirmationRequired), "transfer");
        }

        @Override
        public void consultativeTransfer(@NonNull IImsCallSession transferToSession) {
            executeMethodAsync(() -> {
                ImsCallSessionImplBase otherSession = new ImsCallSessionImplBase();
                otherSession.setServiceImpl(transferToSession);
                ImsCallSessionImplBase.this.transfer(otherSession);
            }, "consultativeTransfer");
        }

        @Override
        public void terminate(int reason) {
            executeMethodAsync(() -> ImsCallSessionImplBase.this.terminate(reason), "terminate");
        }

        @Override
        public void hold(ImsStreamMediaProfile profile) {
            executeMethodAsync(() -> ImsCallSessionImplBase.this.hold(profile), "hold");
        }

        @Override
        public void resume(ImsStreamMediaProfile profile) {
            executeMethodAsync(() -> ImsCallSessionImplBase.this.resume(profile), "resume");
        }

        @Override
        public void merge() {
            executeMethodAsync(() -> ImsCallSessionImplBase.this.merge(), "merge");
        }

        @Override
        public void update(int callType, ImsStreamMediaProfile profile) {
            executeMethodAsync(() -> ImsCallSessionImplBase.this.update(callType, profile),
                    "update");
        }

        @Override
        public void extendToConference(String[] participants) {
            executeMethodAsync(() -> ImsCallSessionImplBase.this.extendToConference(participants),
                    "extendToConference");
        }

        @Override
        public void inviteParticipants(String[] participants) {
            executeMethodAsync(() -> ImsCallSessionImplBase.this.inviteParticipants(participants),
                    "inviteParticipants");
        }

        @Override
        public void removeParticipants(String[] participants) {
            executeMethodAsync(() -> ImsCallSessionImplBase.this.removeParticipants(participants),
                    "removeParticipants");
        }

        @Override
        public void sendDtmf(char c, Message result) {
            executeMethodAsync(() -> ImsCallSessionImplBase.this.sendDtmf(c, result), "sendDtmf");
        }

        @Override
        public void startDtmf(char c) {
            executeMethodAsync(() -> ImsCallSessionImplBase.this.startDtmf(c), "startDtmf");
        }

        @Override
        public void stopDtmf() {
            executeMethodAsync(() -> ImsCallSessionImplBase.this.stopDtmf(), "stopDtmf");
        }

        @Override
        public void sendUssd(String ussdMessage) {
            executeMethodAsync(() -> ImsCallSessionImplBase.this.sendUssd(ussdMessage), "sendUssd");
        }

        @Override
        public IImsVideoCallProvider getVideoCallProvider() {
            return executeMethodAsyncForResult(() -> ImsCallSessionImplBase.this
                    .getVideoCallProvider(), "getVideoCallProvider");
        }

        @Override
        public boolean isMultiparty() {
            return executeMethodAsyncForResult(() -> ImsCallSessionImplBase.this.isMultiparty(),
                    "isMultiparty");
        }

        @Override
        public void sendRttModifyRequest(ImsCallProfile toProfile) {
            executeMethodAsync(() -> ImsCallSessionImplBase.this.sendRttModifyRequest(toProfile),
                    "sendRttModifyRequest");
        }

        @Override
        public void sendRttModifyResponse(boolean status) {
            executeMethodAsync(() -> ImsCallSessionImplBase.this.sendRttModifyResponse(status),
                    "sendRttModifyResponse");
        }

        @Override
        public void sendRttMessage(String rttMessage) {
            executeMethodAsync(() -> ImsCallSessionImplBase.this.sendRttMessage(rttMessage),
                    "sendRttMessage");
        }

        @Override
        public void sendRtpHeaderExtensions(@NonNull List<RtpHeaderExtension> extensions) {
            executeMethodAsync(() -> ImsCallSessionImplBase.this.sendRtpHeaderExtensions(
                    new ArraySet<RtpHeaderExtension>(extensions)), "sendRtpHeaderExtensions");
        }

        // 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) {
            try {
                CompletableFuture.runAsync(
                        () -> TelephonyUtils.runWithCleanCallingIdentity(r), mExecutor).join();
            } catch (CancellationException | CompletionException e) {
                Log.w(LOG_TAG, "ImsCallSessionImplBase Binder - " + errorLogName + " exception: "
                        + e.getMessage());
            }
        }

        private <T> T executeMethodAsyncForResult(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, "ImsCallSessionImplBase Binder - " + errorLogName + " exception: "
                        + e.getMessage());
                return null;
            }
        }
    };

    /**
     * @hide
     */
    public final void setListener(IImsCallSessionListener listener) throws RemoteException {
        setListener(new ImsCallSessionListener(listener));
    }

    /**
     * Sets the listener to listen to the session events. An {@link ImsCallSession}
     * can only hold one listener at a time. Subsequent calls to this method
     * override the previous listener.
     *
     * @param listener {@link ImsCallSessionListener} used to notify the framework of updates
     * to the ImsCallSession
     */
    public void setListener(ImsCallSessionListener listener) {
    }

    /**
     * Closes the object. This {@link ImsCallSessionImplBase} is not usable after being closed.
     */
    @Override
    public void close() {

    }

    /**
     * @return A String containing the unique call ID of this {@link ImsCallSessionImplBase}.
     */
    public String getCallId() {
        return null;
    }

    /**
     * @return The {@link ImsCallProfile} that this {@link ImsCallSessionImplBase} is associated
     * with.
     */
    public ImsCallProfile getCallProfile() {
        return null;
    }

    /**
     * @return The local {@link ImsCallProfile} that this {@link ImsCallSessionImplBase} is
     * associated with.
     */
    public ImsCallProfile getLocalCallProfile() {
        return null;
    }

    /**
     * @return The remote {@link ImsCallProfile} that this {@link ImsCallSessionImplBase} is
     * associated with.
     */
    public ImsCallProfile getRemoteCallProfile() {
        return null;
    }

    /**
     * @param name The String extra key.
     * @return The string extra value associated with the specified property.
     */
    public String getProperty(String name) {
        return null;
    }

    /**
     * @return The {@link ImsCallSessionImplBase} state, defined in
     * {@link ImsCallSessionImplBase.State}.
     */
    public int getState() {
        return ImsCallSessionImplBase.State.INVALID;
    }

    /**
     * @return true if the {@link ImsCallSessionImplBase} is in a call, false otherwise.
     */
    public boolean isInCall() {
        return false;
    }

    /**
     * Mutes or unmutes the mic for the active call.
     *
     * @param muted true if the call should be muted, false otherwise.
     */
    public void setMute(boolean muted) {
    }

    /**
     * Initiates an IMS call with the specified number and call profile.
     * The session listener set in {@link #setListener(ImsCallSessionListener)} is called back upon
     * defined session events.
     * Only valid to call when the session state is in
     * {@link ImsCallSession.State#IDLE}.
     *
     * @param callee dialed string to make the call to
     * @param profile call profile to make the call with the specified service type,
     *      call type and media information
     * @see {@link ImsCallSession.Listener#callSessionStarted},
     * {@link ImsCallSession.Listener#callSessionStartFailed}
     */
    public void start(String callee, ImsCallProfile profile) {
    }

    /**
     * Initiates an IMS call with the specified participants and call profile.
     * The session listener set in {@link #setListener(ImsCallSessionListener)} is called back upon
     * defined session events.
     * The method is only valid to call when the session state is in
     * {@link ImsCallSession.State#IDLE}.
     *
     * @param participants participant list to initiate an IMS conference call
     * @param profile call profile to make the call with the specified service type,
     *      call type and media information
     * @see {@link ImsCallSession.Listener#callSessionStarted},
     * {@link ImsCallSession.Listener#callSessionStartFailed}
     */
    public void startConference(String[] participants, ImsCallProfile profile) {
    }

    /**
     * Accepts an incoming call or session update.
     *
     * @param callType call type specified in {@link ImsCallProfile} to be answered
     * @param profile stream media profile {@link ImsStreamMediaProfile} to be answered
     * @see {@link ImsCallSession.Listener#callSessionStarted}
     */
    public void accept(int callType, ImsStreamMediaProfile profile) {
    }

    /**
     * Deflects an incoming call.
     *
     * @param deflectNumber number to deflect the call
     */
    public void deflect(String deflectNumber) {
    }

    /**
     * Rejects an incoming call or session update.
     *
     * @param reason reason code to reject an incoming call, defined in {@link ImsReasonInfo}.
     *               The {@link android.telecom.InCallService} (dialer app) can use the
     *               {@link android.telecom.Call#reject(int)} API to reject a call while specifying
     *               a user-indicated reason for rejecting the call.
     *               Normal call declines ({@link android.telecom.Call#REJECT_REASON_DECLINED}) will
     *               map to {@link ImsReasonInfo#CODE_USER_DECLINE}.
     *               Unwanted calls ({@link android.telecom.Call#REJECT_REASON_UNWANTED}) will map
     *               to {@link ImsReasonInfo#CODE_SIP_USER_MARKED_UNWANTED}.
     * {@link ImsCallSession.Listener#callSessionStartFailed}
     */
    public void reject(int reason) {
    }

    /**
     * Transfer an established call to given number
     *
     * @param number number to transfer the call
     * @param isConfirmationRequired if {@code True}, indicates a confirmed transfer,
     * if {@code False} it indicates an unconfirmed transfer.
     * @hide
     */
    public void transfer(@NonNull String number, boolean isConfirmationRequired) {
    }

    /**
     * Transfer an established call to another call session
     *
     * @param otherSession The other ImsCallSession to transfer the ongoing session to.
     * @hide
     */
    public void transfer(@NonNull ImsCallSessionImplBase otherSession) {
    }

    /**
     * Terminates a call.
     *
     * @param reason reason code to terminate a call, defined in {@link ImsReasonInfo}.
     *
     * @see {@link ImsCallSession.Listener#callSessionTerminated}
     */
    public void terminate(int reason) {
    }

    /**
     * Puts a call on hold. When it succeeds, {@link ImsCallSession.Listener#callSessionHeld} is
     * called.
     *
     * @param profile stream media profile {@link ImsStreamMediaProfile} to hold the call
     * @see {@link ImsCallSession.Listener#callSessionHeld},
     * {@link ImsCallSession.Listener#callSessionHoldFailed}
     */
    public void hold(ImsStreamMediaProfile profile) {
    }

    /**
     * Continues a call that's on hold. When it succeeds,
     * {@link ImsCallSession.Listener#callSessionResumed} is called.
     *
     * @param profile stream media profile with {@link ImsStreamMediaProfile} to resume the call
     * @see {@link ImsCallSession.Listener#callSessionResumed},
     * {@link ImsCallSession.Listener#callSessionResumeFailed}
     */
    public void resume(ImsStreamMediaProfile profile) {
    }

    /**
     * Merges the active and held call. When the merge starts,
     * {@link ImsCallSession.Listener#callSessionMergeStarted} is called.
     * {@link ImsCallSession.Listener#callSessionMergeComplete} is called if the merge is
     * successful, and {@link ImsCallSession.Listener#callSessionMergeFailed} is called if the merge
     * fails.
     *
     * @see {@link ImsCallSession.Listener#callSessionMergeStarted},
     * {@link ImsCallSession.Listener#callSessionMergeComplete},
     *      {@link ImsCallSession.Listener#callSessionMergeFailed}
     */
    public void merge() {
    }

    /**
     * Updates the current call's properties (ex. call mode change: video upgrade / downgrade).
     *
     * @param callType call type specified in {@link ImsCallProfile} to be updated
     * @param profile stream media profile {@link ImsStreamMediaProfile} to be updated
     * @see {@link ImsCallSession.Listener#callSessionUpdated},
     * {@link ImsCallSession.Listener#callSessionUpdateFailed}
     */
    public void update(int callType, ImsStreamMediaProfile profile) {
    }

    /**
     * Extends this call to the conference call with the specified recipients.
     *
     * @param participants participant list to be invited to the conference call after extending the
     * call
     * @see {@link ImsCallSession.Listener#callSessionConferenceExtended},
     * {@link ImsCallSession.Listener#callSessionConferenceExtendFailed}
     */
    public void extendToConference(String[] participants) {
    }

    /**
     * Requests the conference server to invite an additional participants to the conference.
     *
     * @param participants participant list to be invited to the conference call
     * @see {@link ImsCallSession.Listener#callSessionInviteParticipantsRequestDelivered},
     *      {@link ImsCallSession.Listener#callSessionInviteParticipantsRequestFailed}
     */
    public void inviteParticipants(String[] participants) {
    }

    /**
     * Requests the conference server to remove the specified participants from the conference.
     *
     * @param participants participant list to be removed from the conference call
     * @see {@link ImsCallSession.Listener#callSessionRemoveParticipantsRequestDelivered},
     *      {@link ImsCallSession.Listener#callSessionRemoveParticipantsRequestFailed}
     */
    public void removeParticipants(String[] participants) {
    }

    /**
     * Sends a DTMF code. According to <a href="http://tools.ietf.org/html/rfc2833">RFC 2833</a>,
     * event 0 ~ 9 maps to decimal value 0 ~ 9, '*' to 10, '#' to 11, event 'A' ~ 'D' to 12 ~ 15,
     * and event flash to 16. Currently, event flash is not supported.
     *
     * @param c the DTMF to send. '0' ~ '9', 'A' ~ 'D', '*', '#' are valid inputs.
     * @param result If non-null, the {@link Message} to send when the operation is complete. This
     *         is done by using the associated {@link android.os.Messenger} in
     *         {@link Message#replyTo}. For example:
     * {@code
     *     // Send DTMF and other operations...
     *     try {
     *         // Notify framework that the DTMF was sent.
     *         Messenger dtmfMessenger = result.replyTo;
     *         if (dtmfMessenger != null) {
     *             dtmfMessenger.send(result);
     *         }
     *     } catch (RemoteException e) {
     *         // Remote side is dead
     *     }
     * }
     */
    public void sendDtmf(char c, Message result) {
    }

    /**
     * Start a DTMF code. According to <a href="http://tools.ietf.org/html/rfc2833">RFC 2833</a>,
     * event 0 ~ 9 maps to decimal value 0 ~ 9, '*' to 10, '#' to 11, event 'A' ~ 'D' to 12 ~ 15,
     * and event flash to 16. Currently, event flash is not supported.
     *
     * @param c the DTMF to send. '0' ~ '9', 'A' ~ 'D', '*', '#' are valid inputs.
     */
    public void startDtmf(char c) {
    }

    /**
     * Stop a DTMF code.
     */
    public void stopDtmf() {
    }

    /**
     * Sends an USSD message.
     *
     * @param ussdMessage USSD message to send
     */
    public void sendUssd(String ussdMessage) {
    }

    /**
     * See {@link #getImsVideoCallProvider()}, used directly in older ImsService implementations.
     * @hide
     */
    public IImsVideoCallProvider getVideoCallProvider() {
        ImsVideoCallProvider provider = getImsVideoCallProvider();
        return provider != null ? provider.getInterface() : null;
    }

    /**
     * @return The {@link ImsVideoCallProvider} implementation contained within the IMS service
     * process.
     */
    public ImsVideoCallProvider getImsVideoCallProvider() {
        return null;
    }

    /**
     * Determines if the current session is multiparty.
     * @return {@code True} if the session is multiparty.
     */
    public boolean isMultiparty() {
        return false;
    }

    /**
     * Device issues RTT modify request
     * @param toProfile The profile with requested changes made
     */
    public void sendRttModifyRequest(ImsCallProfile toProfile) {
    }

    /**
     * Device responds to Remote RTT modify request
     * @param status true if the the request was accepted or false of the request is defined.
     */
    public void sendRttModifyResponse(boolean status) {
    }

    /**
     * Device sends RTT message
     * @param rttMessage RTT message to be sent
     */
    public void sendRttMessage(String rttMessage) {
    }

    /**
     * Device requests that {@code rtpHeaderExtensions} are sent as a header extension with the next
     * RTP packet sent by the IMS stack.
     * <p>
     * The {@link RtpHeaderExtensionType}s negotiated during SDP (Session Description Protocol)
     * signalling determine the {@link RtpHeaderExtension}s which can be sent using this method.
     * See RFC8285 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 rtpHeaderExtensions The RTP header extensions to be included in the next RTP header.
     */
    public void sendRtpHeaderExtensions(@NonNull Set<RtpHeaderExtension> rtpHeaderExtensions) {
    }

    /** @hide */
    public IImsCallSession getServiceImpl() {
        return mServiceImpl;
    }

    /** @hide */
    public void setServiceImpl(IImsCallSession serviceImpl) {
        mServiceImpl = serviceImpl;
    }

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