packages/SystemUI/src/com/android/systemui/statusbar/NotificationViewHierarchyManager.java - platform/frameworks/base - Git at Google

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

 package com.android.systemui.statusbar;

 import static com.android.systemui.Dependency.MAIN_HANDLER_NAME;

 import android.content.Context;
 import android.content.res.Resources;
 import android.os.Handler;
 import android.os.Trace;
 import android.os.UserHandle;
 import android.util.Log;
 import android.view.View;
 import android.view.ViewGroup;

 import com.android.systemui.R;
 import com.android.systemui.bubbles.BubbleController;
 import com.android.systemui.plugins.statusbar.StatusBarStateController;
 import com.android.systemui.statusbar.notification.DynamicPrivacyController;
 import com.android.systemui.statusbar.notification.NotificationEntryManager;
 import com.android.systemui.statusbar.notification.VisualStabilityManager;
 import com.android.systemui.statusbar.notification.collection.NotificationEntry;
 import com.android.systemui.statusbar.notification.row.ExpandableNotificationRow;
 import com.android.systemui.statusbar.notification.stack.NotificationListContainer;
 import com.android.systemui.statusbar.phone.KeyguardBypassController;
 import com.android.systemui.statusbar.phone.NotificationGroupManager;
 import com.android.systemui.statusbar.phone.ShadeController;
 import com.android.systemui.util.Assert;

 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Stack;

 import javax.inject.Inject;
 import javax.inject.Named;
 import javax.inject.Singleton;

 import dagger.Lazy;

 /**
  * NotificationViewHierarchyManager manages updating the view hierarchy of notification views based
  * on their group structure. For example, if a notification becomes bundled with another,
  * NotificationViewHierarchyManager will update the view hierarchy to reflect that. It also will
  * tell NotificationListContainer which notifications to display, and inform it of changes to those
  * notifications that might affect their display.
  */
 @Singleton
 public class NotificationViewHierarchyManager implements DynamicPrivacyController.Listener {
     private static final String TAG = "NotificationViewHierarchyManager";

     private final Handler mHandler;

     //TODO: change this top <Entry, List<Entry>>?
     private final HashMap<ExpandableNotificationRow, List<ExpandableNotificationRow>>
             mTmpChildOrderMap = new HashMap<>();

     // Dependencies:
     protected final NotificationLockscreenUserManager mLockscreenUserManager;
     protected final NotificationGroupManager mGroupManager;
     protected final VisualStabilityManager mVisualStabilityManager;
     private final SysuiStatusBarStateController mStatusBarStateController;
     private final NotificationEntryManager mEntryManager;

     // Lazy
     private final Lazy<ShadeController> mShadeController;

     /**
      * {@code true} if notifications not part of a group should by default be rendered in their
      * expanded state. If {@code false}, then only the first notification will be expanded if
      * possible.
      */
     private final boolean mAlwaysExpandNonGroupedNotification;
     private final BubbleController mBubbleController;
     private final DynamicPrivacyController mDynamicPrivacyController;
     private final KeyguardBypassController mBypassController;

     private NotificationPresenter mPresenter;
     private NotificationListContainer mListContainer;

     // Used to help track down re-entrant calls to our update methods, which will cause bugs.
     private boolean mPerformingUpdate;
     // Hack to get around re-entrant call in onDynamicPrivacyChanged() until we can track down
     // the problem.
     private boolean mIsHandleDynamicPrivacyChangeScheduled;

     @Inject
     public NotificationViewHierarchyManager(Context context,
             @Named(MAIN_HANDLER_NAME) Handler mainHandler,
             NotificationLockscreenUserManager notificationLockscreenUserManager,
             NotificationGroupManager groupManager,
             VisualStabilityManager visualStabilityManager,
             StatusBarStateController statusBarStateController,
             NotificationEntryManager notificationEntryManager,
             Lazy<ShadeController> shadeController,
             KeyguardBypassController bypassController,
             BubbleController bubbleController,
             DynamicPrivacyController privacyController) {
         mHandler = mainHandler;
         mLockscreenUserManager = notificationLockscreenUserManager;
         mBypassController = bypassController;
         mGroupManager = groupManager;
         mVisualStabilityManager = visualStabilityManager;
         mStatusBarStateController = (SysuiStatusBarStateController) statusBarStateController;
         mEntryManager = notificationEntryManager;
         mShadeController = shadeController;
         Resources res = context.getResources();
         mAlwaysExpandNonGroupedNotification =
                 res.getBoolean(R.bool.config_alwaysExpandNonGroupedNotifications);
         mBubbleController = bubbleController;
         mDynamicPrivacyController = privacyController;
         privacyController.addListener(this);
     }

     public void setUpWithPresenter(NotificationPresenter presenter,
             NotificationListContainer listContainer) {
         mPresenter = presenter;
         mListContainer = listContainer;
     }

     /**
      * Updates the visual representation of the notifications.
      */
     //TODO: Rewrite this to focus on Entries, or some other data object instead of views
     public void updateNotificationViews() {
         Assert.isMainThread();
         beginUpdate();

         ArrayList<NotificationEntry> activeNotifications = mEntryManager.getNotificationData()
                 .getActiveNotifications();
         ArrayList<ExpandableNotificationRow> toShow = new ArrayList<>(activeNotifications.size());
         final int N = activeNotifications.size();
         for (int i = 0; i < N; i++) {
             NotificationEntry ent = activeNotifications.get(i);
             if (ent.isRowDismissed() || ent.isRowRemoved()
                     || mBubbleController.isBubbleNotificationSuppressedFromShade(ent.key)) {
                 // we don't want to update removed notifications because they could
                 // temporarily become children if they were isolated before.
                 continue;
             }

             int userId = ent.notification.getUserId();

             // Display public version of the notification if we need to redact.
             // TODO: This area uses a lot of calls into NotificationLockscreenUserManager.
             // We can probably move some of this code there.
             int currentUserId = mLockscreenUserManager.getCurrentUserId();
             boolean devicePublic = mLockscreenUserManager.isLockscreenPublicMode(currentUserId);
             boolean userPublic = devicePublic
                     || mLockscreenUserManager.isLockscreenPublicMode(userId);
             if (userPublic && mDynamicPrivacyController.isDynamicallyUnlocked()
                     && (userId == currentUserId || userId == UserHandle.USER_ALL
                     || !mLockscreenUserManager.needsSeparateWorkChallenge(userId))) {
                 userPublic = false;
             }
             boolean needsRedaction = mLockscreenUserManager.needsRedaction(ent);
             boolean sensitive = userPublic && needsRedaction;
             boolean deviceSensitive = devicePublic
                     && !mLockscreenUserManager.userAllowsPrivateNotificationsInPublic(
                     currentUserId);
             ent.setSensitive(sensitive, deviceSensitive);
             ent.getRow().setNeedsRedaction(needsRedaction);
             if (mGroupManager.isChildInGroupWithSummary(ent.notification)) {
                 NotificationEntry summary = mGroupManager.getGroupSummary(ent.notification);
                 List<ExpandableNotificationRow> orderedChildren =
                         mTmpChildOrderMap.get(summary.getRow());
                 if (orderedChildren == null) {
                     orderedChildren = new ArrayList<>();
                     mTmpChildOrderMap.put(summary.getRow(), orderedChildren);
                 }
                 orderedChildren.add(ent.getRow());
             } else {
                 toShow.add(ent.getRow());
             }
         }

         ArrayList<ExpandableNotificationRow> viewsToRemove = new ArrayList<>();
         for (int i=0; i< mListContainer.getContainerChildCount(); i++) {
             View child = mListContainer.getContainerChildAt(i);
             if (!toShow.contains(child) && child instanceof ExpandableNotificationRow) {
                 ExpandableNotificationRow row = (ExpandableNotificationRow) child;

                 // Blocking helper is effectively a detached view. Don't bother removing it from the
                 // layout.
                 if (!row.isBlockingHelperShowing()) {
                     viewsToRemove.add((ExpandableNotificationRow) child);
                 }
             }
         }

         for (ExpandableNotificationRow viewToRemove : viewsToRemove) {
             if (mGroupManager.isChildInGroupWithSummary(viewToRemove.getStatusBarNotification())) {
                 // we are only transferring this notification to its parent, don't generate an
                 // animation
                 mListContainer.setChildTransferInProgress(true);
             }
             if (viewToRemove.isSummaryWithChildren()) {
                 viewToRemove.removeAllChildren();
             }
             mListContainer.removeContainerView(viewToRemove);
             mListContainer.setChildTransferInProgress(false);
         }

         removeNotificationChildren();

         for (int i = 0; i < toShow.size(); i++) {
             View v = toShow.get(i);
             if (v.getParent() == null) {
                 mVisualStabilityManager.notifyViewAddition(v);
                 mListContainer.addContainerView(v);
             } else if (!mListContainer.containsView(v)) {
                 // the view is added somewhere else. Let's make sure
                 // the ordering works properly below, by excluding these
                 toShow.remove(v);
                 i--;
             }
         }

         addNotificationChildrenAndSort();

         // So after all this work notifications still aren't sorted correctly.
         // Let's do that now by advancing through toShow and mListContainer in
         // lock-step, making sure mListContainer matches what we see in toShow.
         int j = 0;
         for (int i = 0; i < mListContainer.getContainerChildCount(); i++) {
             View child = mListContainer.getContainerChildAt(i);
             if (!(child instanceof ExpandableNotificationRow)) {
                 // We don't care about non-notification views.
                 continue;
             }
             if (((ExpandableNotificationRow) child).isBlockingHelperShowing()) {
                 // Don't count/reorder notifications that are showing the blocking helper!
                 continue;
             }

             ExpandableNotificationRow targetChild = toShow.get(j);
             if (child != targetChild) {
                 // Oops, wrong notification at this position. Put the right one
                 // here and advance both lists.
                 if (mVisualStabilityManager.canReorderNotification(targetChild)) {
                     mListContainer.changeViewPosition(targetChild, i);
                 } else {
                     mVisualStabilityManager.addReorderingAllowedCallback(mEntryManager);
                 }
             }
             j++;

         }

         mVisualStabilityManager.onReorderingFinished();
         // clear the map again for the next usage
         mTmpChildOrderMap.clear();

         updateRowStatesInternal();

         mListContainer.onNotificationViewUpdateFinished();

         endUpdate();
     }

     private void addNotificationChildrenAndSort() {
         // Let's now add all notification children which are missing
         boolean orderChanged = false;
         for (int i = 0; i < mListContainer.getContainerChildCount(); i++) {
             View view = mListContainer.getContainerChildAt(i);
             if (!(view instanceof ExpandableNotificationRow)) {
                 // We don't care about non-notification views.
                 continue;
             }

             ExpandableNotificationRow parent = (ExpandableNotificationRow) view;
             List<ExpandableNotificationRow> children = parent.getNotificationChildren();
             List<ExpandableNotificationRow> orderedChildren = mTmpChildOrderMap.get(parent);

             for (int childIndex = 0; orderedChildren != null && childIndex < orderedChildren.size();
                     childIndex++) {
                 ExpandableNotificationRow childView = orderedChildren.get(childIndex);
                 if (children == null || !children.contains(childView)) {
                     if (childView.getParent() != null) {
                         Log.wtf(TAG, "trying to add a notification child that already has " +
                                 "a parent. class:" + childView.getParent().getClass() +
                                 "\n child: " + childView);
                         // This shouldn't happen. We can recover by removing it though.
                         ((ViewGroup) childView.getParent()).removeView(childView);
                     }
                     mVisualStabilityManager.notifyViewAddition(childView);
                     parent.addChildNotification(childView, childIndex);
                     mListContainer.notifyGroupChildAdded(childView);
                 }
             }

             // Finally after removing and adding has been performed we can apply the order.
             orderChanged |= parent.applyChildOrder(orderedChildren, mVisualStabilityManager,
                     mEntryManager);
         }
         if (orderChanged) {
             mListContainer.generateChildOrderChangedEvent();
         }
     }

     private void removeNotificationChildren() {
         // First let's remove all children which don't belong in the parents
         ArrayList<ExpandableNotificationRow> toRemove = new ArrayList<>();
         for (int i = 0; i < mListContainer.getContainerChildCount(); i++) {
             View view = mListContainer.getContainerChildAt(i);
             if (!(view instanceof ExpandableNotificationRow)) {
                 // We don't care about non-notification views.
                 continue;
             }

             ExpandableNotificationRow parent = (ExpandableNotificationRow) view;
             List<ExpandableNotificationRow> children = parent.getNotificationChildren();
             List<ExpandableNotificationRow> orderedChildren = mTmpChildOrderMap.get(parent);

             if (children != null) {
                 toRemove.clear();
                 for (ExpandableNotificationRow childRow : children) {
                     if ((orderedChildren == null
                             || !orderedChildren.contains(childRow))
                             && !childRow.keepInParent()) {
                         toRemove.add(childRow);
                     }
                 }
                 for (ExpandableNotificationRow remove : toRemove) {
                     parent.removeChildNotification(remove);
                     if (mEntryManager.getNotificationData().get(
                             remove.getStatusBarNotification().getKey()) == null) {
                         // We only want to add an animation if the view is completely removed
                         // otherwise it's just a transfer
                         mListContainer.notifyGroupChildRemoved(remove,
                                 parent.getChildrenContainer());
                     }
                 }
             }
         }
     }

     /**
      * Updates expanded, dimmed and locked states of notification rows.
      */
     public void updateRowStates() {
         Assert.isMainThread();
         beginUpdate();
         updateRowStatesInternal();
         endUpdate();
     }

     private void updateRowStatesInternal() {
         Trace.beginSection("NotificationViewHierarchyManager#updateRowStates");
         final int N = mListContainer.getContainerChildCount();

         int visibleNotifications = 0;
         boolean onKeyguard = mStatusBarStateController.getState() == StatusBarState.KEYGUARD;
         int maxNotifications = -1;
         if (onKeyguard && !mBypassController.getBypassEnabled()) {
             maxNotifications = mPresenter.getMaxNotificationsWhileLocked(true /* recompute */);
         }
         mListContainer.setMaxDisplayedNotifications(maxNotifications);
         Stack<ExpandableNotificationRow> stack = new Stack<>();
         for (int i = N - 1; i >= 0; i--) {
             View child = mListContainer.getContainerChildAt(i);
             if (!(child instanceof ExpandableNotificationRow)) {
                 continue;
             }
             stack.push((ExpandableNotificationRow) child);
         }
         while(!stack.isEmpty()) {
             ExpandableNotificationRow row = stack.pop();
             NotificationEntry entry = row.getEntry();
             boolean isChildNotification =
                     mGroupManager.isChildInGroupWithSummary(entry.notification);

             row.setOnKeyguard(onKeyguard);

             if (!onKeyguard) {
                 // If mAlwaysExpandNonGroupedNotification is false, then only expand the
                 // very first notification and if it's not a child of grouped notifications.
                 row.setSystemExpanded(mAlwaysExpandNonGroupedNotification
                         || (visibleNotifications == 0 && !isChildNotification
                         && !row.isLowPriority()));
             }

             int userId = entry.notification.getUserId();
             boolean suppressedSummary = mGroupManager.isSummaryOfSuppressedGroup(
                     entry.notification) && !entry.isRowRemoved();
             boolean showOnKeyguard = mLockscreenUserManager.shouldShowOnKeyguard(entry);
             if (!showOnKeyguard) {
                 // min priority notifications should show if their summary is showing
                 if (mGroupManager.isChildInGroupWithSummary(entry.notification)) {
                     NotificationEntry summary = mGroupManager.getLogicalGroupSummary(
                             entry.notification);
                     if (summary != null && mLockscreenUserManager.shouldShowOnKeyguard(summary)) {
                         showOnKeyguard = true;
                     }
                 }
             }
             if (suppressedSummary
                     || mLockscreenUserManager.shouldHideNotifications(userId)
                     || (onKeyguard && !showOnKeyguard)) {
                 entry.getRow().setVisibility(View.GONE);
             } else {
                 boolean wasGone = entry.getRow().getVisibility() == View.GONE;
                 if (wasGone) {
                     entry.getRow().setVisibility(View.VISIBLE);
                 }
                 if (!isChildNotification && !entry.getRow().isRemoved()) {
                     if (wasGone) {
                         // notify the scroller of a child addition
                         mListContainer.generateAddAnimation(entry.getRow(),
                                 !showOnKeyguard /* fromMoreCard */);
                     }
                     visibleNotifications++;
                 }
             }
             if (row.isSummaryWithChildren()) {
                 List<ExpandableNotificationRow> notificationChildren =
                         row.getNotificationChildren();
                 int size = notificationChildren.size();
                 for (int i = size - 1; i >= 0; i--) {
                     stack.push(notificationChildren.get(i));
                 }
             }

             row.showAppOpsIcons(entry.mActiveAppOps);
             row.setLastAudiblyAlertedMs(entry.lastAudiblyAlertedMs);
         }

         Trace.beginSection("NotificationPresenter#onUpdateRowStates");
         mPresenter.onUpdateRowStates();
         Trace.endSection();
         Trace.endSection();
     }

     @Override
     public void onDynamicPrivacyChanged() {
         if (mPerformingUpdate) {
             Log.w(TAG, "onDynamicPrivacyChanged made a re-entrant call");
         }
         // This listener can be called from updateNotificationViews() via a convoluted listener
         // chain, so we post here to prevent a re-entrant call. See b/136186188
         // TODO: Refactor away the need for this
         if (!mIsHandleDynamicPrivacyChangeScheduled) {
             mIsHandleDynamicPrivacyChangeScheduled = true;
             mHandler.post(this::onHandleDynamicPrivacyChanged);
         }
     }

     private void onHandleDynamicPrivacyChanged() {
         mIsHandleDynamicPrivacyChangeScheduled = false;
         updateNotificationViews();
     }

     private void beginUpdate() {
         if (mPerformingUpdate) {
             Log.wtf(TAG, "Re-entrant code during update", new Exception());
         }
         mPerformingUpdate = true;
     }

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

	package com.android.systemui.statusbar;

	import static com.android.systemui.Dependency.MAIN_HANDLER_NAME;

	import android.content.Context;
	import android.content.res.Resources;
	import android.os.Handler;
	import android.os.Trace;
	import android.os.UserHandle;
	import android.util.Log;
	import android.view.View;
	import android.view.ViewGroup;

	import com.android.systemui.R;
	import com.android.systemui.bubbles.BubbleController;
	import com.android.systemui.plugins.statusbar.StatusBarStateController;
	import com.android.systemui.statusbar.notification.DynamicPrivacyController;
	import com.android.systemui.statusbar.notification.NotificationEntryManager;
	import com.android.systemui.statusbar.notification.VisualStabilityManager;
	import com.android.systemui.statusbar.notification.collection.NotificationEntry;
	import com.android.systemui.statusbar.notification.row.ExpandableNotificationRow;
	import com.android.systemui.statusbar.notification.stack.NotificationListContainer;
	import com.android.systemui.statusbar.phone.KeyguardBypassController;
	import com.android.systemui.statusbar.phone.NotificationGroupManager;
	import com.android.systemui.statusbar.phone.ShadeController;
	import com.android.systemui.util.Assert;

	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.List;
	import java.util.Stack;

	import javax.inject.Inject;
	import javax.inject.Named;
	import javax.inject.Singleton;

	import dagger.Lazy;

	/**
	* NotificationViewHierarchyManager manages updating the view hierarchy of notification views based
	* on their group structure. For example, if a notification becomes bundled with another,
	* NotificationViewHierarchyManager will update the view hierarchy to reflect that. It also will
	* tell NotificationListContainer which notifications to display, and inform it of changes to those
	* notifications that might affect their display.
	*/
	@Singleton
	public class NotificationViewHierarchyManager implements DynamicPrivacyController.Listener {
	private static final String TAG = "NotificationViewHierarchyManager";

	private final Handler mHandler;

	//TODO: change this top <Entry, List<Entry>>?
	private final HashMap<ExpandableNotificationRow, List<ExpandableNotificationRow>>
	mTmpChildOrderMap = new HashMap<>();

	// Dependencies:
	protected final NotificationLockscreenUserManager mLockscreenUserManager;
	protected final NotificationGroupManager mGroupManager;
	protected final VisualStabilityManager mVisualStabilityManager;
	private final SysuiStatusBarStateController mStatusBarStateController;
	private final NotificationEntryManager mEntryManager;

	// Lazy
	private final Lazy<ShadeController> mShadeController;

	/**
	* {@code true} if notifications not part of a group should by default be rendered in their
	* expanded state. If {@code false}, then only the first notification will be expanded if
	* possible.
	*/
	private final boolean mAlwaysExpandNonGroupedNotification;
	private final BubbleController mBubbleController;
	private final DynamicPrivacyController mDynamicPrivacyController;
	private final KeyguardBypassController mBypassController;

	private NotificationPresenter mPresenter;
	private NotificationListContainer mListContainer;

	// Used to help track down re-entrant calls to our update methods, which will cause bugs.
	private boolean mPerformingUpdate;
	// Hack to get around re-entrant call in onDynamicPrivacyChanged() until we can track down
	// the problem.
	private boolean mIsHandleDynamicPrivacyChangeScheduled;

	@Inject
	public NotificationViewHierarchyManager(Context context,
	@Named(MAIN_HANDLER_NAME) Handler mainHandler,
	NotificationLockscreenUserManager notificationLockscreenUserManager,
	NotificationGroupManager groupManager,
	VisualStabilityManager visualStabilityManager,
	StatusBarStateController statusBarStateController,
	NotificationEntryManager notificationEntryManager,
	Lazy<ShadeController> shadeController,
	KeyguardBypassController bypassController,
	BubbleController bubbleController,
	DynamicPrivacyController privacyController) {
	mHandler = mainHandler;
	mLockscreenUserManager = notificationLockscreenUserManager;
	mBypassController = bypassController;
	mGroupManager = groupManager;
	mVisualStabilityManager = visualStabilityManager;
	mStatusBarStateController = (SysuiStatusBarStateController) statusBarStateController;
	mEntryManager = notificationEntryManager;
	mShadeController = shadeController;
	Resources res = context.getResources();
	mAlwaysExpandNonGroupedNotification =
	res.getBoolean(R.bool.config_alwaysExpandNonGroupedNotifications);
	mBubbleController = bubbleController;
	mDynamicPrivacyController = privacyController;
	privacyController.addListener(this);
	}

	public void setUpWithPresenter(NotificationPresenter presenter,
	NotificationListContainer listContainer) {
	mPresenter = presenter;
	mListContainer = listContainer;
	}

	/**
	* Updates the visual representation of the notifications.
	*/
	//TODO: Rewrite this to focus on Entries, or some other data object instead of views
	public void updateNotificationViews() {
	Assert.isMainThread();
	beginUpdate();

	ArrayList<NotificationEntry> activeNotifications = mEntryManager.getNotificationData()
	.getActiveNotifications();
	ArrayList<ExpandableNotificationRow> toShow = new ArrayList<>(activeNotifications.size());
	final int N = activeNotifications.size();
	for (int i = 0; i < N; i++) {
	NotificationEntry ent = activeNotifications.get(i);
	if (ent.isRowDismissed() \|\| ent.isRowRemoved()
	\|\| mBubbleController.isBubbleNotificationSuppressedFromShade(ent.key)) {
	// we don't want to update removed notifications because they could
	// temporarily become children if they were isolated before.
	continue;
	}

	int userId = ent.notification.getUserId();

	// Display public version of the notification if we need to redact.
	// TODO: This area uses a lot of calls into NotificationLockscreenUserManager.
	// We can probably move some of this code there.
	int currentUserId = mLockscreenUserManager.getCurrentUserId();
	boolean devicePublic = mLockscreenUserManager.isLockscreenPublicMode(currentUserId);
	boolean userPublic = devicePublic
	\|\| mLockscreenUserManager.isLockscreenPublicMode(userId);
	if (userPublic && mDynamicPrivacyController.isDynamicallyUnlocked()
	&& (userId == currentUserId \|\| userId == UserHandle.USER_ALL
	\|\| !mLockscreenUserManager.needsSeparateWorkChallenge(userId))) {
	userPublic = false;
	}
	boolean needsRedaction = mLockscreenUserManager.needsRedaction(ent);
	boolean sensitive = userPublic && needsRedaction;
	boolean deviceSensitive = devicePublic
	&& !mLockscreenUserManager.userAllowsPrivateNotificationsInPublic(
	currentUserId);
	ent.setSensitive(sensitive, deviceSensitive);
	ent.getRow().setNeedsRedaction(needsRedaction);
	if (mGroupManager.isChildInGroupWithSummary(ent.notification)) {
	NotificationEntry summary = mGroupManager.getGroupSummary(ent.notification);
	List<ExpandableNotificationRow> orderedChildren =
	mTmpChildOrderMap.get(summary.getRow());
	if (orderedChildren == null) {
	orderedChildren = new ArrayList<>();
	mTmpChildOrderMap.put(summary.getRow(), orderedChildren);
	}
	orderedChildren.add(ent.getRow());
	} else {
	toShow.add(ent.getRow());
	}
	}

	ArrayList<ExpandableNotificationRow> viewsToRemove = new ArrayList<>();
	for (int i=0; i< mListContainer.getContainerChildCount(); i++) {
	View child = mListContainer.getContainerChildAt(i);
	if (!toShow.contains(child) && child instanceof ExpandableNotificationRow) {
	ExpandableNotificationRow row = (ExpandableNotificationRow) child;

	// Blocking helper is effectively a detached view. Don't bother removing it from the
	// layout.
	if (!row.isBlockingHelperShowing()) {
	viewsToRemove.add((ExpandableNotificationRow) child);
	}
	}
	}

	for (ExpandableNotificationRow viewToRemove : viewsToRemove) {
	if (mGroupManager.isChildInGroupWithSummary(viewToRemove.getStatusBarNotification())) {
	// we are only transferring this notification to its parent, don't generate an
	// animation
	mListContainer.setChildTransferInProgress(true);
	}
	if (viewToRemove.isSummaryWithChildren()) {
	viewToRemove.removeAllChildren();
	}
	mListContainer.removeContainerView(viewToRemove);
	mListContainer.setChildTransferInProgress(false);
	}

	removeNotificationChildren();

	for (int i = 0; i < toShow.size(); i++) {
	View v = toShow.get(i);
	if (v.getParent() == null) {
	mVisualStabilityManager.notifyViewAddition(v);
	mListContainer.addContainerView(v);
	} else if (!mListContainer.containsView(v)) {
	// the view is added somewhere else. Let's make sure
	// the ordering works properly below, by excluding these
	toShow.remove(v);
	i--;
	}
	}

	addNotificationChildrenAndSort();

	// So after all this work notifications still aren't sorted correctly.
	// Let's do that now by advancing through toShow and mListContainer in
	// lock-step, making sure mListContainer matches what we see in toShow.
	int j = 0;
	for (int i = 0; i < mListContainer.getContainerChildCount(); i++) {
	View child = mListContainer.getContainerChildAt(i);
	if (!(child instanceof ExpandableNotificationRow)) {
	// We don't care about non-notification views.
	continue;
	}
	if (((ExpandableNotificationRow) child).isBlockingHelperShowing()) {
	// Don't count/reorder notifications that are showing the blocking helper!
	continue;
	}

	ExpandableNotificationRow targetChild = toShow.get(j);
	if (child != targetChild) {
	// Oops, wrong notification at this position. Put the right one
	// here and advance both lists.
	if (mVisualStabilityManager.canReorderNotification(targetChild)) {
	mListContainer.changeViewPosition(targetChild, i);
	} else {
	mVisualStabilityManager.addReorderingAllowedCallback(mEntryManager);
	}
	}
	j++;

	}

	mVisualStabilityManager.onReorderingFinished();
	// clear the map again for the next usage
	mTmpChildOrderMap.clear();

	updateRowStatesInternal();

	mListContainer.onNotificationViewUpdateFinished();

	endUpdate();
	}

	private void addNotificationChildrenAndSort() {
	// Let's now add all notification children which are missing
	boolean orderChanged = false;
	for (int i = 0; i < mListContainer.getContainerChildCount(); i++) {
	View view = mListContainer.getContainerChildAt(i);
	if (!(view instanceof ExpandableNotificationRow)) {
	// We don't care about non-notification views.
	continue;
	}

	ExpandableNotificationRow parent = (ExpandableNotificationRow) view;
	List<ExpandableNotificationRow> children = parent.getNotificationChildren();
	List<ExpandableNotificationRow> orderedChildren = mTmpChildOrderMap.get(parent);

	for (int childIndex = 0; orderedChildren != null && childIndex < orderedChildren.size();
	childIndex++) {
	ExpandableNotificationRow childView = orderedChildren.get(childIndex);
	if (children == null \|\| !children.contains(childView)) {
	if (childView.getParent() != null) {
	Log.wtf(TAG, "trying to add a notification child that already has " +
	"a parent. class:" + childView.getParent().getClass() +
	"\n child: " + childView);
	// This shouldn't happen. We can recover by removing it though.
	((ViewGroup) childView.getParent()).removeView(childView);
	}
	mVisualStabilityManager.notifyViewAddition(childView);
	parent.addChildNotification(childView, childIndex);
	mListContainer.notifyGroupChildAdded(childView);
	}
	}

	// Finally after removing and adding has been performed we can apply the order.
	orderChanged \|= parent.applyChildOrder(orderedChildren, mVisualStabilityManager,
	mEntryManager);
	}
	if (orderChanged) {
	mListContainer.generateChildOrderChangedEvent();
	}
	}

	private void removeNotificationChildren() {
	// First let's remove all children which don't belong in the parents
	ArrayList<ExpandableNotificationRow> toRemove = new ArrayList<>();
	for (int i = 0; i < mListContainer.getContainerChildCount(); i++) {
	View view = mListContainer.getContainerChildAt(i);
	if (!(view instanceof ExpandableNotificationRow)) {
	// We don't care about non-notification views.
	continue;
	}

	ExpandableNotificationRow parent = (ExpandableNotificationRow) view;
	List<ExpandableNotificationRow> children = parent.getNotificationChildren();
	List<ExpandableNotificationRow> orderedChildren = mTmpChildOrderMap.get(parent);

	if (children != null) {
	toRemove.clear();
	for (ExpandableNotificationRow childRow : children) {
	if ((orderedChildren == null
	\|\| !orderedChildren.contains(childRow))
	&& !childRow.keepInParent()) {
	toRemove.add(childRow);
	}
	}
	for (ExpandableNotificationRow remove : toRemove) {
	parent.removeChildNotification(remove);
	if (mEntryManager.getNotificationData().get(
	remove.getStatusBarNotification().getKey()) == null) {
	// We only want to add an animation if the view is completely removed
	// otherwise it's just a transfer
	mListContainer.notifyGroupChildRemoved(remove,
	parent.getChildrenContainer());
	}
	}
	}
	}
	}

	/**
	* Updates expanded, dimmed and locked states of notification rows.
	*/
	public void updateRowStates() {
	Assert.isMainThread();
	beginUpdate();
	updateRowStatesInternal();
	endUpdate();
	}

	private void updateRowStatesInternal() {
	Trace.beginSection("NotificationViewHierarchyManager#updateRowStates");
	final int N = mListContainer.getContainerChildCount();

	int visibleNotifications = 0;
	boolean onKeyguard = mStatusBarStateController.getState() == StatusBarState.KEYGUARD;
	int maxNotifications = -1;
	if (onKeyguard && !mBypassController.getBypassEnabled()) {
	maxNotifications = mPresenter.getMaxNotificationsWhileLocked(true /* recompute */);
	}
	mListContainer.setMaxDisplayedNotifications(maxNotifications);
	Stack<ExpandableNotificationRow> stack = new Stack<>();
	for (int i = N - 1; i >= 0; i--) {
	View child = mListContainer.getContainerChildAt(i);
	if (!(child instanceof ExpandableNotificationRow)) {
	continue;
	}
	stack.push((ExpandableNotificationRow) child);
	}
	while(!stack.isEmpty()) {
	ExpandableNotificationRow row = stack.pop();
	NotificationEntry entry = row.getEntry();
	boolean isChildNotification =
	mGroupManager.isChildInGroupWithSummary(entry.notification);

	row.setOnKeyguard(onKeyguard);

	if (!onKeyguard) {
	// If mAlwaysExpandNonGroupedNotification is false, then only expand the
	// very first notification and if it's not a child of grouped notifications.
	row.setSystemExpanded(mAlwaysExpandNonGroupedNotification
	\|\| (visibleNotifications == 0 && !isChildNotification
	&& !row.isLowPriority()));
	}

	int userId = entry.notification.getUserId();
	boolean suppressedSummary = mGroupManager.isSummaryOfSuppressedGroup(
	entry.notification) && !entry.isRowRemoved();
	boolean showOnKeyguard = mLockscreenUserManager.shouldShowOnKeyguard(entry);
	if (!showOnKeyguard) {
	// min priority notifications should show if their summary is showing
	if (mGroupManager.isChildInGroupWithSummary(entry.notification)) {
	NotificationEntry summary = mGroupManager.getLogicalGroupSummary(
	entry.notification);
	if (summary != null && mLockscreenUserManager.shouldShowOnKeyguard(summary)) {
	showOnKeyguard = true;
	}
	}
	}
	if (suppressedSummary
	\|\| mLockscreenUserManager.shouldHideNotifications(userId)
	\|\| (onKeyguard && !showOnKeyguard)) {
	entry.getRow().setVisibility(View.GONE);
	} else {
	boolean wasGone = entry.getRow().getVisibility() == View.GONE;
	if (wasGone) {
	entry.getRow().setVisibility(View.VISIBLE);
	}
	if (!isChildNotification && !entry.getRow().isRemoved()) {
	if (wasGone) {
	// notify the scroller of a child addition
	mListContainer.generateAddAnimation(entry.getRow(),
	!showOnKeyguard /* fromMoreCard */);
	}
	visibleNotifications++;
	}
	}
	if (row.isSummaryWithChildren()) {
	List<ExpandableNotificationRow> notificationChildren =
	row.getNotificationChildren();
	int size = notificationChildren.size();
	for (int i = size - 1; i >= 0; i--) {
	stack.push(notificationChildren.get(i));
	}
	}

	row.showAppOpsIcons(entry.mActiveAppOps);
	row.setLastAudiblyAlertedMs(entry.lastAudiblyAlertedMs);
	}

	Trace.beginSection("NotificationPresenter#onUpdateRowStates");
	mPresenter.onUpdateRowStates();
	Trace.endSection();
	Trace.endSection();
	}

	@Override
	public void onDynamicPrivacyChanged() {
	if (mPerformingUpdate) {
	Log.w(TAG, "onDynamicPrivacyChanged made a re-entrant call");
	}
	// This listener can be called from updateNotificationViews() via a convoluted listener
	// chain, so we post here to prevent a re-entrant call. See b/136186188
	// TODO: Refactor away the need for this
	if (!mIsHandleDynamicPrivacyChangeScheduled) {
	mIsHandleDynamicPrivacyChangeScheduled = true;
	mHandler.post(this::onHandleDynamicPrivacyChanged);
	}
	}

	private void onHandleDynamicPrivacyChanged() {
	mIsHandleDynamicPrivacyChangeScheduled = false;
	updateNotificationViews();
	}

	private void beginUpdate() {
	if (mPerformingUpdate) {
	Log.wtf(TAG, "Re-entrant code during update", new Exception());
	}
	mPerformingUpdate = true;
	}

	private void endUpdate() {
	if (!mPerformingUpdate) {
	Log.wtf(TAG, "Manager state has become desynced", new Exception());
	}
	mPerformingUpdate = false;
	}
	}