packages/SystemUI/src/com/android/systemui/recents/views/TaskStackLayoutAlgorithm.java

   1 /*
   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
  17 package com.android.systemui.recents.views;
  18
  19 import android.annotation.IntDef;
  20 import android.content.Context;
  21 import android.content.res.Configuration;
  22 import android.content.res.Resources;
  23 import android.graphics.Path;
  24 import android.graphics.Rect;
  25 import android.util.ArraySet;
  26 import android.util.MutableFloat;
  27 import android.util.SparseArray;
  28 import android.util.SparseIntArray;
  29 import android.view.ViewDebug;
  30
  31 import com.android.systemui.R;
  32 import com.android.systemui.recents.Recents;
  33 import com.android.systemui.recents.RecentsActivityLaunchState;
  34 import com.android.systemui.recents.RecentsConfiguration;
  35 import com.android.systemui.recents.RecentsDebugFlags;
  36 import com.android.systemui.recents.misc.FreePathInterpolator;
  37 import com.android.systemui.recents.misc.SystemServicesProxy;
  38 import com.android.systemui.recents.misc.Utilities;
  39 import com.android.systemui.recents.model.Task;
  40 import com.android.systemui.recents.model.TaskStack;
  41
  42 import java.io.PrintWriter;
  43 import java.lang.annotation.Retention;
  44 import java.lang.annotation.RetentionPolicy;
  45 import java.util.ArrayList;
  46 import java.util.List;
  47
  48 /**
  49  * Used to describe a visible range that can be normalized to [0, 1].
  50  */
  51 class Range {
  52     final float relativeMin;
  53     final float relativeMax;
  54     float origin;
  55     float min;
  56     float max;
  57
  58     public Range(float relMin, float relMax) {
  59         min = relativeMin = relMin;
  60         max = relativeMax = relMax;
  61     }
  62
  63     /**
  64      * Offsets this range to a given absolute position.
  65      */
  66     public void offset(float x) {
  67         this.origin = x;
  68         min = x + relativeMin;
  69         max = x + relativeMax;
  70     }
  71
  72     /**
  73      * Returns x normalized to the range 0 to 1 such that 0 = min, 0.5 = origin and 1 = max
  74      *
  75      * @param x is an absolute value in the same domain as origin
  76      */
  77     public float getNormalizedX(float x) {
  78         if (x < origin) {
  79             return 0.5f + 0.5f * (x - origin) / -relativeMin;
  80         } else {
  81             return 0.5f + 0.5f * (x - origin) / relativeMax;
  82         }
  83     }
  84
  85     /**
  86      * Given a normalized {@param x} value in this range, projected onto the full range to get an
  87      * absolute value about the given {@param origin}.
  88      */
  89     public float getAbsoluteX(float normX) {
  90         if (normX < 0.5f) {
  91             return (normX - 0.5f) / 0.5f * -relativeMin;
  92         } else {
  93             return (normX - 0.5f) / 0.5f * relativeMax;
  94         }
  95     }
  96
  97     /**
  98      * Returns whether a value at an absolute x would be within range.
  99      */
 100     public boolean isInRange(float absX) {
 101         return (absX >= Math.floor(min)) && (absX <= Math.ceil(max));
 102     }
 103 }
 104
 105 /**
 106  * The layout logic for a TaskStackView.  This layout needs to be able to calculate the stack layout
 107  * without an activity-specific context only with the information passed in.  This layout can have
 108  * two states focused and unfocused, and in the focused state, there is a task that is displayed
 109  * more prominently in the stack.
 110  */
 111 public class TaskStackLayoutAlgorithm {
 112
 113     private static final String TAG = "TaskStackLayoutAlgorithm";
 114
 115     // The distribution of view bounds alpha
 116     // XXX: This is a hack because you can currently set the max alpha to be > 1f
 117     public static final float OUTLINE_ALPHA_MIN_VALUE = 0f;
 118     public static final float OUTLINE_ALPHA_MAX_VALUE = 2f;
 119
 120     // The medium/maximum dim on the tasks
 121     private static final float MED_DIM = 0.15f;
 122     private static final float MAX_DIM = 0.25f;
 123
 124     // The various focus states
 125     public static final int STATE_FOCUSED = 1;
 126     public static final int STATE_UNFOCUSED = 0;
 127
 128     // The side that an offset is anchored
 129     @Retention(RetentionPolicy.SOURCE)
 130     @IntDef({FROM_TOP, FROM_BOTTOM})
 131     public @interface AnchorSide {}
 132     private static final int FROM_TOP = 0;
 133     private static final int FROM_BOTTOM = 1;
 134
 135     // The extent that we care about when calculating fractions
 136     @Retention(RetentionPolicy.SOURCE)
 137     @IntDef({WIDTH, HEIGHT})
 138     public @interface Extent {}
 139     private static final int WIDTH = 0;
 140     private static final int HEIGHT = 1;
 141
 142     public interface TaskStackLayoutAlgorithmCallbacks {
 143         void onFocusStateChanged(int prevFocusState, int curFocusState);
 144     }
 145
 146     /**
 147      * The various stack/freeform states.
 148      */
 149     public static class StackState {
 150
 151         public static final StackState FREEFORM_ONLY = new StackState(1f, 255);
 152         public static final StackState STACK_ONLY = new StackState(0f, 0);
 153         public static final StackState SPLIT = new StackState(0.5f, 255);
 154
 155         public final float freeformHeightPct;
 156         public final int freeformBackgroundAlpha;
 157
 158         /**
 159          * @param freeformHeightPct the percentage of the stack height (not including paddings) to
 160          *                          allocate to the freeform workspace
 161          * @param freeformBackgroundAlpha the background alpha for the freeform workspace
 162          */
 163         private StackState(float freeformHeightPct, int freeformBackgroundAlpha) {
 164             this.freeformHeightPct = freeformHeightPct;
 165             this.freeformBackgroundAlpha = freeformBackgroundAlpha;
 166         }
 167
 168         /**
 169          * Resolves the stack state for the layout given a task stack.
 170          */
 171         public static StackState getStackStateForStack(TaskStack stack) {
 172             SystemServicesProxy ssp = Recents.getSystemServices();
 173             boolean hasFreeformWorkspaces = ssp.hasFreeformWorkspaceSupport();
 174             int freeformCount = stack.getFreeformTaskCount();
 175             int stackCount = stack.getStackTaskCount();
 176             if (hasFreeformWorkspaces && stackCount > 0 && freeformCount > 0) {
 177                 return SPLIT;
 178             } else if (hasFreeformWorkspaces && freeformCount > 0) {
 179                 return FREEFORM_ONLY;
 180             } else {
 181                 return STACK_ONLY;
 182             }
 183         }
 184
 185         /**
 186          * Computes the freeform and stack rect for this state.
 187          *
 188          * @param freeformRectOut the freeform rect to be written out
 189          * @param stackRectOut the stack rect, we only write out the top of the stack
 190          * @param taskStackBounds the full rect that the freeform rect can take up
 191          */
 192         public void computeRects(Rect freeformRectOut, Rect stackRectOut,
 193                 Rect taskStackBounds, int topMargin, int freeformGap, int stackBottomOffset) {
 194             // The freeform height is the visible height (not including system insets) - padding
 195             // above freeform and below stack - gap between the freeform and stack
 196             int availableHeight = taskStackBounds.height() - topMargin - stackBottomOffset;
 197             int ffPaddedHeight = (int) (availableHeight * freeformHeightPct);
 198             int ffHeight = Math.max(0, ffPaddedHeight - freeformGap);
 199             freeformRectOut.set(taskStackBounds.left,
 200                     taskStackBounds.top + topMargin,
 201                     taskStackBounds.right,
 202                     taskStackBounds.top + topMargin + ffHeight);
 203             stackRectOut.set(taskStackBounds.left,
 204                     taskStackBounds.top,
 205                     taskStackBounds.right,
 206                     taskStackBounds.bottom);
 207             if (ffPaddedHeight > 0) {
 208                 stackRectOut.top += ffPaddedHeight;
 209             } else {
 210                 stackRectOut.top += topMargin;
 211             }
 212         }
 213     }
 214
 215     // A report of the visibility state of the stack
 216     public class VisibilityReport {
 217         public int numVisibleTasks;
 218         public int numVisibleThumbnails;
 219
 220         /** Package level ctor */
 221         VisibilityReport(int tasks, int thumbnails) {
 222             numVisibleTasks = tasks;
 223             numVisibleThumbnails = thumbnails;
 224         }
 225     }
 226
 227     Context mContext;
 228     private StackState mState = StackState.SPLIT;
 229     private TaskStackLayoutAlgorithmCallbacks mCb;
 230
 231     // The task bounds (untransformed) for layout.  This rect is anchored at mTaskRoot.
 232     @ViewDebug.ExportedProperty(category="recents")
 233     public Rect mTaskRect = new Rect();
 234     // The freeform workspace bounds, inset by the top system insets and is a fixed height
 235     @ViewDebug.ExportedProperty(category="recents")
 236     public Rect mFreeformRect = new Rect();
 237     // The stack bounds, inset from the top system insets, and runs to the bottom of the screen
 238     @ViewDebug.ExportedProperty(category="recents")
 239     public Rect mStackRect = new Rect();
 240     // This is the current system insets
 241     @ViewDebug.ExportedProperty(category="recents")
 242     public Rect mSystemInsets = new Rect();
 243     // This is the bounds of the stack action above the stack rect
 244     @ViewDebug.ExportedProperty(category="recents")
 245     public Rect mStackActionButtonRect = new Rect();
 246
 247     // The visible ranges when the stack is focused and unfocused
 248     private Range mUnfocusedRange;
 249     private Range mFocusedRange;
 250
 251     // The base top margin for the stack from the system insets
 252     @ViewDebug.ExportedProperty(category="recents")
 253     private int mBaseTopMargin;
 254     // The base side margin for the stack from the system insets
 255     @ViewDebug.ExportedProperty(category="recents")
 256     private int mBaseSideMargin;
 257     // The base bottom margin for the stack from the system insets
 258     @ViewDebug.ExportedProperty(category="recents")
 259     private int mBaseBottomMargin;
 260     private int mMinMargin;
 261
 262     // The gap between the freeform and stack layouts
 263     @ViewDebug.ExportedProperty(category="recents")
 264     private int mFreeformStackGap;
 265
 266     // The initial offset that the focused task is from the top
 267     @ViewDebug.ExportedProperty(category="recents")
 268     private int mInitialTopOffset;
 269     private int mBaseInitialTopOffset;
 270     // The initial offset that the launch-from task is from the bottom
 271     @ViewDebug.ExportedProperty(category="recents")
 272     private int mInitialBottomOffset;
 273     private int mBaseInitialBottomOffset;
 274
 275     // The height between the top margin and the top of the focused task
 276     @ViewDebug.ExportedProperty(category="recents")
 277     private int mFocusedTopPeekHeight;
 278     // The height between the bottom margin and the top of task in front of the focused task
 279     @ViewDebug.ExportedProperty(category="recents")
 280     private int mFocusedBottomPeekHeight;
 281
 282     // The offset from the bottom of the stack to the bottom of the bounds when the stack is
 283     // scrolled to the front
 284     @ViewDebug.ExportedProperty(category="recents")
 285     private int mStackBottomOffset;
 286
 287     // The paths defining the motion of the tasks when the stack is focused and unfocused
 288     private Path mUnfocusedCurve;
 289     private Path mFocusedCurve;
 290     private FreePathInterpolator mUnfocusedCurveInterpolator;
 291     private FreePathInterpolator mFocusedCurveInterpolator;
 292
 293     // The paths defining the distribution of the dim to apply to tasks in the stack when focused
 294     // and unfocused
 295     private Path mUnfocusedDimCurve;
 296     private Path mFocusedDimCurve;
 297     private FreePathInterpolator mUnfocusedDimCurveInterpolator;
 298     private FreePathInterpolator mFocusedDimCurveInterpolator;
 299
 300     // The state of the stack focus (0..1), which controls the transition of the stack from the
 301     // focused to non-focused state
 302     @ViewDebug.ExportedProperty(category="recents")
 303     private int mFocusState;
 304
 305     // The smallest scroll progress, at this value, the back most task will be visible
 306     @ViewDebug.ExportedProperty(category="recents")
 307     float mMinScrollP;
 308     // The largest scroll progress, at this value, the front most task will be visible above the
 309     // navigation bar
 310     @ViewDebug.ExportedProperty(category="recents")
 311     float mMaxScrollP;
 312     // The initial progress that the scroller is set when you first enter recents
 313     @ViewDebug.ExportedProperty(category="recents")
 314     float mInitialScrollP;
 315     // The task progress for the front-most task in the stack
 316     @ViewDebug.ExportedProperty(category="recents")
 317     float mFrontMostTaskP;
 318
 319     // The last computed task counts
 320     @ViewDebug.ExportedProperty(category="recents")
 321     int mNumStackTasks;
 322     @ViewDebug.ExportedProperty(category="recents")
 323     int mNumFreeformTasks;
 324
 325     // The min/max z translations
 326     @ViewDebug.ExportedProperty(category="recents")
 327     int mMinTranslationZ;
 328     @ViewDebug.ExportedProperty(category="recents")
 329     int mMaxTranslationZ;
 330
 331     // Optimization, allows for quick lookup of task -> index
 332     private SparseIntArray mTaskIndexMap = new SparseIntArray();
 333     private SparseArray<Float> mTaskIndexOverrideMap = new SparseArray<>();
 334
 335     // The freeform workspace layout
 336     FreeformWorkspaceLayoutAlgorithm mFreeformLayoutAlgorithm;
 337
 338     // The transform to place TaskViews at the front and back of the stack respectively
 339     TaskViewTransform mBackOfStackTransform = new TaskViewTransform();
 340     TaskViewTransform mFrontOfStackTransform = new TaskViewTransform();
 341
 342     public TaskStackLayoutAlgorithm(Context context, TaskStackLayoutAlgorithmCallbacks cb) {
 343         Resources res = context.getResources();
 344         mContext = context;
 345         mCb = cb;
 346         mFreeformLayoutAlgorithm = new FreeformWorkspaceLayoutAlgorithm(context);
 347         mMinMargin = res.getDimensionPixelSize(R.dimen.recents_layout_min_margin);
 348         mBaseTopMargin = getDimensionForDevice(context,
 349                 R.dimen.recents_layout_top_margin_phone,
 350                 R.dimen.recents_layout_top_margin_tablet,
 351                 R.dimen.recents_layout_top_margin_tablet_xlarge);
 352         mBaseSideMargin = getDimensionForDevice(context,
 353                 R.dimen.recents_layout_side_margin_phone,
 354                 R.dimen.recents_layout_side_margin_tablet,
 355                 R.dimen.recents_layout_side_margin_tablet_xlarge);
 356         mBaseBottomMargin = res.getDimensionPixelSize(R.dimen.recents_layout_bottom_margin);
 357         mFreeformStackGap =
 358                 res.getDimensionPixelSize(R.dimen.recents_freeform_layout_bottom_margin);
 359
 360         reloadOnConfigurationChange(context);
 361     }
 362
 363     /**
 364      * Reloads the layout for the current configuration.
 365      */
 366     public void reloadOnConfigurationChange(Context context) {
 367         Resources res = context.getResources();
 368         mFocusedRange = new Range(res.getFloat(R.integer.recents_layout_focused_range_min),
 369                 res.getFloat(R.integer.recents_layout_focused_range_max));
 370         mUnfocusedRange = new Range(res.getFloat(R.integer.recents_layout_unfocused_range_min),
 371                 res.getFloat(R.integer.recents_layout_unfocused_range_max));
 372         mFocusState = getInitialFocusState();
 373         mFocusedTopPeekHeight = res.getDimensionPixelSize(R.dimen.recents_layout_top_peek_size);
 374         mFocusedBottomPeekHeight =
 375                 res.getDimensionPixelSize(R.dimen.recents_layout_bottom_peek_size);
 376         mMinTranslationZ = res.getDimensionPixelSize(R.dimen.recents_layout_z_min);
 377         mMaxTranslationZ = res.getDimensionPixelSize(R.dimen.recents_layout_z_max);
 378         mBaseInitialTopOffset = getDimensionForDevice(context,
 379                 R.dimen.recents_layout_initial_top_offset_phone_port,
 380                 R.dimen.recents_layout_initial_top_offset_phone_land,
 381                 R.dimen.recents_layout_initial_top_offset_tablet,
 382                 R.dimen.recents_layout_initial_top_offset_tablet,
 383                 R.dimen.recents_layout_initial_top_offset_tablet,
 384                 R.dimen.recents_layout_initial_top_offset_tablet);
 385         mBaseInitialBottomOffset = getDimensionForDevice(context,
 386                 R.dimen.recents_layout_initial_bottom_offset_phone_port,
 387                 R.dimen.recents_layout_initial_bottom_offset_phone_land,
 388                 R.dimen.recents_layout_initial_bottom_offset_tablet,
 389                 R.dimen.recents_layout_initial_bottom_offset_tablet,
 390                 R.dimen.recents_layout_initial_bottom_offset_tablet,
 391                 R.dimen.recents_layout_initial_bottom_offset_tablet);
 392         mFreeformLayoutAlgorithm.reloadOnConfigurationChange(context);
 393     }
 394
 395     /**
 396      * Resets this layout when the stack view is reset.
 397      */
 398     public void reset() {
 399         mTaskIndexOverrideMap.clear();
 400         setFocusState(getInitialFocusState());
 401     }
 402
 403     /**
 404      * Sets the system insets.
 405      */
 406     public boolean setSystemInsets(Rect systemInsets) {
 407         boolean changed = !mSystemInsets.equals(systemInsets);
 408         mSystemInsets.set(systemInsets);
 409         return changed;
 410     }
 411
 412     /**
 413      * Sets the focused state.
 414      */
 415     public void setFocusState(int focusState) {
 416         int prevFocusState = mFocusState;
 417         mFocusState = focusState;
 418         updateFrontBackTransforms();
 419         if (mCb != null) {
 420             mCb.onFocusStateChanged(prevFocusState, focusState);
 421         }
 422     }
 423
 424     /**
 425      * Gets the focused state.
 426      */
 427     public int getFocusState() {
 428         return mFocusState;
 429     }
 430
 431     /**
 432      * Computes the stack and task rects.  The given task stack bounds already has the top/right
 433      * insets and left/right padding already applied.
 434      */
 435     public void initialize(Rect displayRect, Rect windowRect, Rect taskStackBounds,
 436             StackState state) {
 437         Rect lastStackRect = new Rect(mStackRect);
 438
 439         int topMargin = getScaleForExtent(windowRect, displayRect, mBaseTopMargin, mMinMargin, HEIGHT);
 440         int bottomMargin = getScaleForExtent(windowRect, displayRect, mBaseBottomMargin, mMinMargin,
 441                 HEIGHT);
 442         mInitialTopOffset = getScaleForExtent(windowRect, displayRect, mBaseInitialTopOffset,
 443                 mMinMargin, HEIGHT);
 444         mInitialBottomOffset = mBaseInitialBottomOffset;
 445
 446         // Compute the stack bounds
 447         mState = state;
 448         mStackBottomOffset = mSystemInsets.bottom + bottomMargin;
 449         state.computeRects(mFreeformRect, mStackRect, taskStackBounds, topMargin,
 450                 mFreeformStackGap, mStackBottomOffset);
 451
 452         // The stack action button will take the full un-padded header space above the stack
 453         mStackActionButtonRect.set(mStackRect.left, mStackRect.top - topMargin,
 454                 mStackRect.right, mStackRect.top + mFocusedTopPeekHeight);
 455
 456         // Anchor the task rect top aligned to the stack rect
 457         int height = mStackRect.height() - mInitialTopOffset - mStackBottomOffset;
 458         mTaskRect.set(mStackRect.left, mStackRect.top, mStackRect.right, mStackRect.top + height);
 459
 460         // Short circuit here if the stack rects haven't changed so we don't do all the work below
 461         if (!lastStackRect.equals(mStackRect)) {
 462             // Reinitialize the focused and unfocused curves
 463             mUnfocusedCurve = constructUnfocusedCurve();
 464             mUnfocusedCurveInterpolator = new FreePathInterpolator(mUnfocusedCurve);
 465             mFocusedCurve = constructFocusedCurve();
 466             mFocusedCurveInterpolator = new FreePathInterpolator(mFocusedCurve);
 467             mUnfocusedDimCurve = constructUnfocusedDimCurve();
 468             mUnfocusedDimCurveInterpolator = new FreePathInterpolator(mUnfocusedDimCurve);
 469             mFocusedDimCurve = constructFocusedDimCurve();
 470             mFocusedDimCurveInterpolator = new FreePathInterpolator(mFocusedDimCurve);
 471
 472             updateFrontBackTransforms();
 473         }
 474     }
 475
 476     /**
 477      * Computes the minimum and maximum scroll progress values and the progress values for each task
 478      * in the stack.
 479      */
 480     void update(TaskStack stack, ArraySet<Task.TaskKey> ignoreTasksSet) {
 481         SystemServicesProxy ssp = Recents.getSystemServices();
 482         RecentsActivityLaunchState launchState = Recents.getConfiguration().getLaunchState();
 483
 484         // Clear the progress map
 485         mTaskIndexMap.clear();
 486
 487         // Return early if we have no tasks
 488         ArrayList<Task> tasks = stack.getStackTasks();
 489         if (tasks.isEmpty()) {
 490             mFrontMostTaskP = 0;
 491             mMinScrollP = mMaxScrollP = mInitialScrollP = 0;
 492             mNumStackTasks = mNumFreeformTasks = 0;
 493             return;
 494         }
 495
 496         // Filter the set of freeform and stack tasks
 497         ArrayList<Task> freeformTasks = new ArrayList<>();
 498         ArrayList<Task> stackTasks = new ArrayList<>();
 499         for (int i = 0; i < tasks.size(); i++) {
 500             Task task = tasks.get(i);
 501             if (ignoreTasksSet.contains(task.key)) {
 502                 continue;
 503             }
 504             if (task.isFreeformTask()) {
 505                 freeformTasks.add(task);
 506             } else {
 507                 stackTasks.add(task);
 508             }
 509         }
 510         mNumStackTasks = stackTasks.size();
 511         mNumFreeformTasks = freeformTasks.size();
 512
 513         // Put each of the tasks in the progress map at a fixed index (does not need to actually
 514         // map to a scroll position, just by index)
 515         int taskCount = stackTasks.size();
 516         for (int i = 0; i < taskCount; i++) {
 517             Task task = stackTasks.get(i);
 518             mTaskIndexMap.put(task.key.id, i);
 519         }
 520
 521         // Update the freeform tasks
 522         if (!freeformTasks.isEmpty()) {
 523             mFreeformLayoutAlgorithm.update(freeformTasks, this);
 524         }
 525
 526         // Calculate the min/max/initial scroll
 527         Task launchTask = stack.getLaunchTarget();
 528         int launchTaskIndex = launchTask != null
 529                 ? stack.indexOfStackTask(launchTask)
 530                 : mNumStackTasks - 1;
 531         if (getInitialFocusState() == STATE_FOCUSED) {
 532             int maxBottomOffset = mStackBottomOffset + mTaskRect.height();
 533             float maxBottomNormX = getNormalizedXFromFocusedY(maxBottomOffset, FROM_BOTTOM);
 534             mFocusedRange.offset(0f);
 535             mMinScrollP = 0;
 536             mMaxScrollP = Math.max(mMinScrollP, (mNumStackTasks - 1) -
 537                     Math.max(0, mFocusedRange.getAbsoluteX(maxBottomNormX)));
 538             if (launchState.launchedFromHome) {
 539                 mInitialScrollP = Utilities.clamp(launchTaskIndex, mMinScrollP, mMaxScrollP);
 540             } else {
 541                 mInitialScrollP = Utilities.clamp(launchTaskIndex - 1, mMinScrollP, mMaxScrollP);
 542             }
 543         } else if (!ssp.hasFreeformWorkspaceSupport() && mNumStackTasks == 1) {
 544             // If there is one stack task, ignore the min/max/initial scroll positions
 545             mMinScrollP = 0;
 546             mMaxScrollP = 0;
 547             mInitialScrollP = 0;
 548         } else {
 549             // Set the max scroll to be the point where the front most task is visible with the
 550             // stack bottom offset
 551             int maxBottomOffset = mStackBottomOffset + mTaskRect.height();
 552             float maxBottomNormX = getNormalizedXFromUnfocusedY(maxBottomOffset, FROM_BOTTOM);
 553             mUnfocusedRange.offset(0f);
 554             mMinScrollP = 0;
 555             mMaxScrollP = Math.max(mMinScrollP, (mNumStackTasks - 1) -
 556                     Math.max(0, mUnfocusedRange.getAbsoluteX(maxBottomNormX)));
 557             boolean scrollToFront = launchState.launchedFromHome ||
 558                     launchState.launchedViaDockGesture;
 559             if (launchState.launchedWithAltTab) {
 560                 mInitialScrollP = Utilities.clamp(launchTaskIndex, mMinScrollP, mMaxScrollP);
 561             } else if (scrollToFront) {
 562                 mInitialScrollP = Utilities.clamp(launchTaskIndex, mMinScrollP, mMaxScrollP);
 563             } else {
 564                 // We are overriding the initial two task positions, so set the initial scroll
 565                 // position to match the second task (aka focused task) position
 566                 float initialTopNormX = getNormalizedXFromUnfocusedY(mInitialTopOffset, FROM_TOP);
 567                 mInitialScrollP = Math.max(mMinScrollP, Math.min(mMaxScrollP, (mNumStackTasks - 2))
 568                         - Math.max(0, mUnfocusedRange.getAbsoluteX(initialTopNormX)));
 569             }
 570         }
 571     }
 572
 573     /**
 574      * Creates task overrides to ensure the initial stack layout if necessary.
 575      */
 576     public void setTaskOverridesForInitialState(TaskStack stack, boolean ignoreScrollToFront) {
 577         RecentsActivityLaunchState launchState = Recents.getConfiguration().getLaunchState();
 578
 579         mTaskIndexOverrideMap.clear();
 580
 581         boolean scrollToFront = launchState.launchedFromHome ||
 582                 launchState.launchedViaDockGesture;
 583         if (getInitialFocusState() == STATE_UNFOCUSED && mNumStackTasks > 1) {
 584             if (ignoreScrollToFront || (!launchState.launchedWithAltTab && !scrollToFront)) {
 585                 // Set the initial scroll to the predefined state (which differs from the stack)
 586                 float [] initialNormX = null;
 587                 float minBottomTaskNormX = getNormalizedXFromUnfocusedY(mSystemInsets.bottom +
 588                         mInitialBottomOffset, FROM_BOTTOM);
 589                 float maxBottomTaskNormX = getNormalizedXFromUnfocusedY(mFocusedTopPeekHeight +
 590                         mTaskRect.height() - mMinMargin, FROM_TOP);
 591                 if (mNumStackTasks <= 2) {
 592                     // For small stacks, position the tasks so that they are top aligned to under
 593                     // the action button, but ensure that it is at least a certain offset from the
 594                     // bottom of the stack
 595                     initialNormX = new float[] {
 596                             Math.min(maxBottomTaskNormX, minBottomTaskNormX),
 597                             getNormalizedXFromUnfocusedY(mFocusedTopPeekHeight, FROM_TOP)
 598                     };
 599                 } else {
 600                     initialNormX = new float[] {
 601                             minBottomTaskNormX,
 602                             getNormalizedXFromUnfocusedY(mInitialTopOffset, FROM_TOP)
 603                     };
 604                 }
 605
 606                 mUnfocusedRange.offset(0f);
 607                 List<Task> tasks = stack.getStackTasks();
 608                 int taskCount = tasks.size();
 609                 for (int i = taskCount - 1; i >= 0; i--) {
 610                     int indexFromFront = taskCount - i - 1;
 611                     if (indexFromFront >= initialNormX.length) {
 612                         break;
 613                     }
 614                     float newTaskProgress = mInitialScrollP +
 615                             mUnfocusedRange.getAbsoluteX(initialNormX[indexFromFront]);
 616                     mTaskIndexOverrideMap.put(tasks.get(i).key.id, newTaskProgress);
 617                 }
 618             }
 619         }
 620     }
 621
 622     /**
 623      * Adds and override task progress for the given task when transitioning from focused to
 624      * unfocused state.
 625      */
 626     public void addUnfocusedTaskOverride(Task task, float stackScroll) {
 627         if (mFocusState != STATE_UNFOCUSED) {
 628             mFocusedRange.offset(stackScroll);
 629             mUnfocusedRange.offset(stackScroll);
 630             float focusedRangeX = mFocusedRange.getNormalizedX(mTaskIndexMap.get(task.key.id));
 631             float focusedY = mFocusedCurveInterpolator.getInterpolation(focusedRangeX);
 632             float unfocusedRangeX = mUnfocusedCurveInterpolator.getX(focusedY);
 633             float unfocusedTaskProgress = stackScroll + mUnfocusedRange.getAbsoluteX(unfocusedRangeX);
 634             if (Float.compare(focusedRangeX, unfocusedRangeX) != 0) {
 635                 mTaskIndexOverrideMap.put(task.key.id, unfocusedTaskProgress);
 636             }
 637         }
 638     }
 639
 640     /**
 641      * Adds and override task progress for the given task when transitioning from focused to
 642      * unfocused state.
 643      */
 644     public void addUnfocusedTaskOverride(TaskView taskView, float stackScroll) {
 645         mFocusedRange.offset(stackScroll);
 646         mUnfocusedRange.offset(stackScroll);
 647
 648         Task task = taskView.getTask();
 649         int top = taskView.getTop() - mTaskRect.top;
 650         float focusedRangeX = getNormalizedXFromFocusedY(top, FROM_TOP);
 651         float unfocusedRangeX = getNormalizedXFromUnfocusedY(top, FROM_TOP);
 652         float unfocusedTaskProgress = stackScroll + mUnfocusedRange.getAbsoluteX(unfocusedRangeX);
 653         if (Float.compare(focusedRangeX, unfocusedRangeX) != 0) {
 654             mTaskIndexOverrideMap.put(task.key.id, unfocusedTaskProgress);
 655         }
 656     }
 657
 658     public void clearUnfocusedTaskOverrides() {
 659         mTaskIndexOverrideMap.clear();
 660     }
 661
 662     /**
 663      * Updates this stack when a scroll happens.
 664      *
 665      */
 666     public float updateFocusStateOnScroll(float lastTargetStackScroll, float targetStackScroll,
 667             float lastStackScroll) {
 668         if (targetStackScroll == lastStackScroll) {
 669             return targetStackScroll;
 670         }
 671
 672         float deltaScroll = targetStackScroll - lastStackScroll;
 673         float deltaTargetScroll = targetStackScroll - lastTargetStackScroll;
 674         float newScroll = targetStackScroll;
 675         mUnfocusedRange.offset(targetStackScroll);
 676         for (int i = mTaskIndexOverrideMap.size() - 1; i >= 0; i--) {
 677             int taskId = mTaskIndexOverrideMap.keyAt(i);
 678             float x = mTaskIndexMap.get(taskId);
 679             float overrideX = mTaskIndexOverrideMap.get(taskId, 0f);
 680             float newOverrideX = overrideX + deltaScroll;
 681             if (isInvalidOverrideX(x, overrideX, newOverrideX)) {
 682                 // Remove the override once we reach the original task index
 683                 mTaskIndexOverrideMap.removeAt(i);
 684             } else if ((overrideX >= x && deltaScroll <= 0f) ||
 685                     (overrideX <= x && deltaScroll >= 0f)) {
 686                 // Scrolling from override x towards x, then lock the task in place
 687                 mTaskIndexOverrideMap.put(taskId, newOverrideX);
 688             } else {
 689                 // Scrolling override x away from x, we should still move the scroll towards x
 690                 newScroll = lastStackScroll;
 691                 newOverrideX = overrideX - deltaTargetScroll;
 692                 if (isInvalidOverrideX(x, overrideX, newOverrideX)) {
 693                     mTaskIndexOverrideMap.removeAt(i);
 694                 } else{
 695                     mTaskIndexOverrideMap.put(taskId, newOverrideX);
 696                 }
 697             }
 698         }
 699         return newScroll;
 700     }
 701
 702     private boolean isInvalidOverrideX(float x, float overrideX, float newOverrideX) {
 703         boolean outOfBounds = mUnfocusedRange.getNormalizedX(newOverrideX) < 0f ||
 704                 mUnfocusedRange.getNormalizedX(newOverrideX) > 1f;
 705         return outOfBounds || (overrideX >= x && x >= newOverrideX) ||
 706                 (overrideX <= x && x <= newOverrideX);
 707     }
 708
 709     /**
 710      * Returns the default focus state.
 711      */
 712     public int getInitialFocusState() {
 713         RecentsActivityLaunchState launchState = Recents.getConfiguration().getLaunchState();
 714         RecentsDebugFlags debugFlags = Recents.getDebugFlags();
 715         if (debugFlags.isPagingEnabled() || launchState.launchedWithAltTab) {
 716             return STATE_FOCUSED;
 717         } else {
 718             return STATE_UNFOCUSED;
 719         }
 720     }
 721
 722     /**
 723      * Returns the TaskViewTransform that would put the task just off the back of the stack.
 724      */
 725     public TaskViewTransform getBackOfStackTransform() {
 726         return mBackOfStackTransform;
 727     }
 728
 729     /**
 730      * Returns the TaskViewTransform that would put the task just off the front of the stack.
 731      */
 732     public TaskViewTransform getFrontOfStackTransform() {
 733         return mFrontOfStackTransform;
 734     }
 735
 736     /**
 737      * Returns the current stack state.
 738      */
 739     public StackState getStackState() {
 740         return mState;
 741     }
 742
 743     /**
 744      * Returns whether this stack layout has been initialized.
 745      */
 746     public boolean isInitialized() {
 747         return !mStackRect.isEmpty();
 748     }
 749
 750     /**
 751      * Computes the maximum number of visible tasks and thumbnails when the scroll is at the initial
 752      * stack scroll.  Requires that update() is called first.
 753      */
 754     public VisibilityReport computeStackVisibilityReport(ArrayList<Task> tasks) {
 755         // Ensure minimum visibility count
 756         if (tasks.size() <= 1) {
 757             return new VisibilityReport(1, 1);
 758         }
 759
 760         // Quick return when there are no stack tasks
 761         if (mNumStackTasks == 0) {
 762             return new VisibilityReport(Math.max(mNumFreeformTasks, 1),
 763                     Math.max(mNumFreeformTasks, 1));
 764         }
 765
 766         // Otherwise, walk backwards in the stack and count the number of tasks and visible
 767         // thumbnails and add that to the total freeform task count
 768         TaskViewTransform tmpTransform = new TaskViewTransform();
 769         Range currentRange = getInitialFocusState() > 0f ? mFocusedRange : mUnfocusedRange;
 770         currentRange.offset(mInitialScrollP);
 771         int taskBarHeight = mContext.getResources().getDimensionPixelSize(
 772                 R.dimen.recents_task_view_header_height);
 773         int numVisibleTasks = Math.max(mNumFreeformTasks, 1);
 774         int numVisibleThumbnails = Math.max(mNumFreeformTasks, 1);
 775         float prevScreenY = Integer.MAX_VALUE;
 776         for (int i = tasks.size() - 1; i >= 0; i--) {
 777             Task task = tasks.get(i);
 778
 779             // Skip freeform
 780             if (task.isFreeformTask()) {
 781                 continue;
 782             }
 783
 784             // Skip invisible
 785             float taskProgress = getStackScrollForTask(task);
 786             if (!currentRange.isInRange(taskProgress)) {
 787                 continue;
 788             }
 789
 790             boolean isFrontMostTaskInGroup = task.group == null || task.group.isFrontMostTask(task);
 791             if (isFrontMostTaskInGroup) {
 792                 getStackTransform(taskProgress, taskProgress, mInitialScrollP, mFocusState,
 793                         tmpTransform, null, false /* ignoreSingleTaskCase */,
 794                         false /* forceUpdate */);
 795                 float screenY = tmpTransform.rect.top;
 796                 boolean hasVisibleThumbnail = (prevScreenY - screenY) > taskBarHeight;
 797                 if (hasVisibleThumbnail) {
 798                     numVisibleThumbnails++;
 799                     numVisibleTasks++;
 800                     prevScreenY = screenY;
 801                 } else {
 802                     // Once we hit the next front most task that does not have a visible thumbnail,
 803                     // walk through remaining visible set
 804                     for (int j = i; j >= 0; j--) {
 805                         numVisibleTasks++;
 806                         taskProgress = getStackScrollForTask(tasks.get(j));
 807                         if (!currentRange.isInRange(taskProgress)) {
 808                             continue;
 809                         }
 810                     }
 811                     break;
 812                 }
 813             } else if (!isFrontMostTaskInGroup) {
 814                 // Affiliated task, no thumbnail
 815                 numVisibleTasks++;
 816             }
 817         }
 818         return new VisibilityReport(numVisibleTasks, numVisibleThumbnails);
 819     }
 820
 821     /**
 822      * Returns the transform for the given task.  This transform is relative to the mTaskRect, which
 823      * is what the view is measured and laid out with.
 824      */
 825     public TaskViewTransform getStackTransform(Task task, float stackScroll,
 826             TaskViewTransform transformOut, TaskViewTransform frontTransform) {
 827         return getStackTransform(task, stackScroll, mFocusState, transformOut, frontTransform,
 828                 false /* forceUpdate */, false /* ignoreTaskOverrides */);
 829     }
 830
 831     public TaskViewTransform getStackTransform(Task task, float stackScroll,
 832             TaskViewTransform transformOut, TaskViewTransform frontTransform,
 833             boolean ignoreTaskOverrides) {
 834         return getStackTransform(task, stackScroll, mFocusState, transformOut, frontTransform,
 835                 false /* forceUpdate */, ignoreTaskOverrides);
 836     }
 837
 838     public TaskViewTransform getStackTransform(Task task, float stackScroll, int focusState,
 839             TaskViewTransform transformOut, TaskViewTransform frontTransform, boolean forceUpdate,
 840             boolean ignoreTaskOverrides) {
 841         if (mFreeformLayoutAlgorithm.isTransformAvailable(task, this)) {
 842             mFreeformLayoutAlgorithm.getTransform(task, transformOut, this);
 843             return transformOut;
 844         } else {
 845             // Return early if we have an invalid index
 846             int nonOverrideTaskProgress = mTaskIndexMap.get(task.key.id, -1);
 847             if (task == null || nonOverrideTaskProgress == -1) {
 848                 transformOut.reset();
 849                 return transformOut;
 850             }
 851             float taskProgress = ignoreTaskOverrides
 852                     ? nonOverrideTaskProgress
 853                     : getStackScrollForTask(task);
 854             getStackTransform(taskProgress, nonOverrideTaskProgress, stackScroll, focusState,
 855                     transformOut, frontTransform, false /* ignoreSingleTaskCase */, forceUpdate);
 856             return transformOut;
 857         }
 858     }
 859
 860     /**
 861      * Like {@link #getStackTransform}, but in screen coordinates
 862      */
 863     public TaskViewTransform getStackTransformScreenCoordinates(Task task, float stackScroll,
 864             TaskViewTransform transformOut, TaskViewTransform frontTransform,
 865             Rect windowOverrideRect) {
 866         TaskViewTransform transform = getStackTransform(task, stackScroll, mFocusState,
 867                 transformOut, frontTransform, true /* forceUpdate */,
 868                 false /* ignoreTaskOverrides */);
 869         return transformToScreenCoordinates(transform, windowOverrideRect);
 870     }
 871
 872     /**
 873      * Transforms the given {@param transformOut} to the screen coordinates, overriding the current
 874      * window rectangle with {@param windowOverrideRect} if non-null.
 875      */
 876     public TaskViewTransform transformToScreenCoordinates(TaskViewTransform transformOut,
 877             Rect windowOverrideRect) {
 878         Rect windowRect = windowOverrideRect != null
 879                 ? windowOverrideRect
 880                 : Recents.getSystemServices().getWindowRect();
 881         transformOut.rect.offset(windowRect.left, windowRect.top);
 882         return transformOut;
 883     }
 884
 885     /**
 886      * Update/get the transform.
 887      *
 888      * @param ignoreSingleTaskCase When set, will ensure that the transform computed does not take
 889      *                             into account the special single-task case.  This is only used
 890      *                             internally to ensure that we can calculate the transform for any
 891      *                             position in the stack.
 892      */
 893     public void getStackTransform(float taskProgress, float nonOverrideTaskProgress,
 894             float stackScroll, int focusState, TaskViewTransform transformOut,
 895             TaskViewTransform frontTransform, boolean ignoreSingleTaskCase, boolean forceUpdate) {
 896         SystemServicesProxy ssp = Recents.getSystemServices();
 897
 898         // Ensure that the task is in range
 899         mUnfocusedRange.offset(stackScroll);
 900         mFocusedRange.offset(stackScroll);
 901         boolean unfocusedVisible = mUnfocusedRange.isInRange(taskProgress);
 902         boolean focusedVisible = mFocusedRange.isInRange(taskProgress);
 903
 904         // Skip if the task is not visible
 905         if (!forceUpdate && !unfocusedVisible && !focusedVisible) {
 906             transformOut.reset();
 907             return;
 908         }
 909
 910         // Map the absolute task progress to the normalized x at the stack scroll.  We use this to
 911         // calculate positions along the curve.
 912         mUnfocusedRange.offset(stackScroll);
 913         mFocusedRange.offset(stackScroll);
 914         float unfocusedRangeX = mUnfocusedRange.getNormalizedX(taskProgress);
 915         float focusedRangeX = mFocusedRange.getNormalizedX(taskProgress);
 916
 917         // Map the absolute task progress to the normalized x at the bounded stack scroll.  We use
 918         // this to calculate bounded properties, like translationZ and outline alpha.
 919         float boundedStackScroll = Utilities.clamp(stackScroll, mMinScrollP, mMaxScrollP);
 920         mUnfocusedRange.offset(boundedStackScroll);
 921         mFocusedRange.offset(boundedStackScroll);
 922         float boundedScrollUnfocusedRangeX = mUnfocusedRange.getNormalizedX(taskProgress);
 923         float boundedScrollUnfocusedNonOverrideRangeX =
 924                 mUnfocusedRange.getNormalizedX(nonOverrideTaskProgress);
 925
 926         // Map the absolute task progress to the normalized x at the upper bounded stack scroll.
 927         // We use this to calculate the dim, which is bounded only on one end.
 928         float lowerBoundedStackScroll = Utilities.clamp(stackScroll, -Float.MAX_VALUE, mMaxScrollP);
 929         mUnfocusedRange.offset(lowerBoundedStackScroll);
 930         mFocusedRange.offset(lowerBoundedStackScroll);
 931         float lowerBoundedUnfocusedRangeX = mUnfocusedRange.getNormalizedX(taskProgress);
 932         float lowerBoundedFocusedRangeX = mFocusedRange.getNormalizedX(taskProgress);
 933
 934         int x = (mStackRect.width() - mTaskRect.width()) / 2;
 935         int y;
 936         float z;
 937         float dimAlpha;
 938         float viewOutlineAlpha;
 939         if (!ssp.hasFreeformWorkspaceSupport() && mNumStackTasks == 1 && !ignoreSingleTaskCase) {
 940             // When there is exactly one task, then decouple the task from the stack and just move
 941             // in screen space
 942             float tmpP = (mMinScrollP - stackScroll) / mNumStackTasks;
 943             int centerYOffset = (mStackRect.top - mTaskRect.top) +
 944                     (mStackRect.height() - mSystemInsets.bottom - mTaskRect.height()) / 2;
 945             y = centerYOffset + getYForDeltaP(tmpP, 0);
 946             z = mMaxTranslationZ;
 947             dimAlpha = 0f;
 948             viewOutlineAlpha = OUTLINE_ALPHA_MIN_VALUE +
 949                     (OUTLINE_ALPHA_MAX_VALUE - OUTLINE_ALPHA_MIN_VALUE) / 2f;
 950
 951         } else {
 952             // Otherwise, update the task to the stack layout
 953             int unfocusedY = (int) ((1f - mUnfocusedCurveInterpolator.getInterpolation(
 954                     unfocusedRangeX)) * mStackRect.height());
 955             int focusedY = (int) ((1f - mFocusedCurveInterpolator.getInterpolation(
 956                     focusedRangeX)) * mStackRect.height());
 957             float unfocusedDim = mUnfocusedDimCurveInterpolator.getInterpolation(
 958                     lowerBoundedUnfocusedRangeX);
 959             float focusedDim = mFocusedDimCurveInterpolator.getInterpolation(
 960                     lowerBoundedFocusedRangeX);
 961
 962             // Special case, because we override the initial task positions differently for small
 963             // stacks, we clamp the dim to 0 in the initial position, and then only modulate the
 964             // dim when the task is scrolled back towards the top of the screen
 965             if (mNumStackTasks <= 2 && nonOverrideTaskProgress == 0f) {
 966                 if (boundedScrollUnfocusedRangeX >= 0.5f) {
 967                     unfocusedDim = 0f;
 968                 } else {
 969                     float offset = mUnfocusedDimCurveInterpolator.getInterpolation(0.5f);
 970                     unfocusedDim -= offset;
 971                     unfocusedDim *= MAX_DIM / (MAX_DIM - offset);
 972                 }
 973             }
 974
 975             y = (mStackRect.top - mTaskRect.top) +
 976                     (int) Utilities.mapRange(focusState, unfocusedY, focusedY);
 977             z = Utilities.mapRange(Utilities.clamp01(boundedScrollUnfocusedNonOverrideRangeX),
 978                     mMinTranslationZ, mMaxTranslationZ);
 979             dimAlpha = Utilities.mapRange(focusState, unfocusedDim, focusedDim);
 980             viewOutlineAlpha = Utilities.mapRange(Utilities.clamp01(boundedScrollUnfocusedRangeX),
 981                     OUTLINE_ALPHA_MIN_VALUE, OUTLINE_ALPHA_MAX_VALUE);
 982         }
 983
 984         // Fill out the transform
 985         transformOut.scale = 1f;
 986         transformOut.alpha = 1f;
 987         transformOut.translationZ = z;
 988         transformOut.dimAlpha = dimAlpha;
 989         transformOut.viewOutlineAlpha = viewOutlineAlpha;
 990         transformOut.rect.set(mTaskRect);
 991         transformOut.rect.offset(x, y);
 992         Utilities.scaleRectAboutCenter(transformOut.rect, transformOut.scale);
 993         transformOut.visible = (transformOut.rect.top < mStackRect.bottom) &&
 994                 (frontTransform == null || transformOut.rect.top != frontTransform.rect.top);
 995     }
 996
 997     /**
 998      * Returns the untransformed task view bounds.
 999      */
1000     public Rect getUntransformedTaskViewBounds() {
1001         return new Rect(mTaskRect);
1002     }
1003
1004     /**
1005      * Returns the scroll progress to scroll to such that the top of the task is at the top of the
1006      * stack.
1007      */
1008     float getStackScrollForTask(Task t) {
1009         Float overrideP = mTaskIndexOverrideMap.get(t.key.id, null);
1010         if (overrideP == null) {
1011             return (float) mTaskIndexMap.get(t.key.id, 0);
1012         }
1013         return overrideP;
1014     }
1015
1016     /**
1017      * Returns the original scroll progress to scroll to such that the top of the task is at the top
1018      * of the stack.
1019      */
1020     float getStackScrollForTaskIgnoreOverrides(Task t) {
1021         return (float) mTaskIndexMap.get(t.key.id, 0);
1022     }
1023
1024     /**
1025      * Returns the scroll progress to scroll to such that the top of the task at the initial top
1026      * offset (which is at the task's brightest point).
1027      */
1028     float getStackScrollForTaskAtInitialOffset(Task t) {
1029         float normX = getNormalizedXFromUnfocusedY(mInitialTopOffset, FROM_TOP);
1030         mUnfocusedRange.offset(0f);
1031         return Utilities.clamp((float) mTaskIndexMap.get(t.key.id, 0) - Math.max(0,
1032                 mUnfocusedRange.getAbsoluteX(normX)), mMinScrollP, mMaxScrollP);
1033     }
1034
1035     /**
1036      * Maps a movement in screen y, relative to {@param downY}, to a movement in along the arc
1037      * length of the curve.  We know the curve is mostly flat, so we just map the length of the
1038      * screen along the arc-length proportionally (1/arclength).
1039      */
1040     public float getDeltaPForY(int downY, int y) {
1041         float deltaP = (float) (y - downY) / mStackRect.height() *
1042                 mUnfocusedCurveInterpolator.getArcLength();
1043         return -deltaP;
1044     }
1045
1046     /**
1047      * This is the inverse of {@link #getDeltaPForY}.  Given a movement along the arc length
1048      * of the curve, map back to the screen y.
1049      */
1050     public int getYForDeltaP(float downScrollP, float p) {
1051         int y = (int) ((p - downScrollP) * mStackRect.height() *
1052                 (1f / mUnfocusedCurveInterpolator.getArcLength()));
1053         return -y;
1054     }
1055
1056     /**
1057      * Returns the task stack bounds in the current orientation.  This rect takes into account the
1058      * top and right system insets (but not the bottom inset) and left/right paddings, but _not_
1059      * the top/bottom padding or insets.
1060      */
1061     public void getTaskStackBounds(Rect displayRect, Rect windowRect, int topInset, int rightInset,
1062             Rect taskStackBounds) {
1063         taskStackBounds.set(windowRect.left, windowRect.top + topInset,
1064                 windowRect.right - rightInset, windowRect.bottom);
1065
1066         // Ensure that the new width is at most the smaller display edge size
1067         int sideMargin = getScaleForExtent(windowRect, displayRect, mBaseSideMargin, mMinMargin,
1068                 WIDTH);
1069         int targetStackWidth = taskStackBounds.width() - 2 * sideMargin;
1070         if (Utilities.getAppConfiguration(mContext).orientation
1071                 == Configuration.ORIENTATION_LANDSCAPE) {
1072             // If we are in landscape, calculate the width of the stack in portrait and ensure that
1073             // we are not larger than that size
1074             Rect portraitDisplayRect = new Rect(0, 0,
1075                     Math.min(displayRect.width(), displayRect.height()),
1076                     Math.max(displayRect.width(), displayRect.height()));
1077             int portraitSideMargin = getScaleForExtent(portraitDisplayRect, portraitDisplayRect,
1078                     mBaseSideMargin, mMinMargin, WIDTH);
1079             targetStackWidth = Math.min(targetStackWidth,
1080                     portraitDisplayRect.width() - 2 * portraitSideMargin);
1081         }
1082         taskStackBounds.inset((taskStackBounds.width() - targetStackWidth) / 2, 0);
1083     }
1084
1085     /**
1086      * Retrieves resources that are constant regardless of the current configuration of the device.
1087      */
1088     public static int getDimensionForDevice(Context ctx, int phoneResId,
1089             int tabletResId, int xlargeTabletResId) {
1090         return getDimensionForDevice(ctx, phoneResId, phoneResId, tabletResId, tabletResId,
1091                 xlargeTabletResId, xlargeTabletResId);
1092     }
1093
1094     /**
1095      * Retrieves resources that are constant regardless of the current configuration of the device.
1096      */
1097     public static int getDimensionForDevice(Context ctx, int phonePortResId, int phoneLandResId,
1098             int tabletPortResId, int tabletLandResId, int xlargeTabletPortResId,
1099             int xlargeTabletLandResId) {
1100         RecentsConfiguration config = Recents.getConfiguration();
1101         Resources res = ctx.getResources();
1102         boolean isLandscape = Utilities.getAppConfiguration(ctx).orientation ==
1103                 Configuration.ORIENTATION_LANDSCAPE;
1104         if (config.isXLargeScreen) {
1105             return res.getDimensionPixelSize(isLandscape
1106                     ? xlargeTabletLandResId
1107                     : xlargeTabletPortResId);
1108         } else if (config.isLargeScreen) {
1109             return res.getDimensionPixelSize(isLandscape
1110                     ? tabletLandResId
1111                     : tabletPortResId);
1112         } else {
1113             return res.getDimensionPixelSize(isLandscape
1114                     ? phoneLandResId
1115                     : phonePortResId);
1116         }
1117     }
1118
1119     /**
1120      * Returns the normalized x on the unfocused curve given an absolute Y position (relative to the
1121      * stack height).
1122      */
1123     private float getNormalizedXFromUnfocusedY(float y, @AnchorSide int fromSide) {
1124         float offset = (fromSide == FROM_TOP)
1125                 ? mStackRect.height() - y
1126                 : y;
1127         float offsetPct = offset / mStackRect.height();
1128         return mUnfocusedCurveInterpolator.getX(offsetPct);
1129     }
1130
1131     /**
1132      * Returns the normalized x on the focused curve given an absolute Y position (relative to the
1133      * stack height).
1134      */
1135     private float getNormalizedXFromFocusedY(float y, @AnchorSide int fromSide) {
1136         float offset = (fromSide == FROM_TOP)
1137                 ? mStackRect.height() - y
1138                 : y;
1139         float offsetPct = offset / mStackRect.height();
1140         return mFocusedCurveInterpolator.getX(offsetPct);
1141     }
1142
1143     /**
1144      * Creates a new path for the focused curve.
1145      */
1146     private Path constructFocusedCurve() {
1147         // Initialize the focused curve. This curve is a piecewise curve composed of several
1148         // linear pieces that goes from (0,1) through (0.5, peek height offset),
1149         // (0.5, bottom task offsets), and (1,0).
1150         float topPeekHeightPct = (float) mFocusedTopPeekHeight / mStackRect.height();
1151         float bottomPeekHeightPct = (float) (mStackBottomOffset + mFocusedBottomPeekHeight) /
1152                 mStackRect.height();
1153         float minBottomPeekHeightPct = (float) (mFocusedTopPeekHeight + mTaskRect.height() -
1154                 mMinMargin) / mStackRect.height();
1155         Path p = new Path();
1156         p.moveTo(0f, 1f);
1157         p.lineTo(0.5f, 1f - topPeekHeightPct);
1158         p.lineTo(1f - (0.5f / mFocusedRange.relativeMax), Math.max(1f - minBottomPeekHeightPct,
1159                 bottomPeekHeightPct));
1160         p.lineTo(1f, 0f);
1161         return p;
1162     }
1163
1164     /**
1165      * Creates a new path for the unfocused curve.
1166      */
1167     private Path constructUnfocusedCurve() {
1168         // Initialize the unfocused curve. This curve is a piecewise curve composed of two quadradic
1169         // beziers that goes from (0,1) through (0.5, peek height offset) and ends at (1,0).  This
1170         // ensures that we match the range, at which 0.5 represents the stack scroll at the current
1171         // task progress.  Because the height offset can change depending on a resource, we compute
1172         // the control point of the second bezier such that between it and a first known point,
1173         // there is a tangent at (0.5, peek height offset).
1174         float cpoint1X = 0.4f;
1175         float cpoint1Y = 0.975f;
1176         float topPeekHeightPct = (float) mFocusedTopPeekHeight / mStackRect.height();
1177         float slope = ((1f - topPeekHeightPct) - cpoint1Y) / (0.5f - cpoint1X);
1178         float b = 1f - slope * cpoint1X;
1179         float cpoint2X = 0.65f;
1180         float cpoint2Y = slope * cpoint2X + b;
1181         Path p = new Path();
1182         p.moveTo(0f, 1f);
1183         p.cubicTo(0f, 1f, cpoint1X, cpoint1Y, 0.5f, 1f - topPeekHeightPct);
1184         p.cubicTo(0.5f, 1f - topPeekHeightPct, cpoint2X, cpoint2Y, 1f, 0f);
1185         return p;
1186     }
1187
1188     /**
1189      * Creates a new path for the focused dim curve.
1190      */
1191     private Path constructFocusedDimCurve() {
1192         Path p = new Path();
1193         // The focused dim interpolator starts at max dim, reduces to zero at 0.5 (the focused
1194         // task), then goes back to max dim at the next task
1195         p.moveTo(0f, MAX_DIM);
1196         p.lineTo(0.5f, 0f);
1197         p.lineTo(0.5f + (0.5f / mFocusedRange.relativeMax), MAX_DIM);
1198         p.lineTo(1f, MAX_DIM);
1199         return p;
1200     }
1201
1202     /**
1203      * Creates a new path for the unfocused dim curve.
1204      */
1205     private Path constructUnfocusedDimCurve() {
1206         float focusX = getNormalizedXFromUnfocusedY(mInitialTopOffset, FROM_TOP);
1207         float cpoint2X = focusX + (1f - focusX) / 2;
1208         Path p = new Path();
1209         // The unfocused dim interpolator starts at max dim, reduces to zero at 0.5 (the focused
1210         // task), then goes back to max dim towards the front of the stack
1211         p.moveTo(0f, MAX_DIM);
1212         p.cubicTo(focusX * 0.5f, MAX_DIM, focusX * 0.75f, MAX_DIM * 0.75f, focusX, 0f);
1213         p.cubicTo(cpoint2X, 0f, cpoint2X, MED_DIM, 1f, MED_DIM);
1214         return p;
1215     }
1216
1217     /**
1218      * Scales the given {@param value} to the scale of the {@param instance} rect relative to the
1219      * {@param other} rect in the {@param extent} side.
1220      */
1221     private int getScaleForExtent(Rect instance, Rect other, int value, int minValue,
1222                                   @Extent int extent) {
1223         if (extent == WIDTH) {
1224             float scale = Utilities.clamp01((float) instance.width() / other.width());
1225             return Math.max(minValue, (int) (scale * value));
1226         } else if (extent == HEIGHT) {
1227             float scale = Utilities.clamp01((float) instance.height() / other.height());
1228             return Math.max(minValue, (int) (scale * value));
1229         }
1230         return value;
1231     }
1232
1233     /**
1234      * Updates the current transforms that would put a TaskView at the front and back of the stack.
1235      */
1236     private void updateFrontBackTransforms() {
1237         // Return early if we have not yet initialized
1238         if (mStackRect.isEmpty()) {
1239             return;
1240         }
1241
1242         float min = Utilities.mapRange(mFocusState, mUnfocusedRange.relativeMin,
1243                 mFocusedRange.relativeMin);
1244         float max = Utilities.mapRange(mFocusState, mUnfocusedRange.relativeMax,
1245                 mFocusedRange.relativeMax);
1246         getStackTransform(min, min, 0f, mFocusState, mBackOfStackTransform, null,
1247                 true /* ignoreSingleTaskCase */, true /* forceUpdate */);
1248         getStackTransform(max, max, 0f, mFocusState, mFrontOfStackTransform, null,
1249                 true /* ignoreSingleTaskCase */, true /* forceUpdate */);
1250         mBackOfStackTransform.visible = true;
1251         mFrontOfStackTransform.visible = true;
1252     }
1253
1254     public void dump(String prefix, PrintWriter writer) {
1255         String innerPrefix = prefix + "  ";
1256
1257         writer.print(prefix); writer.print(TAG);
1258         writer.write(" numStackTasks="); writer.write(mNumStackTasks);
1259         writer.println();
1260
1261         writer.print(innerPrefix);
1262         writer.print("insets="); writer.print(Utilities.dumpRect(mSystemInsets));
1263         writer.print(" stack="); writer.print(Utilities.dumpRect(mStackRect));
1264         writer.print(" task="); writer.print(Utilities.dumpRect(mTaskRect));
1265         writer.print(" freeform="); writer.print(Utilities.dumpRect(mFreeformRect));
1266         writer.print(" actionButton="); writer.print(Utilities.dumpRect(mStackActionButtonRect));
1267         writer.println();
1268
1269         writer.print(innerPrefix);
1270         writer.print("minScroll="); writer.print(mMinScrollP);
1271         writer.print(" maxScroll="); writer.print(mMaxScrollP);
1272         writer.print(" initialScroll="); writer.print(mInitialScrollP);
1273         writer.println();
1274
1275         writer.print(innerPrefix);
1276         writer.print("focusState="); writer.print(mFocusState);
1277         writer.println();
1278
1279         if (mTaskIndexOverrideMap.size() > 0) {
1280             for (int i = mTaskIndexOverrideMap.size() - 1; i >= 0; i--) {
1281                 int taskId = mTaskIndexOverrideMap.keyAt(i);
1282                 float x = mTaskIndexMap.get(taskId);
1283                 float overrideX = mTaskIndexOverrideMap.get(taskId, 0f);
1284
1285                 writer.print(innerPrefix);
1286                 writer.print("taskId= "); writer.print(taskId);
1287                 writer.print(" x= "); writer.print(x);
1288                 writer.print(" overrideX= "); writer.print(overrideX);
1289                 writer.println();
1290             }
1291         }
1292     }
1293 }