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.launchedFromBlacklistedApp) { 560 mInitialScrollP = mMaxScrollP; 561 } else if (launchState.launchedWithAltTab) { 562 mInitialScrollP = Utilities.clamp(launchTaskIndex, mMinScrollP, mMaxScrollP); 563 } else if (scrollToFront) { 564 mInitialScrollP = Utilities.clamp(launchTaskIndex, mMinScrollP, mMaxScrollP); 565 } else { 566 // We are overriding the initial two task positions, so set the initial scroll 567 // position to match the second task (aka focused task) position 568 float initialTopNormX = getNormalizedXFromUnfocusedY(mInitialTopOffset, FROM_TOP); 569 mInitialScrollP = Math.max(mMinScrollP, Math.min(mMaxScrollP, (mNumStackTasks - 2)) 570 - Math.max(0, mUnfocusedRange.getAbsoluteX(initialTopNormX))); 571 } 572 } 573 } 574 575 /** 576 * Creates task overrides to ensure the initial stack layout if necessary. 577 */ 578 public void setTaskOverridesForInitialState(TaskStack stack, boolean ignoreScrollToFront) { 579 RecentsActivityLaunchState launchState = Recents.getConfiguration().getLaunchState(); 580 581 mTaskIndexOverrideMap.clear(); 582 583 boolean scrollToFront = launchState.launchedFromHome || 584 launchState.launchedFromBlacklistedApp || 585 launchState.launchedViaDockGesture; 586 if (getInitialFocusState() == STATE_UNFOCUSED && mNumStackTasks > 1) { 587 if (ignoreScrollToFront || (!launchState.launchedWithAltTab && !scrollToFront)) { 588 // Set the initial scroll to the predefined state (which differs from the stack) 589 float [] initialNormX = null; 590 float minBottomTaskNormX = getNormalizedXFromUnfocusedY(mSystemInsets.bottom + 591 mInitialBottomOffset, FROM_BOTTOM); 592 float maxBottomTaskNormX = getNormalizedXFromUnfocusedY(mFocusedTopPeekHeight + 593 mTaskRect.height() - mMinMargin, FROM_TOP); 594 if (mNumStackTasks <= 2) { 595 // For small stacks, position the tasks so that they are top aligned to under 596 // the action button, but ensure that it is at least a certain offset from the 597 // bottom of the stack 598 initialNormX = new float[] { 599 Math.min(maxBottomTaskNormX, minBottomTaskNormX), 600 getNormalizedXFromUnfocusedY(mFocusedTopPeekHeight, FROM_TOP) 601 }; 602 } else { 603 initialNormX = new float[] { 604 minBottomTaskNormX, 605 getNormalizedXFromUnfocusedY(mInitialTopOffset, FROM_TOP) 606 }; 607 } 608 609 mUnfocusedRange.offset(0f); 610 List<Task> tasks = stack.getStackTasks(); 611 int taskCount = tasks.size(); 612 for (int i = taskCount - 1; i >= 0; i--) { 613 int indexFromFront = taskCount - i - 1; 614 if (indexFromFront >= initialNormX.length) { 615 break; 616 } 617 float newTaskProgress = mInitialScrollP + 618 mUnfocusedRange.getAbsoluteX(initialNormX[indexFromFront]); 619 mTaskIndexOverrideMap.put(tasks.get(i).key.id, newTaskProgress); 620 } 621 } 622 } 623 } 624 625 /** 626 * Adds and override task progress for the given task when transitioning from focused to 627 * unfocused state. 628 */ 629 public void addUnfocusedTaskOverride(Task task, float stackScroll) { 630 if (mFocusState != STATE_UNFOCUSED) { 631 mFocusedRange.offset(stackScroll); 632 mUnfocusedRange.offset(stackScroll); 633 float focusedRangeX = mFocusedRange.getNormalizedX(mTaskIndexMap.get(task.key.id)); 634 float focusedY = mFocusedCurveInterpolator.getInterpolation(focusedRangeX); 635 float unfocusedRangeX = mUnfocusedCurveInterpolator.getX(focusedY); 636 float unfocusedTaskProgress = stackScroll + mUnfocusedRange.getAbsoluteX(unfocusedRangeX); 637 if (Float.compare(focusedRangeX, unfocusedRangeX) != 0) { 638 mTaskIndexOverrideMap.put(task.key.id, unfocusedTaskProgress); 639 } 640 } 641 } 642 643 /** 644 * Adds and override task progress for the given task when transitioning from focused to 645 * unfocused state. 646 */ 647 public void addUnfocusedTaskOverride(TaskView taskView, float stackScroll) { 648 mFocusedRange.offset(stackScroll); 649 mUnfocusedRange.offset(stackScroll); 650 651 Task task = taskView.getTask(); 652 int top = taskView.getTop() - mTaskRect.top; 653 float focusedRangeX = getNormalizedXFromFocusedY(top, FROM_TOP); 654 float unfocusedRangeX = getNormalizedXFromUnfocusedY(top, FROM_TOP); 655 float unfocusedTaskProgress = stackScroll + mUnfocusedRange.getAbsoluteX(unfocusedRangeX); 656 if (Float.compare(focusedRangeX, unfocusedRangeX) != 0) { 657 mTaskIndexOverrideMap.put(task.key.id, unfocusedTaskProgress); 658 } 659 } 660 661 public void clearUnfocusedTaskOverrides() { 662 mTaskIndexOverrideMap.clear(); 663 } 664 665 /** 666 * Updates this stack when a scroll happens. 667 * 668 */ 669 public float updateFocusStateOnScroll(float lastTargetStackScroll, float targetStackScroll, 670 float lastStackScroll) { 671 if (targetStackScroll == lastStackScroll) { 672 return targetStackScroll; 673 } 674 675 float deltaScroll = targetStackScroll - lastStackScroll; 676 float deltaTargetScroll = targetStackScroll - lastTargetStackScroll; 677 float newScroll = targetStackScroll; 678 mUnfocusedRange.offset(targetStackScroll); 679 for (int i = mTaskIndexOverrideMap.size() - 1; i >= 0; i--) { 680 int taskId = mTaskIndexOverrideMap.keyAt(i); 681 float x = mTaskIndexMap.get(taskId); 682 float overrideX = mTaskIndexOverrideMap.get(taskId, 0f); 683 float newOverrideX = overrideX + deltaScroll; 684 if (isInvalidOverrideX(x, overrideX, newOverrideX)) { 685 // Remove the override once we reach the original task index 686 mTaskIndexOverrideMap.removeAt(i); 687 } else if ((overrideX >= x && deltaScroll <= 0f) || 688 (overrideX <= x && deltaScroll >= 0f)) { 689 // Scrolling from override x towards x, then lock the task in place 690 mTaskIndexOverrideMap.put(taskId, newOverrideX); 691 } else { 692 // Scrolling override x away from x, we should still move the scroll towards x 693 newScroll = lastStackScroll; 694 newOverrideX = overrideX - deltaTargetScroll; 695 if (isInvalidOverrideX(x, overrideX, newOverrideX)) { 696 mTaskIndexOverrideMap.removeAt(i); 697 } else{ 698 mTaskIndexOverrideMap.put(taskId, newOverrideX); 699 } 700 } 701 } 702 return newScroll; 703 } 704 705 private boolean isInvalidOverrideX(float x, float overrideX, float newOverrideX) { 706 boolean outOfBounds = mUnfocusedRange.getNormalizedX(newOverrideX) < 0f || 707 mUnfocusedRange.getNormalizedX(newOverrideX) > 1f; 708 return outOfBounds || (overrideX >= x && x >= newOverrideX) || 709 (overrideX <= x && x <= newOverrideX); 710 } 711 712 /** 713 * Returns the default focus state. 714 */ 715 public int getInitialFocusState() { 716 RecentsActivityLaunchState launchState = Recents.getConfiguration().getLaunchState(); 717 RecentsDebugFlags debugFlags = Recents.getDebugFlags(); 718 if (debugFlags.isPagingEnabled() || launchState.launchedWithAltTab) { 719 return STATE_FOCUSED; 720 } else { 721 return STATE_UNFOCUSED; 722 } 723 } 724 725 /** 726 * Returns the TaskViewTransform that would put the task just off the back of the stack. 727 */ 728 public TaskViewTransform getBackOfStackTransform() { 729 return mBackOfStackTransform; 730 } 731 732 /** 733 * Returns the TaskViewTransform that would put the task just off the front of the stack. 734 */ 735 public TaskViewTransform getFrontOfStackTransform() { 736 return mFrontOfStackTransform; 737 } 738 739 /** 740 * Returns the current stack state. 741 */ 742 public StackState getStackState() { 743 return mState; 744 } 745 746 /** 747 * Returns whether this stack layout has been initialized. 748 */ 749 public boolean isInitialized() { 750 return !mStackRect.isEmpty(); 751 } 752 753 /** 754 * Computes the maximum number of visible tasks and thumbnails when the scroll is at the initial 755 * stack scroll. Requires that update() is called first. 756 */ 757 public VisibilityReport computeStackVisibilityReport(ArrayList<Task> tasks) { 758 // Ensure minimum visibility count 759 if (tasks.size() <= 1) { 760 return new VisibilityReport(1, 1); 761 } 762 763 // Quick return when there are no stack tasks 764 if (mNumStackTasks == 0) { 765 return new VisibilityReport(Math.max(mNumFreeformTasks, 1), 766 Math.max(mNumFreeformTasks, 1)); 767 } 768 769 // Otherwise, walk backwards in the stack and count the number of tasks and visible 770 // thumbnails and add that to the total freeform task count 771 TaskViewTransform tmpTransform = new TaskViewTransform(); 772 Range currentRange = getInitialFocusState() > 0f ? mFocusedRange : mUnfocusedRange; 773 currentRange.offset(mInitialScrollP); 774 int taskBarHeight = mContext.getResources().getDimensionPixelSize( 775 R.dimen.recents_task_view_header_height); 776 int numVisibleTasks = Math.max(mNumFreeformTasks, 1); 777 int numVisibleThumbnails = Math.max(mNumFreeformTasks, 1); 778 float prevScreenY = Integer.MAX_VALUE; 779 for (int i = tasks.size() - 1; i >= 0; i--) { 780 Task task = tasks.get(i); 781 782 // Skip freeform 783 if (task.isFreeformTask()) { 784 continue; 785 } 786 787 // Skip invisible 788 float taskProgress = getStackScrollForTask(task); 789 if (!currentRange.isInRange(taskProgress)) { 790 continue; 791 } 792 793 boolean isFrontMostTaskInGroup = task.group == null || task.group.isFrontMostTask(task); 794 if (isFrontMostTaskInGroup) { 795 getStackTransform(taskProgress, taskProgress, mInitialScrollP, mFocusState, 796 tmpTransform, null, false /* ignoreSingleTaskCase */, 797 false /* forceUpdate */); 798 float screenY = tmpTransform.rect.top; 799 boolean hasVisibleThumbnail = (prevScreenY - screenY) > taskBarHeight; 800 if (hasVisibleThumbnail) { 801 numVisibleThumbnails++; 802 numVisibleTasks++; 803 prevScreenY = screenY; 804 } else { 805 // Once we hit the next front most task that does not have a visible thumbnail, 806 // walk through remaining visible set 807 for (int j = i; j >= 0; j--) { 808 numVisibleTasks++; 809 taskProgress = getStackScrollForTask(tasks.get(j)); 810 if (!currentRange.isInRange(taskProgress)) { 811 continue; 812 } 813 } 814 break; 815 } 816 } else if (!isFrontMostTaskInGroup) { 817 // Affiliated task, no thumbnail 818 numVisibleTasks++; 819 } 820 } 821 return new VisibilityReport(numVisibleTasks, numVisibleThumbnails); 822 } 823 824 /** 825 * Returns the transform for the given task. This transform is relative to the mTaskRect, which 826 * is what the view is measured and laid out with. 827 */ 828 public TaskViewTransform getStackTransform(Task task, float stackScroll, 829 TaskViewTransform transformOut, TaskViewTransform frontTransform) { 830 return getStackTransform(task, stackScroll, mFocusState, transformOut, frontTransform, 831 false /* forceUpdate */, false /* ignoreTaskOverrides */); 832 } 833 834 public TaskViewTransform getStackTransform(Task task, float stackScroll, 835 TaskViewTransform transformOut, TaskViewTransform frontTransform, 836 boolean ignoreTaskOverrides) { 837 return getStackTransform(task, stackScroll, mFocusState, transformOut, frontTransform, 838 false /* forceUpdate */, ignoreTaskOverrides); 839 } 840 841 public TaskViewTransform getStackTransform(Task task, float stackScroll, int focusState, 842 TaskViewTransform transformOut, TaskViewTransform frontTransform, boolean forceUpdate, 843 boolean ignoreTaskOverrides) { 844 if (mFreeformLayoutAlgorithm.isTransformAvailable(task, this)) { 845 mFreeformLayoutAlgorithm.getTransform(task, transformOut, this); 846 return transformOut; 847 } else { 848 // Return early if we have an invalid index 849 int nonOverrideTaskProgress = mTaskIndexMap.get(task.key.id, -1); 850 if (task == null || nonOverrideTaskProgress == -1) { 851 transformOut.reset(); 852 return transformOut; 853 } 854 float taskProgress = ignoreTaskOverrides 855 ? nonOverrideTaskProgress 856 : getStackScrollForTask(task); 857 getStackTransform(taskProgress, nonOverrideTaskProgress, stackScroll, focusState, 858 transformOut, frontTransform, false /* ignoreSingleTaskCase */, forceUpdate); 859 return transformOut; 860 } 861 } 862 863 /** 864 * Like {@link #getStackTransform}, but in screen coordinates 865 */ 866 public TaskViewTransform getStackTransformScreenCoordinates(Task task, float stackScroll, 867 TaskViewTransform transformOut, TaskViewTransform frontTransform, 868 Rect windowOverrideRect) { 869 TaskViewTransform transform = getStackTransform(task, stackScroll, mFocusState, 870 transformOut, frontTransform, true /* forceUpdate */, 871 false /* ignoreTaskOverrides */); 872 return transformToScreenCoordinates(transform, windowOverrideRect); 873 } 874 875 /** 876 * Transforms the given {@param transformOut} to the screen coordinates, overriding the current 877 * window rectangle with {@param windowOverrideRect} if non-null. 878 */ 879 public TaskViewTransform transformToScreenCoordinates(TaskViewTransform transformOut, 880 Rect windowOverrideRect) { 881 Rect windowRect = windowOverrideRect != null 882 ? windowOverrideRect 883 : Recents.getSystemServices().getWindowRect(); 884 transformOut.rect.offset(windowRect.left, windowRect.top); 885 return transformOut; 886 } 887 888 /** 889 * Update/get the transform. 890 * 891 * @param ignoreSingleTaskCase When set, will ensure that the transform computed does not take 892 * into account the special single-task case. This is only used 893 * internally to ensure that we can calculate the transform for any 894 * position in the stack. 895 */ 896 public void getStackTransform(float taskProgress, float nonOverrideTaskProgress, 897 float stackScroll, int focusState, TaskViewTransform transformOut, 898 TaskViewTransform frontTransform, boolean ignoreSingleTaskCase, boolean forceUpdate) { 899 SystemServicesProxy ssp = Recents.getSystemServices(); 900 901 // Ensure that the task is in range 902 mUnfocusedRange.offset(stackScroll); 903 mFocusedRange.offset(stackScroll); 904 boolean unfocusedVisible = mUnfocusedRange.isInRange(taskProgress); 905 boolean focusedVisible = mFocusedRange.isInRange(taskProgress); 906 907 // Skip if the task is not visible 908 if (!forceUpdate && !unfocusedVisible && !focusedVisible) { 909 transformOut.reset(); 910 return; 911 } 912 913 // Map the absolute task progress to the normalized x at the stack scroll. We use this to 914 // calculate positions along the curve. 915 mUnfocusedRange.offset(stackScroll); 916 mFocusedRange.offset(stackScroll); 917 float unfocusedRangeX = mUnfocusedRange.getNormalizedX(taskProgress); 918 float focusedRangeX = mFocusedRange.getNormalizedX(taskProgress); 919 920 // Map the absolute task progress to the normalized x at the bounded stack scroll. We use 921 // this to calculate bounded properties, like translationZ and outline alpha. 922 float boundedStackScroll = Utilities.clamp(stackScroll, mMinScrollP, mMaxScrollP); 923 mUnfocusedRange.offset(boundedStackScroll); 924 mFocusedRange.offset(boundedStackScroll); 925 float boundedScrollUnfocusedRangeX = mUnfocusedRange.getNormalizedX(taskProgress); 926 float boundedScrollUnfocusedNonOverrideRangeX = 927 mUnfocusedRange.getNormalizedX(nonOverrideTaskProgress); 928 929 // Map the absolute task progress to the normalized x at the upper bounded stack scroll. 930 // We use this to calculate the dim, which is bounded only on one end. 931 float lowerBoundedStackScroll = Utilities.clamp(stackScroll, -Float.MAX_VALUE, mMaxScrollP); 932 mUnfocusedRange.offset(lowerBoundedStackScroll); 933 mFocusedRange.offset(lowerBoundedStackScroll); 934 float lowerBoundedUnfocusedRangeX = mUnfocusedRange.getNormalizedX(taskProgress); 935 float lowerBoundedFocusedRangeX = mFocusedRange.getNormalizedX(taskProgress); 936 937 int x = (mStackRect.width() - mTaskRect.width()) / 2; 938 int y; 939 float z; 940 float dimAlpha; 941 float viewOutlineAlpha; 942 if (!ssp.hasFreeformWorkspaceSupport() && mNumStackTasks == 1 && !ignoreSingleTaskCase) { 943 // When there is exactly one task, then decouple the task from the stack and just move 944 // in screen space 945 float tmpP = (mMinScrollP - stackScroll) / mNumStackTasks; 946 int centerYOffset = (mStackRect.top - mTaskRect.top) + 947 (mStackRect.height() - mSystemInsets.bottom - mTaskRect.height()) / 2; 948 y = centerYOffset + getYForDeltaP(tmpP, 0); 949 z = mMaxTranslationZ; 950 dimAlpha = 0f; 951 viewOutlineAlpha = OUTLINE_ALPHA_MIN_VALUE + 952 (OUTLINE_ALPHA_MAX_VALUE - OUTLINE_ALPHA_MIN_VALUE) / 2f; 953 954 } else { 955 // Otherwise, update the task to the stack layout 956 int unfocusedY = (int) ((1f - mUnfocusedCurveInterpolator.getInterpolation( 957 unfocusedRangeX)) * mStackRect.height()); 958 int focusedY = (int) ((1f - mFocusedCurveInterpolator.getInterpolation( 959 focusedRangeX)) * mStackRect.height()); 960 float unfocusedDim = mUnfocusedDimCurveInterpolator.getInterpolation( 961 lowerBoundedUnfocusedRangeX); 962 float focusedDim = mFocusedDimCurveInterpolator.getInterpolation( 963 lowerBoundedFocusedRangeX); 964 965 // Special case, because we override the initial task positions differently for small 966 // stacks, we clamp the dim to 0 in the initial position, and then only modulate the 967 // dim when the task is scrolled back towards the top of the screen 968 if (mNumStackTasks <= 2 && nonOverrideTaskProgress == 0f) { 969 if (boundedScrollUnfocusedRangeX >= 0.5f) { 970 unfocusedDim = 0f; 971 } else { 972 float offset = mUnfocusedDimCurveInterpolator.getInterpolation(0.5f); 973 unfocusedDim -= offset; 974 unfocusedDim *= MAX_DIM / (MAX_DIM - offset); 975 } 976 } 977 978 y = (mStackRect.top - mTaskRect.top) + 979 (int) Utilities.mapRange(focusState, unfocusedY, focusedY); 980 z = Utilities.mapRange(Utilities.clamp01(boundedScrollUnfocusedNonOverrideRangeX), 981 mMinTranslationZ, mMaxTranslationZ); 982 dimAlpha = Utilities.mapRange(focusState, unfocusedDim, focusedDim); 983 viewOutlineAlpha = Utilities.mapRange(Utilities.clamp01(boundedScrollUnfocusedRangeX), 984 OUTLINE_ALPHA_MIN_VALUE, OUTLINE_ALPHA_MAX_VALUE); 985 } 986 987 // Fill out the transform 988 transformOut.scale = 1f; 989 transformOut.alpha = 1f; 990 transformOut.translationZ = z; 991 transformOut.dimAlpha = dimAlpha; 992 transformOut.viewOutlineAlpha = viewOutlineAlpha; 993 transformOut.rect.set(mTaskRect); 994 transformOut.rect.offset(x, y); 995 Utilities.scaleRectAboutCenter(transformOut.rect, transformOut.scale); 996 transformOut.visible = (transformOut.rect.top < mStackRect.bottom) && 997 (frontTransform == null || transformOut.rect.top != frontTransform.rect.top); 998 } 999 1000 /** 1001 * Returns the untransformed task view bounds. 1002 */ 1003 public Rect getUntransformedTaskViewBounds() { 1004 return new Rect(mTaskRect); 1005 } 1006 1007 /** 1008 * Returns the scroll progress to scroll to such that the top of the task is at the top of the 1009 * stack. 1010 */ 1011 float getStackScrollForTask(Task t) { 1012 Float overrideP = mTaskIndexOverrideMap.get(t.key.id, null); 1013 if (overrideP == null) { 1014 return (float) mTaskIndexMap.get(t.key.id, 0); 1015 } 1016 return overrideP; 1017 } 1018 1019 /** 1020 * Returns the original scroll progress to scroll to such that the top of the task is at the top 1021 * of the stack. 1022 */ 1023 float getStackScrollForTaskIgnoreOverrides(Task t) { 1024 return (float) mTaskIndexMap.get(t.key.id, 0); 1025 } 1026 1027 /** 1028 * Returns the scroll progress to scroll to such that the top of the task at the initial top 1029 * offset (which is at the task's brightest point). 1030 */ 1031 float getStackScrollForTaskAtInitialOffset(Task t) { 1032 float normX = getNormalizedXFromUnfocusedY(mInitialTopOffset, FROM_TOP); 1033 mUnfocusedRange.offset(0f); 1034 return Utilities.clamp((float) mTaskIndexMap.get(t.key.id, 0) - Math.max(0, 1035 mUnfocusedRange.getAbsoluteX(normX)), mMinScrollP, mMaxScrollP); 1036 } 1037 1038 /** 1039 * Maps a movement in screen y, relative to {@param downY}, to a movement in along the arc 1040 * length of the curve. We know the curve is mostly flat, so we just map the length of the 1041 * screen along the arc-length proportionally (1/arclength). 1042 */ 1043 public float getDeltaPForY(int downY, int y) { 1044 float deltaP = (float) (y - downY) / mStackRect.height() * 1045 mUnfocusedCurveInterpolator.getArcLength(); 1046 return -deltaP; 1047 } 1048 1049 /** 1050 * This is the inverse of {@link #getDeltaPForY}. Given a movement along the arc length 1051 * of the curve, map back to the screen y. 1052 */ 1053 public int getYForDeltaP(float downScrollP, float p) { 1054 int y = (int) ((p - downScrollP) * mStackRect.height() * 1055 (1f / mUnfocusedCurveInterpolator.getArcLength())); 1056 return -y; 1057 } 1058 1059 /** 1060 * Returns the task stack bounds in the current orientation. This rect takes into account the 1061 * top and right system insets (but not the bottom inset) and left/right paddings, but _not_ 1062 * the top/bottom padding or insets. 1063 */ 1064 public void getTaskStackBounds(Rect displayRect, Rect windowRect, int topInset, int leftInset, 1065 int rightInset, Rect taskStackBounds) { 1066 taskStackBounds.set(windowRect.left + leftInset, windowRect.top + topInset, 1067 windowRect.right - rightInset, windowRect.bottom); 1068 1069 // Ensure that the new width is at most the smaller display edge size 1070 int sideMargin = getScaleForExtent(windowRect, displayRect, mBaseSideMargin, mMinMargin, 1071 WIDTH); 1072 int targetStackWidth = taskStackBounds.width() - 2 * sideMargin; 1073 if (Utilities.getAppConfiguration(mContext).orientation 1074 == Configuration.ORIENTATION_LANDSCAPE) { 1075 // If we are in landscape, calculate the width of the stack in portrait and ensure that 1076 // we are not larger than that size 1077 Rect portraitDisplayRect = new Rect(0, 0, 1078 Math.min(displayRect.width(), displayRect.height()), 1079 Math.max(displayRect.width(), displayRect.height())); 1080 int portraitSideMargin = getScaleForExtent(portraitDisplayRect, portraitDisplayRect, 1081 mBaseSideMargin, mMinMargin, WIDTH); 1082 targetStackWidth = Math.min(targetStackWidth, 1083 portraitDisplayRect.width() - 2 * portraitSideMargin); 1084 } 1085 taskStackBounds.inset((taskStackBounds.width() - targetStackWidth) / 2, 0); 1086 } 1087 1088 /** 1089 * Retrieves resources that are constant regardless of the current configuration of the device. 1090 */ 1091 public static int getDimensionForDevice(Context ctx, int phoneResId, 1092 int tabletResId, int xlargeTabletResId) { 1093 return getDimensionForDevice(ctx, phoneResId, phoneResId, tabletResId, tabletResId, 1094 xlargeTabletResId, xlargeTabletResId); 1095 } 1096 1097 /** 1098 * Retrieves resources that are constant regardless of the current configuration of the device. 1099 */ 1100 public static int getDimensionForDevice(Context ctx, int phonePortResId, int phoneLandResId, 1101 int tabletPortResId, int tabletLandResId, int xlargeTabletPortResId, 1102 int xlargeTabletLandResId) { 1103 RecentsConfiguration config = Recents.getConfiguration(); 1104 Resources res = ctx.getResources(); 1105 boolean isLandscape = Utilities.getAppConfiguration(ctx).orientation == 1106 Configuration.ORIENTATION_LANDSCAPE; 1107 if (config.isXLargeScreen) { 1108 return res.getDimensionPixelSize(isLandscape 1109 ? xlargeTabletLandResId 1110 : xlargeTabletPortResId); 1111 } else if (config.isLargeScreen) { 1112 return res.getDimensionPixelSize(isLandscape 1113 ? tabletLandResId 1114 : tabletPortResId); 1115 } else { 1116 return res.getDimensionPixelSize(isLandscape 1117 ? phoneLandResId 1118 : phonePortResId); 1119 } 1120 } 1121 1122 /** 1123 * Returns the normalized x on the unfocused curve given an absolute Y position (relative to the 1124 * stack height). 1125 */ 1126 private float getNormalizedXFromUnfocusedY(float y, @AnchorSide int fromSide) { 1127 float offset = (fromSide == FROM_TOP) 1128 ? mStackRect.height() - y 1129 : y; 1130 float offsetPct = offset / mStackRect.height(); 1131 return mUnfocusedCurveInterpolator.getX(offsetPct); 1132 } 1133 1134 /** 1135 * Returns the normalized x on the focused curve given an absolute Y position (relative to the 1136 * stack height). 1137 */ 1138 private float getNormalizedXFromFocusedY(float y, @AnchorSide int fromSide) { 1139 float offset = (fromSide == FROM_TOP) 1140 ? mStackRect.height() - y 1141 : y; 1142 float offsetPct = offset / mStackRect.height(); 1143 return mFocusedCurveInterpolator.getX(offsetPct); 1144 } 1145 1146 /** 1147 * Creates a new path for the focused curve. 1148 */ 1149 private Path constructFocusedCurve() { 1150 // Initialize the focused curve. This curve is a piecewise curve composed of several 1151 // linear pieces that goes from (0,1) through (0.5, peek height offset), 1152 // (0.5, bottom task offsets), and (1,0). 1153 float topPeekHeightPct = (float) mFocusedTopPeekHeight / mStackRect.height(); 1154 float bottomPeekHeightPct = (float) (mStackBottomOffset + mFocusedBottomPeekHeight) / 1155 mStackRect.height(); 1156 float minBottomPeekHeightPct = (float) (mFocusedTopPeekHeight + mTaskRect.height() - 1157 mMinMargin) / mStackRect.height(); 1158 Path p = new Path(); 1159 p.moveTo(0f, 1f); 1160 p.lineTo(0.5f, 1f - topPeekHeightPct); 1161 p.lineTo(1f - (0.5f / mFocusedRange.relativeMax), Math.max(1f - minBottomPeekHeightPct, 1162 bottomPeekHeightPct)); 1163 p.lineTo(1f, 0f); 1164 return p; 1165 } 1166 1167 /** 1168 * Creates a new path for the unfocused curve. 1169 */ 1170 private Path constructUnfocusedCurve() { 1171 // Initialize the unfocused curve. This curve is a piecewise curve composed of two quadradic 1172 // beziers that goes from (0,1) through (0.5, peek height offset) and ends at (1,0). This 1173 // ensures that we match the range, at which 0.5 represents the stack scroll at the current 1174 // task progress. Because the height offset can change depending on a resource, we compute 1175 // the control point of the second bezier such that between it and a first known point, 1176 // there is a tangent at (0.5, peek height offset). 1177 float cpoint1X = 0.4f; 1178 float cpoint1Y = 0.975f; 1179 float topPeekHeightPct = (float) mFocusedTopPeekHeight / mStackRect.height(); 1180 float slope = ((1f - topPeekHeightPct) - cpoint1Y) / (0.5f - cpoint1X); 1181 float b = 1f - slope * cpoint1X; 1182 float cpoint2X = 0.65f; 1183 float cpoint2Y = slope * cpoint2X + b; 1184 Path p = new Path(); 1185 p.moveTo(0f, 1f); 1186 p.cubicTo(0f, 1f, cpoint1X, cpoint1Y, 0.5f, 1f - topPeekHeightPct); 1187 p.cubicTo(0.5f, 1f - topPeekHeightPct, cpoint2X, cpoint2Y, 1f, 0f); 1188 return p; 1189 } 1190 1191 /** 1192 * Creates a new path for the focused dim curve. 1193 */ 1194 private Path constructFocusedDimCurve() { 1195 Path p = new Path(); 1196 // The focused dim interpolator starts at max dim, reduces to zero at 0.5 (the focused 1197 // task), then goes back to max dim at the next task 1198 p.moveTo(0f, MAX_DIM); 1199 p.lineTo(0.5f, 0f); 1200 p.lineTo(0.5f + (0.5f / mFocusedRange.relativeMax), MAX_DIM); 1201 p.lineTo(1f, MAX_DIM); 1202 return p; 1203 } 1204 1205 /** 1206 * Creates a new path for the unfocused dim curve. 1207 */ 1208 private Path constructUnfocusedDimCurve() { 1209 float focusX = getNormalizedXFromUnfocusedY(mInitialTopOffset, FROM_TOP); 1210 float cpoint2X = focusX + (1f - focusX) / 2; 1211 Path p = new Path(); 1212 // The unfocused dim interpolator starts at max dim, reduces to zero at 0.5 (the focused 1213 // task), then goes back to max dim towards the front of the stack 1214 p.moveTo(0f, MAX_DIM); 1215 p.cubicTo(focusX * 0.5f, MAX_DIM, focusX * 0.75f, MAX_DIM * 0.75f, focusX, 0f); 1216 p.cubicTo(cpoint2X, 0f, cpoint2X, MED_DIM, 1f, MED_DIM); 1217 return p; 1218 } 1219 1220 /** 1221 * Scales the given {@param value} to the scale of the {@param instance} rect relative to the 1222 * {@param other} rect in the {@param extent} side. 1223 */ 1224 private int getScaleForExtent(Rect instance, Rect other, int value, int minValue, 1225 @Extent int extent) { 1226 if (extent == WIDTH) { 1227 float scale = Utilities.clamp01((float) instance.width() / other.width()); 1228 return Math.max(minValue, (int) (scale * value)); 1229 } else if (extent == HEIGHT) { 1230 float scale = Utilities.clamp01((float) instance.height() / other.height()); 1231 return Math.max(minValue, (int) (scale * value)); 1232 } 1233 return value; 1234 } 1235 1236 /** 1237 * Updates the current transforms that would put a TaskView at the front and back of the stack. 1238 */ 1239 private void updateFrontBackTransforms() { 1240 // Return early if we have not yet initialized 1241 if (mStackRect.isEmpty()) { 1242 return; 1243 } 1244 1245 float min = Utilities.mapRange(mFocusState, mUnfocusedRange.relativeMin, 1246 mFocusedRange.relativeMin); 1247 float max = Utilities.mapRange(mFocusState, mUnfocusedRange.relativeMax, 1248 mFocusedRange.relativeMax); 1249 getStackTransform(min, min, 0f, mFocusState, mBackOfStackTransform, null, 1250 true /* ignoreSingleTaskCase */, true /* forceUpdate */); 1251 getStackTransform(max, max, 0f, mFocusState, mFrontOfStackTransform, null, 1252 true /* ignoreSingleTaskCase */, true /* forceUpdate */); 1253 mBackOfStackTransform.visible = true; 1254 mFrontOfStackTransform.visible = true; 1255 } 1256 1257 public void dump(String prefix, PrintWriter writer) { 1258 String innerPrefix = prefix + " "; 1259 1260 writer.print(prefix); writer.print(TAG); 1261 writer.write(" numStackTasks="); writer.print(mNumStackTasks); 1262 writer.println(); 1263 1264 writer.print(innerPrefix); 1265 writer.print("insets="); writer.print(Utilities.dumpRect(mSystemInsets)); 1266 writer.print(" stack="); writer.print(Utilities.dumpRect(mStackRect)); 1267 writer.print(" task="); writer.print(Utilities.dumpRect(mTaskRect)); 1268 writer.print(" freeform="); writer.print(Utilities.dumpRect(mFreeformRect)); 1269 writer.print(" actionButton="); writer.print(Utilities.dumpRect(mStackActionButtonRect)); 1270 writer.println(); 1271 1272 writer.print(innerPrefix); 1273 writer.print("minScroll="); writer.print(mMinScrollP); 1274 writer.print(" maxScroll="); writer.print(mMaxScrollP); 1275 writer.print(" initialScroll="); writer.print(mInitialScrollP); 1276 writer.println(); 1277 1278 writer.print(innerPrefix); 1279 writer.print("focusState="); writer.print(mFocusState); 1280 writer.println(); 1281 1282 if (mTaskIndexOverrideMap.size() > 0) { 1283 for (int i = mTaskIndexOverrideMap.size() - 1; i >= 0; i--) { 1284 int taskId = mTaskIndexOverrideMap.keyAt(i); 1285 float x = mTaskIndexMap.get(taskId); 1286 float overrideX = mTaskIndexOverrideMap.get(taskId, 0f); 1287 1288 writer.print(innerPrefix); 1289 writer.print("taskId= "); writer.print(taskId); 1290 writer.print(" x= "); writer.print(x); 1291 writer.print(" overrideX= "); writer.print(overrideX); 1292 writer.println(); 1293 } 1294 } 1295 } 1296 }
