telephony/imsphone/ImsExternalCallTracker.java

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

package com.android.internal.telephony.imsphone;

import com.android.ims.ImsCallProfile;
import com.android.ims.ImsExternalCallState;
import com.android.ims.ImsExternalCallStateListener;
import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.telephony.Call;
import com.android.internal.telephony.Connection;
import com.android.internal.telephony.Phone;
import com.android.internal.telephony.PhoneConstants;

import android.os.AsyncResult;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.telecom.PhoneAccountHandle;
import android.telecom.VideoProfile;
import android.telephony.TelephonyManager;
import android.util.ArrayMap;
import android.util.Log;

import java.util.Iterator;
import java.util.List;
import java.util.Map;

/**
 * Responsible for tracking external calls known to the system.
 */
public class ImsExternalCallTracker implements ImsPhoneCallTracker.PhoneStateListener {

    /**
     * Interface implemented by modules which are capable of notifying interested parties of new
     * unknown connections, and changes to call state.
     * This is used to break the dependency between {@link ImsExternalCallTracker} and
     * {@link ImsPhone}.
     *
     * @hide
     */
    public static interface ImsCallNotify {
        /**
         * Notifies that an unknown connection has been added.
         * @param c The new unknown connection.
         */
        void notifyUnknownConnection(Connection c);

        /**
         * Notifies of a change to call state.
         */
        void notifyPreciseCallStateChanged();
    }


    /**
     * Implements the {@link ImsExternalCallStateListener}, which is responsible for receiving
     * external call state updates from the IMS framework.
     */
    public class ExternalCallStateListener extends ImsExternalCallStateListener {
        @Override
        public void onImsExternalCallStateUpdate(List<ImsExternalCallState> externalCallState) {
            refreshExternalCallState(externalCallState);
        }
    }

    /**
     * Receives callbacks from {@link ImsExternalConnection}s when a call pull has been initiated.
     */
    public class ExternalConnectionListener implements ImsExternalConnection.Listener {
        @Override
        public void onPullExternalCall(ImsExternalConnection connection) {
            Log.d(TAG, "onPullExternalCall: connection = " + connection);
            if (mCallPuller == null) {
                Log.e(TAG, "onPullExternalCall : No call puller defined");
                return;
            }
            mCallPuller.pullExternalCall(connection.getAddress(), connection.getVideoState(),
                    connection.getCallId());
        }
    }

    public final static String TAG = "ImsExternalCallTracker";

    private static final int EVENT_VIDEO_CAPABILITIES_CHANGED = 1;

    /**
     * Extra key used when informing telecom of a new external call using the
     * {@link android.telecom.TelecomManager#addNewUnknownCall(PhoneAccountHandle, Bundle)} API.
     * Used to ensure that when Telecom requests the {@link android.telecom.ConnectionService} to
     * create the connection for the unknown call that we can determine which
     * {@link ImsExternalConnection} in {@link #mExternalConnections} is the one being requested.
     */
    public final static String EXTRA_IMS_EXTERNAL_CALL_ID =
            "android.telephony.ImsExternalCallTracker.extra.EXTERNAL_CALL_ID";

    /**
     * Contains a list of the external connections known by the ImsExternalCallTracker.  These are
     * connections which originated from a dialog event package and reside on another device.
     * Used in multi-endpoint (VoLTE for internet connected endpoints) scenarios.
     */
    private Map<Integer, ImsExternalConnection> mExternalConnections =
            new ArrayMap<>();

    /**
     * Tracks whether each external connection tracked in
     * {@link #mExternalConnections} can be pulled, as reported by the latest dialog event package
     * received from the network.  We need to know this because the pull state of a call can be
     * overridden based on the following factors:
     * 1) An external video call cannot be pulled if the current device does not have video
     *    capability.
     * 2) If the device has any active or held calls locally, no external calls may be pulled to
     *    the local device.
     */
    private Map<Integer, Boolean> mExternalCallPullableState = new ArrayMap<>();
    private final ImsPhone mPhone;
    private final ImsCallNotify mCallStateNotifier;
    private final ExternalCallStateListener mExternalCallStateListener;
    private final ExternalConnectionListener mExternalConnectionListener =
            new ExternalConnectionListener();
    private ImsPullCall mCallPuller;
    private boolean mIsVideoCapable;
    private boolean mHasActiveCalls;

    private final Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
                case EVENT_VIDEO_CAPABILITIES_CHANGED:
                    handleVideoCapabilitiesChanged((AsyncResult) msg.obj);
                    break;
                default:
                    break;
            }
        }
    };

    @VisibleForTesting
    public ImsExternalCallTracker(ImsPhone phone, ImsPullCall callPuller,
            ImsCallNotify callNotifier) {

        mPhone = phone;
        mCallStateNotifier = callNotifier;
        mExternalCallStateListener = new ExternalCallStateListener();
        mCallPuller = callPuller;
    }

    public ImsExternalCallTracker(ImsPhone phone) {
        mPhone = phone;
        mCallStateNotifier = new ImsCallNotify() {
            @Override
            public void notifyUnknownConnection(Connection c) {
                mPhone.notifyUnknownConnection(c);
            }

            @Override
            public void notifyPreciseCallStateChanged() {
                mPhone.notifyPreciseCallStateChanged();
            }
        };
        mExternalCallStateListener = new ExternalCallStateListener();
        registerForNotifications();
    }

    /**
     * Performs any cleanup required before the ImsExternalCallTracker is destroyed.
     */
    public void tearDown() {
        unregisterForNotifications();
    }

    /**
     * Sets the implementation of {@link ImsPullCall} which is responsible for pulling calls.
     *
     * @param callPuller The pull call implementation.
     */
    public void setCallPuller(ImsPullCall callPuller) {
       mCallPuller = callPuller;
    }

    public ExternalCallStateListener getExternalCallStateListener() {
        return mExternalCallStateListener;
    }

    /**
     * Handles changes to the phone state as notified by the {@link ImsPhoneCallTracker}.
     *
     * @param oldState The previous phone state.
     * @param newState The new phone state.
     */
    @Override
    public void onPhoneStateChanged(PhoneConstants.State oldState, PhoneConstants.State newState) {
        mHasActiveCalls = newState != PhoneConstants.State.IDLE;
        Log.i(TAG, "onPhoneStateChanged : hasActiveCalls = " + mHasActiveCalls);

        refreshCallPullState();
    }

    /**
     * Registers for video capability changes.
     */
    private void registerForNotifications() {
        if (mPhone != null) {
            Log.d(TAG, "Registering: " + mPhone);
            mPhone.getDefaultPhone().registerForVideoCapabilityChanged(mHandler,
                    EVENT_VIDEO_CAPABILITIES_CHANGED, null);
        }
    }

    /**
     * Unregisters for video capability changes.
     */
    private void unregisterForNotifications() {
        if (mPhone != null) {
            Log.d(TAG, "Unregistering: " + mPhone);
            mPhone.unregisterForVideoCapabilityChanged(mHandler);
        }
    }


    /**
     * Called when the IMS stack receives a new dialog event package.  Triggers the creation and
     * update of {@link ImsExternalConnection}s to represent the dialogs in the dialog event
     * package data.
     *
     * @param externalCallStates the {@link ImsExternalCallState} information for the dialog event
     *                           package.
     */
    public void refreshExternalCallState(List<ImsExternalCallState> externalCallStates) {
        Log.d(TAG, "refreshExternalCallState");

        // Check to see if any call Ids are no longer present in the external call state.  If they
        // are, the calls are terminated and should be removed.
        Iterator<Map.Entry<Integer, ImsExternalConnection>> connectionIterator =
                mExternalConnections.entrySet().iterator();
        boolean wasCallRemoved = false;
        while (connectionIterator.hasNext()) {
            Map.Entry<Integer, ImsExternalConnection> entry = connectionIterator.next();
            int callId = entry.getKey().intValue();

            if (!containsCallId(externalCallStates, callId)) {
                ImsExternalConnection externalConnection = entry.getValue();
                externalConnection.setTerminated();
                externalConnection.removeListener(mExternalConnectionListener);
                connectionIterator.remove();
                wasCallRemoved = true;
            }
        }
        // If one or more calls were removed, trigger a notification that will cause the
        // TelephonyConnection instancse to refresh their state with Telecom.
        if (wasCallRemoved) {
            mCallStateNotifier.notifyPreciseCallStateChanged();
        }

        // Check for new calls, and updates to existing ones.
        if (externalCallStates != null && !externalCallStates.isEmpty()) {
            for (ImsExternalCallState callState : externalCallStates) {
                if (!mExternalConnections.containsKey(callState.getCallId())) {
                    Log.d(TAG, "refreshExternalCallState: got = " + callState);
                    // If there is a new entry and it is already terminated, don't bother adding it to
                    // telecom.
                    if (callState.getCallState() != ImsExternalCallState.CALL_STATE_CONFIRMED) {
                        continue;
                    }
                    createExternalConnection(callState);
                } else {
                    updateExistingConnection(mExternalConnections.get(callState.getCallId()),
                            callState);
                }
            }
        }
    }

    /**
     * Finds an external connection given a call Id.
     *
     * @param callId The call Id.
     * @return The {@link Connection}, or {@code null} if no match found.
     */
    public Connection getConnectionById(int callId) {
        return mExternalConnections.get(callId);
    }

    /**
     * Given an {@link ImsExternalCallState} instance obtained from a dialog event package,
     * creates a new instance of {@link ImsExternalConnection} to represent the connection, and
     * initiates the addition of the new call to Telecom as an unknown call.
     *
     * @param state External call state from a dialog event package.
     */
    private void createExternalConnection(ImsExternalCallState state) {
        Log.i(TAG, "createExternalConnection : state = " + state);

        int videoState = ImsCallProfile.getVideoStateFromCallType(state.getCallType());

        boolean isCallPullPermitted = isCallPullPermitted(state.isCallPullable(), videoState);
        ImsExternalConnection connection = new ImsExternalConnection(mPhone,
                state.getCallId(), /* Dialog event package call id */
                state.getAddress() /* phone number */,
                isCallPullPermitted);
        connection.setVideoState(videoState);
        connection.addListener(mExternalConnectionListener);

        Log.d(TAG,
                "createExternalConnection - pullable state : externalCallId = "
                        + connection.getCallId()
                        + " ; isPullable = " + isCallPullPermitted
                        + " ; networkPullable = " + state.isCallPullable()
                        + " ; isVideo = " + VideoProfile.isVideo(videoState)
                        + " ; videoEnabled = " + mIsVideoCapable
                        + " ; hasActiveCalls = " + mHasActiveCalls);

        // Add to list of tracked connections.
        mExternalConnections.put(connection.getCallId(), connection);
        mExternalCallPullableState.put(connection.getCallId(), state.isCallPullable());

        // Note: The notification of unknown connection is ultimately handled by
        // PstnIncomingCallNotifier#addNewUnknownCall.  That method will ensure that an extra is set
        // containing the ImsExternalConnection#mCallId so that we have a means of reconciling which
        // unknown call was added.
        mCallStateNotifier.notifyUnknownConnection(connection);
    }

    /**
     * Given an existing {@link ImsExternalConnection}, applies any changes found found in a
     * {@link ImsExternalCallState} instance received from a dialog event package to the connection.
     *
     * @param connection The connection to apply changes to.
     * @param state The new dialog state for the connection.
     */
    private void updateExistingConnection(ImsExternalConnection connection,
            ImsExternalCallState state) {

        Log.i(TAG, "updateExistingConnection : state = " + state);
        Call.State existingState = connection.getState();
        Call.State newState = state.getCallState() == ImsExternalCallState.CALL_STATE_CONFIRMED ?
                Call.State.ACTIVE : Call.State.DISCONNECTED;

        if (existingState != newState) {
            if (newState == Call.State.ACTIVE) {
                connection.setActive();
            } else {
                connection.setTerminated();
                connection.removeListener(mExternalConnectionListener);
                mExternalConnections.remove(connection.getCallId());
                mExternalCallPullableState.remove(connection.getCallId());
                mCallStateNotifier.notifyPreciseCallStateChanged();
            }
        }

        int newVideoState = ImsCallProfile.getVideoStateFromCallType(state.getCallType());
        if (newVideoState != connection.getVideoState()) {
            connection.setVideoState(newVideoState);
        }

        mExternalCallPullableState.put(state.getCallId(), state.isCallPullable());
        boolean isCallPullPermitted = isCallPullPermitted(state.isCallPullable(), newVideoState);
        Log.d(TAG,
                "updateExistingConnection - pullable state : externalCallId = " + connection
                        .getCallId()
                        + " ; isPullable = " + isCallPullPermitted
                        + " ; networkPullable = " + state.isCallPullable()
                        + " ; isVideo = "
                        + VideoProfile.isVideo(connection.getVideoState())
                        + " ; videoEnabled = " + mIsVideoCapable
                        + " ; hasActiveCalls = " + mHasActiveCalls);

        connection.setIsPullable(isCallPullPermitted);
    }

    /**
     * Update whether the external calls known can be pulled.  Combines the last known network
     * pullable state with local device conditions to determine if each call can be pulled.
     */
    private void refreshCallPullState() {
        Log.d(TAG, "refreshCallPullState");

        for (ImsExternalConnection imsExternalConnection : mExternalConnections.values()) {
            boolean isNetworkPullable =
                    mExternalCallPullableState.get(imsExternalConnection.getCallId())
                            .booleanValue();
            boolean isCallPullPermitted =
                    isCallPullPermitted(isNetworkPullable, imsExternalConnection.getVideoState());
            Log.d(TAG,
                    "refreshCallPullState : externalCallId = " + imsExternalConnection.getCallId()
                            + " ; isPullable = " + isCallPullPermitted
                            + " ; networkPullable = " + isNetworkPullable
                            + " ; isVideo = "
                            + VideoProfile.isVideo(imsExternalConnection.getVideoState())
                            + " ; videoEnabled = " + mIsVideoCapable
                            + " ; hasActiveCalls = " + mHasActiveCalls);
            imsExternalConnection.setIsPullable(isCallPullPermitted);
        }
    }

    /**
     * Determines if a list of call states obtained from a dialog event package contacts an existing
     * call Id.
     *
     * @param externalCallStates The dialog event package state information.
     * @param callId The call Id.
     * @return {@code true} if the state information contains the call Id, {@code false} otherwise.
     */
    private boolean containsCallId(List<ImsExternalCallState> externalCallStates, int callId) {
        if (externalCallStates == null) {
            return false;
        }

        for (ImsExternalCallState state : externalCallStates) {
            if (state.getCallId() == callId) {
                return true;
            }
        }

        return false;
    }

    /**
     * Handles a change to the video capabilities reported by
     * {@link Phone#notifyForVideoCapabilityChanged(boolean)}.
     *
     * @param ar The AsyncResult containing the new video capability of the device.
     */
    private void handleVideoCapabilitiesChanged(AsyncResult ar) {
        mIsVideoCapable = (Boolean) ar.result;
        Log.i(TAG, "handleVideoCapabilitiesChanged : isVideoCapable = " + mIsVideoCapable);

        // Refresh pullable state if video capability changed.
        refreshCallPullState();
    }

    /**
     * Determines whether an external call can be pulled based on the pullability state enforced
     * by the network, as well as local device rules.
     *
     * @param isNetworkPullable {@code true} if the network indicates the call can be pulled,
     *      {@code false} otherwise.
     * @param videoState the VideoState of the external call.
     * @return {@code true} if the external call can be pulled, {@code false} otherwise.
     */
    private boolean isCallPullPermitted(boolean isNetworkPullable, int videoState) {
        if (VideoProfile.isVideo(videoState) && !mIsVideoCapable) {
            // If the external call is a video call and the local device does not have video
            // capability at this time, it cannot be pulled.
            return false;
        }

        if (mHasActiveCalls) {
            // If there are active calls on the local device, the call cannot be pulled.
            return false;
        }

        return isNetworkPullable;
    }
}