car/notification/CarHeadsUpNotificationManager.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 com.android.car.notification;

import static com.android.car.assist.client.CarAssistUtils.isCarCompatibleMessagingNotification;

import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.animation.AnimatorSet;
import android.animation.ObjectAnimator;
import android.app.KeyguardManager;
import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.car.drivingstate.CarUxRestrictions;
import android.car.drivingstate.CarUxRestrictionsManager;
import android.car.userlib.CarUserManagerHelper;
import android.content.Context;
import android.graphics.PixelFormat;
import android.os.Bundle;
import android.service.notification.NotificationListenerService;
import android.service.notification.StatusBarNotification;
import android.util.Log;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewTreeObserver;
import android.view.WindowManager;
import android.view.animation.AnimationUtils;
import android.view.animation.Interpolator;
import android.widget.FrameLayout;

import androidx.annotation.VisibleForTesting;

import com.android.car.notification.template.BasicNotificationViewHolder;
import com.android.car.notification.template.CallNotificationViewHolder;
import com.android.car.notification.template.EmergencyNotificationViewHolder;
import com.android.car.notification.template.InboxNotificationViewHolder;
import com.android.car.notification.template.MessageNotificationViewHolder;
import com.android.car.notification.template.NavigationNotificationViewHolder;

import java.util.HashMap;
import java.util.Map;

/**
 * Notification Manager for heads-up notifications in car.
 */
public class CarHeadsUpNotificationManager
        implements CarUxRestrictionsManager.OnUxRestrictionsChangedListener {
    private static final String TAG = CarHeadsUpNotificationManager.class.getSimpleName();

    private final Beeper mBeeper;
    private final Context mContext;
    private final boolean mEnableNavigationHeadsup;
    private final long mDuration;
    private final long mMinDisplayDuration;
    private final long mEnterAnimationDuration;
    private final long mAlphaEnterAnimationDuration;
    private final long mExitAnimationDuration;
    private final int mNotificationHeadsUpCardMarginTop;

    private final KeyguardManager mKeyguardManager;
    private final CarUserManagerHelper mCarUserManagerHelper;
    private final PreprocessingManager mPreprocessingManager;
    private final WindowManager mWindowManager;
    private final LayoutInflater mInflater;

    private boolean mShouldRestrictMessagePreview;
    private NotificationClickHandlerFactory mClickHandlerFactory;
    private NotificationDataManager mNotificationDataManager;

    // key for the map is the statusbarnotification key
    private final Map<String, HeadsUpEntry> mActiveHeadsUpNotifications;
    // view that contains scrim and notification content
    protected final View mHeadsUpPanel;
    // framelayout that notification content should be added to.
    protected final FrameLayout mHeadsUpContentFrame;

    public CarHeadsUpNotificationManager(Context context,
            NotificationClickHandlerFactory clickHandlerFactory,
            NotificationDataManager notificationDataManager) {
        mContext = context.getApplicationContext();
        mEnableNavigationHeadsup =
                context.getResources().getBoolean(R.bool.config_showNavigationHeadsup);
        mClickHandlerFactory = clickHandlerFactory;
        mNotificationDataManager = notificationDataManager;
        mBeeper = new Beeper(mContext);
        mDuration = mContext.getResources().getInteger(R.integer.headsup_notification_duration_ms);
        mNotificationHeadsUpCardMarginTop = (int) mContext.getResources().getDimension(
                R.dimen.headsup_notification_top_margin);
        mMinDisplayDuration = mContext.getResources().getInteger(
                R.integer.heads_up_notification_minimum_time);
        mEnterAnimationDuration =
                mContext.getResources().getInteger(R.integer.headsup_total_enter_duration_ms);
        mAlphaEnterAnimationDuration =
                mContext.getResources().getInteger(R.integer.headsup_alpha_enter_duration_ms);
        mExitAnimationDuration =
                mContext.getResources().getInteger(R.integer.headsup_exit_duration_ms);
        mKeyguardManager = (KeyguardManager) context.getSystemService(Context.KEYGUARD_SERVICE);
        mPreprocessingManager = PreprocessingManager.getInstance(context);
        mWindowManager =
                (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
        mInflater = LayoutInflater.from(mContext);
        mActiveHeadsUpNotifications = new HashMap<>();
        mHeadsUpPanel = createHeadsUpPanel();
        mHeadsUpContentFrame = mHeadsUpPanel.findViewById(R.id.headsup_content);
        mCarUserManagerHelper = new CarUserManagerHelper(mContext);
        addHeadsUpPanelToDisplay();
    }

    /**
     * Construct and return the heads up panel.
     *
     * @return view that contains R.id.headsup_content
     */
    protected View createHeadsUpPanel() {
        return mInflater.inflate(R.layout.headsup_container, null);
    }

    /**
     * Attach the heads up panel to the display
     */
    protected void addHeadsUpPanelToDisplay() {
        WindowManager.LayoutParams wrapperParams = new WindowManager.LayoutParams(
                WindowManager.LayoutParams.MATCH_PARENT,
                WindowManager.LayoutParams.MATCH_PARENT,
                // This type allows covering status bar and receiving touch input
                WindowManager.LayoutParams.TYPE_SYSTEM_ERROR,
                WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN
                        | WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE,
                PixelFormat.TRANSLUCENT);
        wrapperParams.gravity = Gravity.TOP;
        mHeadsUpPanel.setVisibility(View.INVISIBLE);
        mWindowManager.addView(mHeadsUpPanel, wrapperParams);
    }

    /**
     * Set the Heads Up view to visible
     */
    protected void setHeadsUpVisible() {
        mHeadsUpPanel.setVisibility(View.VISIBLE);
    }

    /**
     * Show the notification as a heads-up if it meets the criteria.
     */
    public void maybeShowHeadsUp(
            StatusBarNotification statusBarNotification,
            NotificationListenerService.RankingMap rankingMap,
            Map<String, StatusBarNotification> activeNotifications) {
        if (!shouldShowHeadsUp(statusBarNotification, rankingMap)) {
            // check if this is a update to the existing notification and if it should still show
            // as a heads up or not.
            HeadsUpEntry currentActiveHeadsUpNotification = mActiveHeadsUpNotifications.get(
                    statusBarNotification.getKey());
            if (currentActiveHeadsUpNotification == null) {
                activeNotifications.put(statusBarNotification.getKey(), statusBarNotification);
                return;
            }
            if (CarNotificationDiff.sameNotificationKey(
                    currentActiveHeadsUpNotification.getStatusBarNotification(),
                    statusBarNotification)
                    && currentActiveHeadsUpNotification.getHandler().hasMessagesOrCallbacks()) {
                animateOutHUN(statusBarNotification);
            }
            activeNotifications.put(statusBarNotification.getKey(), statusBarNotification);
            return;
        }
        if (!activeNotifications.containsKey(statusBarNotification.getKey()) || canUpdate(
                statusBarNotification) || alertAgain(statusBarNotification.getNotification())) {
            showHeadsUp(mPreprocessingManager.optimizeForDriving(statusBarNotification),
                    rankingMap);
        }
        activeNotifications.put(statusBarNotification.getKey(), statusBarNotification);
    }

    /**
     * This method gets called when an app wants to cancel or withdraw its notification.
     */
    public void maybeRemoveHeadsUp(StatusBarNotification statusBarNotification) {
        HeadsUpEntry currentActiveHeadsUpNotification = mActiveHeadsUpNotifications.get(
                statusBarNotification.getKey());
        // if the heads up notification is already removed do nothing.
        if (currentActiveHeadsUpNotification == null) {
            return;
        }

        long totalDisplayDuration =
                System.currentTimeMillis() - currentActiveHeadsUpNotification.getPostTime();
        // ongoing notification that has passed the minimum threshold display time.
        if (totalDisplayDuration >= mMinDisplayDuration) {
            animateOutHUN(statusBarNotification);
            return;
        }

        long earliestRemovalTime = mMinDisplayDuration - totalDisplayDuration;

        currentActiveHeadsUpNotification.getHandler().postDelayed(() ->
                animateOutHUN(statusBarNotification), earliestRemovalTime);
    }

    /**
     * Returns true if the notification's flag is not set to
     * {@link Notification#FLAG_ONLY_ALERT_ONCE}
     */
    private boolean alertAgain(Notification newNotification) {
        return (newNotification.flags & Notification.FLAG_ONLY_ALERT_ONCE) == 0;
    }

    /**
     * Return true if the currently displaying notification have the same key as the new added
     * notification. In that case it will be considered as an update to the currently displayed
     * notification.
     */
    private boolean isUpdate(StatusBarNotification statusBarNotification) {
        HeadsUpEntry currentActiveHeadsUpNotification = mActiveHeadsUpNotifications.get(
                statusBarNotification.getKey());
        if (currentActiveHeadsUpNotification == null) {
            return false;
        }
        return CarNotificationDiff.sameNotificationKey(
                currentActiveHeadsUpNotification.getStatusBarNotification(),
                statusBarNotification);
    }

    /**
     * Updates only when the notification is being displayed.
     */
    private boolean canUpdate(StatusBarNotification statusBarNotification) {
        HeadsUpEntry currentActiveHeadsUpNotification = mActiveHeadsUpNotifications.get(
                statusBarNotification.getKey());
        return currentActiveHeadsUpNotification != null && System.currentTimeMillis() -
                currentActiveHeadsUpNotification.getPostTime() < mDuration;
    }

    /**
     * Returns the active headsUpEntry or creates a new one while adding it to the list of
     * mActiveHeadsUpNotifications.
     */
    private HeadsUpEntry addNewHeadsUpEntry(StatusBarNotification statusBarNotification) {
        HeadsUpEntry currentActiveHeadsUpNotification = mActiveHeadsUpNotifications.get(
                statusBarNotification.getKey());
        if (currentActiveHeadsUpNotification == null) {
            currentActiveHeadsUpNotification = new HeadsUpEntry(statusBarNotification);
            mActiveHeadsUpNotifications.put(statusBarNotification.getKey(),
                    currentActiveHeadsUpNotification);
            currentActiveHeadsUpNotification.isAlertAgain = alertAgain(
                    statusBarNotification.getNotification());
            currentActiveHeadsUpNotification.isNewHeadsUp = true;
            return currentActiveHeadsUpNotification;
        }
        currentActiveHeadsUpNotification.isNewHeadsUp = false;
        currentActiveHeadsUpNotification.isAlertAgain = alertAgain(
                statusBarNotification.getNotification());
        if (currentActiveHeadsUpNotification.isAlertAgain) {
            // This is a ongoing notification which needs to be alerted again to the user. This
            // requires for the post time to be updated.
            currentActiveHeadsUpNotification.updatePostTime();
        }
        return currentActiveHeadsUpNotification;
    }

    /**
     * Controls three major conditions while showing heads up notification.
     * <p>
     * <ol>
     * <li> When a new HUN comes in it will be displayed with animations
     * <li> If an update to existing HUN comes in which enforces to alert the HUN again to user,
     * then the post time will be updated to current time. This will only be done if {@link
     * Notification#FLAG_ONLY_ALERT_ONCE} flag is not set.
     * <li> If an update to existing HUN comes in which just updates the data and does not want to
     * alert itself again, then the animations will not be shown and the data will get updated. This
     * will only be done if {@link Notification#FLAG_ONLY_ALERT_ONCE} flag is not set.
     * </ol>
     */
    private void showHeadsUp(StatusBarNotification statusBarNotification,
            NotificationListenerService.RankingMap rankingMap) {
        // Show animations only when there is no active HUN and notification is new. This check
        // needs to be done here because after this the new notification will be added to the map
        // holding ongoing notifications.
        boolean shouldShowAnimation = !isUpdate(statusBarNotification);
        HeadsUpEntry currentNotification = addNewHeadsUpEntry(statusBarNotification);
        if (currentNotification.isNewHeadsUp) {
            playSound(statusBarNotification, rankingMap);
            setHeadsUpVisible();
            setAutoDismissViews(currentNotification, statusBarNotification);
        } else if (currentNotification.isAlertAgain) {
            setAutoDismissViews(currentNotification, statusBarNotification);
        }
        @NotificationViewType int viewType = getNotificationViewType(statusBarNotification);
        mClickHandlerFactory.setHeadsUpNotificationCallBack(
                () -> animateOutHUN(statusBarNotification));
        currentNotification.setClickHandlerFactory(mClickHandlerFactory);
        switch (viewType) {
            case NotificationViewType.CAR_EMERGENCY_HEADSUP: {
                if (currentNotification.getNotificationView() == null) {
                    currentNotification.setNotificationView(mInflater.inflate(
                            R.layout.car_emergency_headsup_notification_template,
                            null));
                    mHeadsUpContentFrame.addView(currentNotification.getNotificationView());
                    currentNotification.setViewHolder(
                            new EmergencyNotificationViewHolder(
                                    currentNotification.getNotificationView(),
                                    mClickHandlerFactory));
                }
                currentNotification.getViewHolder().bind(statusBarNotification,
                        /* isInGroup= */ false, /* isHeadsUp= */ true);
                break;
            }
            case NotificationViewType.NAVIGATION: {
                if (currentNotification.getNotificationView() == null) {
                    currentNotification.setNotificationView(mInflater.inflate(
                            R.layout.navigation_headsup_notification_template,
                            null));
                    mHeadsUpContentFrame.addView(currentNotification.getNotificationView());
                    currentNotification.setViewHolder(
                            new NavigationNotificationViewHolder(
                                    currentNotification.getNotificationView(),
                                    mClickHandlerFactory));
                }
                currentNotification.getViewHolder().bind(statusBarNotification,
                        /* isInGroup= */ false, /* isHeadsUp= */ true);
                break;
            }
            case NotificationViewType.CALL: {
                if (currentNotification.getNotificationView() == null) {
                    currentNotification.setNotificationView(mInflater.inflate(
                            R.layout.call_headsup_notification_template,
                            null));
                    mHeadsUpContentFrame.addView(currentNotification.getNotificationView());
                    currentNotification.setViewHolder(
                            new CallNotificationViewHolder(
                                    currentNotification.getNotificationView(),
                                    mClickHandlerFactory));
                }
                currentNotification.getViewHolder().bind(statusBarNotification,
                        /* isInGroup= */ false, /* isHeadsUp= */ true);
                break;
            }
            case NotificationViewType.CAR_WARNING_HEADSUP: {
                if (currentNotification.getNotificationView() == null) {
                    currentNotification.setNotificationView(mInflater.inflate(
                            R.layout.car_warning_headsup_notification_template,
                            null));
                    mHeadsUpContentFrame.addView(currentNotification.getNotificationView());
                    // Using the basic view holder because they share the same view binding logic
                    // OEMs should create view holders if needed
                    currentNotification.setViewHolder(
                            new BasicNotificationViewHolder(
                                    currentNotification.getNotificationView(),
                                    mClickHandlerFactory));
                }
                currentNotification.getViewHolder().bind(statusBarNotification, /* isInGroup= */
                        false, /* isHeadsUp= */ true);
                break;
            }
            case NotificationViewType.CAR_INFORMATION_HEADSUP: {
                if (currentNotification.getNotificationView() == null) {
                    currentNotification.setNotificationView(mInflater.inflate(
                            R.layout.car_information_headsup_notification_template,
                            null));
                    mHeadsUpContentFrame.addView(currentNotification.getNotificationView());
                    // Using the basic view holder because they share the same view binding logic
                    // OEMs should create view holders if needed
                    currentNotification.setViewHolder(
                            new BasicNotificationViewHolder(
                                    currentNotification.getNotificationView(),
                                    mClickHandlerFactory));
                }
                currentNotification.getViewHolder().bind(statusBarNotification,
                        /* isInGroup= */ false, /* isHeadsUp= */ true);
                break;
            }
            case NotificationViewType.MESSAGE_HEADSUP: {
                if (currentNotification.getNotificationView() == null) {
                    currentNotification.setNotificationView(mInflater.inflate(
                            R.layout.message_headsup_notification_template,
                            null));
                    mHeadsUpContentFrame.addView(currentNotification.getNotificationView());
                    currentNotification.setViewHolder(
                            new MessageNotificationViewHolder(
                                    currentNotification.getNotificationView(),
                                    mClickHandlerFactory));
                }
                if (mShouldRestrictMessagePreview) {
                    ((MessageNotificationViewHolder) currentNotification.getViewHolder())
                            .bindRestricted(statusBarNotification, /* isInGroup= */
                                    false, /* isHeadsUp= */ true);
                } else {
                    currentNotification.getViewHolder().bind(statusBarNotification, /* isInGroup= */
                            false, /* isHeadsUp= */ true);
                }
                break;
            }
            case NotificationViewType.INBOX_HEADSUP: {
                if (currentNotification.getNotificationView() == null) {
                    currentNotification.setNotificationView(mInflater.inflate(
                            R.layout.inbox_headsup_notification_template,
                            null));
                    mHeadsUpContentFrame.addView(currentNotification.getNotificationView());
                    currentNotification.setViewHolder(
                            new InboxNotificationViewHolder(
                                    currentNotification.getNotificationView(),
                                    mClickHandlerFactory));
                }
                currentNotification.getViewHolder().bind(statusBarNotification,
                        /* isInGroup= */ false, /* isHeadsUp= */ true);
                break;
            }
            case NotificationViewType.BASIC_HEADSUP:
            default: {
                if (currentNotification.getNotificationView() == null) {
                    currentNotification.setNotificationView(mInflater.inflate(
                            R.layout.basic_headsup_notification_template,
                            null));
                    mHeadsUpContentFrame.addView(currentNotification.getNotificationView());
                    currentNotification.setViewHolder(
                            new BasicNotificationViewHolder(
                                    currentNotification.getNotificationView(),
                                    mClickHandlerFactory));
                }
                currentNotification.getViewHolder().bind(statusBarNotification,
                        /* isInGroup= */ false, /* isHeadsUp= */ true);
                break;
            }
        }

        // measure the size of the card and make that area of the screen touchable
        currentNotification.getNotificationView().getViewTreeObserver()
                .addOnComputeInternalInsetsListener(
                        info -> setInternalInsetsInfo(info,
                                currentNotification, /* panelExpanded= */false));
        // Get the height of the notification view after onLayout()
        // in order animate the notification in
        currentNotification.getNotificationView().getViewTreeObserver().addOnGlobalLayoutListener(
                new ViewTreeObserver.OnGlobalLayoutListener() {
                    @Override
                    public void onGlobalLayout() {
                        int notificationHeight =
                                currentNotification.getNotificationView().getHeight();

                        if (shouldShowAnimation) {
                            currentNotification.getNotificationView().setY(0 - notificationHeight);
                            currentNotification.getNotificationView().setAlpha(0f);

                            Interpolator yPositionInterpolator = AnimationUtils.loadInterpolator(
                                    mContext,
                                    R.interpolator.heads_up_entry_direction_interpolator);
                            Interpolator alphaInterpolator = AnimationUtils.loadInterpolator(
                                    mContext,
                                    R.interpolator.heads_up_entry_alpha_interpolator);

                            ObjectAnimator moveY = ObjectAnimator.ofFloat(
                                    currentNotification.getNotificationView(), "y", 0f);
                            moveY.setDuration(mEnterAnimationDuration);
                            moveY.setInterpolator(yPositionInterpolator);

                            ObjectAnimator alpha = ObjectAnimator.ofFloat(
                                    currentNotification.getNotificationView(), "alpha", 1f);
                            alpha.setDuration(mAlphaEnterAnimationDuration);
                            alpha.setInterpolator(alphaInterpolator);

                            AnimatorSet animatorSet = new AnimatorSet();
                            animatorSet.playTogether(moveY, alpha);
                            animatorSet.start();

                        }
                        currentNotification.getNotificationView().getViewTreeObserver()
                                .removeOnGlobalLayoutListener(this);
                    }
                });

        if (currentNotification.isNewHeadsUp) {
            boolean shouldDismissOnSwipe = true;
            if (shouldDismissOnSwipe(statusBarNotification)) {
                shouldDismissOnSwipe = false;
            }
            // Add swipe gesture
            View cardView = currentNotification.getNotificationView().findViewById(R.id.card_view);
            cardView.setOnTouchListener(
                    new HeadsUpNotificationOnTouchListener(cardView, shouldDismissOnSwipe,
                            () -> resetView(statusBarNotification)));
        }
    }

    protected void setInternalInsetsInfo(ViewTreeObserver.InternalInsetsInfo info,
            HeadsUpEntry currentNotification, boolean panelExpanded) {
        // If the panel is not on screen don't modify the touch region
        if (mHeadsUpPanel.getVisibility() != View.VISIBLE) return;
        int[] mTmpTwoArray = new int[2];
        View cardView = currentNotification.getNotificationView().findViewById(
                R.id.card_view);

        if (cardView == null) return;

        if (panelExpanded) {
            info.setTouchableInsets(
                    ViewTreeObserver.InternalInsetsInfo.TOUCHABLE_INSETS_FRAME);
            return;
        }

        cardView.getLocationOnScreen(mTmpTwoArray);
        int minX = mTmpTwoArray[0];
        int maxX = mTmpTwoArray[0] + cardView.getWidth();
        int height = cardView.getHeight();
        info.setTouchableInsets(
                ViewTreeObserver.InternalInsetsInfo.TOUCHABLE_INSETS_REGION);
        info.touchableRegion.set(minX, mNotificationHeadsUpCardMarginTop, maxX,
                height + mNotificationHeadsUpCardMarginTop);
    }

    private void playSound(StatusBarNotification statusBarNotification,
            NotificationListenerService.RankingMap rankingMap) {
        NotificationListenerService.Ranking ranking = getRanking();
        if (rankingMap.getRanking(statusBarNotification.getKey(), ranking)) {
            NotificationChannel notificationChannel = ranking.getChannel();
            // If sound is not set on the notification channel and default is not chosen it
            // can be null.
            if (notificationChannel.getSound() != null) {
                // make the sound
                mBeeper.beep(statusBarNotification.getPackageName(),
                        notificationChannel.getSound());
            }
        }
    }

    private boolean shouldDismissOnSwipe(StatusBarNotification statusBarNotification) {
        return hasFullScreenIntent(statusBarNotification)
                && statusBarNotification.getNotification().category.equals(
                Notification.CATEGORY_CALL) && statusBarNotification.isOngoing();
    }


    @VisibleForTesting
    protected Map<String, HeadsUpEntry> getActiveHeadsUpNotifications() {
        return mActiveHeadsUpNotifications;
    }

    private void setAutoDismissViews(HeadsUpEntry currentNotification,
            StatusBarNotification statusBarNotification) {
        // Should not auto dismiss if HUN has a full screen Intent.
        if (hasFullScreenIntent(statusBarNotification)) {
            return;
        }
        currentNotification.getHandler().removeCallbacksAndMessages(null);
        currentNotification.getHandler().postDelayed(() -> animateOutHUN(statusBarNotification),
                mDuration);
    }

    /**
     * Returns true if StatusBarNotification has a full screen Intent.
     */
    private boolean hasFullScreenIntent(StatusBarNotification sbn) {
        return sbn.getNotification().fullScreenIntent != null;
    }

    /**
     * Animates the heads up notification out of the screen and reset the views.
     */
    private void animateOutHUN(StatusBarNotification statusBarNotification) {
        Log.d(TAG, "clearViews for Heads Up Notification: ");
        // get the current notification to perform animations and remove it immediately from the
        // active notification maps and cancel all other call backs if any.
        HeadsUpEntry currentHeadsUpNotification = mActiveHeadsUpNotifications.get(
                statusBarNotification.getKey());
        // view can also be removed when swipped away.
        if (currentHeadsUpNotification == null) {
            return;
        }
        currentHeadsUpNotification.getHandler().removeCallbacksAndMessages(null);
        currentHeadsUpNotification.getClickHandlerFactory().setHeadsUpNotificationCallBack(null);

        Interpolator exitInterpolator = AnimationUtils.loadInterpolator(mContext,
                R.interpolator.heads_up_exit_direction_interpolator);
        Interpolator alphaInterpolator = AnimationUtils.loadInterpolator(mContext,
                R.interpolator.heads_up_exit_alpha_interpolator);

        ObjectAnimator moveY = ObjectAnimator.ofFloat(
                currentHeadsUpNotification.getNotificationView(), "y",
                -1 * currentHeadsUpNotification.getNotificationView().getHeight());
        moveY.setDuration(mExitAnimationDuration);
        moveY.setInterpolator(exitInterpolator);

        ObjectAnimator alpha = ObjectAnimator.ofFloat(
                currentHeadsUpNotification.getNotificationView(), "alpha", 1f);
        alpha.setDuration(mExitAnimationDuration);
        alpha.setInterpolator(alphaInterpolator);

        AnimatorSet animatorSet = new AnimatorSet();
        animatorSet.playTogether(moveY, alpha);
        animatorSet.addListener(new AnimatorListenerAdapter() {
            @Override
            public void onAnimationEnd(Animator animation) {
                removeNotificationFromPanel(currentHeadsUpNotification);

                // Remove HUN after the animation ends to prevent accidental touch on the card
                // triggering another remove call.
                mActiveHeadsUpNotifications.remove(statusBarNotification.getKey());
            }
        });
        animatorSet.start();
    }

    /**
     * Remove notification from the screen. If it was the last notification hide the heads up panel.
     *
     * @param currentHeadsUpNotification The notification to remove
     */
    protected void removeNotificationFromPanel(HeadsUpEntry currentHeadsUpNotification) {
        mHeadsUpContentFrame.removeView(currentHeadsUpNotification.getNotificationView());
        if (mHeadsUpContentFrame.getChildCount() == 0) {
            mHeadsUpPanel.setVisibility(View.INVISIBLE);
        }
    }


    /**
     * Removes the view for the active heads up notification and also removes the HUN from the map
     * of active Notifications.
     */
    private void resetView(StatusBarNotification statusBarNotification) {
        HeadsUpEntry currentHeadsUpNotification = mActiveHeadsUpNotifications.get(
                statusBarNotification.getKey());
        if (currentHeadsUpNotification == null) return;

        currentHeadsUpNotification.getClickHandlerFactory().setHeadsUpNotificationCallBack(null);
        currentHeadsUpNotification.getHandler().removeCallbacksAndMessages(null);
        removeNotificationFromPanel(currentHeadsUpNotification);
        mActiveHeadsUpNotifications.remove(statusBarNotification.getKey());
    }

    /**
     * Choose a correct notification layout for this heads-up notification.
     * Note that the layout chosen can be different for the same notification
     * in the notification center.
     */
    @NotificationViewType
    private static int getNotificationViewType(StatusBarNotification statusBarNotification) {
        String category = statusBarNotification.getNotification().category;
        if (category != null) {
            switch (category) {
                case Notification.CATEGORY_CAR_EMERGENCY:
                    return NotificationViewType.CAR_EMERGENCY_HEADSUP;
                case Notification.CATEGORY_NAVIGATION:
                    return NotificationViewType.NAVIGATION;
                case Notification.CATEGORY_CALL:
                    return NotificationViewType.CALL;
                case Notification.CATEGORY_CAR_WARNING:
                    return NotificationViewType.CAR_WARNING_HEADSUP;
                case Notification.CATEGORY_CAR_INFORMATION:
                    return NotificationViewType.CAR_INFORMATION_HEADSUP;
                case Notification.CATEGORY_MESSAGE:
                    return NotificationViewType.MESSAGE_HEADSUP;
                default:
                    break;
            }
        }
        Bundle extras = statusBarNotification.getNotification().extras;
        if (extras.containsKey(Notification.EXTRA_BIG_TEXT)
                && extras.containsKey(Notification.EXTRA_SUMMARY_TEXT)) {
            return NotificationViewType.INBOX_HEADSUP;
        }
        // progress, media, big text, big picture, and basic templates
        return NotificationViewType.BASIC_HEADSUP;
    }

    /**
     * Helper method that determines whether a notification should show as a heads-up.
     *
     * <p> A notification will never be shown as a heads-up if:
     * <ul>
     * <li> Keyguard (lock screen) is showing
     * <li> OEMs configured CATEGORY_NAVIGATION should not be shown
     * <li> Notification is muted.
     * </ul>
     *
     * <p> A notification will be shown as a heads-up if:
     * <ul>
     * <li> Importance >= HIGH
     * <li> it comes from an app signed with the platform key.
     * <li> it comes from a privileged system app.
     * <li> is a car compatible notification.
     * {@link com.android.car.assist.client.CarAssistUtils#isCarCompatibleMessagingNotification}
     * <li> Notification category is one of CATEGORY_CALL or CATEGORY_NAVIGATION
     * </ul>
     *
     * <p> Group alert behavior still follows API documentation.
     *
     * @return true if a notification should be shown as a heads-up
     */
    private boolean shouldShowHeadsUp(
            StatusBarNotification statusBarNotification,
            NotificationListenerService.RankingMap rankingMap) {
        if (mKeyguardManager.isKeyguardLocked()) {
            return false;
        }
        Notification notification = statusBarNotification.getNotification();

        // Navigation notification configured by OEM
        if (!mEnableNavigationHeadsup && Notification.CATEGORY_NAVIGATION.equals(
                notification.category)) {
            return false;
        }
        // Group alert behavior
        if (notification.suppressAlertingDueToGrouping()) {
            return false;
        }
        // Messaging notification muted by user.
        if (mNotificationDataManager.isMessageNotificationMuted(statusBarNotification)) {
            return false;
        }

        // Do not show if importance < HIGH
        NotificationListenerService.Ranking ranking = getRanking();
        if (rankingMap.getRanking(statusBarNotification.getKey(), ranking)) {
            if (ranking.getImportance() < NotificationManager.IMPORTANCE_HIGH) {
                return false;
            }
        }

        if (NotificationUtils.isSystemPrivilegedOrPlatformKey(mContext,
                statusBarNotification)) {
            return true;
        }

        // Allow car messaging type.
        if (isCarCompatibleMessagingNotification(statusBarNotification)) {
            return true;
        }

        if (notification.category == null) {
            Log.d(TAG, "category not set for: " + statusBarNotification.getPackageName());
        }

        // Allow for Call, and nav TBT categories.
        if (Notification.CATEGORY_CALL.equals(notification.category)
                || Notification.CATEGORY_NAVIGATION.equals(notification.category)) {
            return true;
        }
        return false;
    }

    @VisibleForTesting
    protected NotificationListenerService.Ranking getRanking() {
        return new NotificationListenerService.Ranking();
    }

    @Override
    public void onUxRestrictionsChanged(CarUxRestrictions restrictions) {
        mShouldRestrictMessagePreview =
                (restrictions.getActiveRestrictions()
                        & CarUxRestrictions.UX_RESTRICTIONS_NO_TEXT_MESSAGE) != 0;
    }

    /**
     * Sets the source of {@link View.OnClickListener}
     *
     * @param clickHandlerFactory used to generate onClickListeners
     */
    @VisibleForTesting
    public void setClickHandlerFactory(NotificationClickHandlerFactory clickHandlerFactory) {
        mClickHandlerFactory = clickHandlerFactory;
    }

    /**
     * Callback that will be issued after a heads up notification is clicked
     */
    public interface Callback {
        /**
         * Clears Heads up notification on click.
         */
        void clearHeadsUpNotification();
    }
}