| /* |
| * 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 android.annotation.NonNull; |
| import android.app.Notification; |
| import android.car.drivingstate.CarUxRestrictions; |
| import android.content.Context; |
| import android.os.Build; |
| import android.os.Bundle; |
| import android.util.Log; |
| import android.view.LayoutInflater; |
| import android.view.View; |
| import android.view.ViewGroup; |
| |
| import androidx.annotation.Nullable; |
| import androidx.recyclerview.widget.DiffUtil; |
| import androidx.recyclerview.widget.LinearLayoutManager; |
| import androidx.recyclerview.widget.RecyclerView; |
| |
| import com.android.car.notification.template.CarNotificationBaseViewHolder; |
| import com.android.car.notification.template.CarNotificationFooterViewHolder; |
| import com.android.car.notification.template.CarNotificationHeaderViewHolder; |
| import com.android.car.notification.template.CarNotificationOlderViewHolder; |
| import com.android.car.notification.template.CarNotificationRecentsViewHolder; |
| import com.android.car.notification.template.GroupNotificationViewHolder; |
| import com.android.car.notification.template.GroupSummaryNotificationViewHolder; |
| import com.android.car.notification.template.MessageNotificationViewHolder; |
| import com.android.car.ui.recyclerview.ContentLimitingAdapter; |
| |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.stream.Collectors; |
| |
| /** |
| * Notification data adapter that binds a notification to the corresponding view. |
| */ |
| public class CarNotificationViewAdapter extends ContentLimitingAdapter<RecyclerView.ViewHolder> |
| implements PreprocessingManager.CallStateListener { |
| private static final boolean DEBUG = Build.IS_ENG || Build.IS_USERDEBUG; |
| private static final String TAG = "CarNotificationAdapter"; |
| private static final int ID_HEADER = 0; |
| private static final int ID_RECENT_HEADER = 1; |
| private static final int ID_OLDER_HEADER = 2; |
| private static final int ID_FOOTER = 3; |
| |
| private final Context mContext; |
| private final LayoutInflater mInflater; |
| private final int mMaxNumberGroupChildrenShown; |
| private final boolean mIsGroupNotificationAdapter; |
| private final boolean mShowRecentsAndOlderHeaders; |
| |
| // book keeping expanded notification groups |
| private final List<ExpandedNotification> mExpandedNotifications = new ArrayList<>(); |
| private final CarNotificationItemController mNotificationItemController; |
| |
| private List<NotificationGroup> mNotifications = new ArrayList<>(); |
| private Map<String, Integer> mGroupKeyToCountMap = new HashMap<>(); |
| private LinearLayoutManager mLayoutManager; |
| private RecyclerView.RecycledViewPool mViewPool; |
| private CarUxRestrictions mCarUxRestrictions; |
| private NotificationClickHandlerFactory mClickHandlerFactory; |
| private NotificationDataManager mNotificationDataManager; |
| private boolean mIsInCall; |
| private boolean mHasHeaderAndFooter; |
| private boolean mHasUnseenNotifications; |
| private boolean mHasSeenNotifications; |
| private int mMaxItems = ContentLimitingAdapter.UNLIMITED; |
| |
| /** |
| * Constructor for a notification adapter. |
| * Can be used both by the root notification list view, or a grouped notification view. |
| * |
| * @param context the context for resources and inflating views |
| * @param isGroupNotificationAdapter true if this adapter is used by a grouped notification view |
| * @param notificationItemController shared logic to control notification items. |
| */ |
| public CarNotificationViewAdapter(Context context, boolean isGroupNotificationAdapter, |
| @Nullable CarNotificationItemController notificationItemController) { |
| mContext = context; |
| mInflater = LayoutInflater.from(context); |
| mMaxNumberGroupChildrenShown = |
| mContext.getResources().getInteger(R.integer.max_group_children_number); |
| mShowRecentsAndOlderHeaders = |
| mContext.getResources().getBoolean(R.bool.config_showRecentAndOldHeaders); |
| mIsGroupNotificationAdapter = isGroupNotificationAdapter; |
| mNotificationItemController = notificationItemController; |
| mNotificationDataManager = NotificationDataManager.getInstance(); |
| setHasStableIds(true); |
| if (!mIsGroupNotificationAdapter) { |
| mViewPool = new RecyclerView.RecycledViewPool(); |
| } |
| |
| PreprocessingManager.getInstance(context).addCallStateListener(this::onCallStateChanged); |
| } |
| |
| @Override |
| public void onAttachedToRecyclerView(@NonNull RecyclerView recyclerView) { |
| super.onAttachedToRecyclerView(recyclerView); |
| mLayoutManager = (LinearLayoutManager) recyclerView.getLayoutManager(); |
| } |
| |
| @Override |
| public void onDetachedFromRecyclerView(@NonNull RecyclerView recyclerView) { |
| super.onDetachedFromRecyclerView(recyclerView); |
| mLayoutManager = null; |
| } |
| |
| @Override |
| public RecyclerView.ViewHolder onCreateViewHolderImpl(@NonNull ViewGroup parent, int viewType) { |
| RecyclerView.ViewHolder viewHolder; |
| View view; |
| switch (viewType) { |
| case NotificationViewType.HEADER: |
| view = mInflater.inflate(R.layout.notification_header_template, parent, false); |
| viewHolder = new CarNotificationHeaderViewHolder(mContext, view, |
| mNotificationItemController, mClickHandlerFactory); |
| break; |
| case NotificationViewType.FOOTER: |
| view = mInflater.inflate(R.layout.notification_footer_template, parent, false); |
| viewHolder = new CarNotificationFooterViewHolder(mContext, view, |
| mNotificationItemController, mClickHandlerFactory); |
| break; |
| case NotificationViewType.RECENTS: |
| view = mInflater.inflate(R.layout.notification_recents_template, parent, false); |
| viewHolder = new CarNotificationRecentsViewHolder(mContext, view, |
| mNotificationItemController); |
| break; |
| case NotificationViewType.OLDER: |
| view = mInflater.inflate(R.layout.notification_older_template, parent, false); |
| viewHolder = new CarNotificationOlderViewHolder(mContext, view, |
| mNotificationItemController); |
| break; |
| default: |
| CarNotificationTypeItem carNotificationTypeItem = CarNotificationTypeItem.of( |
| viewType); |
| view = mInflater.inflate( |
| carNotificationTypeItem.getNotificationCenterTemplate(), parent, false); |
| viewHolder = carNotificationTypeItem.getViewHolder(view, mClickHandlerFactory); |
| } |
| |
| return viewHolder; |
| } |
| |
| @Override |
| public void onBindViewHolderImpl(RecyclerView.ViewHolder holder, int position) { |
| NotificationGroup notificationGroup = mNotifications.get(position); |
| |
| int viewType = holder.getItemViewType(); |
| switch (viewType) { |
| case NotificationViewType.HEADER: |
| ((CarNotificationHeaderViewHolder) holder).bind(hasNotifications()); |
| return; |
| case NotificationViewType.FOOTER: |
| ((CarNotificationFooterViewHolder) holder).bind(hasNotifications()); |
| return; |
| case NotificationViewType.RECENTS: |
| ((CarNotificationRecentsViewHolder) holder).bind(mHasUnseenNotifications); |
| return; |
| case NotificationViewType.OLDER: |
| ((CarNotificationOlderViewHolder) holder) |
| .bind(mHasSeenNotifications, !mHasUnseenNotifications); |
| return; |
| case NotificationViewType.GROUP: |
| ((GroupNotificationViewHolder) holder) |
| .bind(notificationGroup, this, /* isExpanded= */ |
| isExpanded(notificationGroup.getGroupKey(), |
| notificationGroup.isSeen())); |
| return; |
| case NotificationViewType.GROUP_SUMMARY: |
| ((CarNotificationBaseViewHolder) holder).setHideDismissButton(true); |
| ((GroupSummaryNotificationViewHolder) holder).bind(notificationGroup); |
| return; |
| } |
| |
| CarNotificationTypeItem carNotificationTypeItem = CarNotificationTypeItem.of(viewType); |
| AlertEntry alertEntry = notificationGroup.getSingleNotification(); |
| |
| if (shouldRestrictMessagePreview() && (viewType == NotificationViewType.MESSAGE |
| || viewType == NotificationViewType.MESSAGE_IN_GROUP)) { |
| ((MessageNotificationViewHolder) holder) |
| .bindRestricted(alertEntry, /* isInGroup= */ false, /* isHeadsUp= */false); |
| } else { |
| carNotificationTypeItem.bind(alertEntry, false, (CarNotificationBaseViewHolder) holder); |
| } |
| } |
| |
| @Override |
| public int getItemViewTypeImpl(int position) { |
| NotificationGroup notificationGroup = mNotifications.get(position); |
| if (notificationGroup.isHeader()) { |
| return NotificationViewType.HEADER; |
| } |
| |
| if (notificationGroup.isFooter()) { |
| return NotificationViewType.FOOTER; |
| } |
| |
| if (notificationGroup.isRecentsHeader()) { |
| return NotificationViewType.RECENTS; |
| } |
| |
| if (notificationGroup.isOlderHeader()) { |
| return NotificationViewType.OLDER; |
| } |
| |
| ExpandedNotification expandedNotification = |
| new ExpandedNotification(notificationGroup.getGroupKey(), |
| notificationGroup.isSeen()); |
| if (notificationGroup.isGroup()) { |
| return NotificationViewType.GROUP; |
| } else if (mExpandedNotifications.contains(expandedNotification)) { |
| // when there are 2 notifications left in the expanded notification and one of them is |
| // removed at that time the item type changes from group to normal and hence the |
| // notification should be removed from expanded notifications. |
| setExpanded(expandedNotification.getKey(), expandedNotification.isExpanded(), |
| /* isExpanded= */ false); |
| } |
| |
| Notification notification = |
| notificationGroup.getSingleNotification().getNotification(); |
| Bundle extras = notification.extras; |
| |
| String category = notification.category; |
| if (category != null) { |
| switch (category) { |
| case Notification.CATEGORY_CALL: |
| return NotificationViewType.CALL; |
| case Notification.CATEGORY_CAR_EMERGENCY: |
| return NotificationViewType.CAR_EMERGENCY; |
| case Notification.CATEGORY_CAR_WARNING: |
| return NotificationViewType.CAR_WARNING; |
| case Notification.CATEGORY_CAR_INFORMATION: |
| return mIsGroupNotificationAdapter |
| ? NotificationViewType.CAR_INFORMATION_IN_GROUP |
| : NotificationViewType.CAR_INFORMATION; |
| case Notification.CATEGORY_MESSAGE: |
| return mIsGroupNotificationAdapter |
| ? NotificationViewType.MESSAGE_IN_GROUP : NotificationViewType.MESSAGE; |
| default: |
| break; |
| } |
| } |
| |
| // progress |
| int progressMax = extras.getInt(Notification.EXTRA_PROGRESS_MAX); |
| boolean isIndeterminate = extras.getBoolean( |
| Notification.EXTRA_PROGRESS_INDETERMINATE); |
| boolean hasValidProgress = isIndeterminate || progressMax != 0; |
| boolean isProgress = extras.containsKey(Notification.EXTRA_PROGRESS) |
| && extras.containsKey(Notification.EXTRA_PROGRESS_MAX) |
| && hasValidProgress |
| && !notification.hasCompletedProgress(); |
| if (isProgress) { |
| return mIsGroupNotificationAdapter |
| ? NotificationViewType.PROGRESS_IN_GROUP : NotificationViewType.PROGRESS; |
| } |
| |
| // inbox |
| boolean isInbox = extras.containsKey(Notification.EXTRA_TITLE_BIG) |
| && extras.containsKey(Notification.EXTRA_SUMMARY_TEXT); |
| if (isInbox) { |
| return mIsGroupNotificationAdapter |
| ? NotificationViewType.INBOX_IN_GROUP : NotificationViewType.INBOX; |
| } |
| |
| // group summary |
| boolean isGroupSummary = notificationGroup.getChildTitles() != null; |
| if (isGroupSummary) { |
| return NotificationViewType.GROUP_SUMMARY; |
| } |
| |
| // the big text and big picture styles are fallen back to basic template in car |
| // i.e. setting the big text and big picture does not have an effect |
| boolean isBigText = extras.containsKey(Notification.EXTRA_BIG_TEXT); |
| if (isBigText) { |
| Log.i(TAG, "Big text style is not supported as a car notification"); |
| } |
| boolean isBigPicture = extras.containsKey(Notification.EXTRA_PICTURE); |
| if (isBigPicture) { |
| Log.i(TAG, "Big picture style is not supported as a car notification"); |
| } |
| |
| // basic, big text, big picture |
| return mIsGroupNotificationAdapter |
| ? NotificationViewType.BASIC_IN_GROUP : NotificationViewType.BASIC; |
| } |
| |
| @Override |
| public int getUnrestrictedItemCount() { |
| return mNotifications.size(); |
| } |
| |
| @Override |
| public void setMaxItems(int maxItems) { |
| if (maxItems == ContentLimitingAdapter.UNLIMITED |
| || (!mHasHeaderAndFooter && !mHasUnseenNotifications && !mHasSeenNotifications)) { |
| mMaxItems = maxItems; |
| } else { |
| // Adding to max limit of notifications for each header so that they do not count |
| // towards limit. |
| // Footer is not accounted for since it as the end of the list and it doesn't affect the |
| // limit of notifications above it. |
| mMaxItems = maxItems; |
| if (mHasHeaderAndFooter) { |
| mMaxItems++; |
| } |
| if (mHasSeenNotifications) { |
| mMaxItems++; |
| } |
| if (mHasUnseenNotifications) { |
| mMaxItems++; |
| } |
| } |
| super.setMaxItems(mMaxItems); |
| } |
| |
| @Override |
| protected int getScrollToPositionWhenRestricted() { |
| if (mLayoutManager == null) { |
| return -1; |
| } |
| int firstItem = mLayoutManager.findFirstVisibleItemPosition(); |
| if (firstItem >= getItemCount() - 1) { |
| return getItemCount() - 1; |
| } |
| return -1; |
| } |
| |
| @Override |
| public long getItemId(int position) { |
| NotificationGroup notificationGroup = mNotifications.get(position); |
| if (notificationGroup.isHeader()) { |
| return ID_HEADER; |
| } |
| if (mShowRecentsAndOlderHeaders && !mIsGroupNotificationAdapter) { |
| if (notificationGroup.isRecentsHeader()) { |
| return ID_RECENT_HEADER; |
| } |
| if (notificationGroup.isOlderHeader()) { |
| return ID_OLDER_HEADER; |
| } |
| if (notificationGroup.isFooter()) { |
| return ID_FOOTER; |
| } |
| } |
| if (notificationGroup.isFooter()) { |
| // We can use recent header's ID when it isn't being used. |
| return ID_RECENT_HEADER; |
| } |
| |
| String key = notificationGroup.isGroup() |
| ? notificationGroup.getGroupKey() |
| : notificationGroup.getSingleNotification().getKey(); |
| |
| if (mShowRecentsAndOlderHeaders) { |
| key += notificationGroup.isSeen(); |
| } |
| |
| return key.hashCode(); |
| } |
| |
| /** |
| * Set the expansion state of a group notification given its group key. |
| * |
| * @param groupKey the unique identifier of a {@link NotificationGroup} |
| * @param isSeen whether the {@link NotificationGroup} has been seen by the user |
| * @param isExpanded whether the group notification should be expanded. |
| */ |
| public void setExpanded(String groupKey, boolean isSeen, boolean isExpanded) { |
| if (isExpanded(groupKey, isSeen) == isExpanded) { |
| return; |
| } |
| |
| ExpandedNotification expandedNotification = new ExpandedNotification(groupKey, isSeen); |
| if (isExpanded) { |
| mExpandedNotifications.add(expandedNotification); |
| } else { |
| mExpandedNotifications.remove(expandedNotification); |
| } |
| if (DEBUG) { |
| Log.d(TAG, "Expanded notification statuses: " + mExpandedNotifications); |
| } |
| } |
| |
| /** |
| * Collapses all expanded groups. |
| */ |
| public void collapseAllGroups() { |
| if (!mExpandedNotifications.isEmpty()) { |
| mExpandedNotifications.clear(); |
| } |
| } |
| |
| /** |
| * Returns whether the notification is expanded given its group key and it's seen status. |
| * |
| * @param groupKey the unique identifier of a {@link NotificationGroup} |
| * @param isSeen whether the {@link NotificationGroup} has been seen by the user |
| */ |
| boolean isExpanded(String groupKey, boolean isSeen) { |
| ExpandedNotification expandedNotification = new ExpandedNotification(groupKey, isSeen); |
| return mExpandedNotifications.contains(expandedNotification); |
| } |
| |
| /** |
| * Gets the current {@link CarUxRestrictions}. |
| */ |
| public CarUxRestrictions getCarUxRestrictions() { |
| return mCarUxRestrictions; |
| } |
| |
| /** |
| * Updates notifications and update views. |
| * |
| * @param setRecyclerViewListHeadersAndFooters sets the header and footer on the entire list of |
| * items within the recycler view. This is NOT the header/footer for the grouped notifications. |
| */ |
| public void setNotifications(List<NotificationGroup> notifications, |
| boolean setRecyclerViewListHeadersAndFooters) { |
| mGroupKeyToCountMap.clear(); |
| notifications.forEach(notificationGroup -> { |
| if ((mGroupKeyToCountMap.computeIfPresent(notificationGroup.getGroupKey(), |
| (key, currentValue) -> currentValue + 1)) == null) { |
| mGroupKeyToCountMap.put(notificationGroup.getGroupKey(), 1); |
| } |
| }); |
| |
| if (mShowRecentsAndOlderHeaders && !mIsGroupNotificationAdapter) { |
| List<NotificationGroup> seenNotifications = new ArrayList<>(); |
| List<NotificationGroup> unseenNotifications = new ArrayList<>(); |
| notifications.forEach(notificationGroup -> { |
| if (notificationGroup.isSeen()) { |
| seenNotifications.add(new NotificationGroup(notificationGroup)); |
| } else { |
| unseenNotifications.add(new NotificationGroup(notificationGroup)); |
| } |
| }); |
| setSeenAndUnseenNotifications(unseenNotifications, seenNotifications, |
| setRecyclerViewListHeadersAndFooters); |
| return; |
| } |
| |
| List<NotificationGroup> notificationGroupList = notifications.stream() |
| .map(notificationGroup -> new NotificationGroup(notificationGroup)) |
| .collect(Collectors.toList()); |
| |
| if (setRecyclerViewListHeadersAndFooters) { |
| // add header as the first item of the list. |
| notificationGroupList.add(0, createNotificationHeader()); |
| // add footer as the last item of the list. |
| notificationGroupList.add(createNotificationFooter()); |
| mHasHeaderAndFooter = true; |
| } else { |
| mHasHeaderAndFooter = false; |
| } |
| |
| CarNotificationDiff notificationDiff = |
| new CarNotificationDiff(mContext, mNotifications, notificationGroupList, mMaxItems); |
| notificationDiff.setShowRecentsAndOlderHeaders(false); |
| DiffUtil.DiffResult diffResult = |
| DiffUtil.calculateDiff(notificationDiff, /* detectMoves= */ false); |
| mNotifications = notificationGroupList; |
| if (DEBUG) { |
| Log.d(TAG, "Updated adapter view holders: " + mNotifications); |
| } |
| updateUnderlyingDataChanged(getUnrestrictedItemCount(), /* newAnchorIndex= */ 0); |
| diffResult.dispatchUpdatesTo(this); |
| } |
| |
| private void setSeenAndUnseenNotifications(List<NotificationGroup> unseenNotifications, |
| List<NotificationGroup> seenNotifications, |
| boolean setRecyclerViewListHeadersAndFooters) { |
| if (DEBUG) { |
| Log.d(TAG, "Seen notifications: " + seenNotifications); |
| Log.d(TAG, "Unseen notifications: " + unseenNotifications); |
| } |
| |
| List<NotificationGroup> notificationGroupList; |
| if (unseenNotifications.isEmpty()) { |
| mHasUnseenNotifications = false; |
| |
| notificationGroupList = new ArrayList<>(); |
| } else { |
| mHasUnseenNotifications = true; |
| |
| notificationGroupList = new ArrayList<>(unseenNotifications); |
| if (setRecyclerViewListHeadersAndFooters) { |
| // Add recents header as the first item of the list. |
| notificationGroupList.add(/* index= */ 0, createRecentsHeader()); |
| } |
| } |
| |
| if (seenNotifications.isEmpty()) { |
| mHasSeenNotifications = false; |
| } else { |
| mHasSeenNotifications = true; |
| |
| if (setRecyclerViewListHeadersAndFooters) { |
| // Append older header to the list. |
| notificationGroupList.add(createOlderHeader()); |
| } |
| notificationGroupList.addAll(seenNotifications); |
| } |
| |
| if (setRecyclerViewListHeadersAndFooters) { |
| // Add header as the first item of the list. |
| notificationGroupList.add(0, createNotificationHeader()); |
| // Add footer as the last item of the list. |
| notificationGroupList.add(createNotificationFooter()); |
| mHasHeaderAndFooter = true; |
| } else { |
| mHasHeaderAndFooter = false; |
| } |
| |
| CarNotificationDiff notificationDiff = |
| new CarNotificationDiff(mContext, mNotifications, notificationGroupList, mMaxItems); |
| notificationDiff.setShowRecentsAndOlderHeaders(true); |
| DiffUtil.DiffResult diffResult = |
| DiffUtil.calculateDiff(notificationDiff, /* detectMoves= */ false); |
| mNotifications = notificationGroupList; |
| if (DEBUG) { |
| Log.d(TAG, "Updated adapter view holders: " + mNotifications); |
| } |
| updateUnderlyingDataChanged(getUnrestrictedItemCount(), /* newAnchorIndex= */ 0); |
| diffResult.dispatchUpdatesTo(this); |
| } |
| |
| /** |
| * Returns {@code true} if notifications are present in adapter. |
| * |
| * Group notification list doesn't have any headers, hence, if there are any notifications |
| * present the size will be more than zero. |
| * |
| * Non-group notification list has header and footer by default. Therefore the min number of |
| * items in the adapter will always be two. If there are any notifications present the size will |
| * be more than two. |
| * |
| * When recent and older headers are enabled, each header will be accounted for when checking |
| * for the presence of notifications. |
| */ |
| public boolean hasNotifications() { |
| int numberOfHeaders; |
| if (mIsGroupNotificationAdapter) { |
| numberOfHeaders = 0; |
| } else { |
| numberOfHeaders = 2; |
| |
| if (mHasSeenNotifications) { |
| numberOfHeaders++; |
| } |
| |
| if (mHasUnseenNotifications) { |
| numberOfHeaders++; |
| } |
| } |
| |
| return getItemCount() > numberOfHeaders; |
| } |
| |
| private NotificationGroup createNotificationHeader() { |
| NotificationGroup notificationGroupWithHeader = new NotificationGroup(); |
| notificationGroupWithHeader.setHeader(true); |
| notificationGroupWithHeader.setGroupKey("notification_header"); |
| return notificationGroupWithHeader; |
| } |
| |
| private NotificationGroup createNotificationFooter() { |
| NotificationGroup notificationGroupWithFooter = new NotificationGroup(); |
| notificationGroupWithFooter.setFooter(true); |
| notificationGroupWithFooter.setGroupKey("notification_footer"); |
| return notificationGroupWithFooter; |
| } |
| |
| private NotificationGroup createRecentsHeader() { |
| NotificationGroup notificationGroupWithRecents = new NotificationGroup(); |
| notificationGroupWithRecents.setRecentsHeader(true); |
| notificationGroupWithRecents.setGroupKey("notification_recents"); |
| notificationGroupWithRecents.setSeen(false); |
| return notificationGroupWithRecents; |
| } |
| |
| private NotificationGroup createOlderHeader() { |
| NotificationGroup notificationGroupWithOlder = new NotificationGroup(); |
| notificationGroupWithOlder.setOlderHeader(true); |
| notificationGroupWithOlder.setGroupKey("notification_older"); |
| notificationGroupWithOlder.setSeen(true); |
| return notificationGroupWithOlder; |
| } |
| |
| /** Implementation of {@link PreprocessingManager.CallStateListener} **/ |
| @Override |
| public void onCallStateChanged(boolean isInCall) { |
| if (isInCall != mIsInCall) { |
| mIsInCall = isInCall; |
| notifyDataSetChanged(); |
| } |
| } |
| |
| /** |
| * Sets the current {@link CarUxRestrictions}. |
| */ |
| public void setCarUxRestrictions(CarUxRestrictions carUxRestrictions) { |
| Log.d(TAG, "setCarUxRestrictions"); |
| mCarUxRestrictions = carUxRestrictions; |
| notifyDataSetChanged(); |
| } |
| |
| /** |
| * Helper method that determines whether a notification is a messaging notification and |
| * should have restricted content (no message preview). |
| */ |
| private boolean shouldRestrictMessagePreview() { |
| return mCarUxRestrictions != null && (mCarUxRestrictions.getActiveRestrictions() |
| & CarUxRestrictions.UX_RESTRICTIONS_NO_TEXT_MESSAGE) != 0; |
| } |
| |
| /** |
| * Get root recycler view's view pool so that the child recycler view can share the same |
| * view pool with the parent. |
| */ |
| public RecyclerView.RecycledViewPool getViewPool() { |
| if (mIsGroupNotificationAdapter) { |
| // currently only support one level of expansion. |
| throw new IllegalStateException("CarNotificationViewAdapter is a child adapter; " |
| + "its view pool should not be reused."); |
| } |
| return mViewPool; |
| } |
| |
| /** |
| * Returns {@code true} if there are multiple groups with the same {@code groupKey}. |
| */ |
| public boolean shouldRemoveGroupSummary(String groupKey) { |
| return mGroupKeyToCountMap.getOrDefault(groupKey, /* defaultValue= */ 0) <= 1; |
| } |
| |
| /** |
| * Sets the NotificationClickHandlerFactory that allows for a hook to run a block off code |
| * when the notification is clicked. This is useful to dismiss a screen after |
| * a notification list clicked. |
| */ |
| public void setClickHandlerFactory(NotificationClickHandlerFactory clickHandlerFactory) { |
| mClickHandlerFactory = clickHandlerFactory; |
| } |
| |
| /** |
| * Set notification groups as seen. |
| * |
| * @param start Initial adapter position of the notification groups. |
| * @param end Final adapter position of the notification groups. |
| */ |
| void setVisibleNotificationsAsSeen(int start, int end) { |
| if (mNotificationDataManager == null || mIsGroupNotificationAdapter) { |
| return; |
| } |
| |
| start = Math.max(start, 0); |
| end = Math.min(end, mNotifications.size() - 1); |
| |
| List<AlertEntry> notifications = new ArrayList(); |
| for (int i = start; i <= end; i++) { |
| NotificationGroup group = mNotifications.get(i); |
| AlertEntry groupSummary = group.getGroupSummaryNotification(); |
| if (groupSummary != null) { |
| notifications.add(groupSummary); |
| } |
| |
| notifications.addAll(group.getChildNotifications()); |
| } |
| |
| mNotificationDataManager.setVisibleNotificationsAsSeen(notifications); |
| } |
| |
| @Override |
| public int getConfigurationId() { |
| return R.id.notification_list_uxr_config; |
| } |
| |
| private static class ExpandedNotification { |
| private String mKey; |
| private boolean mIsExpanded; |
| |
| ExpandedNotification(String key, boolean isExpanded) { |
| mKey = key; |
| mIsExpanded = isExpanded; |
| } |
| |
| @Override |
| public boolean equals(Object obj) { |
| if (!(obj instanceof ExpandedNotification)) { |
| return false; |
| } |
| ExpandedNotification other = (ExpandedNotification) obj; |
| |
| return mKey.equals(other.getKey()) && mIsExpanded == other.isExpanded(); |
| } |
| |
| public String getKey() { |
| return mKey; |
| } |
| |
| public boolean isExpanded() { |
| return mIsExpanded; |
| } |
| } |
| } |
