blob: 2324d3753d72bf6b1998e595e0f9073ca662f8f6 [file] [log] [blame]
Selim Cinek67b22602014-03-10 15:40:16 +01001/*
2 * Copyright (C) 2014 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License
15 */
16
17package com.android.systemui.statusbar.stack;
18
19import android.content.Context;
Jorim Jaggid7c1fae2014-08-13 18:27:47 +020020import android.util.DisplayMetrics;
Christoph Studer6e3eceb2014-04-01 18:40:27 +020021import android.util.Log;
Selim Cinek67b22602014-03-10 15:40:16 +010022import android.view.View;
23import android.view.ViewGroup;
Selim Cinek343e6e22014-04-11 21:23:30 +020024
Selim Cinek67b22602014-03-10 15:40:16 +010025import com.android.systemui.R;
Selim Cinek1685e632014-04-08 02:27:49 +020026import com.android.systemui.statusbar.ExpandableNotificationRow;
Jorim Jaggibe565df2014-04-28 17:51:23 +020027import com.android.systemui.statusbar.ExpandableView;
Selim Cinekb8f09cf2015-03-16 17:09:28 -070028import com.android.systemui.statusbar.policy.HeadsUpManager;
Selim Cinek67b22602014-03-10 15:40:16 +010029
Jorim Jaggid4a57442014-04-10 02:45:55 +020030import java.util.ArrayList;
Selim Cinekb5605e52015-02-20 18:21:41 +010031import java.util.List;
Jorim Jaggid4a57442014-04-10 02:45:55 +020032
Selim Cinek67b22602014-03-10 15:40:16 +010033/**
34 * The Algorithm of the {@link com.android.systemui.statusbar.stack
35 * .NotificationStackScrollLayout} which can be queried for {@link com.android.systemui.statusbar
36 * .stack.StackScrollState}
37 */
38public class StackScrollAlgorithm {
39
Christoph Studer6e3eceb2014-04-01 18:40:27 +020040 private static final String LOG_TAG = "StackScrollAlgorithm";
41
Selim Cinek67b22602014-03-10 15:40:16 +010042 private static final int MAX_ITEMS_IN_BOTTOM_STACK = 3;
43 private static final int MAX_ITEMS_IN_TOP_STACK = 3;
44
Selim Cinek65b2e7c2015-10-26 14:11:31 -070045 public static final float DIMMED_SCALE = 0.98f;
Jorim Jaggid552d9d2014-05-07 19:41:13 +020046
Selim Cinek67b22602014-03-10 15:40:16 +010047 private int mPaddingBetweenElements;
48 private int mCollapsedSize;
49 private int mTopStackPeekSize;
50 private int mBottomStackPeekSize;
51 private int mZDistanceBetweenElements;
52 private int mZBasicHeight;
Selim Cinek708a6c12014-05-28 14:16:02 +020053 private int mRoundedRectCornerRadius;
Selim Cinek67b22602014-03-10 15:40:16 +010054
55 private StackIndentationFunctor mTopStackIndentationFunctor;
56 private StackIndentationFunctor mBottomStackIndentationFunctor;
57
Selim Cinek67b22602014-03-10 15:40:16 +010058 private StackScrollAlgorithmState mTempAlgorithmState = new StackScrollAlgorithmState();
Selim Cinek1685e632014-04-08 02:27:49 +020059 private boolean mIsExpansionChanging;
60 private int mFirstChildMaxHeight;
61 private boolean mIsExpanded;
Jorim Jaggibe565df2014-04-28 17:51:23 +020062 private ExpandableView mFirstChildWhileExpanding;
Selim Cinek1685e632014-04-08 02:27:49 +020063 private boolean mExpandedOnStart;
Selim Cinek343e6e22014-04-11 21:23:30 +020064 private int mTopStackTotalSize;
Selim Cinek34c0a8d2014-05-12 00:01:43 +020065 private int mPaddingBetweenElementsDimmed;
66 private int mPaddingBetweenElementsNormal;
Selim Cinek79d79c42015-05-21 16:14:45 -070067 private int mNotificationsTopPadding;
Selim Cinek34c0a8d2014-05-12 00:01:43 +020068 private int mBottomStackSlowDownLength;
Selim Cinekad3e5af2014-07-04 12:24:11 +020069 private int mTopStackSlowDownLength;
Selim Cinekd83771e2014-07-04 16:45:31 +020070 private int mCollapseSecondCardPadding;
Selim Cinek3afd00e2014-08-11 22:32:57 +020071 private boolean mIsSmallScreen;
72 private int mMaxNotificationHeight;
Jorim Jaggid7c1fae2014-08-13 18:27:47 +020073 private boolean mScaleDimmed;
Selim Cinekd2281152015-04-10 14:37:46 -070074 private HeadsUpManager mHeadsUpManager;
Selim Cinek816c8e42015-11-19 12:00:45 -080075 private int mFirstChildMinHeight;
Selim Cinekaf0dc312015-12-15 17:01:44 -080076 private boolean mDimmed;
Selim Cinek67b22602014-03-10 15:40:16 +010077
78 public StackScrollAlgorithm(Context context) {
Selim Cinekaf0dc312015-12-15 17:01:44 -080079 initView(context);
Selim Cinek34c0a8d2014-05-12 00:01:43 +020080 }
81
Selim Cinekaf0dc312015-12-15 17:01:44 -080082 public void initView(Context context) {
83 initConstants(context);
84 updatePadding();
85 }
86
87 private void updatePadding() {
88 mPaddingBetweenElements = mDimmed && mScaleDimmed
Selim Cinek34c0a8d2014-05-12 00:01:43 +020089 ? mPaddingBetweenElementsDimmed
90 : mPaddingBetweenElementsNormal;
Selim Cinekad3e5af2014-07-04 12:24:11 +020091 mTopStackTotalSize = mTopStackSlowDownLength + mPaddingBetweenElements
92 + mTopStackPeekSize;
Selim Cinek34c0a8d2014-05-12 00:01:43 +020093 mTopStackIndentationFunctor = new PiecewiseLinearIndentationFunctor(
94 MAX_ITEMS_IN_TOP_STACK,
95 mTopStackPeekSize,
Selim Cinekb96924d2014-05-12 15:11:25 +020096 mTopStackTotalSize - mTopStackPeekSize,
Selim Cinek34c0a8d2014-05-12 00:01:43 +020097 0.5f);
98 mBottomStackIndentationFunctor = new PiecewiseLinearIndentationFunctor(
99 MAX_ITEMS_IN_BOTTOM_STACK,
100 mBottomStackPeekSize,
101 getBottomStackSlowDownLength(),
102 0.5f);
103 }
104
105 public int getBottomStackSlowDownLength() {
106 return mBottomStackSlowDownLength + mPaddingBetweenElements;
Selim Cinek67b22602014-03-10 15:40:16 +0100107 }
108
109 private void initConstants(Context context) {
Selim Cinek34c0a8d2014-05-12 00:01:43 +0200110 mPaddingBetweenElementsDimmed = context.getResources()
111 .getDimensionPixelSize(R.dimen.notification_padding_dimmed);
112 mPaddingBetweenElementsNormal = context.getResources()
Jorim Jaggife40f7d2014-04-28 15:20:04 +0200113 .getDimensionPixelSize(R.dimen.notification_padding);
Selim Cinek79d79c42015-05-21 16:14:45 -0700114 mNotificationsTopPadding = context.getResources()
115 .getDimensionPixelSize(R.dimen.notifications_top_padding);
Selim Cinek67b22602014-03-10 15:40:16 +0100116 mCollapsedSize = context.getResources()
Jorim Jaggife40f7d2014-04-28 15:20:04 +0200117 .getDimensionPixelSize(R.dimen.notification_min_height);
Selim Cinek3afd00e2014-08-11 22:32:57 +0200118 mMaxNotificationHeight = context.getResources()
119 .getDimensionPixelSize(R.dimen.notification_max_height);
Selim Cinek67b22602014-03-10 15:40:16 +0100120 mTopStackPeekSize = context.getResources()
121 .getDimensionPixelSize(R.dimen.top_stack_peek_amount);
122 mBottomStackPeekSize = context.getResources()
123 .getDimensionPixelSize(R.dimen.bottom_stack_peek_amount);
124 mZDistanceBetweenElements = context.getResources()
125 .getDimensionPixelSize(R.dimen.z_distance_between_notifications);
126 mZBasicHeight = (MAX_ITEMS_IN_BOTTOM_STACK + 1) * mZDistanceBetweenElements;
Selim Cinek34c0a8d2014-05-12 00:01:43 +0200127 mBottomStackSlowDownLength = context.getResources()
128 .getDimensionPixelSize(R.dimen.bottom_stack_slow_down_length);
Selim Cinekad3e5af2014-07-04 12:24:11 +0200129 mTopStackSlowDownLength = context.getResources()
130 .getDimensionPixelSize(R.dimen.top_stack_slow_down_length);
Selim Cinek708a6c12014-05-28 14:16:02 +0200131 mRoundedRectCornerRadius = context.getResources().getDimensionPixelSize(
Selim Cinek697178b2014-07-02 19:40:30 +0200132 R.dimen.notification_material_rounded_rect_radius);
Selim Cinekd83771e2014-07-04 16:45:31 +0200133 mCollapseSecondCardPadding = context.getResources().getDimensionPixelSize(
134 R.dimen.notification_collapse_second_card_padding);
Jorim Jaggid7c1fae2014-08-13 18:27:47 +0200135 mScaleDimmed = context.getResources().getDisplayMetrics().densityDpi
Jorim Jaggi2cb70042015-08-24 14:52:45 -0700136 >= DisplayMetrics.DENSITY_420;
Selim Cinek67b22602014-03-10 15:40:16 +0100137 }
138
Jorim Jaggid7c1fae2014-08-13 18:27:47 +0200139 public boolean shouldScaleDimmed() {
140 return mScaleDimmed;
141 }
Selim Cinek67b22602014-03-10 15:40:16 +0100142
Jorim Jaggid552d9d2014-05-07 19:41:13 +0200143 public void getStackScrollState(AmbientState ambientState, StackScrollState resultState) {
Selim Cinek67b22602014-03-10 15:40:16 +0100144 // The state of the local variables are saved in an algorithmState to easily subdivide it
145 // into multiple phases.
146 StackScrollAlgorithmState algorithmState = mTempAlgorithmState;
147
148 // First we reset the view states to their default values.
149 resultState.resetViewStates();
150
Selim Cinek343e6e22014-04-11 21:23:30 +0200151 algorithmState.itemsInTopStack = 0.0f;
Selim Cinek67b22602014-03-10 15:40:16 +0100152 algorithmState.partialInTop = 0.0f;
153 algorithmState.lastTopStackIndex = 0;
Selim Cinek343e6e22014-04-11 21:23:30 +0200154 algorithmState.scrolledPixelsTop = 0;
Selim Cinek67b22602014-03-10 15:40:16 +0100155 algorithmState.itemsInBottomStack = 0.0f;
Selim Cinek343e6e22014-04-11 21:23:30 +0200156 algorithmState.partialInBottom = 0.0f;
Selim Cinek8d9ff9c2014-05-12 15:13:04 +0200157 float bottomOverScroll = ambientState.getOverScrollAmount(false /* onTop */);
Selim Cinek1408eb52014-06-02 14:45:38 +0200158
159 int scrollY = ambientState.getScrollY();
160
161 // Due to the overScroller, the stackscroller can have negative scroll state. This is
162 // already accounted for by the top padding and doesn't need an additional adaption
163 scrollY = Math.max(0, scrollY);
Selim Cinek816c8e42015-11-19 12:00:45 -0800164 algorithmState.scrollY = (int) (scrollY + mFirstChildMinHeight + bottomOverScroll);
Selim Cinek343e6e22014-04-11 21:23:30 +0200165
Selim Cineka4baaa32015-04-20 14:27:54 -0700166 updateVisibleChildren(resultState, algorithmState);
Selim Cinek67b22602014-03-10 15:40:16 +0100167
168 // Phase 1:
Selim Cinekb8f09cf2015-03-16 17:09:28 -0700169 findNumberOfItemsInTopStackAndUpdateState(resultState, algorithmState, ambientState);
Selim Cinek67b22602014-03-10 15:40:16 +0100170
171 // Phase 2:
Selim Cinekb8f09cf2015-03-16 17:09:28 -0700172 updatePositionsForState(resultState, algorithmState, ambientState);
Selim Cinek67b22602014-03-10 15:40:16 +0100173
174 // Phase 3:
175 updateZValuesForState(resultState, algorithmState);
Selim Cinekeb973562014-05-02 17:07:49 +0200176
Jorim Jaggid552d9d2014-05-07 19:41:13 +0200177 handleDraggedViews(ambientState, resultState, algorithmState);
Jorim Jaggiae441282014-08-01 02:45:18 +0200178 updateDimmedActivatedHideSensitive(ambientState, resultState, algorithmState);
Selim Cineka59ecc32015-04-07 10:51:49 -0700179 updateClipping(resultState, algorithmState, ambientState);
Selim Cinek3d2b94bf2014-07-02 22:12:47 +0200180 updateSpeedBumpState(resultState, algorithmState, ambientState.getSpeedBumpIndex());
Selim Cinekb5605e52015-02-20 18:21:41 +0100181 getNotificationChildrenStates(resultState, algorithmState);
182 }
183
184 private void getNotificationChildrenStates(StackScrollState resultState,
185 StackScrollAlgorithmState algorithmState) {
186 int childCount = algorithmState.visibleChildren.size();
187 for (int i = 0; i < childCount; i++) {
188 ExpandableView v = algorithmState.visibleChildren.get(i);
189 if (v instanceof ExpandableNotificationRow) {
190 ExpandableNotificationRow row = (ExpandableNotificationRow) v;
191 row.getChildrenStates(resultState);
192 }
193 }
Selim Cinek3d2b94bf2014-07-02 22:12:47 +0200194 }
195
196 private void updateSpeedBumpState(StackScrollState resultState,
197 StackScrollAlgorithmState algorithmState, int speedBumpIndex) {
198 int childCount = algorithmState.visibleChildren.size();
199 for (int i = 0; i < childCount; i++) {
200 View child = algorithmState.visibleChildren.get(i);
Selim Cinekb036ca42015-02-20 15:56:28 +0100201 StackViewState childViewState = resultState.getViewStateForView(child);
Selim Cinek3107cfa2014-07-22 15:24:29 +0200202
203 // The speed bump can also be gone, so equality needs to be taken when comparing
204 // indices.
205 childViewState.belowSpeedBump = speedBumpIndex != -1 && i >= speedBumpIndex;
Selim Cinek3d2b94bf2014-07-02 22:12:47 +0200206 }
Selim Cinekf54090e2014-06-17 17:24:51 -0700207 }
208
Selim Cinek708a6c12014-05-28 14:16:02 +0200209 private void updateClipping(StackScrollState resultState,
Selim Cineka59ecc32015-04-07 10:51:49 -0700210 StackScrollAlgorithmState algorithmState, AmbientState ambientState) {
Selim Cinek9c17b772015-07-07 20:37:09 -0700211 boolean dismissAllInProgress = ambientState.isDismissAllInProgress();
Selim Cinek708a6c12014-05-28 14:16:02 +0200212 float previousNotificationEnd = 0;
213 float previousNotificationStart = 0;
214 boolean previousNotificationIsSwiped = false;
215 int childCount = algorithmState.visibleChildren.size();
216 for (int i = 0; i < childCount; i++) {
217 ExpandableView child = algorithmState.visibleChildren.get(i);
Selim Cinekb036ca42015-02-20 15:56:28 +0100218 StackViewState state = resultState.getViewStateForView(child);
Jorim Jaggi2e34ec32014-07-01 03:17:05 +0200219 float newYTranslation = state.yTranslation + state.height * (1f - state.scale) / 2f;
220 float newHeight = state.height * state.scale;
Selim Cinek708a6c12014-05-28 14:16:02 +0200221 // apply clipping and shadow
222 float newNotificationEnd = newYTranslation + newHeight;
223
Selim Cinekc5baa3e2014-10-29 19:04:19 +0100224 float clipHeight;
225 if (previousNotificationIsSwiped) {
226 // When the previous notification is swiped, we don't clip the content to the
227 // bottom of it.
228 clipHeight = newHeight;
229 } else {
230 clipHeight = newNotificationEnd - previousNotificationEnd;
231 clipHeight = Math.max(0.0f, clipHeight);
232 if (clipHeight != 0.0f) {
Selim Cinek708a6c12014-05-28 14:16:02 +0200233
Selim Cinekc5baa3e2014-10-29 19:04:19 +0100234 // In the unlocked shade we have to clip a little bit higher because of the rounded
235 // corners of the notifications, but only if we are not fully overlapped by
236 // the top card.
237 float clippingCorrection = state.dimmed
238 ? 0
239 : mRoundedRectCornerRadius * state.scale;
240 clipHeight += clippingCorrection;
241 }
242 }
Selim Cinek708a6c12014-05-28 14:16:02 +0200243
244 updateChildClippingAndBackground(state, newHeight, clipHeight,
Jorim Jaggi2e34ec32014-07-01 03:17:05 +0200245 newHeight - (previousNotificationStart - newYTranslation));
Selim Cinek708a6c12014-05-28 14:16:02 +0200246
Selim Cinek9c17b772015-07-07 20:37:09 -0700247 if (dismissAllInProgress) {
248 state.clipTopAmount = Math.max(child.getMinClipTopAmount(), state.clipTopAmount);
249 }
250
Selim Cinek708a6c12014-05-28 14:16:02 +0200251 if (!child.isTransparent()) {
252 // Only update the previous values if we are not transparent,
253 // otherwise we would clip to a transparent view.
Selim Cinek9c17b772015-07-07 20:37:09 -0700254 if ((dismissAllInProgress && canChildBeDismissed(child))) {
255 previousNotificationIsSwiped = true;
256 } else {
257 previousNotificationIsSwiped = ambientState.getDraggedViews().contains(child);
258 previousNotificationEnd = newNotificationEnd;
259 previousNotificationStart = newYTranslation + state.clipTopAmount * state.scale;
260 }
Selim Cinek708a6c12014-05-28 14:16:02 +0200261 }
262 }
263 }
264
Selim Cinek9c17b772015-07-07 20:37:09 -0700265 public static boolean canChildBeDismissed(View v) {
266 final View veto = v.findViewById(R.id.veto);
267 return (veto != null && veto.getVisibility() != View.GONE);
268 }
269
Selim Cinek708a6c12014-05-28 14:16:02 +0200270 /**
271 * Updates the shadow outline and the clipping for a view.
272 *
273 * @param state the viewState to update
274 * @param realHeight the currently applied height of the view
275 * @param clipHeight the desired clip height, the rest of the view will be clipped from the top
276 * @param backgroundHeight the desired background height. The shadows of the view will be
277 * based on this height and the content will be clipped from the top
278 */
Selim Cinekb036ca42015-02-20 15:56:28 +0100279 private void updateChildClippingAndBackground(StackViewState state, float realHeight,
280 float clipHeight, float backgroundHeight) {
Selim Cinek708a6c12014-05-28 14:16:02 +0200281 if (realHeight > clipHeight) {
Jorim Jaggi2e34ec32014-07-01 03:17:05 +0200282 // Rather overlap than create a hole.
283 state.topOverLap = (int) Math.floor((realHeight - clipHeight) / state.scale);
Selim Cinek708a6c12014-05-28 14:16:02 +0200284 } else {
285 state.topOverLap = 0;
286 }
287 if (realHeight > backgroundHeight) {
Jorim Jaggi2e34ec32014-07-01 03:17:05 +0200288 // Rather overlap than create a hole.
289 state.clipTopAmount = (int) Math.floor((realHeight - backgroundHeight) / state.scale);
Selim Cinek708a6c12014-05-28 14:16:02 +0200290 } else {
291 state.clipTopAmount = 0;
292 }
Jorim Jaggid552d9d2014-05-07 19:41:13 +0200293 }
294
295 /**
Jorim Jaggiae441282014-08-01 02:45:18 +0200296 * Updates the dimmed, activated and hiding sensitive states of the children.
Jorim Jaggid552d9d2014-05-07 19:41:13 +0200297 */
Jorim Jaggiae441282014-08-01 02:45:18 +0200298 private void updateDimmedActivatedHideSensitive(AmbientState ambientState,
299 StackScrollState resultState, StackScrollAlgorithmState algorithmState) {
Jorim Jaggid552d9d2014-05-07 19:41:13 +0200300 boolean dimmed = ambientState.isDimmed();
John Spurlockbf370992014-06-17 13:58:31 -0400301 boolean dark = ambientState.isDark();
Jorim Jaggiae441282014-08-01 02:45:18 +0200302 boolean hideSensitive = ambientState.isHideSensitive();
Jorim Jaggid552d9d2014-05-07 19:41:13 +0200303 View activatedChild = ambientState.getActivatedChild();
304 int childCount = algorithmState.visibleChildren.size();
305 for (int i = 0; i < childCount; i++) {
306 View child = algorithmState.visibleChildren.get(i);
Selim Cinekb036ca42015-02-20 15:56:28 +0100307 StackViewState childViewState = resultState.getViewStateForView(child);
Jorim Jaggid552d9d2014-05-07 19:41:13 +0200308 childViewState.dimmed = dimmed;
John Spurlockbf370992014-06-17 13:58:31 -0400309 childViewState.dark = dark;
Jorim Jaggiae441282014-08-01 02:45:18 +0200310 childViewState.hideSensitive = hideSensitive;
Selim Cinekb89de4e2014-06-10 10:47:05 +0200311 boolean isActivatedChild = activatedChild == child;
Jorim Jaggid7c1fae2014-08-13 18:27:47 +0200312 childViewState.scale = !mScaleDimmed || !dimmed || isActivatedChild
Jorim Jaggid552d9d2014-05-07 19:41:13 +0200313 ? 1.0f
314 : DIMMED_SCALE;
Jorim Jaggi4538cee2014-09-09 15:21:38 +0200315 if (dimmed && isActivatedChild) {
316 childViewState.zTranslation += 2.0f * mZDistanceBetweenElements;
Jorim Jaggid552d9d2014-05-07 19:41:13 +0200317 }
318 }
Selim Cinekeb973562014-05-02 17:07:49 +0200319 }
320
321 /**
322 * Handle the special state when views are being dragged
323 */
Jorim Jaggid552d9d2014-05-07 19:41:13 +0200324 private void handleDraggedViews(AmbientState ambientState, StackScrollState resultState,
Selim Cinekeb973562014-05-02 17:07:49 +0200325 StackScrollAlgorithmState algorithmState) {
Jorim Jaggid552d9d2014-05-07 19:41:13 +0200326 ArrayList<View> draggedViews = ambientState.getDraggedViews();
327 for (View draggedView : draggedViews) {
Selim Cinekeb973562014-05-02 17:07:49 +0200328 int childIndex = algorithmState.visibleChildren.indexOf(draggedView);
329 if (childIndex >= 0 && childIndex < algorithmState.visibleChildren.size() - 1) {
330 View nextChild = algorithmState.visibleChildren.get(childIndex + 1);
Jorim Jaggid552d9d2014-05-07 19:41:13 +0200331 if (!draggedViews.contains(nextChild)) {
Selim Cinekeb973562014-05-02 17:07:49 +0200332 // only if the view is not dragged itself we modify its state to be fully
333 // visible
Selim Cinekb036ca42015-02-20 15:56:28 +0100334 StackViewState viewState = resultState.getViewStateForView(
Selim Cinekeb973562014-05-02 17:07:49 +0200335 nextChild);
336 // The child below the dragged one must be fully visible
Selim Cinek131c1e22015-05-11 19:04:49 -0700337 if (ambientState.isShadeExpanded()) {
Selim Cineka59ecc32015-04-07 10:51:49 -0700338 viewState.alpha = 1;
339 }
Selim Cinekeb973562014-05-02 17:07:49 +0200340 }
341
342 // Lets set the alpha to the one it currently has, as its currently being dragged
Selim Cinekb036ca42015-02-20 15:56:28 +0100343 StackViewState viewState = resultState.getViewStateForView(draggedView);
Selim Cinekeb973562014-05-02 17:07:49 +0200344 // The dragged child should keep the set alpha
345 viewState.alpha = draggedView.getAlpha();
346 }
347 }
Selim Cinek343e6e22014-04-11 21:23:30 +0200348 }
Selim Cinek67b22602014-03-10 15:40:16 +0100349
Selim Cinek343e6e22014-04-11 21:23:30 +0200350 /**
Jorim Jaggid4a57442014-04-10 02:45:55 +0200351 * Update the visible children on the state.
352 */
353 private void updateVisibleChildren(StackScrollState resultState,
Selim Cineka4baaa32015-04-20 14:27:54 -0700354 StackScrollAlgorithmState state) {
Jorim Jaggid4a57442014-04-10 02:45:55 +0200355 ViewGroup hostView = resultState.getHostView();
356 int childCount = hostView.getChildCount();
357 state.visibleChildren.clear();
358 state.visibleChildren.ensureCapacity(childCount);
Selim Cinekb036ca42015-02-20 15:56:28 +0100359 int notGoneIndex = 0;
Jorim Jaggid4a57442014-04-10 02:45:55 +0200360 for (int i = 0; i < childCount; i++) {
Jorim Jaggibe565df2014-04-28 17:51:23 +0200361 ExpandableView v = (ExpandableView) hostView.getChildAt(i);
Jorim Jaggid4a57442014-04-10 02:45:55 +0200362 if (v.getVisibility() != View.GONE) {
Selim Cineka4baaa32015-04-20 14:27:54 -0700363 notGoneIndex = updateNotGoneIndex(resultState, state, notGoneIndex, v);
Selim Cinekb5605e52015-02-20 18:21:41 +0100364 if (v instanceof ExpandableNotificationRow) {
365 ExpandableNotificationRow row = (ExpandableNotificationRow) v;
Selim Cinekb8f09cf2015-03-16 17:09:28 -0700366
367 // handle the notgoneIndex for the children as well
Selim Cinekb5605e52015-02-20 18:21:41 +0100368 List<ExpandableNotificationRow> children =
369 row.getNotificationChildren();
Selim Cinek83bc7832015-10-22 13:26:54 -0700370 if (row.isSummaryWithChildren() && children != null) {
Selim Cinekb5605e52015-02-20 18:21:41 +0100371 for (ExpandableNotificationRow childRow : children) {
372 if (childRow.getVisibility() != View.GONE) {
373 StackViewState childState
374 = resultState.getViewStateForView(childRow);
375 childState.notGoneIndex = notGoneIndex;
376 notGoneIndex++;
377 }
378 }
379 }
380 }
Jorim Jaggid4a57442014-04-10 02:45:55 +0200381 }
382 }
383 }
384
Selim Cinekb8f09cf2015-03-16 17:09:28 -0700385 private int updateNotGoneIndex(StackScrollState resultState,
386 StackScrollAlgorithmState state, int notGoneIndex,
387 ExpandableView v) {
388 StackViewState viewState = resultState.getViewStateForView(v);
389 viewState.notGoneIndex = notGoneIndex;
390 state.visibleChildren.add(v);
391 notGoneIndex++;
392 return notGoneIndex;
393 }
394
Jorim Jaggid4a57442014-04-10 02:45:55 +0200395 /**
Selim Cinek67b22602014-03-10 15:40:16 +0100396 * Determine the positions for the views. This is the main part of the algorithm.
397 *
Selim Cinek684a4422015-04-15 16:18:39 -0700398 * @param resultState The result state to update if a change to the properties of a child occurs
Selim Cinek67b22602014-03-10 15:40:16 +0100399 * @param algorithmState The state in which the current pass of the algorithm is currently in
Selim Cinekb8f09cf2015-03-16 17:09:28 -0700400 * @param ambientState The current ambient state
Selim Cinek67b22602014-03-10 15:40:16 +0100401 */
402 private void updatePositionsForState(StackScrollState resultState,
Selim Cinekb8f09cf2015-03-16 17:09:28 -0700403 StackScrollAlgorithmState algorithmState, AmbientState ambientState) {
Selim Cinek67b22602014-03-10 15:40:16 +0100404
Selim Cinek1685e632014-04-08 02:27:49 +0200405 // The starting position of the bottom stack peek
Selim Cinekb8f09cf2015-03-16 17:09:28 -0700406 float bottomPeekStart = ambientState.getInnerHeight() - mBottomStackPeekSize;
Selim Cinek1685e632014-04-08 02:27:49 +0200407
Selim Cinek67b22602014-03-10 15:40:16 +0100408 // The position where the bottom stack starts.
Selim Cinek34c0a8d2014-05-12 00:01:43 +0200409 float bottomStackStart = bottomPeekStart - mBottomStackSlowDownLength;
Selim Cinek67b22602014-03-10 15:40:16 +0100410
411 // The y coordinate of the current child.
412 float currentYPosition = 0.0f;
413
414 // How far in is the element currently transitioning into the bottom stack.
415 float yPositionInScrollView = 0.0f;
416
Selim Cineka59ecc32015-04-07 10:51:49 -0700417 // If we have a heads-up higher than the collapsed height we need to add the difference to
418 // the padding of all other elements, i.e push in the top stack slightly.
419 ExpandableNotificationRow topHeadsUpEntry = ambientState.getTopHeadsUpEntry();
420
Jorim Jaggid4a57442014-04-10 02:45:55 +0200421 int childCount = algorithmState.visibleChildren.size();
Selim Cinekf92a1fd2015-07-31 16:10:32 -0700422 int numberOfElementsCompletelyIn = algorithmState.partialInTop == 1.0f
423 ? algorithmState.lastTopStackIndex
424 : (int) algorithmState.itemsInTopStack;
Selim Cinek67b22602014-03-10 15:40:16 +0100425 for (int i = 0; i < childCount; i++) {
Jorim Jaggibe565df2014-04-28 17:51:23 +0200426 ExpandableView child = algorithmState.visibleChildren.get(i);
Selim Cinekb036ca42015-02-20 15:56:28 +0100427 StackViewState childViewState = resultState.getViewStateForView(child);
428 childViewState.location = StackViewState.LOCATION_UNKNOWN;
Selim Cineka59ecc32015-04-07 10:51:49 -0700429 int childHeight = getMaxAllowedChildHeight(child, ambientState);
Selim Cinek3e881372015-12-10 15:13:42 -0800430 int minHeight = child.getMinHeight();
Selim Cinek67b22602014-03-10 15:40:16 +0100431 float yPositionInScrollViewAfterElement = yPositionInScrollView
432 + childHeight
433 + mPaddingBetweenElements;
Selim Cinek816c8e42015-11-19 12:00:45 -0800434 float scrollOffset = yPositionInScrollView - algorithmState.scrollY +
435 mFirstChildMinHeight;
Selim Cinek343e6e22014-04-11 21:23:30 +0200436
437 if (i == algorithmState.lastTopStackIndex + 1) {
438 // Normally the position of this child is the position in the regular scrollview,
439 // but if the two stacks are very close to each other,
440 // then have have to push it even more upwards to the position of the bottom
441 // stack start.
442 currentYPosition = Math.min(scrollOffset, bottomStackStart);
443 }
444 childViewState.yTranslation = currentYPosition;
445
446 // The y position after this element
447 float nextYPosition = currentYPosition + childHeight +
448 mPaddingBetweenElements;
449
450 if (i <= algorithmState.lastTopStackIndex) {
Selim Cinek67b22602014-03-10 15:40:16 +0100451 // Case 1:
452 // We are in the top Stack
Selim Cinek343e6e22014-04-11 21:23:30 +0200453 updateStateForTopStackChild(algorithmState,
454 numberOfElementsCompletelyIn, i, childHeight, childViewState, scrollOffset);
Selim Cinek3afd00e2014-08-11 22:32:57 +0200455 clampPositionToTopStackEnd(childViewState, childHeight);
456
Selim Cinek343e6e22014-04-11 21:23:30 +0200457 // check if we are overlapping with the bottom stack
458 if (childViewState.yTranslation + childHeight + mPaddingBetweenElements
Selim Cinek3e881372015-12-10 15:13:42 -0800459 >= bottomStackStart && !mIsExpansionChanging && i != 0) {
Selim Cinek3afd00e2014-08-11 22:32:57 +0200460 // we just collapse this element slightly
461 int newSize = (int) Math.max(bottomStackStart - mPaddingBetweenElements -
Selim Cinek3e881372015-12-10 15:13:42 -0800462 childViewState.yTranslation, minHeight);
Selim Cinek3afd00e2014-08-11 22:32:57 +0200463 childViewState.height = newSize;
Selim Cinek4581cf82014-08-12 12:40:32 +0200464 updateStateForChildTransitioningInBottom(algorithmState, bottomStackStart,
Selim Cinek816c8e42015-11-19 12:00:45 -0800465 child, childViewState.yTranslation, childViewState,
Selim Cinek4581cf82014-08-12 12:40:32 +0200466 childHeight);
Selim Cinek343e6e22014-04-11 21:23:30 +0200467 }
Selim Cinekb8f09cf2015-03-16 17:09:28 -0700468 clampPositionToBottomStackStart(childViewState, childViewState.height,
Selim Cinek3e881372015-12-10 15:13:42 -0800469 minHeight, ambientState);
Selim Cinek343e6e22014-04-11 21:23:30 +0200470 } else if (nextYPosition >= bottomStackStart) {
Selim Cinek67b22602014-03-10 15:40:16 +0100471 // Case 2:
Selim Cinek343e6e22014-04-11 21:23:30 +0200472 // We are in the bottom stack.
473 if (currentYPosition >= bottomStackStart) {
Selim Cinek67b22602014-03-10 15:40:16 +0100474 // According to the regular scroll view we are fully translated out of the
475 // bottom of the screen so we are fully in the bottom stack
Selim Cinek343e6e22014-04-11 21:23:30 +0200476 updateStateForChildFullyInBottomStack(algorithmState,
Selim Cinek3e881372015-12-10 15:13:42 -0800477 bottomStackStart, childViewState, minHeight, ambientState);
Selim Cinek67b22602014-03-10 15:40:16 +0100478 } else {
Selim Cinek67b22602014-03-10 15:40:16 +0100479 // According to the regular scroll view we are currently translating out of /
480 // into the bottom of the screen
Selim Cinek343e6e22014-04-11 21:23:30 +0200481 updateStateForChildTransitioningInBottom(algorithmState,
Selim Cinek816c8e42015-11-19 12:00:45 -0800482 bottomStackStart, child, currentYPosition,
Selim Cinek343e6e22014-04-11 21:23:30 +0200483 childViewState, childHeight);
Selim Cinek67b22602014-03-10 15:40:16 +0100484 }
Christoph Studer6e3eceb2014-04-01 18:40:27 +0200485 } else {
Selim Cinek343e6e22014-04-11 21:23:30 +0200486 // Case 3:
487 // We are in the regular scroll area.
Selim Cinekb036ca42015-02-20 15:56:28 +0100488 childViewState.location = StackViewState.LOCATION_MAIN_AREA;
Selim Cinekb8f09cf2015-03-16 17:09:28 -0700489 clampYTranslation(childViewState, childHeight, ambientState);
Christoph Studer6e3eceb2014-04-01 18:40:27 +0200490 }
Selim Cinek343e6e22014-04-11 21:23:30 +0200491
Christoph Studer6e3eceb2014-04-01 18:40:27 +0200492 // The first card is always rendered.
493 if (i == 0) {
494 childViewState.alpha = 1.0f;
Selim Cinek816c8e42015-11-19 12:00:45 -0800495 childViewState.yTranslation = Math.max(
496 mFirstChildMinHeight - algorithmState.scrollY, 0);
Selim Cinekd83771e2014-07-04 16:45:31 +0200497 if (childViewState.yTranslation + childViewState.height
498 > bottomPeekStart - mCollapseSecondCardPadding) {
Selim Cinek4fe3e472014-07-03 16:32:54 +0200499 childViewState.height = (int) Math.max(
Selim Cinekd83771e2014-07-04 16:45:31 +0200500 bottomPeekStart - mCollapseSecondCardPadding
Selim Cinek816c8e42015-11-19 12:00:45 -0800501 - childViewState.yTranslation, mFirstChildMinHeight);
Selim Cinek4fe3e472014-07-03 16:32:54 +0200502 }
Selim Cinekb036ca42015-02-20 15:56:28 +0100503 childViewState.location = StackViewState.LOCATION_FIRST_CARD;
Christoph Studer6e3eceb2014-04-01 18:40:27 +0200504 }
Selim Cinekb036ca42015-02-20 15:56:28 +0100505 if (childViewState.location == StackViewState.LOCATION_UNKNOWN) {
Christoph Studer6e3eceb2014-04-01 18:40:27 +0200506 Log.wtf(LOG_TAG, "Failed to assign location for child " + i);
Selim Cinek67b22602014-03-10 15:40:16 +0100507 }
Selim Cinek343e6e22014-04-11 21:23:30 +0200508 currentYPosition = childViewState.yTranslation + childHeight + mPaddingBetweenElements;
Selim Cinek67b22602014-03-10 15:40:16 +0100509 yPositionInScrollView = yPositionInScrollViewAfterElement;
Jorim Jaggi8c1a44b2014-04-29 19:04:02 +0200510
Selim Cineka59ecc32015-04-07 10:51:49 -0700511 if (ambientState.isShadeExpanded() && topHeadsUpEntry != null
512 && child != topHeadsUpEntry) {
Selim Cinek816c8e42015-11-19 12:00:45 -0800513 childViewState.yTranslation += topHeadsUpEntry.getHeadsUpHeight() -
514 mFirstChildMinHeight;
Selim Cineka59ecc32015-04-07 10:51:49 -0700515 }
Selim Cinekb8f09cf2015-03-16 17:09:28 -0700516 childViewState.yTranslation += ambientState.getTopPadding()
Selim Cineka59ecc32015-04-07 10:51:49 -0700517 + ambientState.getStackTranslation();
Selim Cinekb8f09cf2015-03-16 17:09:28 -0700518 }
Selim Cineka4baaa32015-04-20 14:27:54 -0700519 updateHeadsUpStates(resultState, algorithmState, ambientState);
Selim Cinekb8f09cf2015-03-16 17:09:28 -0700520 }
521
Selim Cineka4baaa32015-04-20 14:27:54 -0700522 private void updateHeadsUpStates(StackScrollState resultState,
523 StackScrollAlgorithmState algorithmState, AmbientState ambientState) {
524 int childCount = algorithmState.visibleChildren.size();
525 ExpandableNotificationRow topHeadsUpEntry = null;
526 for (int i = 0; i < childCount; i++) {
527 View child = algorithmState.visibleChildren.get(i);
528 if (!(child instanceof ExpandableNotificationRow)) {
529 break;
530 }
531 ExpandableNotificationRow row = (ExpandableNotificationRow) child;
532 if (!row.isHeadsUp()) {
533 break;
534 } else if (topHeadsUpEntry == null) {
535 topHeadsUpEntry = row;
536 }
Selim Cinekb8f09cf2015-03-16 17:09:28 -0700537 StackViewState childState = resultState.getViewStateForView(row);
Selim Cinek1f3f5442015-04-10 17:54:46 -0700538 boolean isTopEntry = topHeadsUpEntry == row;
Selim Cinek131c1e22015-05-11 19:04:49 -0700539 if (mIsExpanded) {
540 if (isTopEntry) {
Selim Cinek816c8e42015-11-19 12:00:45 -0800541 childState.height += row.getHeadsUpHeight() - mFirstChildMinHeight;
Selim Cinek131c1e22015-05-11 19:04:49 -0700542 }
543 childState.height = Math.max(childState.height, row.getHeadsUpHeight());
544 // Ensure that the heads up is always visible even when scrolled off from the bottom
545 float bottomPosition = ambientState.getMaxHeadsUpTranslation() - childState.height;
546 childState.yTranslation = Math.min(childState.yTranslation,
547 bottomPosition);
548 }
Selim Cinek684a4422015-04-15 16:18:39 -0700549 if (row.isPinned()) {
Selim Cinek79d79c42015-05-21 16:14:45 -0700550 childState.yTranslation = Math.max(childState.yTranslation,
551 mNotificationsTopPadding);
Selim Cinek496126a2015-12-11 17:02:17 -0800552 childState.height = Math.max(row.getHeadsUpHeight(), childState.height);
Selim Cinek1f3f5442015-04-10 17:54:46 -0700553 if (!isTopEntry) {
Selim Cinek684a4422015-04-15 16:18:39 -0700554 // Ensure that a headsUp doesn't vertically extend further than the heads-up at
555 // the top most z-position
Selim Cinek1f3f5442015-04-10 17:54:46 -0700556 StackViewState topState = resultState.getViewStateForView(topHeadsUpEntry);
557 childState.height = row.getHeadsUpHeight();
Selim Cineke53e6bb2015-04-13 16:14:26 -0700558 childState.yTranslation = topState.yTranslation + topState.height
559 - childState.height;
Selim Cinek1f3f5442015-04-10 17:54:46 -0700560 }
Selim Cinekb8f09cf2015-03-16 17:09:28 -0700561 }
Selim Cinekb8f09cf2015-03-16 17:09:28 -0700562 }
Selim Cinek67b22602014-03-10 15:40:16 +0100563 }
564
Selim Cinek1685e632014-04-08 02:27:49 +0200565 /**
Selim Cinek343e6e22014-04-11 21:23:30 +0200566 * Clamp the yTranslation both up and down to valid positions.
Selim Cinek1685e632014-04-08 02:27:49 +0200567 *
Selim Cinek1685e632014-04-08 02:27:49 +0200568 * @param childViewState the view state of the child
Selim Cinek3e881372015-12-10 15:13:42 -0800569 * @param minHeight the minimum height of this child
Selim Cinek1685e632014-04-08 02:27:49 +0200570 */
Selim Cinek3e881372015-12-10 15:13:42 -0800571 private void clampYTranslation(StackViewState childViewState, int minHeight,
Selim Cinekb8f09cf2015-03-16 17:09:28 -0700572 AmbientState ambientState) {
Selim Cinek3e881372015-12-10 15:13:42 -0800573 clampPositionToBottomStackStart(childViewState, childViewState.height, minHeight,
574 ambientState);
575 clampPositionToTopStackEnd(childViewState, childViewState.height);
Selim Cinek343e6e22014-04-11 21:23:30 +0200576 }
577
578 /**
579 * Clamp the yTranslation of the child down such that its end is at most on the beginning of
580 * the bottom stack.
581 *
582 * @param childViewState the view state of the child
583 * @param childHeight the height of this child
Selim Cinek3e881372015-12-10 15:13:42 -0800584 * @param minHeight the minumum Height of the View
Selim Cinek343e6e22014-04-11 21:23:30 +0200585 */
Selim Cinekb036ca42015-02-20 15:56:28 +0100586 private void clampPositionToBottomStackStart(StackViewState childViewState,
Selim Cinek3e881372015-12-10 15:13:42 -0800587 int childHeight, int minHeight, AmbientState ambientState) {
588
589 int bottomStackStart = ambientState.getInnerHeight()
590 - mBottomStackPeekSize - mCollapseSecondCardPadding;
591 int childStart = bottomStackStart - childHeight;
592 if (childStart < childViewState.yTranslation) {
593 float newHeight = bottomStackStart - childViewState.yTranslation;
594 if (newHeight < minHeight) {
595 newHeight = minHeight;
596 childViewState.yTranslation = bottomStackStart - minHeight;
597 }
598 childViewState.height = (int) newHeight;
599 }
Selim Cinek343e6e22014-04-11 21:23:30 +0200600 }
601
602 /**
603 * Clamp the yTranslation of the child up such that its end is at lest on the end of the top
Selim Cineka59ecc32015-04-07 10:51:49 -0700604 * stack.
Selim Cinek343e6e22014-04-11 21:23:30 +0200605 *
606 * @param childViewState the view state of the child
607 * @param childHeight the height of this child
608 */
Selim Cinekb036ca42015-02-20 15:56:28 +0100609 private void clampPositionToTopStackEnd(StackViewState childViewState,
Selim Cinek343e6e22014-04-11 21:23:30 +0200610 int childHeight) {
611 childViewState.yTranslation = Math.max(childViewState.yTranslation,
Selim Cinek816c8e42015-11-19 12:00:45 -0800612 mFirstChildMinHeight - childHeight);
Selim Cinek1685e632014-04-08 02:27:49 +0200613 }
614
Selim Cineka59ecc32015-04-07 10:51:49 -0700615 private int getMaxAllowedChildHeight(View child, AmbientState ambientState) {
Selim Cinek1685e632014-04-08 02:27:49 +0200616 if (child instanceof ExpandableNotificationRow) {
617 ExpandableNotificationRow row = (ExpandableNotificationRow) child;
Selim Cinekd2281152015-04-10 14:37:46 -0700618 if (ambientState == null && row.isHeadsUp()
619 || ambientState != null && ambientState.getTopHeadsUpEntry() == child) {
Selim Cinek8d490d42015-04-10 00:05:50 -0700620 int extraSize = row.getIntrinsicHeight() - row.getHeadsUpHeight();
Selim Cinek816c8e42015-11-19 12:00:45 -0800621 return mFirstChildMinHeight + extraSize;
Selim Cineka59ecc32015-04-07 10:51:49 -0700622 }
Jorim Jaggi9cbadd32014-05-01 20:18:31 +0200623 return row.getIntrinsicHeight();
Jorim Jaggibe565df2014-04-28 17:51:23 +0200624 } else if (child instanceof ExpandableView) {
625 ExpandableView expandableView = (ExpandableView) child;
Selim Cinek8d5727f2015-04-28 19:17:32 -0700626 return expandableView.getIntrinsicHeight();
Selim Cinek1685e632014-04-08 02:27:49 +0200627 }
Jorim Jaggibe565df2014-04-28 17:51:23 +0200628 return child == null? mCollapsedSize : child.getHeight();
Selim Cinek1685e632014-04-08 02:27:49 +0200629 }
630
Selim Cinek343e6e22014-04-11 21:23:30 +0200631 private void updateStateForChildTransitioningInBottom(StackScrollAlgorithmState algorithmState,
Selim Cinek816c8e42015-11-19 12:00:45 -0800632 float transitioningPositionStart, ExpandableView child, float currentYPosition,
Selim Cinekb036ca42015-02-20 15:56:28 +0100633 StackViewState childViewState, int childHeight) {
Christoph Studer6e3eceb2014-04-01 18:40:27 +0200634
Selim Cinek343e6e22014-04-11 21:23:30 +0200635 // This is the transitioning element on top of bottom stack, calculate how far we are in.
636 algorithmState.partialInBottom = 1.0f - (
637 (transitioningPositionStart - currentYPosition) / (childHeight +
638 mPaddingBetweenElements));
639
640 // the offset starting at the transitionPosition of the bottom stack
641 float offset = mBottomStackIndentationFunctor.getValue(algorithmState.partialInBottom);
642 algorithmState.itemsInBottomStack += algorithmState.partialInBottom;
Selim Cinek3afd00e2014-08-11 22:32:57 +0200643 int newHeight = childHeight;
Selim Cinek3e881372015-12-10 15:13:42 -0800644 if (childHeight > child.getMinHeight()) {
Selim Cinek3afd00e2014-08-11 22:32:57 +0200645 newHeight = (int) Math.max(Math.min(transitioningPositionStart + offset -
Selim Cinek816c8e42015-11-19 12:00:45 -0800646 mPaddingBetweenElements - currentYPosition, childHeight),
647 child.getMinHeight());
Selim Cinek3afd00e2014-08-11 22:32:57 +0200648 childViewState.height = newHeight;
649 }
650 childViewState.yTranslation = transitioningPositionStart + offset - newHeight
Jorim Jaggife40f7d2014-04-28 15:20:04 +0200651 - mPaddingBetweenElements;
Selim Cinek3afd00e2014-08-11 22:32:57 +0200652
Selim Cinek343e6e22014-04-11 21:23:30 +0200653 // We want at least to be at the end of the top stack when collapsing
Selim Cinek3afd00e2014-08-11 22:32:57 +0200654 clampPositionToTopStackEnd(childViewState, newHeight);
Selim Cinekb036ca42015-02-20 15:56:28 +0100655 childViewState.location = StackViewState.LOCATION_MAIN_AREA;
Selim Cinek67b22602014-03-10 15:40:16 +0100656 }
657
Selim Cinek343e6e22014-04-11 21:23:30 +0200658 private void updateStateForChildFullyInBottomStack(StackScrollAlgorithmState algorithmState,
Selim Cinekb036ca42015-02-20 15:56:28 +0100659 float transitioningPositionStart, StackViewState childViewState,
Selim Cinek3e881372015-12-10 15:13:42 -0800660 int minHeight, AmbientState ambientState) {
Selim Cinek343e6e22014-04-11 21:23:30 +0200661 float currentYPosition;
Selim Cinek67b22602014-03-10 15:40:16 +0100662 algorithmState.itemsInBottomStack += 1.0f;
663 if (algorithmState.itemsInBottomStack < MAX_ITEMS_IN_BOTTOM_STACK) {
664 // We are visually entering the bottom stack
Selim Cinek343e6e22014-04-11 21:23:30 +0200665 currentYPosition = transitioningPositionStart
Jorim Jaggife40f7d2014-04-28 15:20:04 +0200666 + mBottomStackIndentationFunctor.getValue(algorithmState.itemsInBottomStack)
667 - mPaddingBetweenElements;
Selim Cinekb036ca42015-02-20 15:56:28 +0100668 childViewState.location = StackViewState.LOCATION_BOTTOM_STACK_PEEKING;
Selim Cinek67b22602014-03-10 15:40:16 +0100669 } else {
670 // we are fully inside the stack
671 if (algorithmState.itemsInBottomStack > MAX_ITEMS_IN_BOTTOM_STACK + 2) {
672 childViewState.alpha = 0.0f;
673 } else if (algorithmState.itemsInBottomStack
674 > MAX_ITEMS_IN_BOTTOM_STACK + 1) {
675 childViewState.alpha = 1.0f - algorithmState.partialInBottom;
676 }
Selim Cinekb036ca42015-02-20 15:56:28 +0100677 childViewState.location = StackViewState.LOCATION_BOTTOM_STACK_HIDDEN;
Selim Cinekb8f09cf2015-03-16 17:09:28 -0700678 currentYPosition = ambientState.getInnerHeight();
Selim Cinek67b22602014-03-10 15:40:16 +0100679 }
Selim Cinek3e881372015-12-10 15:13:42 -0800680 childViewState.height = minHeight;
681 childViewState.yTranslation = currentYPosition - minHeight;
682 clampPositionToTopStackEnd(childViewState, minHeight);
Selim Cinek67b22602014-03-10 15:40:16 +0100683 }
684
Selim Cinek343e6e22014-04-11 21:23:30 +0200685 private void updateStateForTopStackChild(StackScrollAlgorithmState algorithmState,
686 int numberOfElementsCompletelyIn, int i, int childHeight,
Selim Cinekb036ca42015-02-20 15:56:28 +0100687 StackViewState childViewState, float scrollOffset) {
Selim Cinek67b22602014-03-10 15:40:16 +0100688
Selim Cinek67b22602014-03-10 15:40:16 +0100689
690 // First we calculate the index relative to the current stack window of size at most
691 // {@link #MAX_ITEMS_IN_TOP_STACK}
Selim Cinek343e6e22014-04-11 21:23:30 +0200692 int paddedIndex = i - 1
Selim Cinek67b22602014-03-10 15:40:16 +0100693 - Math.max(numberOfElementsCompletelyIn - MAX_ITEMS_IN_TOP_STACK, 0);
694 if (paddedIndex >= 0) {
Selim Cinek343e6e22014-04-11 21:23:30 +0200695
Selim Cinek67b22602014-03-10 15:40:16 +0100696 // We are currently visually entering the top stack
Selim Cinekad3e5af2014-07-04 12:24:11 +0200697 float distanceToStack = (childHeight + mPaddingBetweenElements)
698 - algorithmState.scrolledPixelsTop;
699 if (i == algorithmState.lastTopStackIndex
700 && distanceToStack > (mTopStackTotalSize + mPaddingBetweenElements)) {
Selim Cinek343e6e22014-04-11 21:23:30 +0200701
702 // Child is currently translating into stack but not yet inside slow down zone.
703 // Handle it like the regular scrollview.
704 childViewState.yTranslation = scrollOffset;
Christoph Studer6e3eceb2014-04-01 18:40:27 +0200705 } else {
Selim Cinek343e6e22014-04-11 21:23:30 +0200706 // Apply stacking logic.
707 float numItemsBefore;
708 if (i == algorithmState.lastTopStackIndex) {
Selim Cinekad3e5af2014-07-04 12:24:11 +0200709 numItemsBefore = 1.0f
710 - (distanceToStack / (mTopStackTotalSize + mPaddingBetweenElements));
Selim Cinek343e6e22014-04-11 21:23:30 +0200711 } else {
712 numItemsBefore = algorithmState.itemsInTopStack - i;
713 }
714 // The end position of the current child
Selim Cinek816c8e42015-11-19 12:00:45 -0800715 float currentChildEndY = mFirstChildMinHeight + mTopStackTotalSize
Selim Cinekad3e5af2014-07-04 12:24:11 +0200716 - mTopStackIndentationFunctor.getValue(numItemsBefore);
Selim Cinek343e6e22014-04-11 21:23:30 +0200717 childViewState.yTranslation = currentChildEndY - childHeight;
Selim Cinek67b22602014-03-10 15:40:16 +0100718 }
Selim Cinekb036ca42015-02-20 15:56:28 +0100719 childViewState.location = StackViewState.LOCATION_TOP_STACK_PEEKING;
Selim Cinek67b22602014-03-10 15:40:16 +0100720 } else {
Selim Cinek343e6e22014-04-11 21:23:30 +0200721 if (paddedIndex == -1) {
722 childViewState.alpha = 1.0f - algorithmState.partialInTop;
723 } else {
724 // We are hidden behind the top card and faded out, so we can hide ourselves.
725 childViewState.alpha = 0.0f;
726 }
Selim Cinek816c8e42015-11-19 12:00:45 -0800727 childViewState.yTranslation = mFirstChildMinHeight - childHeight;
Selim Cinekb036ca42015-02-20 15:56:28 +0100728 childViewState.location = StackViewState.LOCATION_TOP_STACK_HIDDEN;
Selim Cinek67b22602014-03-10 15:40:16 +0100729 }
Selim Cinek343e6e22014-04-11 21:23:30 +0200730
731
Selim Cinek67b22602014-03-10 15:40:16 +0100732 }
733
734 /**
735 * Find the number of items in the top stack and update the result state if needed.
736 *
737 * @param resultState The result state to update if a height change of an child occurs
738 * @param algorithmState The state in which the current pass of the algorithm is currently in
Selim Cinek67b22602014-03-10 15:40:16 +0100739 */
740 private void findNumberOfItemsInTopStackAndUpdateState(StackScrollState resultState,
Selim Cinekb8f09cf2015-03-16 17:09:28 -0700741 StackScrollAlgorithmState algorithmState, AmbientState ambientState) {
Selim Cinek67b22602014-03-10 15:40:16 +0100742
743 // The y Position if the element would be in a regular scrollView
744 float yPositionInScrollView = 0.0f;
Jorim Jaggid4a57442014-04-10 02:45:55 +0200745 int childCount = algorithmState.visibleChildren.size();
Selim Cinek67b22602014-03-10 15:40:16 +0100746
747 // find the number of elements in the top stack.
748 for (int i = 0; i < childCount; i++) {
Jorim Jaggibe565df2014-04-28 17:51:23 +0200749 ExpandableView child = algorithmState.visibleChildren.get(i);
Selim Cinekb036ca42015-02-20 15:56:28 +0100750 StackViewState childViewState = resultState.getViewStateForView(child);
Selim Cineka59ecc32015-04-07 10:51:49 -0700751 int childHeight = getMaxAllowedChildHeight(child, ambientState);
Selim Cinek67b22602014-03-10 15:40:16 +0100752 float yPositionInScrollViewAfterElement = yPositionInScrollView
753 + childHeight
754 + mPaddingBetweenElements;
755 if (yPositionInScrollView < algorithmState.scrollY) {
Selim Cinek816c8e42015-11-19 12:00:45 -0800756 if (i == 0 && algorithmState.scrollY <= mFirstChildMinHeight) {
Selim Cinek343e6e22014-04-11 21:23:30 +0200757
758 // The starting position of the bottom stack peek
Selim Cinekb8f09cf2015-03-16 17:09:28 -0700759 int bottomPeekStart = ambientState.getInnerHeight() - mBottomStackPeekSize -
Selim Cinekd83771e2014-07-04 16:45:31 +0200760 mCollapseSecondCardPadding;
Selim Cinek343e6e22014-04-11 21:23:30 +0200761 // Collapse and expand the first child while the shade is being expanded
762 float maxHeight = mIsExpansionChanging && child == mFirstChildWhileExpanding
763 ? mFirstChildMaxHeight
764 : childHeight;
765 childViewState.height = (int) Math.max(Math.min(bottomPeekStart, maxHeight),
Selim Cinek816c8e42015-11-19 12:00:45 -0800766 mFirstChildMinHeight);
Selim Cinek343e6e22014-04-11 21:23:30 +0200767 algorithmState.itemsInTopStack = 1.0f;
768
769 } else if (yPositionInScrollViewAfterElement < algorithmState.scrollY) {
Selim Cinek67b22602014-03-10 15:40:16 +0100770 // According to the regular scroll view we are fully off screen
771 algorithmState.itemsInTopStack += 1.0f;
Selim Cinek343e6e22014-04-11 21:23:30 +0200772 if (i == 0) {
Selim Cinek816c8e42015-11-19 12:00:45 -0800773 childViewState.height = child.getMinHeight();
Selim Cinek67b22602014-03-10 15:40:16 +0100774 }
775 } else {
776 // According to the regular scroll view we are partially off screen
Selim Cinek343e6e22014-04-11 21:23:30 +0200777
Selim Cinek67b22602014-03-10 15:40:16 +0100778 // How much did we scroll into this child
Selim Cinekad3e5af2014-07-04 12:24:11 +0200779 algorithmState.scrolledPixelsTop = algorithmState.scrollY
780 - yPositionInScrollView;
Selim Cinek343e6e22014-04-11 21:23:30 +0200781 algorithmState.partialInTop = (algorithmState.scrolledPixelsTop) / (childHeight
Selim Cinek67b22602014-03-10 15:40:16 +0100782 + mPaddingBetweenElements);
783
784 // Our element can be expanded, so this can get negative
785 algorithmState.partialInTop = Math.max(0.0f, algorithmState.partialInTop);
786 algorithmState.itemsInTopStack += algorithmState.partialInTop;
Selim Cinekad3e5af2014-07-04 12:24:11 +0200787
Selim Cinek343e6e22014-04-11 21:23:30 +0200788 if (i == 0) {
Selim Cinekad3e5af2014-07-04 12:24:11 +0200789 // If it is expanded we have to collapse it to a new size
790 float newSize = yPositionInScrollViewAfterElement
791 - mPaddingBetweenElements
Selim Cinek816c8e42015-11-19 12:00:45 -0800792 - algorithmState.scrollY + mFirstChildMinHeight;
793 newSize = Math.max(mFirstChildMinHeight, newSize);
Selim Cinek4e456be2014-06-12 18:09:43 +0200794 algorithmState.itemsInTopStack = 1.0f;
Selim Cinek67b22602014-03-10 15:40:16 +0100795 childViewState.height = (int) newSize;
Selim Cinek67b22602014-03-10 15:40:16 +0100796 }
Selim Cinek343e6e22014-04-11 21:23:30 +0200797 algorithmState.lastTopStackIndex = i;
798 break;
Selim Cinek67b22602014-03-10 15:40:16 +0100799 }
800 } else {
Selim Cinek343e6e22014-04-11 21:23:30 +0200801 algorithmState.lastTopStackIndex = i - 1;
Selim Cinek67b22602014-03-10 15:40:16 +0100802 // We are already past the stack so we can end the loop
803 break;
804 }
805 yPositionInScrollView = yPositionInScrollViewAfterElement;
806 }
807 }
808
809 /**
810 * Calculate the Z positions for all children based on the number of items in both stacks and
811 * save it in the resultState
812 *
813 * @param resultState The result state to update the zTranslation values
814 * @param algorithmState The state in which the current pass of the algorithm is currently in
815 */
816 private void updateZValuesForState(StackScrollState resultState,
817 StackScrollAlgorithmState algorithmState) {
Jorim Jaggid4a57442014-04-10 02:45:55 +0200818 int childCount = algorithmState.visibleChildren.size();
Selim Cinek67b22602014-03-10 15:40:16 +0100819 for (int i = 0; i < childCount; i++) {
Jorim Jaggid4a57442014-04-10 02:45:55 +0200820 View child = algorithmState.visibleChildren.get(i);
Selim Cinekb036ca42015-02-20 15:56:28 +0100821 StackViewState childViewState = resultState.getViewStateForView(child);
Selim Cinek67b22602014-03-10 15:40:16 +0100822 if (i < algorithmState.itemsInTopStack) {
823 float stackIndex = algorithmState.itemsInTopStack - i;
Selim Cinekc5baa3e2014-10-29 19:04:19 +0100824
825 // Ensure that the topmost item is a little bit higher than the rest when fully
826 // scrolled, to avoid drawing errors when swiping it out
827 float max = MAX_ITEMS_IN_TOP_STACK + (i == 0 ? 2.5f : 2);
828 stackIndex = Math.min(stackIndex, max);
Selim Cinek4e456be2014-06-12 18:09:43 +0200829 if (i == 0 && algorithmState.itemsInTopStack < 2.0f) {
830
831 // We only have the top item and an additional item in the top stack,
832 // Interpolate the index from 0 to 2 while the second item is
833 // translating in.
834 stackIndex -= 1.0f;
Selim Cinek816c8e42015-11-19 12:00:45 -0800835 if (algorithmState.scrollY > mFirstChildMinHeight) {
Selim Cinek4e456be2014-06-12 18:09:43 +0200836
837 // Since there is a shadow treshhold, we cant just interpolate from 0 to
838 // 2 but we interpolate from 0.1f to 2.0f when scrolled in. The jump in
839 // height will not be noticable since we have padding in between.
840 stackIndex = 0.1f + stackIndex * 1.9f;
841 }
842 }
Selim Cinek67b22602014-03-10 15:40:16 +0100843 childViewState.zTranslation = mZBasicHeight
844 + stackIndex * mZDistanceBetweenElements;
845 } else if (i > (childCount - 1 - algorithmState.itemsInBottomStack)) {
846 float numItemsAbove = i - (childCount - 1 - algorithmState.itemsInBottomStack);
847 float translationZ = mZBasicHeight
848 - numItemsAbove * mZDistanceBetweenElements;
849 childViewState.zTranslation = translationZ;
850 } else {
851 childViewState.zTranslation = mZBasicHeight;
852 }
853 }
854 }
855
Selim Cinek1685e632014-04-08 02:27:49 +0200856 public void onExpansionStarted(StackScrollState currentState) {
857 mIsExpansionChanging = true;
858 mExpandedOnStart = mIsExpanded;
859 ViewGroup hostView = currentState.getHostView();
860 updateFirstChildHeightWhileExpanding(hostView);
861 }
862
863 private void updateFirstChildHeightWhileExpanding(ViewGroup hostView) {
Jorim Jaggibe565df2014-04-28 17:51:23 +0200864 mFirstChildWhileExpanding = (ExpandableView) findFirstVisibleChild(hostView);
Jorim Jaggi9f347ae2014-04-11 00:47:18 +0200865 if (mFirstChildWhileExpanding != null) {
Selim Cinek1685e632014-04-08 02:27:49 +0200866 if (mExpandedOnStart) {
867
868 // We are collapsing the shade, so the first child can get as most as high as the
Selim Cinek02af41e2014-10-14 15:46:43 +0200869 // current height or the end value of the animation.
870 mFirstChildMaxHeight = StackStateAnimator.getFinalActualHeight(
871 mFirstChildWhileExpanding);
Selim Cinekd2281152015-04-10 14:37:46 -0700872 if (mFirstChildWhileExpanding instanceof ExpandableNotificationRow) {
873 ExpandableNotificationRow row =
874 (ExpandableNotificationRow) mFirstChildWhileExpanding;
875 if (row.isHeadsUp()) {
Selim Cinek816c8e42015-11-19 12:00:45 -0800876 mFirstChildMaxHeight += mFirstChildMinHeight - row.getHeadsUpHeight();
Selim Cinekd2281152015-04-10 14:37:46 -0700877 }
878 }
Selim Cinek1685e632014-04-08 02:27:49 +0200879 } else {
Selim Cinek31094df2014-08-14 19:28:15 +0200880 updateFirstChildMaxSizeToMaxHeight();
Selim Cinek1685e632014-04-08 02:27:49 +0200881 }
882 } else {
Selim Cinek1685e632014-04-08 02:27:49 +0200883 mFirstChildMaxHeight = 0;
884 }
885 }
886
Selim Cinek31094df2014-08-14 19:28:15 +0200887 private void updateFirstChildMaxSizeToMaxHeight() {
888 // We are expanding the shade, expand it to its full height.
889 if (!isMaxSizeInitialized(mFirstChildWhileExpanding)) {
890
891 // This child was not layouted yet, wait for a layout pass
892 mFirstChildWhileExpanding
893 .addOnLayoutChangeListener(new View.OnLayoutChangeListener() {
894 @Override
895 public void onLayoutChange(View v, int left, int top, int right,
896 int bottom, int oldLeft, int oldTop, int oldRight,
897 int oldBottom) {
898 if (mFirstChildWhileExpanding != null) {
899 mFirstChildMaxHeight = getMaxAllowedChildHeight(
Selim Cineka59ecc32015-04-07 10:51:49 -0700900 mFirstChildWhileExpanding, null);
Selim Cinek31094df2014-08-14 19:28:15 +0200901 } else {
902 mFirstChildMaxHeight = 0;
903 }
904 v.removeOnLayoutChangeListener(this);
905 }
906 });
907 } else {
Selim Cineka59ecc32015-04-07 10:51:49 -0700908 mFirstChildMaxHeight = getMaxAllowedChildHeight(mFirstChildWhileExpanding, null);
Selim Cinek31094df2014-08-14 19:28:15 +0200909 }
910 }
911
Selim Cinek7d447722014-06-10 15:51:59 +0200912 private boolean isMaxSizeInitialized(ExpandableView child) {
913 if (child instanceof ExpandableNotificationRow) {
914 ExpandableNotificationRow row = (ExpandableNotificationRow) child;
Selim Cinek31094df2014-08-14 19:28:15 +0200915 return row.isMaxExpandHeightInitialized();
Selim Cinek7d447722014-06-10 15:51:59 +0200916 }
917 return child == null || child.getWidth() != 0;
918 }
919
Jorim Jaggi9f347ae2014-04-11 00:47:18 +0200920 private View findFirstVisibleChild(ViewGroup container) {
921 int childCount = container.getChildCount();
922 for (int i = 0; i < childCount; i++) {
923 View child = container.getChildAt(i);
924 if (child.getVisibility() != View.GONE) {
925 return child;
926 }
927 }
928 return null;
929 }
930
Selim Cinek1685e632014-04-08 02:27:49 +0200931 public void onExpansionStopped() {
932 mIsExpansionChanging = false;
933 mFirstChildWhileExpanding = null;
934 }
935
936 public void setIsExpanded(boolean isExpanded) {
937 this.mIsExpanded = isExpanded;
938 }
939
Selim Cinekaf0dc312015-12-15 17:01:44 -0800940 public void notifyChildrenSizesChanged(final NotificationStackScrollLayout hostView) {
Selim Cinek816c8e42015-11-19 12:00:45 -0800941 int firstItemMinHeight = hostView.getFirstItemMinHeight();
942 if (firstItemMinHeight != mFirstChildMinHeight) {
943 mFirstChildMinHeight = firstItemMinHeight;
944 }
Selim Cinek1685e632014-04-08 02:27:49 +0200945 if (mIsExpansionChanging) {
Selim Cinek02af41e2014-10-14 15:46:43 +0200946 hostView.post(new Runnable() {
947 @Override
948 public void run() {
949 updateFirstChildHeightWhileExpanding(hostView);
950 }
951 });
Selim Cinek1685e632014-04-08 02:27:49 +0200952 }
953 }
954
Selim Cinek34c0a8d2014-05-12 00:01:43 +0200955 public void setDimmed(boolean dimmed) {
Selim Cinekaf0dc312015-12-15 17:01:44 -0800956 mDimmed = dimmed;
957 updatePadding();
Selim Cinek34c0a8d2014-05-12 00:01:43 +0200958 }
959
Selim Cinek31094df2014-08-14 19:28:15 +0200960 public void onReset(ExpandableView view) {
961 if (view.equals(mFirstChildWhileExpanding)) {
962 updateFirstChildMaxSizeToMaxHeight();
963 }
964 }
965
Selim Cinekd2281152015-04-10 14:37:46 -0700966 public void setHeadsUpManager(HeadsUpManager headsUpManager) {
967 mHeadsUpManager = headsUpManager;
968 }
969
Selim Cinek67b22602014-03-10 15:40:16 +0100970 class StackScrollAlgorithmState {
971
972 /**
973 * The scroll position of the algorithm
974 */
975 public int scrollY;
976
977 /**
978 * The quantity of items which are in the top stack.
979 */
980 public float itemsInTopStack;
981
982 /**
983 * how far in is the element currently transitioning into the top stack
984 */
985 public float partialInTop;
986
987 /**
Selim Cinek343e6e22014-04-11 21:23:30 +0200988 * The number of pixels the last child in the top stack has scrolled in to the stack
989 */
990 public float scrolledPixelsTop;
991
992 /**
Selim Cinek67b22602014-03-10 15:40:16 +0100993 * The last item index which is in the top stack.
Selim Cinek67b22602014-03-10 15:40:16 +0100994 */
995 public int lastTopStackIndex;
996
997 /**
998 * The quantity of items which are in the bottom stack.
999 */
1000 public float itemsInBottomStack;
1001
1002 /**
1003 * how far in is the element currently transitioning into the bottom stack
1004 */
1005 public float partialInBottom;
Jorim Jaggid4a57442014-04-10 02:45:55 +02001006
1007 /**
1008 * The children from the host view which are not gone.
1009 */
Jorim Jaggibe565df2014-04-28 17:51:23 +02001010 public final ArrayList<ExpandableView> visibleChildren = new ArrayList<ExpandableView>();
Selim Cinek67b22602014-03-10 15:40:16 +01001011 }
1012
1013}