blob: 3ddc90e7bd6d4f57291fb37ca542fcfea002c14d [file] [log] [blame]
Winson Chungb3800242013-10-24 11:01:54 -07001/*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.launcher3;
18
Thales Lima12d0eff2022-03-25 17:06:11 +000019import static com.android.launcher3.InvariantDeviceProfile.INDEX_DEFAULT;
20import static com.android.launcher3.InvariantDeviceProfile.INDEX_LANDSCAPE;
21import static com.android.launcher3.InvariantDeviceProfile.INDEX_TWO_PANEL_LANDSCAPE;
22import static com.android.launcher3.InvariantDeviceProfile.INDEX_TWO_PANEL_PORTRAIT;
Jon Mirandae126d722021-02-25 10:45:20 -050023import static com.android.launcher3.ResourceUtils.pxFromDp;
Jon Miranda58561d42021-03-17 10:51:54 -040024import static com.android.launcher3.Utilities.dpiFromPx;
Jon Mirandaaf3aed02021-05-06 18:28:45 -070025import static com.android.launcher3.Utilities.pxFromSp;
Jon Miranda92c1b5d2021-07-20 13:57:16 -070026import static com.android.launcher3.folder.ClippedFolderIconLayoutRule.ICON_OVERLAP_FACTOR;
Jon Miranda228877d2021-02-09 11:05:00 -050027
Sunny Goyal35c7b192021-04-20 16:51:10 -070028import android.annotation.SuppressLint;
Winson Chungb3800242013-10-24 11:01:54 -070029import android.content.Context;
Jon Mirandab28c4fc2017-06-20 10:58:36 -070030import android.content.res.Configuration;
Winson Chungb3800242013-10-24 11:01:54 -070031import android.content.res.Resources;
Sunny Goyal8b9919d2021-04-07 14:45:17 -070032import android.graphics.Path;
Winson Chungb3800242013-10-24 11:01:54 -070033import android.graphics.Point;
Jon Miranda7ae64ff2016-11-21 16:18:46 -080034import android.graphics.PointF;
Winson Chungb3800242013-10-24 11:01:54 -070035import android.graphics.Rect;
Sunny Goyal35c7b192021-04-20 16:51:10 -070036import android.util.DisplayMetrics;
Sunny Goyal59d086c2018-05-07 17:31:40 -070037import android.view.Surface;
Winson Chungb3800242013-10-24 11:01:54 -070038
Sunny Goyalc13403c2016-11-18 23:44:48 -080039import com.android.launcher3.CellLayout.ContainerType;
Jon Miranda228877d2021-02-09 11:05:00 -050040import com.android.launcher3.DevicePaddings.DevicePadding;
Tony Wickham8912b042018-11-29 15:28:53 -080041import com.android.launcher3.icons.DotRenderer;
Sunny Goyal8b9919d2021-04-07 14:45:17 -070042import com.android.launcher3.icons.GraphicsUtils;
Hyunyoung Song48cb7bc2018-09-25 17:03:34 -070043import com.android.launcher3.icons.IconNormalizer;
Sunny Goyal57b22792021-05-25 14:35:01 -070044import com.android.launcher3.uioverrides.ApiWrapper;
Sunny Goyalfd58da62020-08-11 12:06:49 -070045import com.android.launcher3.util.DisplayController;
46import com.android.launcher3.util.DisplayController.Info;
Sunny Goyalb46703d2020-05-27 17:52:03 -070047import com.android.launcher3.util.WindowBounds;
Winson1f064272016-07-18 17:18:02 -070048
Jon Miranda58561d42021-03-17 10:51:54 -040049import java.io.PrintWriter;
Brian Isganitis099945b2022-01-31 18:15:00 -050050import java.util.List;
Jon Miranda58561d42021-03-17 10:51:54 -040051
Sunny Goyal35c7b192021-04-20 16:51:10 -070052@SuppressLint("NewApi")
Winson Chungb3800242013-10-24 11:01:54 -070053public class DeviceProfile {
Adam Cohen2e6da152015-05-06 11:42:25 -070054
Sunny Goyal8b9919d2021-04-07 14:45:17 -070055 private static final int DEFAULT_DOT_SIZE = 100;
Sunny Goyal57b22792021-05-25 14:35:01 -070056 // Ratio of empty space, qsb should take up to appear visually centered.
Pratyush9afe1ea2021-10-13 11:13:27 +000057 private final float mQsbCenterFactor;
Sunny Goyal1890f672020-04-30 12:28:00 -070058
Adam Cohen2e6da152015-05-06 11:42:25 -070059 public final InvariantDeviceProfile inv;
Sunny Goyalfd58da62020-08-11 12:06:49 -070060 private final Info mInfo;
Sunny Goyal35c7b192021-04-20 16:51:10 -070061 private final DisplayMetrics mMetrics;
Winson Chungbe876472014-05-14 14:15:20 -070062
Sunny Goyalc6205602015-05-21 20:46:33 -070063 // Device properties
64 public final boolean isTablet;
Sunny Goyalc6205602015-05-21 20:46:33 -070065 public final boolean isPhone;
66 public final boolean transposeLayoutWithOrientation;
Sunny Goyal19ff7282021-04-22 10:12:54 -070067 public final boolean isTwoPanels;
Thales Limaa1012902022-01-13 17:58:42 +000068 public final boolean isQsbInline;
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -070069
Sunny Goyalc6205602015-05-21 20:46:33 -070070 // Device properties in current orientation
Sunny Goyald792a772018-04-05 13:37:46 -070071 public final boolean isLandscape;
Sunny Goyald70e75a2018-02-22 10:07:32 -080072 public final boolean isMultiWindowMode;
Alex Chau6ed408f2022-03-04 12:58:05 +000073 public final boolean isGestureMode;
Sunny Goyald70e75a2018-02-22 10:07:32 -080074
Sunny Goyal0addbf02020-04-28 14:17:35 -070075 public final int windowX;
76 public final int windowY;
Sunny Goyalc6205602015-05-21 20:46:33 -070077 public final int widthPx;
78 public final int heightPx;
79 public final int availableWidthPx;
80 public final int availableHeightPx;
Sunny Goyal187b16c2022-03-01 16:53:23 -080081 public final int rotationHint;
Jon Mirandabba64512019-03-27 10:54:17 -070082
83 public final float aspectRatio;
84
Jon Mirandae126d722021-02-25 10:45:20 -050085 public final boolean isScalableGrid;
Thales Lima83bedbf2021-10-05 17:47:39 +010086 private final int mTypeIndex;
Jon Mirandae126d722021-02-25 10:45:20 -050087
Tony Wickhamd6b40372015-09-23 18:37:57 -070088 /**
89 * The maximum amount of left/right workspace padding as a percentage of the screen width.
90 * To be clear, this means that up to 7% of the screen width can be used as left padding, and
91 * 7% of the screen width can be used as right padding.
92 */
93 private static final float MAX_HORIZONTAL_PADDING_PERCENT = 0.14f;
Winson Chungb3800242013-10-24 11:01:54 -070094
Jon Miranda3f9bab22017-07-28 14:50:17 -070095 private static final float TALL_DEVICE_ASPECT_RATIO_THRESHOLD = 2.0f;
Jon Miranda80cddbc2021-07-22 13:51:16 -070096 private static final float TALLER_DEVICE_ASPECT_RATIO_THRESHOLD = 2.15f;
Jon Miranda80dda302021-07-28 14:14:59 -070097 private static final float TALL_DEVICE_EXTRA_SPACE_THRESHOLD_DP = 252;
98 private static final float TALL_DEVICE_MORE_EXTRA_SPACE_THRESHOLD_DP = 268;
Jon Miranda30d0aa22017-07-25 15:55:29 -070099
Sunny Goyalc6205602015-05-21 20:46:33 -0700100 // Workspace
Thales Limad90faab2021-09-21 17:18:47 +0100101 public final int desiredWorkspaceHorizontalMarginOriginalPx;
102 public int desiredWorkspaceHorizontalMarginPx;
Thales Lima78d00ad2021-09-30 11:29:06 +0100103 public Point cellLayoutBorderSpaceOriginalPx;
104 public Point cellLayoutBorderSpacePx;
Pat Manning08610ca2022-04-05 21:03:16 +0100105 public Rect cellLayoutPaddingPx = new Rect();
106
Sunny Goyalc6205602015-05-21 20:46:33 -0700107 public final int edgeMarginPx;
Pat Manningde25c0d2022-04-05 19:11:26 +0100108 public float workspaceSpringLoadShrunkTop;
109 public float workspaceSpringLoadShrunkBottom;
Sunny Goyal47328fd2016-05-25 18:56:41 -0700110 public final int workspaceSpringLoadedBottomSpace;
Alex Chau906d8822022-05-23 10:42:25 +0100111 public final int workspaceSpringLoadedMinNextPageVisiblePx;
Sunny Goyalc6205602015-05-21 20:46:33 -0700112
Jon Miranda58561d42021-03-17 10:51:54 -0400113 private final int extraSpace;
Jon Miranda228877d2021-02-09 11:05:00 -0500114 public int workspaceTopPadding;
115 public int workspaceBottomPadding;
Jon Miranda58561d42021-03-17 10:51:54 -0400116 public int extraHotseatBottomPadding;
Jon Miranda228877d2021-02-09 11:05:00 -0500117
Tony Wickham5edf9e22020-03-27 20:06:52 -0700118 // Workspace page indicator
119 public final int workspacePageIndicatorHeight;
120 private final int mWorkspacePageIndicatorOverlapWorkspace;
Winson1f064272016-07-18 17:18:02 -0700121
Sunny Goyalc6205602015-05-21 20:46:33 -0700122 // Workspace icons
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400123 public float iconScale;
Sunny Goyalc6205602015-05-21 20:46:33 -0700124 public int iconSizePx;
125 public int iconTextSizePx;
126 public int iconDrawablePaddingPx;
Winson Chung5f4e0fd2015-05-22 11:12:27 -0700127 public int iconDrawablePaddingOriginalPx;
Winson Chungb3800242013-10-24 11:01:54 -0700128
Jon Mirandaab3c6812021-06-28 15:42:28 -0700129 public float cellScaleToFit;
Adam Cohen59400422014-03-05 18:07:04 -0800130 public int cellWidthPx;
131 public int cellHeightPx;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700132 public int workspaceCellPaddingXPx;
Adam Cohen59400422014-03-05 18:07:04 -0800133
Jon Mirandae126d722021-02-25 10:45:20 -0500134 public int cellYPaddingPx;
Jon Mirandae126d722021-02-25 10:45:20 -0500135
Sunny Goyalc6205602015-05-21 20:46:33 -0700136 // Folder
Jon Mirandae126d722021-02-25 10:45:20 -0500137 public float folderLabelTextScale;
138 public int folderLabelTextSizePx;
Sunny Goyalc6205602015-05-21 20:46:33 -0700139 public int folderIconSizePx;
Jon Miranda591e3602018-03-28 11:37:00 -0700140 public int folderIconOffsetYPx;
Jon Mirandabf7d8122016-11-03 15:29:29 -0700141
Jon Mirandae126d722021-02-25 10:45:20 -0500142 // Folder content
Thales Lima78d00ad2021-09-30 11:29:06 +0100143 public Point folderCellLayoutBorderSpacePx;
144 public int folderCellLayoutBorderSpaceOriginalPx;
Jon Mirandae126d722021-02-25 10:45:20 -0500145 public int folderContentPaddingLeftRight;
146 public int folderContentPaddingTop;
147
Jon Mirandabf7d8122016-11-03 15:29:29 -0700148 // Folder cell
Sunny Goyalc6205602015-05-21 20:46:33 -0700149 public int folderCellWidthPx;
150 public int folderCellHeightPx;
Jon Mirandabf7d8122016-11-03 15:29:29 -0700151
152 // Folder child
153 public int folderChildIconSizePx;
154 public int folderChildTextSizePx;
Sunny Goyalbaec6ff2016-09-14 11:26:21 -0700155 public int folderChildDrawablePaddingPx;
Winson Chungb3800242013-10-24 11:01:54 -0700156
Sunny Goyalc6205602015-05-21 20:46:33 -0700157 // Hotseat
Jon Miranda80cddbc2021-07-22 13:51:16 -0700158 public int hotseatBarSizeExtraSpacePx;
Tony Wickhamb87f3cd2021-04-07 15:02:37 -0700159 public final int numShownHotseatIcons;
Sunny Goyalc6205602015-05-21 20:46:33 -0700160 public int hotseatCellHeightPx;
Jon Miranda0d284852021-06-22 14:50:55 -0700161 private final int hotseatExtraVerticalSize;
Thales Lima425f6822022-05-10 13:44:58 -0300162 private final boolean areNavButtonsInline;
Jon Miranda18751b62017-07-31 17:25:27 -0700163 // In portrait: size = height, in landscape: size = width
164 public int hotseatBarSizePx;
Jon Miranda80cddbc2021-07-22 13:51:16 -0700165 public int hotseatBarTopPaddingPx;
Jon Miranda0d284852021-06-22 14:50:55 -0700166 public final int hotseatBarBottomPaddingPx;
Pat Manningde25c0d2022-04-05 19:11:26 +0100167 public int springLoadedHotseatBarTopMarginPx;
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700168 // Start is the side next to the nav bar, end is the side next to the workspace
169 public final int hotseatBarSidePaddingStartPx;
170 public final int hotseatBarSidePaddingEndPx;
Sunny Goyal57b22792021-05-25 14:35:01 -0700171 public final int hotseatQsbHeight;
Thales Limadd027342022-01-07 12:54:37 +0000172 public int hotseatBorderSpace;
Adam Cohen2e6da152015-05-06 11:42:25 -0700173
Jon Miranda8bdb2222021-06-23 18:10:10 -0700174 public final float qsbBottomMarginOriginalPx;
175 public int qsbBottomMarginPx;
Thales Limaa1012902022-01-13 17:58:42 +0000176 public int qsbWidth; // only used when isQsbInline
Jon Miranda8bdb2222021-06-23 18:10:10 -0700177
Sunny Goyalc6205602015-05-21 20:46:33 -0700178 // All apps
Thales Lima85c942f2021-12-31 13:04:20 +0000179 public Point allAppsBorderSpacePx;
Alex Chaub8c22e12022-02-14 18:35:58 +0000180 public int allAppsShiftRange;
181 public int allAppsTopPadding;
Andras Kloczl142b0542022-03-09 21:26:02 +0000182 public int bottomSheetTopPadding;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700183 public int allAppsCellHeightPx;
Samuel Fufaf1424a32019-10-04 15:15:19 -0700184 public int allAppsCellWidthPx;
Winson1f064272016-07-18 17:18:02 -0700185 public int allAppsIconSizePx;
186 public int allAppsIconDrawablePaddingPx;
sfufa@google.comde013292021-09-21 18:22:44 -0700187 public int allAppsLeftRightPadding;
Alex Chau27b39b92022-01-14 18:02:18 +0000188 public int allAppsLeftRightMargin;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700189 public final int numShownAllAppsColumns;
Winson1f064272016-07-18 17:18:02 -0700190 public float allAppsIconTextSizePx;
191
Zak Cohen334efeb2021-03-19 16:42:07 -0700192 // Overview
Zak Cohen334efeb2021-03-19 16:42:07 -0700193 public int overviewTaskMarginPx;
Alex Chaueaa6d682021-08-17 12:56:15 +0100194 public int overviewTaskMarginGridPx;
Alex Chaudedbc8a2021-03-17 16:53:26 +0000195 public int overviewTaskIconSizePx;
Alex Chauac9df382021-08-02 19:08:41 +0100196 public int overviewTaskIconDrawableSizePx;
197 public int overviewTaskIconDrawableSizeGridPx;
Alex Chaudedbc8a2021-03-17 16:53:26 +0000198 public int overviewTaskThumbnailTopMarginPx;
Alex Chau19c6eca2022-03-10 20:12:56 +0000199 public final int overviewActionsHeight;
Alex Chaua2fc7642022-04-21 14:20:23 +0100200 public final int overviewActionsTopMarginPx;
Alex Chau1bf0fe12021-11-30 15:32:45 +0000201 public final int overviewActionsButtonSpacing;
Alex Chau5fd9d492021-07-22 17:27:11 +0100202 public int overviewPageSpacing;
203 public int overviewRowSpacing;
Alex Chau56bd2572021-11-03 18:48:18 +0000204 public int overviewGridSideMargin;
Zak Cohen334efeb2021-03-19 16:42:07 -0700205
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800206 // Widgets
207 public final PointF appWidgetScale = new PointF(1.0f, 1.0f);
208
Sunny Goyal47328fd2016-05-25 18:56:41 -0700209 // Drop Target
210 public int dropTargetBarSizePx;
Pat Manningde25c0d2022-04-05 19:11:26 +0100211 public int dropTargetBarTopMarginPx;
212 public int dropTargetBarBottomMarginPx;
Alex Chaua02eddc2021-04-29 00:36:06 +0100213 public int dropTargetDragPaddingPx;
214 public int dropTargetTextSizePx;
Pat Manningde25c0d2022-04-05 19:11:26 +0100215 public int dropTargetHorizontalPaddingPx;
216 public int dropTargetVerticalPaddingPx;
217 public int dropTargetGapPx;
Adam Cohen4ae96ce2014-08-29 15:05:48 -0700218
Winson1f064272016-07-18 17:18:02 -0700219 // Insets
Sunny Goyal07b69292018-01-08 14:19:34 -0800220 private final Rect mInsets = new Rect();
221 public final Rect workspacePadding = new Rect();
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700222 private final Rect mHotseatPadding = new Rect();
Jon Miranda0bd63d12019-03-06 17:29:29 -0800223 // When true, nav bar is on the left side of the screen.
Sunny Goyal59d086c2018-05-07 17:31:40 -0700224 private boolean mIsSeascape;
Winson1f064272016-07-18 17:18:02 -0700225
Tony Wickhamf34bee82018-12-03 18:11:39 -0800226 // Notification dots
Samuel Fufac96fa242019-09-26 23:06:32 -0700227 public DotRenderer mDotRendererWorkSpace;
228 public DotRenderer mDotRendererAllApps;
Tony Wickham9a8d11f2017-01-11 09:53:12 -0800229
Pierre Barbier de Reuille578deba2021-09-24 13:47:44 +0100230 // Taskbar
Tony Wickham15883892021-02-12 11:24:40 -0800231 public boolean isTaskbarPresent;
Tony Wickham635e1802021-07-22 14:28:04 -1000232 // Whether Taskbar will inset the bottom of apps by taskbarSize.
233 public boolean isTaskbarPresentInApps;
Tony Wickham15883892021-02-12 11:24:40 -0800234 public int taskbarSize;
Alex Chau6a7d1e22022-01-20 19:54:17 +0000235 public int stashedTaskbarSize;
Tony Wickham15883892021-02-12 11:24:40 -0800236
Alex Chaua02eddc2021-04-29 00:36:06 +0100237 // DragController
238 public int flingToDeleteThresholdVelocity;
239
Vinit Nayak17c4b332021-08-05 12:54:58 -0700240 /** TODO: Once we fully migrate to staged split, remove "isMultiWindowMode" */
Sunny Goyal19ff7282021-04-22 10:12:54 -0700241 DeviceProfile(Context context, InvariantDeviceProfile inv, Info info, WindowBounds windowBounds,
Sunny Goyal0addbf02020-04-28 14:17:35 -0700242 boolean isMultiWindowMode, boolean transposeLayoutWithOrientation,
Alex Chau6ed408f2022-03-04 12:58:05 +0000243 boolean useTwoPanels, boolean isGestureMode) {
Sunny Goyalfee35bb2015-05-11 11:38:19 -0700244
Adam Cohen2e6da152015-05-06 11:42:25 -0700245 this.inv = inv;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700246 this.isLandscape = windowBounds.isLandscape();
Sunny Goyald70e75a2018-02-22 10:07:32 -0800247 this.isMultiWindowMode = isMultiWindowMode;
Jon Mirandae126d722021-02-25 10:45:20 -0500248 this.transposeLayoutWithOrientation = transposeLayoutWithOrientation;
Alex Chau6ed408f2022-03-04 12:58:05 +0000249 this.isGestureMode = isGestureMode;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700250 windowX = windowBounds.bounds.left;
251 windowY = windowBounds.bounds.top;
Sunny Goyal187b16c2022-03-01 16:53:23 -0800252 this.rotationHint = windowBounds.rotationHint;
Alex Chaue0227552022-04-06 19:44:43 +0100253 mInsets.set(windowBounds.insets);
Winson Chungb3800242013-10-24 11:01:54 -0700254
Jon Mirandae126d722021-02-25 10:45:20 -0500255 isScalableGrid = inv.isScalable && !isVerticalBarLayout() && !isMultiWindowMode;
Alex Chaudfc8ddf2022-01-25 11:26:25 +0000256 // Determine device posture.
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700257 mInfo = info;
Alex Chau29983072021-11-19 15:14:20 +0000258 isTablet = info.isTablet(windowBounds);
Sunny Goyal19ff7282021-04-22 10:12:54 -0700259 isPhone = !isTablet;
Alex Chau90125822021-11-17 14:16:58 +0000260 isTwoPanels = isTablet && useTwoPanels;
Vinit Nayak58c27cc2022-02-16 17:42:21 -0800261 isTaskbarPresent = isTablet && ApiWrapper.TASKBAR_DRAWN_IN_PROCESS;
Adam Cohen2e6da152015-05-06 11:42:25 -0700262
Alex Chaudfc8ddf2022-01-25 11:26:25 +0000263 // Some more constants.
Alex Chau635b3ab2022-01-26 16:49:10 +0000264 context = getContext(context, info, isVerticalBarLayout() || (isTablet && isLandscape)
Brandon Dayauon07ca8842022-04-27 10:52:28 -0700265 ? Configuration.ORIENTATION_LANDSCAPE
266 : Configuration.ORIENTATION_PORTRAIT,
Alex Chaua6907dc2022-03-18 15:24:07 +0000267 windowBounds);
Sunny Goyal1890f672020-04-30 12:28:00 -0700268 final Resources res = context.getResources();
Alex Chaudfc8ddf2022-01-25 11:26:25 +0000269 mMetrics = res.getDisplayMetrics();
270
271 // Determine sizes.
272 widthPx = windowBounds.bounds.width();
273 heightPx = windowBounds.bounds.height();
274 availableWidthPx = windowBounds.availableSize.x;
Alex Chau6a7d1e22022-01-20 19:54:17 +0000275 availableHeightPx = windowBounds.availableSize.y;
Alex Chaudfc8ddf2022-01-25 11:26:25 +0000276
277 aspectRatio = ((float) Math.max(widthPx, heightPx)) / Math.min(widthPx, heightPx);
278 boolean isTallDevice = Float.compare(aspectRatio, TALL_DEVICE_ASPECT_RATIO_THRESHOLD) >= 0;
279 mQsbCenterFactor = res.getFloat(R.dimen.qsb_center_factor);
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700280
Thales Lima83bedbf2021-10-05 17:47:39 +0100281 if (isTwoPanels) {
282 if (isLandscape) {
Thales Lima12d0eff2022-03-25 17:06:11 +0000283 mTypeIndex = INDEX_TWO_PANEL_LANDSCAPE;
Thales Lima83bedbf2021-10-05 17:47:39 +0100284 } else {
Thales Lima12d0eff2022-03-25 17:06:11 +0000285 mTypeIndex = INDEX_TWO_PANEL_PORTRAIT;
Thales Lima83bedbf2021-10-05 17:47:39 +0100286 }
287 } else {
288 if (isLandscape) {
Thales Lima12d0eff2022-03-25 17:06:11 +0000289 mTypeIndex = INDEX_LANDSCAPE;
Thales Lima83bedbf2021-10-05 17:47:39 +0100290 } else {
Thales Lima12d0eff2022-03-25 17:06:11 +0000291 mTypeIndex = INDEX_DEFAULT;
Thales Lima83bedbf2021-10-05 17:47:39 +0100292 }
293 }
294
Tony Wickham15883892021-02-12 11:24:40 -0800295 if (isTaskbarPresent) {
Tony Wickham15883892021-02-12 11:24:40 -0800296 taskbarSize = res.getDimensionPixelSize(R.dimen.taskbar_size);
Alex Chau6a7d1e22022-01-20 19:54:17 +0000297 stashedTaskbarSize = res.getDimensionPixelSize(R.dimen.taskbar_stashed_size);
Tony Wickham15883892021-02-12 11:24:40 -0800298 }
Tony Wickham15883892021-02-12 11:24:40 -0800299
Winson Chungb3800242013-10-24 11:01:54 -0700300 edgeMarginPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_edge_margin);
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700301
Thales Limad90faab2021-09-21 17:18:47 +0100302 desiredWorkspaceHorizontalMarginPx = getHorizontalMarginPx(inv, res);
303 desiredWorkspaceHorizontalMarginOriginalPx = desiredWorkspaceHorizontalMarginPx;
Samuel Fufaee9aff92021-04-05 13:30:40 -0500304
Alex Chaue0227552022-04-06 19:44:43 +0100305 bottomSheetTopPadding = mInsets.top // statusbar height
Andras Kloczl142b0542022-03-09 21:26:02 +0000306 + res.getDimensionPixelSize(R.dimen.bottom_sheet_extra_top_padding)
307 + (isTablet ? 0 : edgeMarginPx); // phones need edgeMarginPx additional padding
308
309 allAppsTopPadding = isTablet ? bottomSheetTopPadding : 0;
Alex Chaub8c22e12022-02-14 18:35:58 +0000310 allAppsShiftRange = isTablet
311 ? heightPx - allAppsTopPadding
312 : res.getDimensionPixelSize(R.dimen.all_apps_starting_vertical_translate);
Jon Mirandae126d722021-02-25 10:45:20 -0500313 folderLabelTextScale = res.getFloat(R.dimen.folder_label_text_scale);
314 folderContentPaddingLeftRight =
315 res.getDimensionPixelSize(R.dimen.folder_content_padding_left_right);
316 folderContentPaddingTop = res.getDimensionPixelSize(R.dimen.folder_content_padding_top);
317
Thales Lima78d00ad2021-09-30 11:29:06 +0100318 cellLayoutBorderSpacePx = getCellLayoutBorderSpace(inv);
Thales Lima85c942f2021-12-31 13:04:20 +0000319 allAppsBorderSpacePx = new Point(
Thales Limabb7d3882021-12-22 12:56:29 +0000320 pxFromDp(inv.allAppsBorderSpaces[mTypeIndex].x, mMetrics),
321 pxFromDp(inv.allAppsBorderSpaces[mTypeIndex].y, mMetrics));
Thales Lima78d00ad2021-09-30 11:29:06 +0100322 cellLayoutBorderSpaceOriginalPx = new Point(cellLayoutBorderSpacePx);
Thales Lima080d8902022-03-28 15:30:29 +0100323 folderCellLayoutBorderSpaceOriginalPx = pxFromDp(inv.folderBorderSpace, mMetrics);
Thales Lima78d00ad2021-09-30 11:29:06 +0100324 folderCellLayoutBorderSpacePx = new Point(folderCellLayoutBorderSpaceOriginalPx,
325 folderCellLayoutBorderSpaceOriginalPx);
Jon Mirandae126d722021-02-25 10:45:20 -0500326
Tony Wickham5edf9e22020-03-27 20:06:52 -0700327 workspacePageIndicatorHeight = res.getDimensionPixelSize(
328 R.dimen.workspace_page_indicator_height);
329 mWorkspacePageIndicatorOverlapWorkspace =
330 res.getDimensionPixelSize(R.dimen.workspace_page_indicator_overlap_workspace);
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700331
Winson Chungb3800242013-10-24 11:01:54 -0700332 iconDrawablePaddingOriginalPx =
333 res.getDimensionPixelSize(R.dimen.dynamic_grid_icon_drawable_padding);
Alex Chaua02eddc2021-04-29 00:36:06 +0100334
Sunny Goyal47328fd2016-05-25 18:56:41 -0700335 dropTargetBarSizePx = res.getDimensionPixelSize(R.dimen.dynamic_grid_drop_target_size);
Pat Manningde25c0d2022-04-05 19:11:26 +0100336 dropTargetBarTopMarginPx = res.getDimensionPixelSize(R.dimen.drop_target_top_margin);
337 dropTargetBarBottomMarginPx = res.getDimensionPixelSize(R.dimen.drop_target_bottom_margin);
Alex Chaua02eddc2021-04-29 00:36:06 +0100338 dropTargetDragPaddingPx = res.getDimensionPixelSize(R.dimen.drop_target_drag_padding);
339 dropTargetTextSizePx = res.getDimensionPixelSize(R.dimen.drop_target_text_size);
Pat Manningde25c0d2022-04-05 19:11:26 +0100340 dropTargetHorizontalPaddingPx = res.getDimensionPixelSize(
341 R.dimen.drop_target_button_drawable_horizontal_padding);
342 dropTargetVerticalPaddingPx = res.getDimensionPixelSize(
343 R.dimen.drop_target_button_drawable_vertical_padding);
344 dropTargetGapPx = res.getDimensionPixelSize(R.dimen.drop_target_button_gap);
Alex Chaua02eddc2021-04-29 00:36:06 +0100345
Sunny Goyal47328fd2016-05-25 18:56:41 -0700346 workspaceSpringLoadedBottomSpace =
347 res.getDimensionPixelSize(R.dimen.dynamic_grid_min_spring_loaded_space);
Alex Chau906d8822022-05-23 10:42:25 +0100348 workspaceSpringLoadedMinNextPageVisiblePx = res.getDimensionPixelSize(
349 R.dimen.dynamic_grid_spring_loaded_min_next_space_visible);
Sunny Goyald5190522017-04-24 03:06:54 -0700350
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700351 workspaceCellPaddingXPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_cell_padding_x);
Jon Miranda09660722017-06-14 14:20:14 -0700352
Thales Limaa1012902022-01-13 17:58:42 +0000353 hotseatQsbHeight = res.getDimensionPixelSize(R.dimen.qsb_widget_height);
Thales Lima12d0eff2022-03-25 17:06:11 +0000354 // Whether QSB might be inline in appropriate orientation (e.g. landscape).
355 boolean canQsbInline = (isTwoPanels ? inv.inlineQsb[INDEX_TWO_PANEL_PORTRAIT]
356 || inv.inlineQsb[INDEX_TWO_PANEL_LANDSCAPE]
357 : inv.inlineQsb[INDEX_DEFAULT] || inv.inlineQsb[INDEX_LANDSCAPE])
358 && hotseatQsbHeight > 0;
359 isQsbInline = inv.inlineQsb[mTypeIndex] && canQsbInline;
Alex Chau6ed408f2022-03-04 12:58:05 +0000360
Alex Chau8175da92022-03-09 11:19:47 +0000361 // We shrink hotseat sizes regardless of orientation, if nav buttons are inline and QSB
362 // might be inline in either orientations, to keep hotseat size consistent across rotation.
Thales Lima425f6822022-05-10 13:44:58 -0300363 areNavButtonsInline = isTaskbarPresent && !isGestureMode;
Alex Chau8175da92022-03-09 11:19:47 +0000364 if (areNavButtonsInline && canQsbInline) {
Alex Chau6ed408f2022-03-04 12:58:05 +0000365 numShownHotseatIcons = inv.numShrunkenHotseatIcons;
366 } else {
367 numShownHotseatIcons =
368 isTwoPanels ? inv.numDatabaseHotseatIcons : inv.numShownHotseatIcons;
369 }
370
Sunny Goyal19ff7282021-04-22 10:12:54 -0700371 numShownAllAppsColumns =
372 isTwoPanels ? inv.numDatabaseAllAppsColumns : inv.numAllAppsColumns;
Jon Miranda80cddbc2021-07-22 13:51:16 -0700373 hotseatBarSizeExtraSpacePx = 0;
Winson1f064272016-07-18 17:18:02 -0700374 hotseatBarTopPaddingPx =
375 res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_top_padding);
Thales Limaa1012902022-01-13 17:58:42 +0000376 if (isQsbInline) {
377 hotseatBarBottomPaddingPx = res.getDimensionPixelSize(R.dimen.inline_qsb_bottom_margin);
Thales Limaa1012902022-01-13 17:58:42 +0000378 } else {
379 hotseatBarBottomPaddingPx = (isTallDevice ? res.getDimensionPixelSize(
380 R.dimen.dynamic_grid_hotseat_bottom_tall_padding)
381 : res.getDimensionPixelSize(
382 R.dimen.dynamic_grid_hotseat_bottom_non_tall_padding))
383 + res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_bottom_padding);
Thales Limaa1012902022-01-13 17:58:42 +0000384 }
Thales Lima425f6822022-05-10 13:44:58 -0300385
Pat Manningde25c0d2022-04-05 19:11:26 +0100386 springLoadedHotseatBarTopMarginPx = res.getDimensionPixelSize(
387 R.dimen.spring_loaded_hotseat_top_margin);
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700388 hotseatBarSidePaddingEndPx =
Sunny Goyal228153d2018-01-04 15:35:22 -0800389 res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_side_padding);
Jon Miranda3f411e72019-05-16 17:15:16 -0700390 // Add a bit of space between nav bar and hotseat in vertical bar layout.
Tony Wickham5edf9e22020-03-27 20:06:52 -0700391 hotseatBarSidePaddingStartPx = isVerticalBarLayout() ? workspacePageIndicatorHeight : 0;
Jon Miranda0d284852021-06-22 14:50:55 -0700392 hotseatExtraVerticalSize =
Jon Miranda228877d2021-02-09 11:05:00 -0500393 res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_extra_vertical_size);
Thales Lima425f6822022-05-10 13:44:58 -0300394 updateHotseatIconSize(pxFromDp(inv.iconSize[INDEX_DEFAULT], mMetrics));
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700395
Jon Miranda8bdb2222021-06-23 18:10:10 -0700396 qsbBottomMarginOriginalPx = isScalableGrid
397 ? res.getDimensionPixelSize(R.dimen.scalable_grid_qsb_bottom_margin)
398 : 0;
399
Alex Chau635b3ab2022-01-26 16:49:10 +0000400 overviewTaskMarginPx = res.getDimensionPixelSize(R.dimen.overview_task_margin);
Alex Chaueaa6d682021-08-17 12:56:15 +0100401 overviewTaskMarginGridPx = res.getDimensionPixelSize(R.dimen.overview_task_margin_grid);
Alex Chau5fd9d492021-07-22 17:27:11 +0100402 overviewTaskIconSizePx = res.getDimensionPixelSize(R.dimen.task_thumbnail_icon_size);
Alex Chauac9df382021-08-02 19:08:41 +0100403 overviewTaskIconDrawableSizePx =
404 res.getDimensionPixelSize(R.dimen.task_thumbnail_icon_drawable_size);
405 overviewTaskIconDrawableSizeGridPx =
406 res.getDimensionPixelSize(R.dimen.task_thumbnail_icon_drawable_size_grid);
Alex Chaudedbc8a2021-03-17 16:53:26 +0000407 overviewTaskThumbnailTopMarginPx = overviewTaskIconSizePx + overviewTaskMarginPx * 2;
Alex Chaua2fc7642022-04-21 14:20:23 +0100408 // In vertical bar, use the smaller task margin for the top regardless of mode.
409 overviewActionsTopMarginPx = isVerticalBarLayout()
410 ? overviewTaskMarginPx
411 : res.getDimensionPixelSize(R.dimen.overview_actions_top_margin);
Alex Chau635b3ab2022-01-26 16:49:10 +0000412 overviewPageSpacing = res.getDimensionPixelSize(R.dimen.overview_page_spacing);
413 overviewActionsButtonSpacing = res.getDimensionPixelSize(
414 R.dimen.overview_actions_button_spacing);
Alex Chau19c6eca2022-03-10 20:12:56 +0000415 overviewActionsHeight = res.getDimensionPixelSize(R.dimen.overview_actions_height);
Alex Chau4c983742021-12-10 13:09:53 +0000416 // Grid task's top margin is only overviewTaskIconSizePx + overviewTaskMarginGridPx, but
417 // overviewTaskThumbnailTopMarginPx is applied to all TaskThumbnailView, so exclude the
418 // extra margin when calculating row spacing.
419 int extraTopMargin = overviewTaskThumbnailTopMarginPx - overviewTaskIconSizePx
420 - overviewTaskMarginGridPx;
421 overviewRowSpacing = res.getDimensionPixelSize(R.dimen.overview_grid_row_spacing)
422 - extraTopMargin;
Alex Chau635b3ab2022-01-26 16:49:10 +0000423 overviewGridSideMargin = res.getDimensionPixelSize(R.dimen.overview_grid_side_margin);
Zak Cohen334efeb2021-03-19 16:42:07 -0700424
Jon Miranda2ed276e2017-06-29 11:36:34 -0700425 // Calculate all of the remaining variables.
Jon Miranda58561d42021-03-17 10:51:54 -0400426 extraSpace = updateAvailableDimensions(res);
Jon Miranda80cddbc2021-07-22 13:51:16 -0700427
Jon Miranda2ed276e2017-06-29 11:36:34 -0700428 // Now that we have all of the variables calculated, we can tune certain sizes.
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400429 if (isScalableGrid && inv.devicePaddings != null) {
430 // Paddings were created assuming no scaling, so we first unscale the extra space.
Jon Mirandaab3c6812021-06-28 15:42:28 -0700431 int unscaledExtraSpace = (int) (extraSpace / cellScaleToFit);
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400432 DevicePadding padding = inv.devicePaddings.getDevicePadding(unscaledExtraSpace);
Jon Miranda228877d2021-02-09 11:05:00 -0500433
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400434 int paddingWorkspaceTop = padding.getWorkspaceTopPadding(unscaledExtraSpace);
435 int paddingWorkspaceBottom = padding.getWorkspaceBottomPadding(unscaledExtraSpace);
436 int paddingHotseatBottom = padding.getHotseatBottomPadding(unscaledExtraSpace);
437
Jon Mirandaab3c6812021-06-28 15:42:28 -0700438 workspaceTopPadding = Math.round(paddingWorkspaceTop * cellScaleToFit);
439 workspaceBottomPadding = Math.round(paddingWorkspaceBottom * cellScaleToFit);
440 extraHotseatBottomPadding = Math.round(paddingHotseatBottom * cellScaleToFit);
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400441
Jon Miranda58561d42021-03-17 10:51:54 -0400442 hotseatBarSizePx += extraHotseatBottomPadding;
Jon Miranda8bdb2222021-06-23 18:10:10 -0700443
Jon Mirandaab3c6812021-06-28 15:42:28 -0700444 qsbBottomMarginPx = Math.round(qsbBottomMarginOriginalPx * cellScaleToFit);
Jon Miranda228877d2021-02-09 11:05:00 -0500445 } else if (!isVerticalBarLayout() && isPhone && isTallDevice) {
Jon Miranda3f9bab22017-07-28 14:50:17 -0700446 // We increase the hotseat size when there is extra space.
Jon Miranda80cddbc2021-07-22 13:51:16 -0700447
Jon Miranda80dda302021-07-28 14:14:59 -0700448 if (Float.compare(aspectRatio, TALLER_DEVICE_ASPECT_RATIO_THRESHOLD) >= 0
449 && extraSpace >= Utilities.dpToPx(TALL_DEVICE_EXTRA_SPACE_THRESHOLD_DP)) {
450 // For taller devices, we will take a piece of the extra space from each row,
Jon Miranda80cddbc2021-07-22 13:51:16 -0700451 // and add it to the space above and below the hotseat.
Jon Miranda80dda302021-07-28 14:14:59 -0700452
453 // For devices with more extra space, we take a larger piece from each cell.
454 int piece = extraSpace < Utilities.dpToPx(TALL_DEVICE_MORE_EXTRA_SPACE_THRESHOLD_DP)
Jon Mirandaa56cb842021-08-03 17:26:44 -0700455 ? 7 : 5;
Jon Miranda80dda302021-07-28 14:14:59 -0700456
Jon Miranda80cddbc2021-07-22 13:51:16 -0700457 int extraSpace = ((getCellSize().y - iconSizePx - iconDrawablePaddingPx * 2)
Jon Miranda80dda302021-07-28 14:14:59 -0700458 * inv.numRows) / piece;
Jon Miranda80cddbc2021-07-22 13:51:16 -0700459
Jon Mirandaa56cb842021-08-03 17:26:44 -0700460 workspaceTopPadding = extraSpace / 8;
461 int halfLeftOver = (extraSpace - workspaceTopPadding) / 2;
462 hotseatBarTopPaddingPx += halfLeftOver;
463 hotseatBarSizeExtraSpacePx = halfLeftOver;
Jon Miranda80cddbc2021-07-22 13:51:16 -0700464 } else {
465 // ie. For a display with a large aspect ratio, we can keep the icons on the
466 // workspace in portrait mode closer together by adding more height to the hotseat.
467 // Note: This calculation was created after noticing a pattern in the design spec.
468 hotseatBarSizeExtraSpacePx = getCellSize().y - iconSizePx
469 - iconDrawablePaddingPx * 2 - workspacePageIndicatorHeight;
470 }
471
472 updateHotseatIconSize(iconSizePx);
Jon Miranda30d0aa22017-07-25 15:55:29 -0700473
Jon Miranda3f9bab22017-07-28 14:50:17 -0700474 // Recalculate the available dimensions using the new hotseat size.
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700475 updateAvailableDimensions(res);
Jon Miranda2ed276e2017-06-29 11:36:34 -0700476 }
Pat Manning08610ca2022-04-05 21:03:16 +0100477
478 int cellLayoutPadding =
479 isTwoPanels ? cellLayoutBorderSpacePx.x / 2 : res.getDimensionPixelSize(
480 R.dimen.cell_layout_padding);
481 cellLayoutPaddingPx = new Rect(cellLayoutPadding, cellLayoutPadding, cellLayoutPadding,
482 cellLayoutPadding);
Sunny Goyal07b69292018-01-08 14:19:34 -0800483 updateWorkspacePadding();
Tony Wickham1237df02017-02-24 08:59:36 -0800484
Thales Lima425f6822022-05-10 13:44:58 -0300485 // Hotseat and QSB width depends on updated cellSize and workspace padding
486 hotseatBorderSpace = calculateHotseatBorderSpace();
487 qsbWidth = calculateQsbWidth();
488
Alex Chaua02eddc2021-04-29 00:36:06 +0100489 flingToDeleteThresholdVelocity = res.getDimensionPixelSize(
490 R.dimen.drag_flingToDeleteMinVelocity);
491
Tony Wickham1237df02017-02-24 08:59:36 -0800492 // This is done last, after iconSizePx is calculated above.
Sunny Goyal8b9919d2021-04-07 14:45:17 -0700493 Path dotPath = GraphicsUtils.getShapePath(DEFAULT_DOT_SIZE);
494 mDotRendererWorkSpace = new DotRenderer(iconSizePx, dotPath, DEFAULT_DOT_SIZE);
Samuel Fufac96fa242019-09-26 23:06:32 -0700495 mDotRendererAllApps = iconSizePx == allAppsIconSizePx ? mDotRendererWorkSpace :
Sunny Goyal8b9919d2021-04-07 14:45:17 -0700496 new DotRenderer(allAppsIconSizePx, dotPath, DEFAULT_DOT_SIZE);
Adam Cohen63f1ec02014-08-12 09:23:13 -0700497 }
498
Thales Lima425f6822022-05-10 13:44:58 -0300499 /**
500 * QSB width is always calculated because when in 3 button nav the width doesn't follow the
501 * width of the hotseat.
502 */
Thales Limaa1012902022-01-13 17:58:42 +0000503 private int calculateQsbWidth() {
Thales Lima425f6822022-05-10 13:44:58 -0300504 if (isQsbInline) {
Alex Chau906d8822022-05-23 10:42:25 +0100505 int columns = getPanelCount() * inv.numColumns;
Thales Lima425f6822022-05-10 13:44:58 -0300506 return getIconToIconWidthForColumns(columns)
507 - iconSizePx * numShownHotseatIcons
508 - hotseatBorderSpace * numShownHotseatIcons;
509 } else {
510 int columns = inv.hotseatColumnSpan[mTypeIndex];
511 return getIconToIconWidthForColumns(columns);
512 }
513 }
Thales Lima2903a622022-03-17 13:52:19 +0000514
Thales Lima425f6822022-05-10 13:44:58 -0300515 private int getIconToIconWidthForColumns(int columns) {
516 return columns * getCellSize().x
517 + (columns - 1) * cellLayoutBorderSpacePx.x
518 - (getCellSize().x - iconSizePx); // left and right cell space
Thales Limaa1012902022-01-13 17:58:42 +0000519 }
520
Thales Limad90faab2021-09-21 17:18:47 +0100521 private int getHorizontalMarginPx(InvariantDeviceProfile idp, Resources res) {
522 if (isVerticalBarLayout()) {
523 return 0;
524 }
525
Thales Lima83bedbf2021-10-05 17:47:39 +0100526 return isScalableGrid
527 ? pxFromDp(idp.horizontalMargin[mTypeIndex], mMetrics)
528 : res.getDimensionPixelSize(R.dimen.dynamic_grid_left_right_margin);
Thales Limad90faab2021-09-21 17:18:47 +0100529 }
530
Jon Miranda0d284852021-06-22 14:50:55 -0700531 private void updateHotseatIconSize(int hotseatIconSizePx) {
Jon Miranda92c1b5d2021-07-20 13:57:16 -0700532 // Ensure there is enough space for folder icons, which have a slightly larger radius.
533 hotseatCellHeightPx = (int) Math.ceil(hotseatIconSizePx * ICON_OVERLAP_FACTOR);
Jon Miranda0d284852021-06-22 14:50:55 -0700534 if (isVerticalBarLayout()) {
535 hotseatBarSizePx = hotseatIconSizePx + hotseatBarSidePaddingStartPx
536 + hotseatBarSidePaddingEndPx;
537 } else {
538 hotseatBarSizePx = hotseatIconSizePx + hotseatBarTopPaddingPx
Jon Miranda80cddbc2021-07-22 13:51:16 -0700539 + hotseatBarBottomPaddingPx + (isScalableGrid ? 0 : hotseatExtraVerticalSize)
540 + hotseatBarSizeExtraSpacePx;
Jon Miranda0d284852021-06-22 14:50:55 -0700541 }
542 }
543
Thales Lima78d00ad2021-09-30 11:29:06 +0100544 private Point getCellLayoutBorderSpace(InvariantDeviceProfile idp) {
Thales Lima080d8902022-03-28 15:30:29 +0100545 return getCellLayoutBorderSpace(idp, 1f);
546
547 }
548
549 private Point getCellLayoutBorderSpace(InvariantDeviceProfile idp, float scale) {
Thales Lima78d00ad2021-09-30 11:29:06 +0100550 if (!isScalableGrid) {
551 return new Point(0, 0);
552 }
553
Thales Lima080d8902022-03-28 15:30:29 +0100554 int horizontalSpacePx = pxFromDp(idp.borderSpaces[mTypeIndex].x, mMetrics, scale);
555 int verticalSpacePx = pxFromDp(idp.borderSpaces[mTypeIndex].y, mMetrics, scale);
Thales Lima78d00ad2021-09-30 11:29:06 +0100556
557 return new Point(horizontalSpacePx, verticalSpacePx);
558 }
559
Sunny Goyal69a8eec2021-07-22 10:02:50 -0700560 public Info getDisplayInfo() {
561 return mInfo;
562 }
563
Jon Miranda611dba42021-03-02 14:12:13 -0500564 /**
565 * We inset the widget padding added by the system and instead rely on the border spacing
566 * between cells to create reliable consistency between widgets
567 */
568 public boolean shouldInsetWidgets() {
569 Rect widgetPadding = inv.defaultWidgetPadding;
570
Jon Miranda49811182021-06-03 09:52:40 -0700571 // Check all sides to ensure that the widget won't overlap into another cell, or into
572 // status bar.
573 return workspaceTopPadding > widgetPadding.top
Thales Lima78d00ad2021-09-30 11:29:06 +0100574 && cellLayoutBorderSpacePx.x > widgetPadding.left
575 && cellLayoutBorderSpacePx.y > widgetPadding.top
576 && cellLayoutBorderSpacePx.x > widgetPadding.right
577 && cellLayoutBorderSpacePx.y > widgetPadding.bottom;
Jon Miranda611dba42021-03-02 14:12:13 -0500578 }
Jon Mirandae126d722021-02-25 10:45:20 -0500579
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700580 public Builder toBuilder(Context context) {
Sunny Goyal187b16c2022-03-01 16:53:23 -0800581 WindowBounds bounds = new WindowBounds(
582 widthPx, heightPx, availableWidthPx, availableHeightPx, rotationHint);
Sunny Goyal19ff7282021-04-22 10:12:54 -0700583 bounds.bounds.offsetTo(windowX, windowY);
Alex Chaue0227552022-04-06 19:44:43 +0100584 bounds.insets.set(mInsets);
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700585 return new Builder(context, inv, mInfo)
Sunny Goyal19ff7282021-04-22 10:12:54 -0700586 .setWindowBounds(bounds)
587 .setUseTwoPanels(isTwoPanels)
Alex Chau6ed408f2022-03-04 12:58:05 +0000588 .setMultiWindowMode(isMultiWindowMode)
589 .setGestureMode(isGestureMode);
Sunny Goyal1a52ef52018-01-11 10:15:03 -0800590 }
591
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700592 public DeviceProfile copy(Context context) {
593 return toBuilder(context).build();
594 }
595
596 /**
597 * TODO: Move this to the builder as part of setMultiWindowMode
598 */
Sunny Goyalb46703d2020-05-27 17:52:03 -0700599 public DeviceProfile getMultiWindowProfile(Context context, WindowBounds windowBounds) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700600 DeviceProfile profile = toBuilder(context)
Sunny Goyal19ff7282021-04-22 10:12:54 -0700601 .setWindowBounds(windowBounds)
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700602 .setMultiWindowMode(true)
603 .build();
Jon Miranda93e1f042016-11-11 14:13:04 -0800604
Jon Miranda941375e2021-03-31 13:10:45 -0400605 profile.hideWorkspaceLabelsIfNotEnoughSpace();
Jon Miranda93e1f042016-11-11 14:13:04 -0800606
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800607 // We use these scales to measure and layout the widgets using their full invariant profile
608 // sizes and then draw them scaled and centered to fit in their multi-window mode cellspans.
609 float appWidgetScaleX = (float) profile.getCellSize().x / getCellSize().x;
610 float appWidgetScaleY = (float) profile.getCellSize().y / getCellSize().y;
611 profile.appWidgetScale.set(appWidgetScaleX, appWidgetScaleY);
612
Jon Miranda93e1f042016-11-11 14:13:04 -0800613 return profile;
Jon Mirandacc42c5b2016-10-27 17:15:27 -0700614 }
615
Adam Cohen63f1ec02014-08-12 09:23:13 -0700616 /**
Jon Miranda941375e2021-03-31 13:10:45 -0400617 * Checks if there is enough space for labels on the workspace.
618 * If there is not, labels on the Workspace are hidden.
Jon Miranda1091e532017-07-21 13:31:50 -0700619 * It is important to call this method after the All Apps variables have been set.
620 */
Jon Miranda941375e2021-03-31 13:10:45 -0400621 private void hideWorkspaceLabelsIfNotEnoughSpace() {
622 float iconTextHeight = Utilities.calculateTextHeight(iconTextSizePx);
623 float workspaceCellPaddingY = getCellSize().y - iconSizePx - iconDrawablePaddingPx
624 - iconTextHeight;
625
626 // We want enough space so that the text is closer to its corresponding icon.
627 if (workspaceCellPaddingY < iconTextHeight) {
628 iconTextSizePx = 0;
629 iconDrawablePaddingPx = 0;
Jon Miranda92c1b5d2021-07-20 13:57:16 -0700630 cellHeightPx = (int) Math.ceil(iconSizePx * ICON_OVERLAP_FACTOR);
Jon Miranda941375e2021-03-31 13:10:45 -0400631 autoResizeAllAppsCells();
632 }
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700633 }
Jon Miranda1091e532017-07-21 13:31:50 -0700634
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700635 /**
636 * Re-computes the all-apps cell size to be independent of workspace
637 */
638 public void autoResizeAllAppsCells() {
Jon Miranda941375e2021-03-31 13:10:45 -0400639 int textHeight = Utilities.calculateTextHeight(allAppsIconTextSizePx);
640 int topBottomPadding = textHeight;
Jon Miranda1091e532017-07-21 13:31:50 -0700641 allAppsCellHeightPx = allAppsIconSizePx + allAppsIconDrawablePaddingPx
Jon Miranda941375e2021-03-31 13:10:45 -0400642 + textHeight + (topBottomPadding * 2);
Jon Miranda1091e532017-07-21 13:31:50 -0700643 }
644
Thales Limab7ef5692022-03-10 10:32:36 +0000645 private void updateAllAppsContainerWidth(Resources res) {
Pat Manning08610ca2022-04-05 21:03:16 +0100646 int cellLayoutHorizontalPadding =
647 (cellLayoutPaddingPx.left + cellLayoutPaddingPx.right) / 2;
Alex Chau27b39b92022-01-14 18:02:18 +0000648 if (isTablet) {
Thales Limab7ef5692022-03-10 10:32:36 +0000649 allAppsLeftRightPadding =
Pat Manning08610ca2022-04-05 21:03:16 +0100650 res.getDimensionPixelSize(R.dimen.all_apps_bottom_sheet_horizontal_padding);
651
sfufa@google.comde013292021-09-21 18:22:44 -0700652 int usedWidth = (allAppsCellWidthPx * numShownAllAppsColumns)
Thales Limab7ef5692022-03-10 10:32:36 +0000653 + (allAppsBorderSpacePx.x * (numShownAllAppsColumns - 1))
Alex Chau27b39b92022-01-14 18:02:18 +0000654 + allAppsLeftRightPadding * 2;
655 allAppsLeftRightMargin = Math.max(1, (availableWidthPx - usedWidth) / 2);
sfufa@google.comde013292021-09-21 18:22:44 -0700656 } else {
657 allAppsLeftRightPadding =
Pat Manning08610ca2022-04-05 21:03:16 +0100658 desiredWorkspaceHorizontalMarginPx + cellLayoutHorizontalPadding;
sfufa@google.comde013292021-09-21 18:22:44 -0700659 }
660 }
661
Jon Miranda228877d2021-02-09 11:05:00 -0500662 /**
663 * Returns the amount of extra (or unused) vertical space.
664 */
665 private int updateAvailableDimensions(Resources res) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700666 updateIconSize(1f, res);
Winson Chung59a488a2013-12-10 12:32:14 -0800667
Pat Manning08610ca2022-04-05 21:03:16 +0100668 updateWorkspacePadding();
Jon Mirandae126d722021-02-25 10:45:20 -0500669
670 // Check to see if the icons fit within the available height.
Pat Manninga2e14992022-04-22 11:29:17 +0100671 float usedHeight = getCellLayoutHeightSpecification();
Pat Manning25d53342022-05-10 09:58:49 +0000672 final int maxHeight = getCellLayoutHeight();
Jon Miranda228877d2021-02-09 11:05:00 -0500673 float extraHeight = Math.max(0, maxHeight - usedHeight);
Jon Mirandae126d722021-02-25 10:45:20 -0500674 float scaleY = maxHeight / usedHeight;
675 boolean shouldScale = scaleY < 1f;
676
677 float scaleX = 1f;
678 if (isScalableGrid) {
679 // We scale to fit the cellWidth and cellHeight in the available space.
680 // The benefit of scalable grids is that we can get consistent aspect ratios between
681 // devices.
Pat Manninga2e14992022-04-22 11:29:17 +0100682 float usedWidth =
683 getCellLayoutWidthSpecification() + (desiredWorkspaceHorizontalMarginPx * 2);
Jon Mirandae126d722021-02-25 10:45:20 -0500684 // We do not subtract padding here, as we also scale the workspace padding if needed.
685 scaleX = availableWidthPx / usedWidth;
686 shouldScale = true;
Winson Chungb3800242013-10-24 11:01:54 -0700687 }
Jon Mirandae126d722021-02-25 10:45:20 -0500688
689 if (shouldScale) {
690 float scale = Math.min(scaleX, scaleY);
691 updateIconSize(scale, res);
Pat Manninga2e14992022-04-22 11:29:17 +0100692 extraHeight = Math.max(0, maxHeight - getCellLayoutHeightSpecification());
Jon Mirandae126d722021-02-25 10:45:20 -0500693 }
694
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700695 updateAvailableFolderCellDimensions(res);
Jon Miranda228877d2021-02-09 11:05:00 -0500696 return Math.round(extraHeight);
Winson Chungb3800242013-10-24 11:01:54 -0700697 }
698
Pat Manninga2e14992022-04-22 11:29:17 +0100699 private int getCellLayoutHeightSpecification() {
Pat Manning08610ca2022-04-05 21:03:16 +0100700 return (cellHeightPx * inv.numRows) + (cellLayoutBorderSpacePx.y * (inv.numRows - 1))
701 + cellLayoutPaddingPx.top + cellLayoutPaddingPx.bottom;
702 }
703
Pat Manninga2e14992022-04-22 11:29:17 +0100704 private int getCellLayoutWidthSpecification() {
Pat Manning25d53342022-05-10 09:58:49 +0000705 int numColumns = getPanelCount() * inv.numColumns;
Pat Manning08610ca2022-04-05 21:03:16 +0100706 return (cellWidthPx * numColumns) + (cellLayoutBorderSpacePx.x * (numColumns - 1))
707 + cellLayoutPaddingPx.left + cellLayoutPaddingPx.right;
Jon Mirandae126d722021-02-25 10:45:20 -0500708 }
709
Jon Miranda6f7e9702019-09-16 14:44:14 -0700710 /**
711 * Updating the iconSize affects many aspects of the launcher layout, such as: iconSizePx,
712 * iconTextSizePx, iconDrawablePaddingPx, cellWidth/Height, allApps* variants,
713 * hotseat sizes, workspaceSpringLoadedShrinkFactor, folderIconSizePx, and folderIconOffsetYPx.
714 */
Tony Wickham7ba547c2021-02-02 17:12:08 -0800715 public void updateIconSize(float scale, Resources res) {
Jon Mirandaab3c6812021-06-28 15:42:28 -0700716 // Icon scale should never exceed 1, otherwise pixellation may occur.
717 iconScale = Math.min(1f, scale);
718 cellScaleToFit = scale;
719
Jon Miranda18751b62017-07-31 17:25:27 -0700720 // Workspace
Sunny Goyal07b69292018-01-08 14:19:34 -0800721 final boolean isVerticalLayout = isVerticalBarLayout();
Thales Lima83bedbf2021-10-05 17:47:39 +0100722 float invIconSizeDp = inv.iconSize[mTypeIndex];
723 float invIconTextSizeSp = inv.iconTextSize[mTypeIndex];
Andras Kloczl30fe9152021-08-05 18:02:29 +0200724
Jon Mirandaab3c6812021-06-28 15:42:28 -0700725 iconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mMetrics, iconScale));
Jon Mirandaab3c6812021-06-28 15:42:28 -0700726 iconTextSizePx = (int) (pxFromSp(invIconTextSizeSp, mMetrics) * iconScale);
727 iconDrawablePaddingPx = (int) (iconDrawablePaddingOriginalPx * iconScale);
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700728
Thales Lima080d8902022-03-28 15:30:29 +0100729 cellLayoutBorderSpacePx = getCellLayoutBorderSpace(inv, scale);
Jon Mirandae126d722021-02-25 10:45:20 -0500730
731 if (isScalableGrid) {
Thales Lima83bedbf2021-10-05 17:47:39 +0100732 cellWidthPx = pxFromDp(inv.minCellSize[mTypeIndex].x, mMetrics, scale);
733 cellHeightPx = pxFromDp(inv.minCellSize[mTypeIndex].y, mMetrics, scale);
Jon Mirandae126d722021-02-25 10:45:20 -0500734 int cellContentHeight = iconSizePx + iconDrawablePaddingPx
735 + Utilities.calculateTextHeight(iconTextSizePx);
736 cellYPaddingPx = Math.max(0, cellHeightPx - cellContentHeight) / 2;
Thales Limad90faab2021-09-21 17:18:47 +0100737 desiredWorkspaceHorizontalMarginPx =
738 (int) (desiredWorkspaceHorizontalMarginOriginalPx * scale);
Jon Miranda228877d2021-02-09 11:05:00 -0500739 } else {
Jon Mirandae126d722021-02-25 10:45:20 -0500740 cellWidthPx = iconSizePx + iconDrawablePaddingPx;
Jon Miranda92c1b5d2021-07-20 13:57:16 -0700741 cellHeightPx = (int) Math.ceil(iconSizePx * ICON_OVERLAP_FACTOR)
742 + iconDrawablePaddingPx
Jon Miranda228877d2021-02-09 11:05:00 -0500743 + Utilities.calculateTextHeight(iconTextSizePx);
744 int cellPaddingY = (getCellSize().y - cellHeightPx) / 2;
745 if (iconDrawablePaddingPx > cellPaddingY && !isVerticalLayout
746 && !isMultiWindowMode) {
747 // Ensures that the label is closer to its corresponding icon. This is not an issue
748 // with vertical bar layout or multi-window mode since the issue is handled
749 // separately with their calls to {@link #adjustToHideWorkspaceLabels}.
750 cellHeightPx -= (iconDrawablePaddingPx - cellPaddingY);
751 iconDrawablePaddingPx = cellPaddingY;
752 }
Jon Miranda846455e2017-10-02 14:58:52 -0700753 }
Jon Miranda18751b62017-07-31 17:25:27 -0700754
Sunny Goyalae190ff2020-04-14 00:19:01 +0000755 // All apps
Brian Isganitis25b2ac82022-01-28 16:25:13 -0500756 updateAllAppsIconSize(scale, res);
Winson Chungb3800242013-10-24 11:01:54 -0700757
Jon Miranda0d284852021-06-22 14:50:55 -0700758 updateHotseatIconSize(iconSizePx);
Winson Chungb3800242013-10-24 11:01:54 -0700759
Sunny Goyalbaec6ff2016-09-14 11:26:21 -0700760 // Folder icon
Jon Miranda591e3602018-03-28 11:37:00 -0700761 folderIconSizePx = IconNormalizer.getNormalizedCircleSize(iconSizePx);
762 folderIconOffsetYPx = (iconSizePx - folderIconSizePx) / 2;
Winson Chung0f785722015-04-08 10:27:49 -0700763 }
764
Thales Lima425f6822022-05-10 13:44:58 -0300765 /**
766 * Hotseat width spans a certain number of columns on scalable grids.
767 * This method calculates the space between the icons to achieve that width.
768 */
769 private int calculateHotseatBorderSpace() {
770 if (!isScalableGrid) return 0;
771 //TODO(http://b/228998082) remove this when 3 button spaces are fixed
772 if (areNavButtonsInline) {
773 return pxFromDp(inv.hotseatBorderSpaces[mTypeIndex], mMetrics);
774 } else {
775 int columns = inv.hotseatColumnSpan[mTypeIndex];
776 float hotseatWidthPx = getIconToIconWidthForColumns(columns);
777 float hotseatIconsTotalPx = iconSizePx * numShownHotseatIcons;
778 return (int) (hotseatWidthPx - hotseatIconsTotalPx) / (numShownHotseatIcons - 1);
779 }
780 }
781
Brian Isganitis25b2ac82022-01-28 16:25:13 -0500782
783 /**
784 * Updates the iconSize for allApps* variants.
785 */
786 public void updateAllAppsIconSize(float scale, Resources res) {
Thales Lima080d8902022-03-28 15:30:29 +0100787 allAppsBorderSpacePx = new Point(
788 pxFromDp(inv.allAppsBorderSpaces[mTypeIndex].x, mMetrics, scale),
789 pxFromDp(inv.allAppsBorderSpaces[mTypeIndex].y, mMetrics, scale));
Brandon Dayauon07ca8842022-04-27 10:52:28 -0700790 // AllApps cells don't have real space between cells,
791 // so we add the border space to the cell height
792 allAppsCellHeightPx = pxFromDp(inv.allAppsCellSize[mTypeIndex].y, mMetrics, scale)
793 + allAppsBorderSpacePx.y;
794 // but width is just the cell,
795 // the border is added in #updateAllAppsContainerWidth
796 allAppsCellWidthPx = pxFromDp(inv.allAppsCellSize[mTypeIndex].x, mMetrics, scale);
Thales Lima080d8902022-03-28 15:30:29 +0100797 if (isScalableGrid) {
Brian Isganitis25b2ac82022-01-28 16:25:13 -0500798 allAppsIconSizePx =
799 pxFromDp(inv.allAppsIconSize[mTypeIndex], mMetrics);
800 allAppsIconTextSizePx =
801 pxFromSp(inv.allAppsIconTextSize[mTypeIndex], mMetrics);
802 allAppsIconDrawablePaddingPx = iconDrawablePaddingOriginalPx;
Brian Isganitis25b2ac82022-01-28 16:25:13 -0500803 } else {
Brandon Dayauon07ca8842022-04-27 10:52:28 -0700804 float invIconSizeDp = inv.allAppsIconSize[mTypeIndex];
805 float invIconTextSizeSp = inv.allAppsIconTextSize[mTypeIndex];
Brian Isganitis25b2ac82022-01-28 16:25:13 -0500806 allAppsIconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mMetrics, scale));
807 allAppsIconTextSizePx = (int) (pxFromSp(invIconTextSizeSp, mMetrics) * scale);
Brandon Dayauon07ca8842022-04-27 10:52:28 -0700808 allAppsIconDrawablePaddingPx =
809 res.getDimensionPixelSize(R.dimen.all_apps_icon_drawable_padding);
Brian Isganitis25b2ac82022-01-28 16:25:13 -0500810 }
811
Thales Limab7ef5692022-03-10 10:32:36 +0000812 updateAllAppsContainerWidth(res);
Brian Isganitis25b2ac82022-01-28 16:25:13 -0500813 if (isVerticalBarLayout()) {
814 hideWorkspaceLabelsIfNotEnoughSpace();
815 }
816 }
817
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700818 private void updateAvailableFolderCellDimensions(Resources res) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700819 updateFolderCellSize(1f, res);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700820
Jon Mirandae126d722021-02-25 10:45:20 -0500821 final int folderBottomPanelSize = res.getDimensionPixelSize(R.dimen.folder_label_height);
822
Jon Mirandac1b23992016-12-13 08:57:36 -0800823 // Don't let the folder get too close to the edges of the screen.
Jon Miranda1786df32018-09-25 13:05:23 -0700824 int folderMargin = edgeMarginPx * 2;
Sunny Goyal07b69292018-01-08 14:19:34 -0800825 Point totalWorkspacePadding = getTotalWorkspacePadding();
Jon Mirandac1b23992016-12-13 08:57:36 -0800826
827 // Check if the icons fit within the available height.
Jon Miranda228877d2021-02-09 11:05:00 -0500828 float contentUsedHeight = folderCellHeightPx * inv.numFolderRows
Thales Lima78d00ad2021-09-30 11:29:06 +0100829 + ((inv.numFolderRows - 1) * folderCellLayoutBorderSpacePx.y);
Samuel Fufa1c8d90a2019-11-12 17:54:58 -0800830 int contentMaxHeight = availableHeightPx - totalWorkspacePadding.y - folderBottomPanelSize
Jon Mirandae126d722021-02-25 10:45:20 -0500831 - folderMargin - folderContentPaddingTop;
Samuel Fufa1c8d90a2019-11-12 17:54:58 -0800832 float scaleY = contentMaxHeight / contentUsedHeight;
Jon Mirandac1b23992016-12-13 08:57:36 -0800833
834 // Check if the icons fit within the available width.
Jon Miranda228877d2021-02-09 11:05:00 -0500835 float contentUsedWidth = folderCellWidthPx * inv.numFolderColumns
Thales Lima78d00ad2021-09-30 11:29:06 +0100836 + ((inv.numFolderColumns - 1) * folderCellLayoutBorderSpacePx.x);
Jon Mirandae126d722021-02-25 10:45:20 -0500837 int contentMaxWidth = availableWidthPx - totalWorkspacePadding.x - folderMargin
838 - folderContentPaddingLeftRight * 2;
Samuel Fufa1c8d90a2019-11-12 17:54:58 -0800839 float scaleX = contentMaxWidth / contentUsedWidth;
Jon Mirandac1b23992016-12-13 08:57:36 -0800840
841 float scale = Math.min(scaleX, scaleY);
842 if (scale < 1f) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700843 updateFolderCellSize(scale, res);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700844 }
845 }
846
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700847 private void updateFolderCellSize(float scale, Resources res) {
Thales Lima83bedbf2021-10-05 17:47:39 +0100848 float invIconSizeDp = isVerticalBarLayout()
Thales Lima12d0eff2022-03-25 17:06:11 +0000849 ? inv.iconSize[INDEX_LANDSCAPE]
850 : inv.iconSize[INDEX_DEFAULT];
Sunny Goyal35c7b192021-04-20 16:51:10 -0700851 folderChildIconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mMetrics, scale));
Thales Lima83bedbf2021-10-05 17:47:39 +0100852 folderChildTextSizePx =
Thales Lima12d0eff2022-03-25 17:06:11 +0000853 pxFromSp(inv.iconTextSize[INDEX_DEFAULT], mMetrics, scale);
Jon Mirandae126d722021-02-25 10:45:20 -0500854 folderLabelTextSizePx = (int) (folderChildTextSizePx * folderLabelTextScale);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700855
856 int textHeight = Utilities.calculateTextHeight(folderChildTextSizePx);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700857
Jon Miranda823da222021-03-23 08:08:45 -0400858 if (isScalableGrid) {
Jon Mirandaf33f5b32021-07-22 17:15:31 -0700859 int minWidth = folderChildIconSizePx + iconDrawablePaddingPx * 2;
860 int minHeight = folderChildIconSizePx + iconDrawablePaddingPx * 2 + textHeight;
861
862 folderCellWidthPx = (int) Math.max(minWidth, cellWidthPx * scale);
863 folderCellHeightPx = (int) Math.max(minHeight, cellHeightPx * scale);
Jon Miranda823da222021-03-23 08:08:45 -0400864
Thales Lima78d00ad2021-09-30 11:29:06 +0100865 int scaledSpace = (int) (folderCellLayoutBorderSpaceOriginalPx * scale);
866 folderCellLayoutBorderSpacePx = new Point(scaledSpace, scaledSpace);
867 folderContentPaddingLeftRight = scaledSpace;
868 folderContentPaddingTop = scaledSpace;
Jon Miranda823da222021-03-23 08:08:45 -0400869 } else {
870 int cellPaddingX = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_x_padding)
871 * scale);
872 int cellPaddingY = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_y_padding)
873 * scale);
874
875 folderCellWidthPx = folderChildIconSizePx + 2 * cellPaddingX;
876 folderCellHeightPx = folderChildIconSizePx + 2 * cellPaddingY + textHeight;
877 }
878
Jonathan Miranda9ad87462017-07-26 17:41:02 +0000879 folderChildDrawablePaddingPx = Math.max(0,
880 (folderCellHeightPx - folderChildIconSizePx - textHeight) / 3);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700881 }
882
Winson1f064272016-07-18 17:18:02 -0700883 public void updateInsets(Rect insets) {
884 mInsets.set(insets);
885 }
886
Sunny Goyalae6e3182019-04-30 12:04:37 -0700887 /**
888 * The current device insets. This is generally same as the insets being dispatched to
889 * {@link Insettable} elements, but can differ if the element is using a different profile.
890 */
Sunny Goyal1a52ef52018-01-11 10:15:03 -0800891 public Rect getInsets() {
892 return mInsets;
893 }
894
Sunny Goyal756cd262015-08-20 12:33:21 -0700895 public Point getCellSize() {
Sunny Goyal19ff7282021-04-22 10:12:54 -0700896 return getCellSize(null);
Jon Miranda6f7e9702019-09-16 14:44:14 -0700897 }
898
Sunny Goyal19ff7282021-04-22 10:12:54 -0700899 public Point getCellSize(Point result) {
900 if (result == null) {
901 result = new Point();
902 }
Thales Limad1df5fc2021-09-03 18:37:19 +0100903
Pat Manning25d53342022-05-10 09:58:49 +0000904 int shortcutAndWidgetContainerWidth =
905 getCellLayoutWidth() - (cellLayoutPaddingPx.left + cellLayoutPaddingPx.right);
906 result.x = calculateCellWidth(shortcutAndWidgetContainerWidth, cellLayoutBorderSpacePx.x,
907 inv.numColumns);
908 int shortcutAndWidgetContainerHeight =
909 getCellLayoutHeight() - (cellLayoutPaddingPx.top + cellLayoutPaddingPx.bottom);
910 result.y = calculateCellHeight(shortcutAndWidgetContainerHeight, cellLayoutBorderSpacePx.y,
911 inv.numRows);
Sunny Goyal3e8a04b2022-05-09 19:31:45 +0000912 return result;
Pat Manningb45d6c42022-05-03 14:32:06 +0100913 }
914
915 /**
Pat Manning25d53342022-05-10 09:58:49 +0000916 * Gets the number of panels within the workspace.
917 */
918 public int getPanelCount() {
919 return isTwoPanels ? 2 : 1;
920 }
921
922 /**
Pat Manningde25c0d2022-04-05 19:11:26 +0100923 * Gets the space in px from the bottom of last item in the vertical-bar hotseat to the
924 * bottom of the screen.
925 */
926 public int getVerticalHotseatLastItemBottomOffset() {
927 int cellHeight = calculateCellHeight(
928 heightPx - mHotseatPadding.top - mHotseatPadding.bottom, hotseatBorderSpace,
929 numShownHotseatIcons);
930 int hotseatSize = (cellHeight * numShownHotseatIcons)
931 + (hotseatBorderSpace * (numShownHotseatIcons - 1));
932 int extraHotseatEndSpacing = (heightPx - hotseatSize) / 2;
933 int extraIconEndSpacing = (cellHeight - iconSizePx) / 2;
934 return extraHotseatEndSpacing + extraIconEndSpacing + mHotseatPadding.bottom;
935 }
936
937 /**
938 * Gets the scaled top of the workspace in px for the spring-loaded edit state.
939 */
Pat Manning25d53342022-05-10 09:58:49 +0000940 public float getCellLayoutSpringLoadShrunkTop() {
Pat Manningde25c0d2022-04-05 19:11:26 +0100941 workspaceSpringLoadShrunkTop = mInsets.top + dropTargetBarTopMarginPx + dropTargetBarSizePx
942 + dropTargetBarBottomMarginPx;
943 return workspaceSpringLoadShrunkTop;
944 }
945
946 /**
947 * Gets the scaled bottom of the workspace in px for the spring-loaded edit state.
948 */
Pat Manning25d53342022-05-10 09:58:49 +0000949 private float getCellLayoutSpringLoadShrunkBottom() {
Pat Manningde25c0d2022-04-05 19:11:26 +0100950 int topOfHotseat = hotseatBarSizePx + springLoadedHotseatBarTopMarginPx;
951 workspaceSpringLoadShrunkBottom =
952 heightPx - (isVerticalBarLayout() ? getVerticalHotseatLastItemBottomOffset()
953 : topOfHotseat);
954 return workspaceSpringLoadShrunkBottom;
955 }
956
Pat Manningea5c1d22022-04-14 10:58:16 +0100957 /**
Pat Manninga2e14992022-04-22 11:29:17 +0100958 * Gets the scale of the workspace for the spring-loaded edit state.
959 */
960 public float getWorkspaceSpringLoadScale() {
Pat Manning25d53342022-05-10 09:58:49 +0000961 float scale = (getCellLayoutSpringLoadShrunkBottom() - getCellLayoutSpringLoadShrunkTop())
962 / getCellLayoutHeight();
Pat Manninga2e14992022-04-22 11:29:17 +0100963 scale = Math.min(scale, 1f);
964
965 // Reduce scale if next pages would not be visible after scaling the workspace
Pat Manning25d53342022-05-10 09:58:49 +0000966 int workspaceWidth = availableWidthPx;
Pat Manninga2e14992022-04-22 11:29:17 +0100967 float scaledWorkspaceWidth = workspaceWidth * scale;
Alex Chau906d8822022-05-23 10:42:25 +0100968 float maxAvailableWidth = workspaceWidth - (2 * workspaceSpringLoadedMinNextPageVisiblePx);
Pat Manninga2e14992022-04-22 11:29:17 +0100969 if (scaledWorkspaceWidth > maxAvailableWidth) {
970 scale *= maxAvailableWidth / scaledWorkspaceWidth;
971 }
972 return scale;
973 }
974
Pat Manning25d53342022-05-10 09:58:49 +0000975 /**
976 * Gets the width of a single Cell Layout, aka a single panel within a Workspace.
977 *
978 * <p>This is the width of a Workspace, less its horizontal padding. Note that two-panel
979 * layouts have two Cell Layouts per workspace.
980 */
981 public int getCellLayoutWidth() {
982 return (availableWidthPx - getTotalWorkspacePadding().x) / getPanelCount();
Alex Chau60953332021-11-24 12:41:07 +0000983 }
984
Pat Manning25d53342022-05-10 09:58:49 +0000985 /**
986 * Gets the height of a single Cell Layout, aka a single panel within a Workspace.
987 *
988 * <p>This is the height of a Workspace, less its vertical padding.
989 */
990 public int getCellLayoutHeight() {
991 return availableHeightPx - getTotalWorkspacePadding().y;
Pat Manning08610ca2022-04-05 21:03:16 +0100992 }
993
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700994 public Point getTotalWorkspacePadding() {
Sunny Goyal07b69292018-01-08 14:19:34 -0800995 return new Point(workspacePadding.left + workspacePadding.right,
996 workspacePadding.top + workspacePadding.bottom);
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700997 }
998
999 /**
Sunny Goyal07b69292018-01-08 14:19:34 -08001000 * Updates {@link #workspacePadding} as a result of any internal value change to reflect the
1001 * new workspace padding
Sunny Goyal6c2975e2016-07-06 09:47:56 -07001002 */
Sunny Goyal07b69292018-01-08 14:19:34 -08001003 private void updateWorkspacePadding() {
1004 Rect padding = workspacePadding;
Tony Wickham3a3517f2015-10-06 11:27:04 -07001005 if (isVerticalBarLayout()) {
Sunny Goyal228153d2018-01-04 15:35:22 -08001006 padding.top = 0;
1007 padding.bottom = edgeMarginPx;
Sunny Goyal7e2e67f2018-01-26 13:40:08 -08001008 if (isSeascape()) {
Tony Wickham1eeffbe2018-06-12 15:01:15 -07001009 padding.left = hotseatBarSizePx;
Tony Wickham5edf9e22020-03-27 20:06:52 -07001010 padding.right = hotseatBarSidePaddingStartPx;
Winson1f064272016-07-18 17:18:02 -07001011 } else {
Tony Wickham5edf9e22020-03-27 20:06:52 -07001012 padding.left = hotseatBarSidePaddingStartPx;
Tony Wickham1eeffbe2018-06-12 15:01:15 -07001013 padding.right = hotseatBarSizePx;
Winson1f064272016-07-18 17:18:02 -07001014 }
Winson Chungb3800242013-10-24 11:01:54 -07001015 } else {
Thales Lima7a6752d2021-09-23 14:31:00 +01001016 // Pad the bottom of the workspace with search/hotseat bar sizes
Tony Wickham21970cc2021-09-15 15:44:05 -07001017 int hotseatTop = hotseatBarSizePx;
Tony Wickhama29a0462021-03-02 12:28:25 -08001018 int paddingBottom = hotseatTop + workspacePageIndicatorHeight
Jon Miranda228877d2021-02-09 11:05:00 -05001019 + workspaceBottomPadding - mWorkspacePageIndicatorOverlapWorkspace;
Pat Manning08610ca2022-04-05 21:03:16 +01001020 int paddingTop = workspaceTopPadding + (isScalableGrid ? 0 : edgeMarginPx);
1021 int paddingSide = desiredWorkspaceHorizontalMarginPx;
Andras Kloczl8e57cce2021-02-11 23:51:19 +01001022
Pat Manning08610ca2022-04-05 21:03:16 +01001023 padding.set(paddingSide, paddingTop, paddingSide, paddingBottom);
Winson Chungb3800242013-10-24 11:01:54 -07001024 }
Pat Manning08610ca2022-04-05 21:03:16 +01001025 insetPadding(workspacePadding, cellLayoutPaddingPx);
1026 }
1027
1028 private void insetPadding(Rect paddings, Rect insets) {
1029 insets.left = Math.min(insets.left, paddings.left);
1030 paddings.left -= insets.left;
1031
1032 insets.top = Math.min(insets.top, paddings.top);
1033 paddings.top -= insets.top;
1034
1035 insets.right = Math.min(insets.right, paddings.right);
1036 paddings.right -= insets.right;
1037
1038 insets.bottom = Math.min(insets.bottom, paddings.bottom);
1039 paddings.bottom -= insets.bottom;
Winson Chungb3800242013-10-24 11:01:54 -07001040 }
1041
Sunny Goyal57b22792021-05-25 14:35:01 -07001042 /**
1043 * Returns the padding for hotseat view
1044 */
1045 public Rect getHotseatLayoutPadding(Context context) {
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001046 if (isVerticalBarLayout()) {
Sihua Ma38bb3b02022-03-21 22:20:14 -07001047 // The hotseat icons will be placed in the middle of the hotseat cells.
1048 // Changing the hotseatCellHeightPx is not affecting hotseat icon positions
1049 // in vertical bar layout.
1050 // Workspace icons are moved up by a small factor. The variable diffOverlapFactor
1051 // is set to account for that difference.
1052 float diffOverlapFactor = iconSizePx * (ICON_OVERLAP_FACTOR - 1) / 2;
Pat Manning08610ca2022-04-05 21:03:16 +01001053 int paddingTop = Math.max((int) (mInsets.top + cellLayoutPaddingPx.top
1054 - diffOverlapFactor), 0);
1055 int paddingBottom = Math.max((int) (mInsets.bottom + cellLayoutPaddingPx.bottom
Sihua Ma38bb3b02022-03-21 22:20:14 -07001056 + diffOverlapFactor), 0);
1057
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001058 if (isSeascape()) {
Pat Manning08610ca2022-04-05 21:03:16 +01001059 mHotseatPadding.set(mInsets.left + hotseatBarSidePaddingStartPx, paddingTop,
1060 hotseatBarSidePaddingEndPx, paddingBottom);
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001061 } else {
Pat Manning08610ca2022-04-05 21:03:16 +01001062 mHotseatPadding.set(hotseatBarSidePaddingEndPx, paddingTop,
1063 mInsets.right + hotseatBarSidePaddingStartPx, paddingBottom);
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001064 }
Sunny Goyal57b22792021-05-25 14:35:01 -07001065 } else if (isTaskbarPresent) {
Thales Lima612230d2022-03-31 18:04:37 +01001066 boolean isRtl = Utilities.isRtl(context.getResources());
Tony Wickham21970cc2021-09-15 15:44:05 -07001067 int hotseatHeight = workspacePadding.bottom;
Sunny Goyal57b22792021-05-25 14:35:01 -07001068 int taskbarOffset = getTaskbarOffsetY();
Thales Lima612230d2022-03-31 18:04:37 +01001069 // Push icons to the side
1070 int additionalQsbSpace = isQsbInline ? qsbWidth + hotseatBorderSpace : 0;
Thales Limaa1012902022-01-13 17:58:42 +00001071
Thales Lima612230d2022-03-31 18:04:37 +01001072 // Center the QSB vertically with hotseat
Thales Lima7d149232022-03-21 18:27:45 +00001073 int hotseatTopPadding = hotseatHeight - taskbarOffset - hotseatCellHeightPx;
Sunny Goyal57b22792021-05-25 14:35:01 -07001074
Vinit Nayak8dcbde82021-07-19 12:53:28 -07001075 int endOffset = ApiWrapper.getHotseatEndOffset(context);
Thales Lima6e7f36c2022-01-04 12:14:11 +00001076 int requiredWidth = iconSizePx * numShownHotseatIcons
Thales Limaa1012902022-01-13 17:58:42 +00001077 + hotseatBorderSpace * (numShownHotseatIcons - 1)
Thales Lima612230d2022-03-31 18:04:37 +01001078 + additionalQsbSpace;
Sunny Goyal57b22792021-05-25 14:35:01 -07001079
Thales Lima612230d2022-03-31 18:04:37 +01001080 int hotseatWidth = Math.min(requiredWidth, availableWidthPx - endOffset);
1081 int sideSpacing = (availableWidthPx - hotseatWidth) / 2;
1082 mHotseatPadding.set(sideSpacing, hotseatTopPadding, sideSpacing, taskbarOffset);
1083
1084 if (isRtl) {
1085 mHotseatPadding.right += additionalQsbSpace;
1086 } else {
1087 mHotseatPadding.left += additionalQsbSpace;
1088 }
Sunny Goyal57b22792021-05-25 14:35:01 -07001089
Vinit Nayak8dcbde82021-07-19 12:53:28 -07001090 if (endOffset > sideSpacing) {
Thales Lima612230d2022-03-31 18:04:37 +01001091 int diff = isRtl
Vinit Nayak8dcbde82021-07-19 12:53:28 -07001092 ? sideSpacing - endOffset
1093 : endOffset - sideSpacing;
1094 mHotseatPadding.left -= diff;
1095 mHotseatPadding.right += diff;
Sunny Goyal57b22792021-05-25 14:35:01 -07001096 }
Thales Lima425f6822022-05-10 13:44:58 -03001097 } else if (isScalableGrid) {
1098 int sideSpacing = (availableWidthPx - qsbWidth) / 2;
1099 mHotseatPadding.set(sideSpacing,
1100 hotseatBarTopPaddingPx,
1101 sideSpacing,
1102 hotseatBarSizePx - hotseatCellHeightPx - hotseatBarTopPaddingPx
1103 + mInsets.bottom);
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001104 } else {
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001105 // We want the edges of the hotseat to line up with the edges of the workspace, but the
1106 // icons in the hotseat are a different size, and so don't line up perfectly. To account
1107 // for this, we pad the left and right of the hotseat with half of the difference of a
1108 // workspace cell vs a hotseat cell.
1109 float workspaceCellWidth = (float) widthPx / inv.numColumns;
Sunny Goyal19ff7282021-04-22 10:12:54 -07001110 float hotseatCellWidth = (float) widthPx / numShownHotseatIcons;
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001111 int hotseatAdjustment = Math.round((workspaceCellWidth - hotseatCellWidth) / 2);
Pat Manning08610ca2022-04-05 21:03:16 +01001112 mHotseatPadding.set(hotseatAdjustment + workspacePadding.left + cellLayoutPaddingPx.left
1113 + mInsets.left, hotseatBarTopPaddingPx,
1114 hotseatAdjustment + workspacePadding.right + cellLayoutPaddingPx.right
Sunny Goyal786940a2020-06-02 02:31:31 -07001115 + mInsets.right,
Jon Miranda0d284852021-06-22 14:50:55 -07001116 hotseatBarSizePx - hotseatCellHeightPx - hotseatBarTopPaddingPx
Pat Manning08610ca2022-04-05 21:03:16 +01001117 + mInsets.bottom);
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001118 }
1119 return mHotseatPadding;
1120 }
1121
Winsonfadbe8f2016-07-22 16:35:37 -07001122 /**
Sunny Goyal57b22792021-05-25 14:35:01 -07001123 * Returns the number of pixels the QSB is translated from the bottom of the screen.
1124 */
1125 public int getQsbOffsetY() {
Thales Limaa1012902022-01-13 17:58:42 +00001126 if (isQsbInline) {
1127 return hotseatBarBottomPaddingPx;
1128 }
1129
Sunny Goyal57b22792021-05-25 14:35:01 -07001130 int freeSpace = isTaskbarPresent
1131 ? workspacePadding.bottom
1132 : hotseatBarSizePx - hotseatCellHeightPx - hotseatQsbHeight;
Jonathan Miranda7a273e22021-06-24 21:29:10 +00001133
Jonathan Miranda8f16a772021-07-23 23:10:37 +00001134 if (isScalableGrid && qsbBottomMarginPx > mInsets.bottom) {
Tony Wickham21970cc2021-09-15 15:44:05 -07001135 // Note that taskbarSize = 0 unless isTaskbarPresent.
1136 return Math.min(qsbBottomMarginPx + taskbarSize, freeSpace);
Jonathan Miranda8f16a772021-07-23 23:10:37 +00001137 } else {
Pratyush9afe1ea2021-10-13 11:13:27 +00001138 return (int) (freeSpace * mQsbCenterFactor)
Brandon Dayauon07ca8842022-04-27 10:52:28 -07001139 + (isTaskbarPresent ? taskbarSize : mInsets.bottom);
Jonathan Miranda7a273e22021-06-24 21:29:10 +00001140 }
Sunny Goyal57b22792021-05-25 14:35:01 -07001141 }
1142
1143 /**
1144 * Returns the number of pixels the taskbar is translated from the bottom of the screen.
1145 */
1146 public int getTaskbarOffsetY() {
Thales Limaa1012902022-01-13 17:58:42 +00001147 if (isQsbInline) {
Thales Lima612230d2022-03-31 18:04:37 +01001148 return getQsbOffsetY() - (Math.abs(hotseatQsbHeight - hotseatCellHeightPx) / 2);
Thales Limaa1012902022-01-13 17:58:42 +00001149 } else {
1150 return (getQsbOffsetY() - taskbarSize) / 2;
1151 }
Sunny Goyal57b22792021-05-25 14:35:01 -07001152 }
1153
1154 /**
Alex Chaua2fc7642022-04-21 14:20:23 +01001155 * Returns the number of pixels required below OverviewActions excluding insets.
1156 */
1157 public int getOverviewActionsClaimedSpaceBelow() {
1158 if (isTaskbarPresent && !isGestureMode) {
1159 // Align vertically to where nav buttons are.
1160 return ((taskbarSize - overviewActionsHeight) / 2) + getTaskbarOffsetY();
1161 }
1162
Alex Chau1fe83fe2022-05-09 19:21:13 +01001163 return isTaskbarPresent ? stashedTaskbarSize : mInsets.bottom;
Alex Chaua2fc7642022-04-21 14:20:23 +01001164 }
1165
1166 /** Gets the space that the overview actions will take, including bottom margin. */
1167 public int getOverviewActionsClaimedSpace() {
1168 return overviewActionsTopMarginPx + overviewActionsHeight
1169 + getOverviewActionsClaimedSpaceBelow();
1170 }
1171
1172 /**
Winsonfadbe8f2016-07-22 16:35:37 -07001173 * @return the bounds for which the open folders should be contained within
1174 */
1175 public Rect getAbsoluteOpenFolderBounds() {
1176 if (isVerticalBarLayout()) {
1177 // Folders should only appear right of the drop target bar and left of the hotseat
1178 return new Rect(mInsets.left + dropTargetBarSizePx + edgeMarginPx,
1179 mInsets.top,
Jon Miranda18751b62017-07-31 17:25:27 -07001180 mInsets.left + availableWidthPx - hotseatBarSizePx - edgeMarginPx,
Winsonfadbe8f2016-07-22 16:35:37 -07001181 mInsets.top + availableHeightPx);
1182 } else {
1183 // Folders should only appear below the drop target bar and above the hotseat
Tony Wickhamae72b462021-03-10 16:18:40 -08001184 int hotseatTop = isTaskbarPresent ? taskbarSize : hotseatBarSizePx;
Tony Wickhamb4b7e202018-01-12 17:39:24 -08001185 return new Rect(mInsets.left + edgeMarginPx,
Winsonfadbe8f2016-07-22 16:35:37 -07001186 mInsets.top + dropTargetBarSizePx + edgeMarginPx,
Tony Wickhamb4b7e202018-01-12 17:39:24 -08001187 mInsets.left + availableWidthPx - edgeMarginPx,
Tony Wickhamae72b462021-03-10 16:18:40 -08001188 mInsets.top + availableHeightPx - hotseatTop
Tony Wickham5edf9e22020-03-27 20:06:52 -07001189 - workspacePageIndicatorHeight - edgeMarginPx);
Winsonfadbe8f2016-07-22 16:35:37 -07001190 }
1191 }
1192
Jon Miranda228877d2021-02-09 11:05:00 -05001193 public static int calculateCellWidth(int width, int borderSpacing, int countX) {
1194 return (width - ((countX - 1) * borderSpacing)) / countX;
Winson Chungb3800242013-10-24 11:01:54 -07001195 }
Pierre Barbier de Reuille578deba2021-09-24 13:47:44 +01001196
Jon Miranda228877d2021-02-09 11:05:00 -05001197 public static int calculateCellHeight(int height, int borderSpacing, int countY) {
1198 return (height - ((countY - 1) * borderSpacing)) / countY;
Winson Chungb3800242013-10-24 11:01:54 -07001199 }
1200
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -07001201 /**
Tony Wickham55616cd2015-09-23 14:55:17 -07001202 * When {@code true}, the device is in landscape mode and the hotseat is on the right column.
1203 * When {@code false}, either device is in portrait mode or the device is in landscape mode and
1204 * the hotseat is on the bottom row.
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -07001205 */
Tony Wickhamab946a12015-09-16 15:38:16 -07001206 public boolean isVerticalBarLayout() {
Winson Chungb3800242013-10-24 11:01:54 -07001207 return isLandscape && transposeLayoutWithOrientation;
1208 }
1209
Sunny Goyal59d086c2018-05-07 17:31:40 -07001210 /**
1211 * Updates orientation information and returns true if it has changed from the previous value.
1212 */
Winson Chung13c1c2c2019-09-06 11:46:19 -07001213 public boolean updateIsSeascape(Context context) {
Sunny Goyal59d086c2018-05-07 17:31:40 -07001214 if (isVerticalBarLayout()) {
Sunny Goyal35c7b192021-04-20 16:51:10 -07001215 boolean isSeascape = DisplayController.INSTANCE.get(context)
1216 .getInfo().rotation == Surface.ROTATION_270;
Sunny Goyal59d086c2018-05-07 17:31:40 -07001217 if (mIsSeascape != isSeascape) {
1218 mIsSeascape = isSeascape;
Pat Manning08610ca2022-04-05 21:03:16 +01001219 // Hotseat changing sides requires updating workspace left/right paddings
1220 updateWorkspacePadding();
Sunny Goyal59d086c2018-05-07 17:31:40 -07001221 return true;
1222 }
1223 }
1224 return false;
1225 }
1226
Sunny Goyal7e2e67f2018-01-26 13:40:08 -08001227 public boolean isSeascape() {
Sunny Goyal59d086c2018-05-07 17:31:40 -07001228 return isVerticalBarLayout() && mIsSeascape;
Sunny Goyal7e2e67f2018-01-26 13:40:08 -08001229 }
1230
Sunny Goyal07b69292018-01-08 14:19:34 -08001231 public boolean shouldFadeAdjacentWorkspaceScreens() {
Sunny Goyal19ff7282021-04-22 10:12:54 -07001232 return isVerticalBarLayout();
Winson Chungb3800242013-10-24 11:01:54 -07001233 }
1234
Jon Miranda92c1b5d2021-07-20 13:57:16 -07001235 public int getCellContentHeight(@ContainerType int containerType) {
Sunny Goyalc13403c2016-11-18 23:44:48 -08001236 switch (containerType) {
1237 case CellLayout.WORKSPACE:
1238 return cellHeightPx;
1239 case CellLayout.FOLDER:
1240 return folderCellHeightPx;
1241 case CellLayout.HOTSEAT:
Jon Miranda92c1b5d2021-07-20 13:57:16 -07001242 // The hotseat is the only container where the cell height is going to be
1243 // different from the content within that cell.
1244 return iconSizePx;
Sunny Goyalc13403c2016-11-18 23:44:48 -08001245 default:
1246 // ??
1247 return 0;
1248 }
1249 }
Sunny Goyal13178ac2016-04-04 16:35:22 -07001250
Jon Miranda58561d42021-03-17 10:51:54 -04001251 private String pxToDpStr(String name, float value) {
Sunny Goyal35c7b192021-04-20 16:51:10 -07001252 return "\t" + name + ": " + value + "px (" + dpiFromPx(value, mMetrics.densityDpi) + "dp)";
Jon Miranda58561d42021-03-17 10:51:54 -04001253 }
1254
1255 public void dump(String prefix, PrintWriter writer) {
1256 writer.println(prefix + "DeviceProfile:");
Sunny Goyal35c7b192021-04-20 16:51:10 -07001257 writer.println(prefix + "\t1 dp = " + mMetrics.density + " px");
Jon Miranda58561d42021-03-17 10:51:54 -04001258
1259 writer.println(prefix + "\tisTablet:" + isTablet);
Jon Miranda58561d42021-03-17 10:51:54 -04001260 writer.println(prefix + "\tisPhone:" + isPhone);
1261 writer.println(prefix + "\ttransposeLayoutWithOrientation:"
1262 + transposeLayoutWithOrientation);
Alex Chau6ed408f2022-03-04 12:58:05 +00001263 writer.println(prefix + "\tisGestureMode:" + isGestureMode);
Jon Miranda58561d42021-03-17 10:51:54 -04001264
1265 writer.println(prefix + "\tisLandscape:" + isLandscape);
1266 writer.println(prefix + "\tisMultiWindowMode:" + isMultiWindowMode);
Sunny Goyal19ff7282021-04-22 10:12:54 -07001267 writer.println(prefix + "\tisTwoPanels:" + isTwoPanels);
Jon Miranda58561d42021-03-17 10:51:54 -04001268
1269 writer.println(prefix + pxToDpStr("windowX", windowX));
1270 writer.println(prefix + pxToDpStr("windowY", windowY));
1271 writer.println(prefix + pxToDpStr("widthPx", widthPx));
1272 writer.println(prefix + pxToDpStr("heightPx", heightPx));
Jon Miranda58561d42021-03-17 10:51:54 -04001273 writer.println(prefix + pxToDpStr("availableWidthPx", availableWidthPx));
1274 writer.println(prefix + pxToDpStr("availableHeightPx", availableHeightPx));
Alex Chaue0227552022-04-06 19:44:43 +01001275 writer.println(prefix + pxToDpStr("mInsets.left", mInsets.left));
1276 writer.println(prefix + pxToDpStr("mInsets.top", mInsets.top));
1277 writer.println(prefix + pxToDpStr("mInsets.right", mInsets.right));
1278 writer.println(prefix + pxToDpStr("mInsets.bottom", mInsets.bottom));
Jon Miranda58561d42021-03-17 10:51:54 -04001279
1280 writer.println(prefix + "\taspectRatio:" + aspectRatio);
1281
1282 writer.println(prefix + "\tisScalableGrid:" + isScalableGrid);
1283
Thales Lima83bedbf2021-10-05 17:47:39 +01001284 writer.println(prefix + "\tinv.numRows: " + inv.numRows);
Alex Chau9fee3fd2021-12-01 18:43:10 +00001285 writer.println(prefix + "\tinv.numColumns: " + inv.numColumns);
1286 writer.println(prefix + "\tinv.numSearchContainerColumns: "
1287 + inv.numSearchContainerColumns);
Jon Miranda58561d42021-03-17 10:51:54 -04001288
Thales Lima83bedbf2021-10-05 17:47:39 +01001289 writer.println(prefix + "\tminCellSize: " + inv.minCellSize[mTypeIndex] + "dp");
Jon Mirandaab3c6812021-06-28 15:42:28 -07001290
Jon Miranda58561d42021-03-17 10:51:54 -04001291 writer.println(prefix + pxToDpStr("cellWidthPx", cellWidthPx));
1292 writer.println(prefix + pxToDpStr("cellHeightPx", cellHeightPx));
1293
1294 writer.println(prefix + pxToDpStr("getCellSize().x", getCellSize().x));
1295 writer.println(prefix + pxToDpStr("getCellSize().y", getCellSize().y));
1296
Thales Lima83bedbf2021-10-05 17:47:39 +01001297 writer.println(prefix + pxToDpStr("cellLayoutBorderSpacePx Horizontal",
1298 cellLayoutBorderSpacePx.x));
1299 writer.println(prefix + pxToDpStr("cellLayoutBorderSpacePx Vertical",
1300 cellLayoutBorderSpacePx.y));
Pat Manning08610ca2022-04-05 21:03:16 +01001301 writer.println(prefix + pxToDpStr("cellLayoutPaddingPx.left", cellLayoutPaddingPx.left));
1302 writer.println(prefix + pxToDpStr("cellLayoutPaddingPx.top", cellLayoutPaddingPx.top));
1303 writer.println(prefix + pxToDpStr("cellLayoutPaddingPx.right", cellLayoutPaddingPx.right));
1304 writer.println(
1305 prefix + pxToDpStr("cellLayoutPaddingPx.bottom", cellLayoutPaddingPx.bottom));
Thales Lima83bedbf2021-10-05 17:47:39 +01001306
Jon Miranda58561d42021-03-17 10:51:54 -04001307 writer.println(prefix + pxToDpStr("iconSizePx", iconSizePx));
1308 writer.println(prefix + pxToDpStr("iconTextSizePx", iconTextSizePx));
1309 writer.println(prefix + pxToDpStr("iconDrawablePaddingPx", iconDrawablePaddingPx));
1310
1311 writer.println(prefix + pxToDpStr("folderCellWidthPx", folderCellWidthPx));
1312 writer.println(prefix + pxToDpStr("folderCellHeightPx", folderCellHeightPx));
1313 writer.println(prefix + pxToDpStr("folderChildIconSizePx", folderChildIconSizePx));
1314 writer.println(prefix + pxToDpStr("folderChildTextSizePx", folderChildTextSizePx));
1315 writer.println(prefix + pxToDpStr("folderChildDrawablePaddingPx",
1316 folderChildDrawablePaddingPx));
Thales Lima78d00ad2021-09-30 11:29:06 +01001317 writer.println(prefix + pxToDpStr("folderCellLayoutBorderSpaceOriginalPx",
1318 folderCellLayoutBorderSpaceOriginalPx));
1319 writer.println(prefix + pxToDpStr("folderCellLayoutBorderSpacePx Horizontal",
1320 folderCellLayoutBorderSpacePx.x));
1321 writer.println(prefix + pxToDpStr("folderCellLayoutBorderSpacePx Vertical",
1322 folderCellLayoutBorderSpacePx.y));
Jon Miranda58561d42021-03-17 10:51:54 -04001323
Alex Chaue0227552022-04-06 19:44:43 +01001324 writer.println(prefix + pxToDpStr("bottomSheetTopPadding", bottomSheetTopPadding));
1325
1326 writer.println(prefix + pxToDpStr("allAppsShiftRange", allAppsShiftRange));
1327 writer.println(prefix + pxToDpStr("allAppsTopPadding", allAppsTopPadding));
Jon Miranda58561d42021-03-17 10:51:54 -04001328 writer.println(prefix + pxToDpStr("allAppsIconSizePx", allAppsIconSizePx));
1329 writer.println(prefix + pxToDpStr("allAppsIconTextSizePx", allAppsIconTextSizePx));
1330 writer.println(prefix + pxToDpStr("allAppsIconDrawablePaddingPx",
1331 allAppsIconDrawablePaddingPx));
1332 writer.println(prefix + pxToDpStr("allAppsCellHeightPx", allAppsCellHeightPx));
Alex Chau27b39b92022-01-14 18:02:18 +00001333 writer.println(prefix + pxToDpStr("allAppsCellWidthPx", allAppsCellWidthPx));
Thales Limab7ef5692022-03-10 10:32:36 +00001334 writer.println(prefix + pxToDpStr("allAppsBorderSpacePx", allAppsBorderSpacePx.x));
Sunny Goyal19ff7282021-04-22 10:12:54 -07001335 writer.println(prefix + "\tnumShownAllAppsColumns: " + numShownAllAppsColumns);
Alex Chau27b39b92022-01-14 18:02:18 +00001336 writer.println(prefix + pxToDpStr("allAppsLeftRightPadding", allAppsLeftRightPadding));
1337 writer.println(prefix + pxToDpStr("allAppsLeftRightMargin", allAppsLeftRightMargin));
Jon Miranda58561d42021-03-17 10:51:54 -04001338
1339 writer.println(prefix + pxToDpStr("hotseatBarSizePx", hotseatBarSizePx));
Thales Lima425f6822022-05-10 13:44:58 -03001340 writer.println(prefix + "\tinv.hotseatColumnSpan: " + inv.hotseatColumnSpan[mTypeIndex]);
Jon Miranda58561d42021-03-17 10:51:54 -04001341 writer.println(prefix + pxToDpStr("hotseatCellHeightPx", hotseatCellHeightPx));
1342 writer.println(prefix + pxToDpStr("hotseatBarTopPaddingPx", hotseatBarTopPaddingPx));
1343 writer.println(prefix + pxToDpStr("hotseatBarBottomPaddingPx", hotseatBarBottomPaddingPx));
1344 writer.println(prefix + pxToDpStr("hotseatBarSidePaddingStartPx",
1345 hotseatBarSidePaddingStartPx));
1346 writer.println(prefix + pxToDpStr("hotseatBarSidePaddingEndPx",
1347 hotseatBarSidePaddingEndPx));
Pat Manningde25c0d2022-04-05 19:11:26 +01001348 writer.println(prefix + pxToDpStr("springLoadedHotseatBarTopMarginPx",
1349 springLoadedHotseatBarTopMarginPx));
1350 writer.println(prefix + pxToDpStr("mHotseatPadding.top", mHotseatPadding.top));
1351 writer.println(prefix + pxToDpStr("mHotseatPadding.bottom", mHotseatPadding.bottom));
1352 writer.println(prefix + pxToDpStr("mHotseatPadding.left", mHotseatPadding.left));
1353 writer.println(prefix + pxToDpStr("mHotseatPadding.right", mHotseatPadding.right));
Sunny Goyal19ff7282021-04-22 10:12:54 -07001354 writer.println(prefix + "\tnumShownHotseatIcons: " + numShownHotseatIcons);
Thales Lima116b51a2022-02-03 16:19:47 +00001355 writer.println(prefix + pxToDpStr("hotseatBorderSpace", hotseatBorderSpace));
Thales Limaa1012902022-01-13 17:58:42 +00001356 writer.println(prefix + "\tisQsbInline: " + isQsbInline);
1357 writer.println(prefix + pxToDpStr("qsbWidth", qsbWidth));
Jon Miranda58561d42021-03-17 10:51:54 -04001358
1359 writer.println(prefix + "\tisTaskbarPresent:" + isTaskbarPresent);
Tony Wickham635e1802021-07-22 14:28:04 -10001360 writer.println(prefix + "\tisTaskbarPresentInApps:" + isTaskbarPresentInApps);
Jon Miranda58561d42021-03-17 10:51:54 -04001361 writer.println(prefix + pxToDpStr("taskbarSize", taskbarSize));
Jon Miranda58561d42021-03-17 10:51:54 -04001362
Thales Lima83bedbf2021-10-05 17:47:39 +01001363 writer.println(prefix + pxToDpStr("desiredWorkspaceHorizontalMarginPx",
1364 desiredWorkspaceHorizontalMarginPx));
Jon Miranda58561d42021-03-17 10:51:54 -04001365 writer.println(prefix + pxToDpStr("workspacePadding.left", workspacePadding.left));
1366 writer.println(prefix + pxToDpStr("workspacePadding.top", workspacePadding.top));
1367 writer.println(prefix + pxToDpStr("workspacePadding.right", workspacePadding.right));
1368 writer.println(prefix + pxToDpStr("workspacePadding.bottom", workspacePadding.bottom));
1369
Jon Mirandaab3c6812021-06-28 15:42:28 -07001370 writer.println(prefix + pxToDpStr("iconScale", iconScale));
1371 writer.println(prefix + pxToDpStr("cellScaleToFit ", cellScaleToFit));
Jon Miranda58561d42021-03-17 10:51:54 -04001372 writer.println(prefix + pxToDpStr("extraSpace", extraSpace));
Thales Lima7a6752d2021-09-23 14:31:00 +01001373 writer.println(prefix + pxToDpStr("unscaled extraSpace", extraSpace / iconScale));
Jon Mirandac9e69fa2021-03-22 17:13:34 -04001374
1375 if (inv.devicePaddings != null) {
1376 int unscaledExtraSpace = (int) (extraSpace / iconScale);
1377 writer.println(prefix + pxToDpStr("maxEmptySpace",
1378 inv.devicePaddings.getDevicePadding(unscaledExtraSpace).getMaxEmptySpacePx()));
1379 }
Jon Miranda58561d42021-03-17 10:51:54 -04001380 writer.println(prefix + pxToDpStr("workspaceTopPadding", workspaceTopPadding));
1381 writer.println(prefix + pxToDpStr("workspaceBottomPadding", workspaceBottomPadding));
1382 writer.println(prefix + pxToDpStr("extraHotseatBottomPadding", extraHotseatBottomPadding));
Alex Chau635b3ab2022-01-26 16:49:10 +00001383
1384 writer.println(prefix + pxToDpStr("overviewTaskMarginPx", overviewTaskMarginPx));
1385 writer.println(prefix + pxToDpStr("overviewTaskMarginGridPx", overviewTaskMarginGridPx));
1386 writer.println(prefix + pxToDpStr("overviewTaskIconSizePx", overviewTaskIconSizePx));
1387 writer.println(prefix + pxToDpStr("overviewTaskIconDrawableSizePx",
1388 overviewTaskIconDrawableSizePx));
1389 writer.println(prefix + pxToDpStr("overviewTaskIconDrawableSizeGridPx",
1390 overviewTaskIconDrawableSizeGridPx));
1391 writer.println(prefix + pxToDpStr("overviewTaskThumbnailTopMarginPx",
1392 overviewTaskThumbnailTopMarginPx));
Alex Chaua2fc7642022-04-21 14:20:23 +01001393 writer.println(prefix + pxToDpStr("overviewActionsTopMarginPx",
1394 overviewActionsTopMarginPx));
1395 writer.println(prefix + pxToDpStr("overviewActionsHeight",
1396 overviewActionsHeight));
Alex Chau635b3ab2022-01-26 16:49:10 +00001397 writer.println(prefix + pxToDpStr("overviewActionsButtonSpacing",
1398 overviewActionsButtonSpacing));
1399 writer.println(prefix + pxToDpStr("overviewPageSpacing", overviewPageSpacing));
1400 writer.println(prefix + pxToDpStr("overviewRowSpacing", overviewRowSpacing));
1401 writer.println(prefix + pxToDpStr("overviewGridSideMargin", overviewGridSideMargin));
Pat Manningde25c0d2022-04-05 19:11:26 +01001402
1403 writer.println(prefix + pxToDpStr("dropTargetBarTopMarginPx", dropTargetBarTopMarginPx));
1404 writer.println(prefix + pxToDpStr("dropTargetBarSizePx", dropTargetBarSizePx));
1405 writer.println(
1406 prefix + pxToDpStr("dropTargetBarBottomMarginPx", dropTargetBarBottomMarginPx));
1407
1408 writer.println(
1409 prefix + pxToDpStr("workspaceSpringLoadShrunkTop", workspaceSpringLoadShrunkTop));
1410 writer.println(prefix + pxToDpStr("workspaceSpringLoadShrunkBottom",
1411 workspaceSpringLoadShrunkBottom));
Alex Chau906d8822022-05-23 10:42:25 +01001412 writer.println(prefix + pxToDpStr("workspaceSpringLoadedBottomSpace",
1413 workspaceSpringLoadedBottomSpace));
1414 writer.println(prefix + pxToDpStr("workspaceSpringLoadedMinNextPageVisiblePx",
1415 workspaceSpringLoadedMinNextPageVisiblePx));
Pat Manninga2e14992022-04-22 11:29:17 +01001416 writer.println(
1417 prefix + pxToDpStr("getWorkspaceSpringLoadScale()", getWorkspaceSpringLoadScale()));
Jon Miranda58561d42021-03-17 10:51:54 -04001418 }
1419
Alex Chaua6907dc2022-03-18 15:24:07 +00001420 private static Context getContext(Context c, Info info, int orientation, WindowBounds bounds) {
Sunny Goyal1890f672020-04-30 12:28:00 -07001421 Configuration config = new Configuration(c.getResources().getConfiguration());
1422 config.orientation = orientation;
Thales Lima425f6822022-05-10 13:44:58 -03001423 config.densityDpi = info.getDensityDpi();
Alex Chaua6907dc2022-03-18 15:24:07 +00001424 config.smallestScreenWidthDp = (int) info.smallestSizeDp(bounds);
Sunny Goyal1890f672020-04-30 12:28:00 -07001425 return c.createConfigurationContext(config);
Jon Mirandab28c4fc2017-06-20 10:58:36 -07001426 }
Sunny Goyalfde55052018-02-01 14:46:13 -08001427
1428 /**
1429 * Callback when a component changes the DeviceProfile associated with it, as a result of
1430 * configuration change
1431 */
1432 public interface OnDeviceProfileChangeListener {
1433
1434 /**
1435 * Called when the device profile is reassigned. Note that for layout and measurements, it
1436 * is sufficient to listen for inset changes. Use this callback when you need to perform
1437 * a one time operation.
1438 */
1439 void onDeviceProfileChanged(DeviceProfile dp);
1440 }
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001441
Brian Isganitis099945b2022-01-31 18:15:00 -05001442 /** Allows registering listeners for {@link DeviceProfile} changes. */
1443 public interface DeviceProfileListenable {
1444
1445 /** The current device profile. */
1446 DeviceProfile getDeviceProfile();
1447
1448 /** Registered {@link OnDeviceProfileChangeListener} instances. */
1449 List<OnDeviceProfileChangeListener> getOnDeviceProfileChangeListeners();
1450
1451 /** Notifies listeners of a {@link DeviceProfile} change. */
1452 default void dispatchDeviceProfileChanged() {
1453 DeviceProfile deviceProfile = getDeviceProfile();
1454 List<OnDeviceProfileChangeListener> listeners = getOnDeviceProfileChangeListeners();
1455 for (int i = listeners.size() - 1; i >= 0; i--) {
1456 listeners.get(i).onDeviceProfileChanged(deviceProfile);
1457 }
1458 }
1459
1460 /** Register listener for {@link DeviceProfile} changes. */
1461 default void addOnDeviceProfileChangeListener(OnDeviceProfileChangeListener listener) {
1462 getOnDeviceProfileChangeListeners().add(listener);
1463 }
1464
1465 /** Unregister listener for {@link DeviceProfile} changes. */
1466 default void removeOnDeviceProfileChangeListener(OnDeviceProfileChangeListener listener) {
1467 getOnDeviceProfileChangeListeners().remove(listener);
1468 }
1469 }
1470
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001471 public static class Builder {
1472 private Context mContext;
1473 private InvariantDeviceProfile mInv;
Sunny Goyalfd58da62020-08-11 12:06:49 -07001474 private Info mInfo;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001475
Sunny Goyal19ff7282021-04-22 10:12:54 -07001476 private WindowBounds mWindowBounds;
1477 private boolean mUseTwoPanels;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001478
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001479 private boolean mIsMultiWindowMode = false;
Sunny Goyal19ff7282021-04-22 10:12:54 -07001480 private Boolean mTransposeLayoutWithOrientation;
Alex Chau6ed408f2022-03-04 12:58:05 +00001481 private Boolean mIsGestureMode;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001482
Sunny Goyalfd58da62020-08-11 12:06:49 -07001483 public Builder(Context context, InvariantDeviceProfile inv, Info info) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001484 mContext = context;
1485 mInv = inv;
1486 mInfo = info;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001487 }
1488
1489 public Builder setMultiWindowMode(boolean isMultiWindowMode) {
1490 mIsMultiWindowMode = isMultiWindowMode;
1491 return this;
1492 }
1493
Sunny Goyal19ff7282021-04-22 10:12:54 -07001494 public Builder setUseTwoPanels(boolean useTwoPanels) {
1495 mUseTwoPanels = useTwoPanels;
1496 return this;
1497 }
1498
1499
1500 public Builder setWindowBounds(WindowBounds bounds) {
1501 mWindowBounds = bounds;
Sunny Goyal0addbf02020-04-28 14:17:35 -07001502 return this;
1503 }
1504
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001505 public Builder setTransposeLayoutWithOrientation(boolean transposeLayoutWithOrientation) {
1506 mTransposeLayoutWithOrientation = transposeLayoutWithOrientation;
1507 return this;
1508 }
1509
Alex Chau6ed408f2022-03-04 12:58:05 +00001510 public Builder setGestureMode(boolean isGestureMode) {
1511 mIsGestureMode = isGestureMode;
1512 return this;
1513 }
1514
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001515 public DeviceProfile build() {
Sunny Goyal19ff7282021-04-22 10:12:54 -07001516 if (mWindowBounds == null) {
1517 throw new IllegalArgumentException("Window bounds not set");
1518 }
1519 if (mTransposeLayoutWithOrientation == null) {
1520 mTransposeLayoutWithOrientation = !mInfo.isTablet(mWindowBounds);
1521 }
Alex Chau6ed408f2022-03-04 12:58:05 +00001522 if (mIsGestureMode == null) {
1523 mIsGestureMode = DisplayController.getNavigationMode(mContext).hasGestures;
1524 }
1525 return new DeviceProfile(mContext, mInv, mInfo, mWindowBounds, mIsMultiWindowMode,
1526 mTransposeLayoutWithOrientation, mUseTwoPanels, mIsGestureMode);
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001527 }
1528 }
1529
Winson Chungb3800242013-10-24 11:01:54 -07001530}