android/incallui/StatusBarNotifier.java

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

import com.google.common.base.Preconditions;

import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;

import com.android.incallui.InCallApp.NotificationBroadcastReceiver;
import com.android.incallui.InCallPresenter.InCallState;
import com.android.services.telephony.common.Call;

/**
 * This class adds Notifications to the status bar for the in-call experience.
 */
public class StatusBarNotifier implements InCallPresenter.InCallStateListener {
    // notification types
    private static final int IN_CALL_NOTIFICATION = 1;

    private final Context mContext;
    private final NotificationManager mNotificationManager;
    private boolean mIsShowingNotification = false;
    private InCallState mInCallState = InCallState.HIDDEN;
    private int mSavedIcon = 0;
    private int mSavedContent = 0;

    public StatusBarNotifier(Context context) {
        Preconditions.checkNotNull(context);

        mContext = context;
        mNotificationManager =
                (NotificationManager) mContext.getSystemService(Context.NOTIFICATION_SERVICE);
    }

    /**
     * Creates notifications according to the state we receive from {@link InCallPresenter}.
     */
    @Override
    public void onStateChange(InCallState state, CallList callList) {
        updateNotification(state, callList);
    }

    /**
     * Updates the phone app's status bar notification based on the
     * current telephony state, or cancels the notification if the phone
     * is totally idle.
     *
     * This method will never actually launch the incoming-call UI.
     * (Use updateNotificationAndLaunchIncomingCallUi() for that.)
     */
    public void updateNotification(InCallState state, CallList callList) {
        // allowFullScreenIntent=false means *don't* allow the incoming
        // call UI to be launched.
        updateInCallNotification(false, state, callList);
    }

    /**
     * Updates the phone app's status bar notification *and* launches the
     * incoming call UI in response to a new incoming call.
     *
     * This is just like updateInCallNotification(), with one exception:
     * If an incoming call is ringing (or call-waiting), the notification
     * will also include a "fullScreenIntent" that will cause the
     * InCallScreen to be launched immediately, unless the current
     * foreground activity is marked as "immersive".
     *
     * (This is the mechanism that actually brings up the incoming call UI
     * when we receive a "new ringing connection" event from the telephony
     * layer.)
     *
     * Watch out: this method should ONLY be called directly from the code
     * path in CallNotifier that handles the "new ringing connection"
     * event from the telephony layer.  All other places that update the
     * in-call notification (like for phone state changes) should call
     * updateInCallNotification() instead.  (This ensures that we don't
     * end up launching the InCallScreen multiple times for a single
     * incoming call, which could cause slow responsiveness and/or visible
     * glitches.)
     *
     * Also note that this method is safe to call even if the phone isn't
     * actually ringing (or, more likely, if an incoming call *was*
     * ringing briefly but then disconnected).  In that case, we'll simply
     * update or cancel the in-call notification based on the current
     * phone state.
     *
     * @see #updateInCallNotification(boolean)
     */
    public void updateNotificationAndLaunchIncomingCallUi(InCallState state, CallList callList) {
        // Set allowFullScreenIntent=true to indicate that we *should*
        // launch the incoming call UI if necessary.
        updateInCallNotification(true, state, callList);
    }


    /**
     * Take down the in-call notification.
     * @see updateInCallNotification()
     */
    private void cancelInCall() {
        Logger.d(this, "cancelInCall()...");
        mNotificationManager.cancel(IN_CALL_NOTIFICATION);

        mIsShowingNotification = false;
    }

    /**
     * Helper method for updateInCallNotification() and
     * updateNotificationAndLaunchIncomingCallUi(): Update the phone app's
     * status bar notification based on the current telephony state, or
     * cancels the notification if the phone is totally idle.
     *
     * @param allowFullScreenIntent If true, *and* an incoming call is
     *   ringing, the notification will include a "fullScreenIntent"
     *   pointing at the InCallActivity (which will cause the InCallActivity
     *   to be launched.)
     *   Watch out: This should be set to true *only* when directly
     *   handling a new incoming call for the first time.
     */
    private void updateInCallNotification(boolean allowFullScreenIntent, InCallState state,
            CallList callList) {
        Logger.d(this, "updateInCallNotification(allowFullScreenIntent = "
                     + allowFullScreenIntent + ")...");

        if (shouldSuppressNotification(state, callList)) {
            cancelInCall();
            return;
        }

        buildAndSendNotification(state, callList, allowFullScreenIntent);

    }

    /**
     * Sets up the main Ui for the notification
     */
    private void buildAndSendNotification(InCallState state, CallList callList,
            boolean allowFullScreenIntent) {

        final Call call = getCallToShow(callList);
        if (call == null) {
            Logger.wtf(this, "No call for the notification!");
        }

        final int iconResId = getIconToDisplay(call);
        final int contentResId = getContentString(call);

        // If we checked and found that nothing is different, dont issue another notification.
        if (!checkForChangeAndSaveData(iconResId, contentResId, state, allowFullScreenIntent)) {
            return;
        }


        /*
         * Nothing more to check...build and send it.
         */
        final Notification.Builder builder = getNotificationBuilder();

        // Set up the main intent to send the user to the in-call screen
        final PendingIntent inCallPendingIntent = createLaunchPendingIntent();
        builder.setContentIntent(inCallPendingIntent);

        // Set the intent as a full screen intent as well if requested
        if (allowFullScreenIntent) {
            configureFullScreenIntent(builder, inCallPendingIntent);
        }

        // set the content
        builder.setContentText(mContext.getString(contentResId));
        builder.setSmallIcon(iconResId);

        // Add special Content for calls that are ongoing
        if (InCallState.INCALL == state || InCallState.OUTGOING == state) {
            addHangupAction(builder);
        }

        /*
         * Fire off the notification
         */
        Notification notification = builder.build();
        Logger.d(this, "Notifying IN_CALL_NOTIFICATION: " + notification);
        mNotificationManager.notify(IN_CALL_NOTIFICATION, notification);
        mIsShowingNotification = true;
    }

    /**
     * Checks the new notification data and compares it against any notification that we
     * are already displaying. If the data is exactly the same, we return false so that
     * we do not issue a new notification for the exact same data.
     */
    private boolean checkForChangeAndSaveData(int icon, int content, InCallState state,
            boolean showFullScreenIntent) {
        boolean retval = (mSavedIcon != icon) || (mSavedContent != content) ||
                (mInCallState == state);

        // A full screen intent means that we have been asked to interrupt an activity,
        // so we definitely want to show it.
        if (showFullScreenIntent) {
            Logger.d(this, "Forcing full screen intent");
            retval = true;
        }

        // If we aren't showing a notification right now, definitely start showing one.
        if (!mIsShowingNotification) {
            Logger.d(this, "Showing notification for first time.");
            retval = true;
        }

        mSavedIcon = icon;
        mSavedContent = content;
        mInCallState = state;

        if (retval) {
            Logger.d(this, "Data changed.  Showing notification");
        }

        return retval;
    }

    /**
     * Returns the appropriate icon res Id to display based on the call for which
     * we want to display information.
     */
    private int getIconToDisplay(Call call) {
        // Even if both lines are in use, we only show a single item in
        // the expanded Notifications UI.  It's labeled "Ongoing call"
        // (or "On hold" if there's only one call, and it's on hold.)
        // Also, we don't have room to display caller-id info from two
        // different calls.  So if both lines are in use, display info
        // from the foreground call.  And if there's a ringing call,
        // display that regardless of the state of the other calls.
        if (call.getState() == Call.State.ONHOLD) {
            return R.drawable.stat_sys_phone_call_on_hold;
        }
        return R.drawable.stat_sys_phone_call;
    }

    /**
     * Returns the message to use with the notificaiton.
     */
    private int getContentString(Call call) {
        int resId = R.string.notification_ongoing_call;

        if (call.getState() == Call.State.INCOMING) {
            resId = R.string.notification_incoming_call;

        } else if (call.getState() == Call.State.ONHOLD) {
            resId = R.string.notification_on_hold;

        } else if (call.getState() == Call.State.DIALING) {
            resId = R.string.notification_dialing;
        }

        return resId;
    }

    /**
     * Gets the most relevant call to display in the notification.
     */
    private Call getCallToShow(CallList callList) {
        Call call = callList.getIncomingCall();
        if (call == null) {
            call = callList.getOutgoingCall();
        }
        if (call == null) {
            call = callList.getActiveOrBackgroundCall();
        }
        return call;
    }

    private void addHangupAction(Notification.Builder builder) {
        Logger.i(this, "Will show \"hang-up\" action in the ongoing active call Notification");

        // TODO: use better asset.
        builder.addAction(R.drawable.stat_sys_phone_call_end,
                mContext.getText(R.string.notification_action_end_call),
                createHangUpOngoingCallPendingIntent(mContext));
    }

    /**
     * Adds fullscreen intent to the builder.
     */
    private void configureFullScreenIntent(Notification.Builder builder, PendingIntent intent) {
        // Ok, we actually want to launch the incoming call
        // UI at this point (in addition to simply posting a notification
        // to the status bar).  Setting fullScreenIntent will cause
        // the InCallScreen to be launched immediately *unless* the
        // current foreground activity is marked as "immersive".
        Logger.d(this, "- Setting fullScreenIntent: " + intent);
        builder.setFullScreenIntent(intent, true);

        // Ugly hack alert:
        //
        // The NotificationManager has the (undocumented) behavior
        // that it will *ignore* the fullScreenIntent field if you
        // post a new Notification that matches the ID of one that's
        // already active.  Unfortunately this is exactly what happens
        // when you get an incoming call-waiting call:  the
        // "ongoing call" notification is already visible, so the
        // InCallScreen won't get launched in this case!
        // (The result: if you bail out of the in-call UI while on a
        // call and then get a call-waiting call, the incoming call UI
        // won't come up automatically.)
        //
        // The workaround is to just notice this exact case (this is a
        // call-waiting call *and* the InCallScreen is not in the
        // foreground) and manually cancel the in-call notification
        // before (re)posting it.
        //
        // TODO: there should be a cleaner way of avoiding this
        // problem (see discussion in bug 3184149.)

        // TODO(klp): reenable this for klp
        /*if (incomingCall.getState() == Call.State.CALL_WAITING) {
            Logger.i(this, "updateInCallNotification: call-waiting! force relaunch...");
            // Cancel the IN_CALL_NOTIFICATION immediately before
            // (re)posting it; this seems to force the
            // NotificationManager to launch the fullScreenIntent.
            mNotificationManager.cancel(IN_CALL_NOTIFICATION);
        }*/
    }

    private Notification.Builder getNotificationBuilder() {
        final Notification.Builder builder = new Notification.Builder(mContext);
        builder.setOngoing(true);

        // Make the notification prioritized over the other normal notifications.
        builder.setPriority(Notification.PRIORITY_HIGH);

        return builder;
    }

    /**
     * Returns true if notification should not be shown in the current state.
     */
    private boolean shouldSuppressNotification(InCallState state, CallList callList) {
        // Suppress the in-call notification if the InCallScreen is the
        // foreground activity, since it's already obvious that you're on a
        // call.  (The status bar icon is needed only if you navigate *away*
        // from the in-call UI.)
        boolean shouldSuppress = InCallPresenter.getInstance().isShowingInCallUi();

        // Suppress if the call is not active.
        if (!state.isConnectingOrConnected()) {
            shouldSuppress = true;
        }

        // We can still be in the INCALL state when a call is disconnected (in order to show
        // the "Call ended" screen.  So check that we have an active connection too.
        final Call call = getCallToShow(callList);
        if (call == null) {
            shouldSuppress = true;
        }

        // If there's an incoming ringing call: always show the
        // notification, since the in-call notification is what actually
        // launches the incoming call UI in the first place (see
        // notification.fullScreenIntent below.)  This makes sure that we'll
        // correctly handle the case where a new incoming call comes in but
        // the InCallScreen is already in the foreground.
        if (state.isIncoming()) {
            shouldSuppress = false;
        }

        // JANK fix:
        // This class will issue a notification when user makes an outgoing call.
        // However, since we suppress the notification when the user is in the in-call screen,
        // that results is us showing it for a split second, until the in-call screen comes up.
        // It looks ugly.
        //
        // The solution is to ignore the change from HIDDEN to OUTGOING since in that particular
        // case, we know we'll get called to update again when the UI finally starts.
        if (InCallState.OUTGOING == state && InCallState.HIDDEN == mInCallState) {
            shouldSuppress = true;
        }

        return shouldSuppress;
    }

    private PendingIntent createLaunchPendingIntent() {

        final Intent intent = new Intent(Intent.ACTION_MAIN, null);
        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK
                | Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS
                | Intent.FLAG_ACTIVITY_NO_USER_ACTION);
        intent.setClass(mContext, InCallActivity.class);

        // PendingIntent that can be used to launch the InCallActivity.  The
        // system fires off this intent if the user pulls down the windowshade
        // and clicks the notification's expanded view.  It's also used to
        // launch the InCallActivity immediately when when there's an incoming
        // call (see the "fullScreenIntent" field below).
        PendingIntent inCallPendingIntent = PendingIntent.getActivity(mContext, 0, intent, 0);

        return inCallPendingIntent;
    }

    /**
     * Returns PendingIntent for hanging up ongoing phone call. This will typically be used from
     * Notification context.
     */
    private static PendingIntent createHangUpOngoingCallPendingIntent(Context context) {
        final Intent intent = new Intent(InCallApp.ACTION_HANG_UP_ONGOING_CALL, null,
                context, NotificationBroadcastReceiver.class);
        return PendingIntent.getBroadcast(context, 0, intent, 0);
    }
}