BubbleData [7/n]: BubbleData impl and tests!! (9ba6cea8) · Commits · e / os / android_frameworks_base

packages/SystemUI/src/com/android/systemui/bubbles/Bubble.java

+38 −1

Original line number	Original line	Diff line number	Diff line
	@@ -16,9 +16,12 @@
	package com.android.systemui.bubbles;		package com.android.systemui.bubbles;


			import static com.android.internal.annotations.VisibleForTesting.Visibility.PRIVATE;

	import android.os.UserHandle;		import android.os.UserHandle;
	import android.view.LayoutInflater;		import android.view.LayoutInflater;

			import com.android.internal.annotations.VisibleForTesting;
	import com.android.systemui.R;		import com.android.systemui.R;
	import com.android.systemui.statusbar.notification.collection.NotificationEntry;		import com.android.systemui.statusbar.notification.collection.NotificationEntry;

	@@ -40,15 +43,24 @@ class Bubble {
	public NotificationEntry entry;		public NotificationEntry entry;
	BubbleView iconView;		BubbleView iconView;
	BubbleExpandedView expandedView;		BubbleExpandedView expandedView;
			private long mLastUpdated;
			private long mLastAccessed;

	private static String groupId(NotificationEntry entry) {		private static String groupId(NotificationEntry entry) {
	UserHandle user = entry.notification.getUser();		UserHandle user = entry.notification.getUser();
	return user.getIdentifier() + '\|' + entry.notification.getPackageName();		return user.getIdentifier() + "\|" + entry.notification.getPackageName();
			}

			/** Used in tests when no UI is required. */
			@VisibleForTesting(visibility = PRIVATE)
			Bubble(NotificationEntry e) {
			this (e, null);
	}		}

	Bubble(NotificationEntry e, BubbleExpandedView.OnBubbleBlockedListener listener) {		Bubble(NotificationEntry e, BubbleExpandedView.OnBubbleBlockedListener listener) {
	entry = e;		entry = e;
	mKey = e.key;		mKey = e.key;
			mLastUpdated = e.notification.getPostTime();
	mGroupId = groupId(e);		mGroupId = groupId(e);
	mListener = listener;		mListener = listener;
	}		}
	@@ -101,12 +113,37 @@ class Bubble {

	void setEntry(NotificationEntry entry) {		void setEntry(NotificationEntry entry) {
	this.entry = entry;		this.entry = entry;
			mLastUpdated = entry.notification.getPostTime();
	if (mInflated) {		if (mInflated) {
	iconView.update(entry);		iconView.update(entry);
	expandedView.update(entry);		expandedView.update(entry);
	}		}
	}		}

			public long getLastActivity() {
			return Math.max(mLastUpdated, mLastAccessed);
			}

			/**
			* Should be invoked whenever a Bubble is accessed (selected while expanded).
			*/
			void markAsAccessedAt(long lastAccessedMillis) {
			mLastAccessed = lastAccessedMillis;
			entry.setShowInShadeWhenBubble(false);
			}

			/**
			* @return whether bubble is from a notification associated with a foreground service.
			*/
			public boolean isOngoing() {
			return entry.isForegroundService();
			}

			@Override
			public String toString() {
			return "Bubble{" + mKey + '}';
			}

	@Override		@Override
	public boolean equals(Object o) {		public boolean equals(Object o) {
	if (this == o) return true;		if (this == o) return true;

packages/SystemUI/src/com/android/systemui/bubbles/BubbleController.java

+35 −4

Original line number	Original line	Diff line number	Diff line
	@@ -41,6 +41,7 @@ import android.os.RemoteException;
	import android.os.ServiceManager;		import android.os.ServiceManager;
	import android.provider.Settings;		import android.provider.Settings;
	import android.service.notification.StatusBarNotification;		import android.service.notification.StatusBarNotification;
			import android.util.Log;
	import android.view.Display;		import android.view.Display;
	import android.view.IPinnedStackController;		import android.view.IPinnedStackController;
	import android.view.IPinnedStackListener;		import android.view.IPinnedStackListener;
	@@ -83,6 +84,7 @@ import javax.inject.Singleton;
	public class BubbleController implements ConfigurationController.ConfigurationListener {		public class BubbleController implements ConfigurationController.ConfigurationListener {

	private static final String TAG = "BubbleController";		private static final String TAG = "BubbleController";
			private static final boolean DEBUG = true;

	@Retention(SOURCE)		@Retention(SOURCE)
	@IntDef({DISMISS_USER_GESTURE, DISMISS_AGED, DISMISS_TASK_FINISHED, DISMISS_BLOCKED,		@IntDef({DISMISS_USER_GESTURE, DISMISS_AGED, DISMISS_TASK_FINISHED, DISMISS_BLOCKED,
	@@ -203,6 +205,9 @@ public class BubbleController implements ConfigurationController.ConfigurationLi

	configurationController.addCallback(this /* configurationListener */);		configurationController.addCallback(this /* configurationListener */);

			mBubbleData = data;
			mBubbleData.setListener(mBubbleDataListener);

	mNotificationEntryManager = Dependency.get(NotificationEntryManager.class);		mNotificationEntryManager = Dependency.get(NotificationEntryManager.class);
	mNotificationEntryManager.addNotificationEntryListener(mEntryListener);		mNotificationEntryManager.addNotificationEntryListener(mEntryListener);

	@@ -219,9 +224,6 @@ public class BubbleController implements ConfigurationController.ConfigurationLi
	} catch (RemoteException e) {		} catch (RemoteException e) {
	e.printStackTrace();		e.printStackTrace();
	}		}

	mBubbleData = data;
	mBubbleData.setListener(mBubbleDataListener);
	mSurfaceSynchronizer = synchronizer;		mSurfaceSynchronizer = synchronizer;

	mBarService = IStatusBarService.Stub.asInterface(		mBarService = IStatusBarService.Stub.asInterface(
	@@ -482,7 +484,7 @@ public class BubbleController implements ConfigurationController.ConfigurationLi
	}		}

	@Override		@Override
	public void onSelectionChanged(Bubble selectedBubble) {		public void onSelectionChanged(@Nullable Bubble selectedBubble) {
	if (mStackView != null) {		if (mStackView != null) {
	mStackView.setSelectedBubble(selectedBubble);		mStackView.setSelectedBubble(selectedBubble);
	}		}
	@@ -506,6 +508,18 @@ public class BubbleController implements ConfigurationController.ConfigurationLi
	public void apply() {		public void apply() {
	mNotificationEntryManager.updateNotifications();		mNotificationEntryManager.updateNotifications();
	updateVisibility();		updateVisibility();

			if (DEBUG) {
			Log.d(TAG, "[BubbleData]");
			Log.d(TAG, formatBubblesString(mBubbleData.getBubbles(),
			mBubbleData.getSelectedBubble()));

			if (mStackView != null) {
			Log.d(TAG, "[BubbleStackView]");
			Log.d(TAG, formatBubblesString(mStackView.getBubblesOnScreen(),
			mStackView.getExpandedBubble()));
			}
			}
	}		}
	};		};

	@@ -623,6 +637,23 @@ public class BubbleController implements ConfigurationController.ConfigurationLi
	entry.setShowInShadeWhenBubble(!suppressNotification);		entry.setShowInShadeWhenBubble(!suppressNotification);
	}		}

			static String formatBubblesString(List<Bubble> bubbles, Bubble selected) {
			StringBuilder sb = new StringBuilder();
			for (Bubble bubble : bubbles) {
			if (bubble == null) {
			sb.append(" <null> !!!!!\n");
			} else {
			boolean isSelected = (bubble == selected);
			sb.append(String.format("%s Bubble{act=%12d, ongoing=%d, key=%s}\n",
			((isSelected) ? "->" : " "),
			bubble.getLastActivity(),
			(bubble.isOngoing() ? 1 : 0),
			bubble.getKey()));
			}
			}
			return sb.toString();
			}

	/**		/**
	* Return true if the applications with the package name is running in foreground.		* Return true if the applications with the package name is running in foreground.
	*		*

packages/SystemUI/src/com/android/systemui/bubbles/BubbleData.java

+308 −68

Original line number	Original line	Diff line number	Diff line
	@@ -17,21 +17,26 @@ package com.android.systemui.bubbles;

	import static com.android.internal.annotations.VisibleForTesting.Visibility.PRIVATE;		import static com.android.internal.annotations.VisibleForTesting.Visibility.PRIVATE;

	import android.app.ActivityManager;		import static java.util.stream.Collectors.toList;

	import android.app.Notification;		import android.app.Notification;
	import android.app.PendingIntent;		import android.app.PendingIntent;
	import android.content.Context;		import android.content.Context;
	import android.util.Log;		import android.util.Log;

			import androidx.annotation.Nullable;

	import com.android.internal.annotations.VisibleForTesting;		import com.android.internal.annotations.VisibleForTesting;
	import com.android.systemui.bubbles.BubbleController.DismissReason;		import com.android.systemui.bubbles.BubbleController.DismissReason;
	import com.android.systemui.statusbar.notification.collection.NotificationEntry;		import com.android.systemui.statusbar.notification.collection.NotificationEntry;

	import java.util.ArrayList;		import java.util.ArrayList;
	import java.util.Collection;
	import java.util.Collections;		import java.util.Collections;
			import java.util.Comparator;
			import java.util.HashMap;
	import java.util.Iterator;		import java.util.Iterator;
	import java.util.List;		import java.util.List;
			import java.util.Map;
	import java.util.Objects;		import java.util.Objects;

	import javax.inject.Inject;		import javax.inject.Inject;
	@@ -44,6 +49,15 @@ import javax.inject.Singleton;
	public class BubbleData {		public class BubbleData {

	private static final String TAG = "BubbleData";		private static final String TAG = "BubbleData";
			private static final boolean DEBUG = false;

			private static final int MAX_BUBBLES = 5;

			private static final Comparator<Bubble> BUBBLES_BY_LAST_ACTIVITY_DESCENDING =
			Comparator.comparing(Bubble::getLastActivity).reversed();

			private static final Comparator<Map.Entry<String, Long>> GROUPS_BY_LAST_ACTIVITY_DESCENDING =
			Comparator.<Map.Entry<String, Long>, Long>comparing(Map.Entry::getValue).reversed();

	/**		/**
	* This interface reports changes to the state and appearance of bubbles which should be applied		* This interface reports changes to the state and appearance of bubbles which should be applied
	@@ -83,7 +97,7 @@ public class BubbleData {
	void onOrderChanged(List<Bubble> bubbles);		void onOrderChanged(List<Bubble> bubbles);

	/** Indicates the selected bubble changed. */		/** Indicates the selected bubble changed. */
	void onSelectionChanged(Bubble selectedBubble);		void onSelectionChanged(@Nullable Bubble selectedBubble);

	/**		/**
	* The UI should transition to the given state, incorporating any pending changes during		* The UI should transition to the given state, incorporating any pending changes during
	@@ -98,16 +112,28 @@ public class BubbleData {
	void apply();		void apply();
	}		}

			interface TimeSource {
			long currentTimeMillis();
			}

	private final Context mContext;		private final Context mContext;
	private final List<Bubble> mBubbles = new ArrayList<>();		private List<Bubble> mBubbles;
	private Bubble mSelectedBubble;		private Bubble mSelectedBubble;
	private boolean mExpanded;		private boolean mExpanded;

			// TODO: ensure this is invalidated at the appropriate time
			private int mSelectedBubbleExpandedPosition = -1;

			private TimeSource mTimeSource = System::currentTimeMillis;

			@Nullable
	private Listener mListener;		private Listener mListener;

	@VisibleForTesting		@VisibleForTesting
	@Inject		@Inject
	public BubbleData(Context context) {		public BubbleData(Context context) {
	mContext = context;		mContext = context;
			mBubbles = new ArrayList<>();
	}		}

	public boolean hasBubbles() {		public boolean hasBubbles() {
	@@ -122,29 +148,41 @@ public class BubbleData {
	return getBubbleWithKey(key) != null;		return getBubbleWithKey(key) != null;
	}		}

			@Nullable
			public Bubble getSelectedBubble() {
			return mSelectedBubble;
			}

	public void setExpanded(boolean expanded) {		public void setExpanded(boolean expanded) {
	if (setExpandedInternal(expanded)) {		if (setExpandedInternal(expanded)) {
	mListener.apply();		dispatchApply();
	}		}
	}		}

	public void setSelectedBubble(Bubble bubble) {		public void setSelectedBubble(Bubble bubble) {
			if (DEBUG) {
			Log.d(TAG, "setSelectedBubble: " + bubble);
			}
	if (setSelectedBubbleInternal(bubble)) {		if (setSelectedBubbleInternal(bubble)) {
	mListener.apply();		dispatchApply();
	}		}
	}		}

	public void notificationEntryUpdated(NotificationEntry entry) {		public void notificationEntryUpdated(NotificationEntry entry) {
			if (DEBUG) {
			Log.d(TAG, "notificationEntryUpdated: " + entry);
			}
	Bubble bubble = getBubbleWithKey(entry.key);		Bubble bubble = getBubbleWithKey(entry.key);
	if (bubble == null) {		if (bubble == null) {
	// Create a new bubble		// Create a new bubble
	bubble = new Bubble(entry, this::onBubbleBlocked);		bubble = new Bubble(entry, this::onBubbleBlocked);
	mBubbles.add(0, bubble); // TODO: reorder/group		doAdd(bubble);
	mListener.onBubbleAdded(bubble);		dispatchOnBubbleAdded(bubble);
	} else {		} else {
	// Updates an existing bubble		// Updates an existing bubble
	bubble.setEntry(entry);		bubble.setEntry(entry);
	mListener.onBubbleUpdated(bubble);		doUpdate(bubble);
			dispatchOnBubbleUpdated(bubble);
	}		}
	if (shouldAutoExpand(entry)) {		if (shouldAutoExpand(entry)) {
	setSelectedBubbleInternal(bubble);		setSelectedBubbleInternal(bubble);
	@@ -154,49 +192,148 @@ public class BubbleData {
	} else if (mSelectedBubble == null) {		} else if (mSelectedBubble == null) {
	setSelectedBubbleInternal(bubble);		setSelectedBubbleInternal(bubble);
	}		}
	// TODO: reorder/group		dispatchApply();
	mListener.apply();		}

			private void doAdd(Bubble bubble) {
			if (DEBUG) {
			Log.d(TAG, "doAdd: " + bubble);
			}
			int minInsertPoint = 0;
			boolean newGroup = !hasBubbleWithGroupId(bubble.getGroupId());
			if (isExpanded()) {
			// first bubble of a group goes to the end, otherwise it goes within the existing group
			minInsertPoint =
			newGroup ? mBubbles.size() : findFirstIndexForGroup(bubble.getGroupId());
			}
			insertBubble(minInsertPoint, bubble);
			if (!isExpanded()) {
			packGroup(findFirstIndexForGroup(bubble.getGroupId()));
			}
			if (mBubbles.size() > MAX_BUBBLES) {
			mBubbles.stream()
			// sort oldest first (ascending lastActivity)
			.sorted(Comparator.comparingLong(Bubble::getLastActivity))
			// skip the selected bubble
			.filter((b) -> !b.equals(mSelectedBubble))
			.findFirst()
			.ifPresent((b) -> {
			doRemove(b.getKey(), BubbleController.DISMISS_AGED);
			dispatchApply();
			});
			}
			}

			private void doUpdate(Bubble bubble) {
			if (DEBUG) {
			Log.d(TAG, "doUpdate: " + bubble);
			}
			if (!isExpanded()) {
			// while collapsed, update causes re-sort
			mBubbles.remove(bubble);
			insertBubble(0, bubble);
			packGroup(findFirstIndexForGroup(bubble.getGroupId()));
			}
	}		}

	public void notificationEntryRemoved(NotificationEntry entry, @DismissReason int reason) {		public void notificationEntryRemoved(NotificationEntry entry, @DismissReason int reason) {
	int indexToRemove = indexForKey(entry.key);		if (DEBUG) {
	if (indexToRemove >= 0) {		Log.d(TAG, "notificationEntryRemoved: entry=" + entry + " reason=" + reason);
	Bubble removed = mBubbles.remove(indexToRemove);		}
	removed.setDismissed();		doRemove(entry.key, reason);
	mListener.onBubbleRemoved(removed, reason);		dispatchApply();
	maybeSendDeleteIntent(reason, removed.entry);		}

	if (mBubbles.isEmpty()) {		private void doRemove(String key, @DismissReason int reason) {
			int indexToRemove = indexForKey(key);
			if (indexToRemove >= 0) {
			Bubble bubbleToRemove = mBubbles.get(indexToRemove);
			if (mBubbles.size() == 1) {
			// Going to become empty, handle specially.
	setExpandedInternal(false);		setExpandedInternal(false);
	setSelectedBubbleInternal(null);		setSelectedBubbleInternal(null);
	} else if (removed == mSelectedBubble) {		}
			mBubbles.remove(indexToRemove);
			dispatchOnBubbleRemoved(bubbleToRemove, reason);

			// Note: If mBubbles.isEmpty(), then mSelectedBubble is now null.
			if (Objects.equals(mSelectedBubble, bubbleToRemove)) {
			// Move selection to the new bubble at the same position.
	int newIndex = Math.min(indexToRemove, mBubbles.size() - 1);		int newIndex = Math.min(indexToRemove, mBubbles.size() - 1);
	Bubble newSelected = mBubbles.get(newIndex);		Bubble newSelected = mBubbles.get(newIndex);
	setSelectedBubbleInternal(newSelected);		setSelectedBubbleInternal(newSelected);
	}		}
	// TODO: reorder/group		bubbleToRemove.setDismissed();
	mListener.apply();		maybeSendDeleteIntent(reason, bubbleToRemove.entry);
	}		}
	}		}

	public void dismissAll(@DismissReason int reason) {		public void dismissAll(@DismissReason int reason) {
	boolean changed = setExpandedInternal(false);		if (DEBUG) {
			Log.d(TAG, "dismissAll: reason=" + reason);
			}
			if (mBubbles.isEmpty()) {
			return;
			}
			setExpandedInternal(false);
			setSelectedBubbleInternal(null);
	while (!mBubbles.isEmpty()) {		while (!mBubbles.isEmpty()) {
	Bubble bubble = mBubbles.remove(0);		Bubble bubble = mBubbles.remove(0);
	bubble.setDismissed();		bubble.setDismissed();
	maybeSendDeleteIntent(reason, bubble.entry);		maybeSendDeleteIntent(reason, bubble.entry);
	mListener.onBubbleRemoved(bubble, reason);		dispatchOnBubbleRemoved(bubble, reason);
	changed = true;
	}		}
	if (setSelectedBubbleInternal(null)) {		dispatchApply();
	changed = true;
	}		}
	if (changed) {
	// TODO: reorder/group		private void dispatchApply() {
			if (mListener != null) {
	mListener.apply();		mListener.apply();
	}		}
	}		}

			private void dispatchOnBubbleAdded(Bubble bubble) {
			if (mListener != null) {
			mListener.onBubbleAdded(bubble);
			}
			}

			private void dispatchOnBubbleRemoved(Bubble bubble, @DismissReason int reason) {
			if (mListener != null) {
			mListener.onBubbleRemoved(bubble, reason);
			}
			}

			private void dispatchOnExpandedChanged(boolean expanded) {
			if (mListener != null) {
			mListener.onExpandedChanged(expanded);
			}
			}

			private void dispatchOnSelectionChanged(@Nullable Bubble bubble) {
			if (mListener != null) {
			mListener.onSelectionChanged(bubble);
			}
			}

			private void dispatchOnBubbleUpdated(Bubble bubble) {
			if (mListener != null) {
			mListener.onBubbleUpdated(bubble);
			}
			}

			private void dispatchOnOrderChanged(List<Bubble> bubbles) {
			if (mListener != null) {
			mListener.onOrderChanged(bubbles);
			}
			}

			private void dispatchShowFlyoutText(Bubble bubble, String text) {
			if (mListener != null) {
			mListener.showFlyoutText(bubble, text);
			}
			}

	/**		/**
	* Requests a change to the selected bubble. Calls {@link Listener#onSelectionChanged} if		* Requests a change to the selected bubble. Calls {@link Listener#onSelectionChanged} if
	* the value changes.		* the value changes.
	@@ -204,7 +341,10 @@ public class BubbleData {
	* @param bubble the new selected bubble		* @param bubble the new selected bubble
	* @return true if the state changed as a result		* @return true if the state changed as a result
	*/		*/
	private boolean setSelectedBubbleInternal(Bubble bubble) {		private boolean setSelectedBubbleInternal(@Nullable Bubble bubble) {
			if (DEBUG) {
			Log.d(TAG, "setSelectedBubbleInternal: " + bubble);
			}
	if (Objects.equals(bubble, mSelectedBubble)) {		if (Objects.equals(bubble, mSelectedBubble)) {
	return false;		return false;
	}		}
	@@ -213,16 +353,17 @@ public class BubbleData {
	+ " (" + bubble + ") bubbles=" + mBubbles);		+ " (" + bubble + ") bubbles=" + mBubbles);
	return false;		return false;
	}		}
	if (mExpanded) {		if (mExpanded && bubble != null) {
	// TODO: bubble.markAsActive() ?		mSelectedBubble.markAsAccessedAt(mTimeSource.currentTimeMillis());
	bubble.entry.setShowInShadeWhenBubble(false);
	}		}
	mSelectedBubble = bubble;		mSelectedBubble = bubble;
	mListener.onSelectionChanged(mSelectedBubble);		dispatchOnSelectionChanged(mSelectedBubble);
			if (!mExpanded \|\| mSelectedBubble == null) {
			mSelectedBubbleExpandedPosition = -1;
			}
	return true;		return true;
	}		}


	/**		/**
	* Requests a change to the expanded state. Calls {@link Listener#onExpandedChanged} if		* Requests a change to the expanded state. Calls {@link Listener#onExpandedChanged} if
	* the value changes.		* the value changes.
	@@ -231,9 +372,15 @@ public class BubbleData {
	* @return true if the state changed as a result		* @return true if the state changed as a result
	*/		*/
	private boolean setExpandedInternal(boolean shouldExpand) {		private boolean setExpandedInternal(boolean shouldExpand) {
			if (DEBUG) {
			Log.d(TAG, "setExpandedInternal: shouldExpand=" + shouldExpand);
			}
	if (mExpanded == shouldExpand) {		if (mExpanded == shouldExpand) {
	return false;		return false;
	}		}
			if (mSelectedBubble != null) {
			mSelectedBubble.markAsAccessedAt(mTimeSource.currentTimeMillis());
			}
	if (shouldExpand) {		if (shouldExpand) {
	if (mBubbles.isEmpty()) {		if (mBubbles.isEmpty()) {
	Log.e(TAG, "Attempt to expand stack when empty!");		Log.e(TAG, "Attempt to expand stack when empty!");
	@@ -243,15 +390,126 @@ public class BubbleData {
	Log.e(TAG, "Attempt to expand stack without selected bubble!");		Log.e(TAG, "Attempt to expand stack without selected bubble!");
	return false;		return false;
	}		}
	// TODO: bubble.markAsActive() ?		} else {
	mSelectedBubble.entry.setShowInShadeWhenBubble(false);		repackAll();
	}		}
	// TODO: reorder/regroup
	mExpanded = shouldExpand;		mExpanded = shouldExpand;
	mListener.onExpandedChanged(mExpanded);		dispatchOnExpandedChanged(mExpanded);
	return true;		return true;
	}		}

			private static long sortKey(Bubble bubble) {
			long key = bubble.getLastActivity();
			if (bubble.isOngoing()) {
			// Set 2nd highest bit (signed long int), to partition between ongoing and regular
			key \|= 0x4000000000000000L;
			}
			return key;
			}

			/**
			* Locates and inserts the bubble into a sorted position. The is inserted
			* based on sort key, groupId is not considered. A call to {@link #packGroup(int)} may be
			* required to keep grouping intact.
			*
			* @param minPosition the first insert point to consider
			* @param newBubble the bubble to insert
			* @return the position where the bubble was inserted
			*/
			private int insertBubble(int minPosition, Bubble newBubble) {
			long newBubbleSortKey = sortKey(newBubble);
			String previousGroupId = null;

			for (int pos = minPosition; pos < mBubbles.size(); pos++) {
			Bubble bubbleAtPos = mBubbles.get(pos);
			String groupIdAtPos = bubbleAtPos.getGroupId();
			boolean atStartOfGroup = !groupIdAtPos.equals(previousGroupId);

			if (atStartOfGroup && newBubbleSortKey > sortKey(bubbleAtPos)) {
			// Insert before the start of first group which has older bubbles.
			mBubbles.add(pos, newBubble);
			return pos;
			}
			previousGroupId = groupIdAtPos;
			}
			mBubbles.add(newBubble);
			return mBubbles.size() - 1;
			}

			private boolean hasBubbleWithGroupId(String groupId) {
			return mBubbles.stream().anyMatch(b -> b.getGroupId().equals(groupId));
			}

			private int findFirstIndexForGroup(String appId) {
			for (int i = 0; i < mBubbles.size(); i++) {
			Bubble bubbleAtPos = mBubbles.get(i);
			if (bubbleAtPos.getGroupId().equals(appId)) {
			return i;
			}
			}
			return 0;
			}

			/**
			* Starting at the given position, moves all bubbles with the same group id to follow. Bubbles
			* at positions lower than {@code position} are unchanged. Relative order within the group
			* unchanged. Relative order of any other bubbles are also unchanged.
			*
			* @param position the position of the first bubble for the group
			*/
			private void packGroup(int position) {
			if (DEBUG) {
			Log.d(TAG, "packGroup: position=" + position);
			}
			Bubble groupStart = mBubbles.get(position);
			final String groupAppId = groupStart.getGroupId();
			List<Bubble> moving = new ArrayList<>();

			// Walk backward, collect bubbles within the group
			for (int i = mBubbles.size() - 1; i > position; i--) {
			if (mBubbles.get(i).getGroupId().equals(groupAppId)) {
			moving.add(0, mBubbles.get(i));
			}
			}
			mBubbles.removeAll(moving);
			mBubbles.addAll(position + 1, moving);
			}

			private void repackAll() {
			if (DEBUG) {
			Log.d(TAG, "repackAll()");
			}
			if (mBubbles.isEmpty()) {
			return;
			}
			Map<String, Long> groupLastActivity = new HashMap<>();
			for (Bubble bubble : mBubbles) {
			long maxSortKeyForGroup = groupLastActivity.getOrDefault(bubble.getGroupId(), 0L);
			long sortKeyForBubble = sortKey(bubble);
			if (sortKeyForBubble > maxSortKeyForGroup) {
			groupLastActivity.put(bubble.getGroupId(), sortKeyForBubble);
			}
			}

			// Sort groups by their most recently active bubble
			List<String> groupsByMostRecentActivity =
			groupLastActivity.entrySet().stream()
			.sorted(GROUPS_BY_LAST_ACTIVITY_DESCENDING)
			.map(Map.Entry::getKey)
			.collect(toList());

			List<Bubble> repacked = new ArrayList<>(mBubbles.size());

			// For each group, add bubbles, freshest to oldest
			for (String appId : groupsByMostRecentActivity) {
			mBubbles.stream()
			.filter((b) -> b.getGroupId().equals(appId))
			.sorted(BUBBLES_BY_LAST_ACTIVITY_DESCENDING)
			.forEachOrdered(repacked::add);
			}
			mBubbles = repacked;
			}

	private void maybeSendDeleteIntent(@DismissReason int reason, NotificationEntry entry) {		private void maybeSendDeleteIntent(@DismissReason int reason, NotificationEntry entry) {
	if (reason == BubbleController.DISMISS_USER_GESTURE) {		if (reason == BubbleController.DISMISS_USER_GESTURE) {
	Notification.BubbleMetadata bubbleMetadata = entry.getBubbleMetadata();		Notification.BubbleMetadata bubbleMetadata = entry.getBubbleMetadata();
	@@ -275,13 +533,14 @@ public class BubbleData {
	Bubble bubble = i.next();		Bubble bubble = i.next();
	if (bubble.getPackageName().equals(blockedPackage)) {		if (bubble.getPackageName().equals(blockedPackage)) {
	i.remove();		i.remove();
	mListener.onBubbleRemoved(bubble, BubbleController.DISMISS_BLOCKED);		// TODO: handle removal of selected bubble, and collapse safely if emptied (see
			// dismissAll)
			dispatchOnBubbleRemoved(bubble, BubbleController.DISMISS_BLOCKED);
	changed = true;		changed = true;
	}		}
	}		}
	if (changed) {		if (changed) {
	// TODO: reorder/group		dispatchApply();
	mListener.apply();
	}		}
	}		}

	@@ -295,24 +554,11 @@ public class BubbleData {
	return -1;		return -1;
	}		}

	private Bubble removeBubbleWithKey(String key) {
	for (int i = 0; i < mBubbles.size(); i++) {
	Bubble bubble = mBubbles.get(i);
	if (bubble.getKey().equals(key)) {
	mBubbles.remove(i);
	return bubble;
	}
	}
	return null;
	}

	/**		/**
	* The set of bubbles.		* The set of bubbles.
	*
	* @deprecated
	*/		*/
	@Deprecated		@VisibleForTesting(visibility = PRIVATE)
	public Collection<Bubble> getBubbles() {		public List<Bubble> getBubbles() {
	return Collections.unmodifiableList(mBubbles);		return Collections.unmodifiableList(mBubbles);
	}		}

	@@ -327,6 +573,11 @@ public class BubbleData {
	return null;		return null;
	}		}

			@VisibleForTesting(visibility = PRIVATE)
			void setTimeSource(TimeSource timeSource) {
			mTimeSource = timeSource;
			}

	public void setListener(Listener listener) {		public void setListener(Listener listener) {
	mListener = listener;		mListener = listener;
	}		}
	@@ -334,17 +585,6 @@ public class BubbleData {
	boolean shouldAutoExpand(NotificationEntry entry) {		boolean shouldAutoExpand(NotificationEntry entry) {
	Notification.BubbleMetadata metadata = entry.getBubbleMetadata();		Notification.BubbleMetadata metadata = entry.getBubbleMetadata();
	return metadata != null && metadata.getAutoExpandBubble()		return metadata != null && metadata.getAutoExpandBubble()
	&& isForegroundApp(entry.notification.getPackageName());		&& BubbleController.isForegroundApp(mContext, entry.notification.getPackageName());
	}

	/**
	* Return true if the applications with the package name is running in foreground.
	*
	* @param pkgName application package name.
	*/
	boolean isForegroundApp(String pkgName) {
	ActivityManager am = mContext.getSystemService(ActivityManager.class);
	List<ActivityManager.RunningTaskInfo> tasks = am.getRunningTasks(1 /* maxNum */);
	return !tasks.isEmpty() && pkgName.equals(tasks.get(0).topActivity.getPackageName());
	}		}
	}		}
			No newline at end of file

packages/SystemUI/src/com/android/systemui/bubbles/BubbleStackView.java

+76 −9

File changed.

Preview size limit exceeded, changes collapsed.

packages/SystemUI/src/com/android/systemui/bubbles/BubbleTouchHandler.java

+14 −11

File changed.

Preview size limit exceeded, changes collapsed.