blob: b7fcd980b2f65a3489b61c2082bda2473fd545e8 [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
Kateryna Ivanova71203732023-05-24 15:09:00 +000019import static com.android.app.animation.Interpolators.LINEAR;
Jordan Silvaf2402e22023-10-26 19:53:16 +010020import static com.android.launcher3.Flags.enableOverviewIconMenu;
Luca Zuccarinic9cbc9d2024-03-11 14:29:48 +000021import static com.android.launcher3.Flags.enableScalingRevealHomeAnimation;
Thales Lima12d0eff2022-03-25 17:06:11 +000022import static com.android.launcher3.InvariantDeviceProfile.INDEX_DEFAULT;
23import static com.android.launcher3.InvariantDeviceProfile.INDEX_LANDSCAPE;
24import static com.android.launcher3.InvariantDeviceProfile.INDEX_TWO_PANEL_LANDSCAPE;
25import static com.android.launcher3.InvariantDeviceProfile.INDEX_TWO_PANEL_PORTRAIT;
Jon Miranda58561d42021-03-17 10:51:54 -040026import static com.android.launcher3.Utilities.dpiFromPx;
Jon Mirandaaf3aed02021-05-06 18:28:45 -070027import static com.android.launcher3.Utilities.pxFromSp;
Jon Miranda92c1b5d2021-07-20 13:57:16 -070028import static com.android.launcher3.folder.ClippedFolderIconLayoutRule.ICON_OVERLAP_FACTOR;
Sunny Goyal65190ae2022-08-02 14:16:26 -070029import static com.android.launcher3.icons.GraphicsUtils.getShapePath;
Jon Miranda95f44722023-06-06 19:48:19 -070030import static com.android.launcher3.icons.IconNormalizer.ICON_VISIBLE_AREA_FACTOR;
Thales Limab35faed2022-09-05 16:30:01 -030031import static com.android.launcher3.testing.shared.ResourceUtils.INVALID_RESOURCE_HANDLE;
Pat Manning5f74bfd2022-07-20 12:08:54 +010032import static com.android.launcher3.testing.shared.ResourceUtils.pxFromDp;
Thales Lima7eee74b2023-03-16 16:00:55 -030033import static com.android.launcher3.testing.shared.ResourceUtils.roundPxValueFromFloat;
mpodoliandfb48212024-09-13 17:43:11 -070034import static com.android.wm.shell.Flags.enableBubbleBar;
35import static com.android.wm.shell.Flags.enableBubbleBarInPersistentTaskBar;
Brian Isganitise1eaefd2024-05-21 15:38:08 -040036import static com.android.wm.shell.Flags.enableTinyTaskbar;
Jon Miranda228877d2021-02-09 11:05:00 -050037
Sunny Goyal35c7b192021-04-20 16:51:10 -070038import android.annotation.SuppressLint;
Winson Chungb3800242013-10-24 11:01:54 -070039import android.content.Context;
Jon Mirandab28c4fc2017-06-20 10:58:36 -070040import android.content.res.Configuration;
Winson Chungb3800242013-10-24 11:01:54 -070041import android.content.res.Resources;
Thales Limab35faed2022-09-05 16:30:01 -030042import android.content.res.TypedArray;
Winson Chungb3800242013-10-24 11:01:54 -070043import android.graphics.Point;
Jon Miranda7ae64ff2016-11-21 16:18:46 -080044import android.graphics.PointF;
Winson Chungb3800242013-10-24 11:01:54 -070045import android.graphics.Rect;
Sunny Goyal35c7b192021-04-20 16:51:10 -070046import android.util.DisplayMetrics;
Sunny Goyal65190ae2022-08-02 14:16:26 -070047import android.util.SparseArray;
Sunny Goyal59d086c2018-05-07 17:31:40 -070048import android.view.Surface;
Winson Chungb3800242013-10-24 11:01:54 -070049
Sunny Goyal65190ae2022-08-02 14:16:26 -070050import androidx.annotation.NonNull;
Sihua Mae04aa202022-07-18 12:43:56 -070051import androidx.annotation.Nullable;
fbarone4b0b712024-03-29 14:31:17 -070052import androidx.annotation.VisibleForTesting;
Jon Miranda9c478b62023-03-23 21:38:49 -070053import androidx.core.content.res.ResourcesCompat;
Sunny Goyal65190ae2022-08-02 14:16:26 -070054
Sunny Goyalc13403c2016-11-18 23:44:48 -080055import com.android.launcher3.CellLayout.ContainerType;
Jon Miranda228877d2021-02-09 11:05:00 -050056import com.android.launcher3.DevicePaddings.DevicePadding;
Tony Wickham8912b042018-11-29 15:28:53 -080057import com.android.launcher3.icons.DotRenderer;
Hyunyoung Song48cb7bc2018-09-25 17:03:34 -070058import com.android.launcher3.icons.IconNormalizer;
Sihua Mae04aa202022-07-18 12:43:56 -070059import com.android.launcher3.model.data.ItemInfo;
Jordan Silva999dd2a2023-11-17 19:31:43 +000060import com.android.launcher3.responsive.CalculatedCellSpec;
Thales Limaf8bfb032023-07-24 15:08:05 +010061import com.android.launcher3.responsive.CalculatedHotseatSpec;
Jordan Silvaf2402e22023-10-26 19:53:16 +010062import com.android.launcher3.responsive.CalculatedResponsiveSpec;
63import com.android.launcher3.responsive.HotseatSpecsProvider;
Jordan Silva999dd2a2023-11-17 19:31:43 +000064import com.android.launcher3.responsive.ResponsiveCellSpecsProvider;
Jordan Silvaf2402e22023-10-26 19:53:16 +010065import com.android.launcher3.responsive.ResponsiveSpec.Companion.ResponsiveSpecType;
66import com.android.launcher3.responsive.ResponsiveSpec.DimensionType;
67import com.android.launcher3.responsive.ResponsiveSpecsProvider;
Thales Lima24ceca62023-09-25 16:21:17 -070068import com.android.launcher3.util.CellContentDimensions;
mpodoliandfb48212024-09-13 17:43:11 -070069import com.android.launcher3.util.DisplayController;
Sunny Goyalfd58da62020-08-11 12:06:49 -070070import com.android.launcher3.util.DisplayController.Info;
Thales Lima2759aa32023-06-05 16:25:45 +010071import com.android.launcher3.util.IconSizeSteps;
mpodoliandfb48212024-09-13 17:43:11 -070072import com.android.launcher3.util.NavigationMode;
Thales Limac98b7812023-04-14 15:04:23 +010073import com.android.launcher3.util.ResourceHelper;
Sunny Goyalb46703d2020-05-27 17:52:03 -070074import com.android.launcher3.util.WindowBounds;
Sunny Goyal11117d92024-03-25 16:12:10 -070075import com.android.launcher3.util.window.WindowManagerProxy;
Winson1f064272016-07-18 17:18:02 -070076
Jon Miranda58561d42021-03-17 10:51:54 -040077import java.io.PrintWriter;
Alex Chaue818bcb2022-09-02 17:27:11 +010078import java.util.Locale;
Jon Miranda2b25ded2023-02-02 14:48:45 -080079import java.util.function.Consumer;
Jon Miranda58561d42021-03-17 10:51:54 -040080
Sunny Goyal35c7b192021-04-20 16:51:10 -070081@SuppressLint("NewApi")
Winson Chungb3800242013-10-24 11:01:54 -070082public class DeviceProfile {
Adam Cohen2e6da152015-05-06 11:42:25 -070083
Sunny Goyal8b9919d2021-04-07 14:45:17 -070084 private static final int DEFAULT_DOT_SIZE = 100;
Thales Limab35faed2022-09-05 16:30:01 -030085 private static final float MIN_FOLDER_TEXT_SIZE_SP = 16f;
Sunny Goyal6c304b12023-04-10 12:03:04 -070086 private static final float MIN_WIDGET_PADDING_DP = 6f;
Alex Chau206ede92022-08-01 17:46:12 +010087
Shamali Pbe55f822024-01-16 15:07:19 +000088 // Minimum aspect ratio beyond which an extra top padding may be applied to a bottom sheet.
89 private static final float MIN_ASPECT_RATIO_FOR_EXTRA_TOP_PADDING = 1.5f;
fbaron3bb6d4b2024-02-23 10:54:13 -080090 private static final float MAX_ASPECT_RATIO_FOR_ALTERNATE_EDIT_STATE = 1.5f;
Shamali Pbe55f822024-01-16 15:07:19 +000091
Sihua Mae04aa202022-07-18 12:43:56 -070092 public static final PointF DEFAULT_SCALE = new PointF(1.0f, 1.0f);
93 public static final ViewScaleProvider DEFAULT_PROVIDER = itemInfo -> DEFAULT_SCALE;
Jordan Silvaf2402e22023-10-26 19:53:16 +010094 public static final Consumer<DeviceProfile> DEFAULT_DIMENSION_PROVIDER = dp -> {
95 };
Sihua Mae04aa202022-07-18 12:43:56 -070096
Adam Cohen2e6da152015-05-06 11:42:25 -070097 public final InvariantDeviceProfile inv;
Sunny Goyalfd58da62020-08-11 12:06:49 -070098 private final Info mInfo;
Sunny Goyal35c7b192021-04-20 16:51:10 -070099 private final DisplayMetrics mMetrics;
Thales Lima2759aa32023-06-05 16:25:45 +0100100 private final IconSizeSteps mIconSizeSteps;
Winson Chungbe876472014-05-14 14:15:20 -0700101
Sunny Goyalc6205602015-05-21 20:46:33 -0700102 // Device properties
103 public final boolean isTablet;
Sunny Goyalc6205602015-05-21 20:46:33 -0700104 public final boolean isPhone;
105 public final boolean transposeLayoutWithOrientation;
Alex Chauab800f72022-12-13 17:46:06 +0000106 public final boolean isMultiDisplay;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700107 public final boolean isTwoPanels;
Fengjiang Lie90f0982024-03-12 09:36:54 -0700108 public boolean isPredictiveBackSwipe;
Thales Limaa1012902022-01-13 17:58:42 +0000109 public final boolean isQsbInline;
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -0700110
Sunny Goyalc6205602015-05-21 20:46:33 -0700111 // Device properties in current orientation
Sunny Goyald792a772018-04-05 13:37:46 -0700112 public final boolean isLandscape;
Sunny Goyald70e75a2018-02-22 10:07:32 -0800113 public final boolean isMultiWindowMode;
Alex Chau6ed408f2022-03-04 12:58:05 +0000114 public final boolean isGestureMode;
Sunny Goyald70e75a2018-02-22 10:07:32 -0800115
Winson Chung104a4c82023-11-08 18:56:15 +0000116 public final boolean isLeftRightSplit;
117
Sunny Goyal0addbf02020-04-28 14:17:35 -0700118 public final int windowX;
119 public final int windowY;
Sunny Goyalc6205602015-05-21 20:46:33 -0700120 public final int widthPx;
121 public final int heightPx;
122 public final int availableWidthPx;
123 public final int availableHeightPx;
Sunny Goyal187b16c2022-03-01 16:53:23 -0800124 public final int rotationHint;
Jon Mirandabba64512019-03-27 10:54:17 -0700125
126 public final float aspectRatio;
127
Thales Lima79456492023-05-23 11:32:22 +0100128 private final boolean mIsScalableGrid;
Thales Lima83bedbf2021-10-05 17:47:39 +0100129 private final int mTypeIndex;
Jon Mirandae126d722021-02-25 10:45:20 -0500130
Thales Limac98b7812023-04-14 15:04:23 +0100131 // Responsive grid
132 private final boolean mIsResponsiveGrid;
Jordan Silva8f7986a2023-11-08 12:11:25 +0000133 private CalculatedResponsiveSpec mResponsiveWorkspaceWidthSpec;
134 private CalculatedResponsiveSpec mResponsiveWorkspaceHeightSpec;
135 private CalculatedResponsiveSpec mResponsiveAllAppsWidthSpec;
136 private CalculatedResponsiveSpec mResponsiveAllAppsHeightSpec;
Jordan Silvaf2402e22023-10-26 19:53:16 +0100137 private CalculatedResponsiveSpec mResponsiveFolderWidthSpec;
138 private CalculatedResponsiveSpec mResponsiveFolderHeightSpec;
Thales Limaf8bfb032023-07-24 15:08:05 +0100139 private CalculatedHotseatSpec mResponsiveHotseatSpec;
Jordan Silva999dd2a2023-11-17 19:31:43 +0000140 private CalculatedCellSpec mResponsiveWorkspaceCellSpec;
141 private CalculatedCellSpec mResponsiveAllAppsCellSpec;
Thales Limac98b7812023-04-14 15:04:23 +0100142
Tony Wickhamd6b40372015-09-23 18:37:57 -0700143 /**
144 * The maximum amount of left/right workspace padding as a percentage of the screen width.
145 * To be clear, this means that up to 7% of the screen width can be used as left padding, and
146 * 7% of the screen width can be used as right padding.
147 */
148 private static final float MAX_HORIZONTAL_PADDING_PERCENT = 0.14f;
Winson Chungb3800242013-10-24 11:01:54 -0700149
Jon Miranda3f9bab22017-07-28 14:50:17 -0700150 private static final float TALL_DEVICE_ASPECT_RATIO_THRESHOLD = 2.0f;
Jon Miranda80cddbc2021-07-22 13:51:16 -0700151 private static final float TALLER_DEVICE_ASPECT_RATIO_THRESHOLD = 2.15f;
Jon Miranda80dda302021-07-28 14:14:59 -0700152 private static final float TALL_DEVICE_EXTRA_SPACE_THRESHOLD_DP = 252;
153 private static final float TALL_DEVICE_MORE_EXTRA_SPACE_THRESHOLD_DP = 268;
Jon Miranda30d0aa22017-07-25 15:55:29 -0700154
Sunny Goyalc6205602015-05-21 20:46:33 -0700155 // Workspace
Thales Limad90faab2021-09-21 17:18:47 +0100156 public final int desiredWorkspaceHorizontalMarginOriginalPx;
157 public int desiredWorkspaceHorizontalMarginPx;
Alex Chau51da2192022-05-20 13:32:10 +0100158 public int gridVisualizationPaddingX;
159 public int gridVisualizationPaddingY;
Thales Lima78d00ad2021-09-30 11:29:06 +0100160 public Point cellLayoutBorderSpaceOriginalPx;
161 public Point cellLayoutBorderSpacePx;
Pat Manning08610ca2022-04-05 21:03:16 +0100162 public Rect cellLayoutPaddingPx = new Rect();
163
Sunny Goyalc6205602015-05-21 20:46:33 -0700164 public final int edgeMarginPx;
Alex Chau0c4e11b2022-07-08 18:41:36 +0100165 public final float workspaceContentScale;
Alex Chau906d8822022-05-23 10:42:25 +0100166 public final int workspaceSpringLoadedMinNextPageVisiblePx;
Sunny Goyalc6205602015-05-21 20:46:33 -0700167
Jon Miranda58561d42021-03-17 10:51:54 -0400168 private final int extraSpace;
Thales Lima171ee662022-11-22 15:52:49 +0000169 private int maxEmptySpace;
Jon Miranda228877d2021-02-09 11:05:00 -0500170 public int workspaceTopPadding;
171 public int workspaceBottomPadding;
172
Tony Wickham5edf9e22020-03-27 20:06:52 -0700173 // Workspace page indicator
174 public final int workspacePageIndicatorHeight;
175 private final int mWorkspacePageIndicatorOverlapWorkspace;
Winson1f064272016-07-18 17:18:02 -0700176
Sunny Goyalc6205602015-05-21 20:46:33 -0700177 // Workspace icons
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400178 public float iconScale;
Sunny Goyalc6205602015-05-21 20:46:33 -0700179 public int iconSizePx;
180 public int iconTextSizePx;
181 public int iconDrawablePaddingPx;
Jordan Silva999dd2a2023-11-17 19:31:43 +0000182 private int mIconDrawablePaddingOriginalPx;
Thales Lima79456492023-05-23 11:32:22 +0100183 public boolean iconCenterVertically;
Winson Chungb3800242013-10-24 11:01:54 -0700184
Jon Mirandaab3c6812021-06-28 15:42:28 -0700185 public float cellScaleToFit;
Adam Cohen59400422014-03-05 18:07:04 -0800186 public int cellWidthPx;
187 public int cellHeightPx;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700188 public int workspaceCellPaddingXPx;
Adam Cohen59400422014-03-05 18:07:04 -0800189
Thales Lima79456492023-05-23 11:32:22 +0100190 public int cellYPaddingPx = -1;
Jon Mirandae126d722021-02-25 10:45:20 -0500191
Sunny Goyalc6205602015-05-21 20:46:33 -0700192 // Folder
Thales Lima1faa4ed2023-12-01 16:48:19 +0000193 public final int numFolderRows;
194 public final int numFolderColumns;
Jordan Silva999dd2a2023-11-17 19:31:43 +0000195 public final float folderLabelTextScale;
Jon Mirandae126d722021-02-25 10:45:20 -0500196 public int folderLabelTextSizePx;
Thales Limab35faed2022-09-05 16:30:01 -0300197 public int folderFooterHeightPx;
Sunny Goyalc6205602015-05-21 20:46:33 -0700198 public int folderIconSizePx;
Jon Miranda591e3602018-03-28 11:37:00 -0700199 public int folderIconOffsetYPx;
Jon Mirandabf7d8122016-11-03 15:29:29 -0700200
Jon Mirandae126d722021-02-25 10:45:20 -0500201 // Folder content
Jordan Silva637f4eb2023-06-13 11:21:53 +0100202 public Point folderCellLayoutBorderSpacePx;
Jon Mirandae126d722021-02-25 10:45:20 -0500203 public int folderContentPaddingLeftRight;
204 public int folderContentPaddingTop;
205
Jon Mirandabf7d8122016-11-03 15:29:29 -0700206 // Folder cell
Sunny Goyalc6205602015-05-21 20:46:33 -0700207 public int folderCellWidthPx;
208 public int folderCellHeightPx;
Jon Mirandabf7d8122016-11-03 15:29:29 -0700209
210 // Folder child
211 public int folderChildIconSizePx;
212 public int folderChildTextSizePx;
Sunny Goyalbaec6ff2016-09-14 11:26:21 -0700213 public int folderChildDrawablePaddingPx;
Winson Chungb3800242013-10-24 11:01:54 -0700214
Sunny Goyalc6205602015-05-21 20:46:33 -0700215 // Hotseat
Thales Lima9938c2f2022-07-25 14:38:16 +0100216 public int numShownHotseatIcons;
Sunny Goyalc6205602015-05-21 20:46:33 -0700217 public int hotseatCellHeightPx;
fbarone4b0b712024-03-29 14:31:17 -0700218 private int mHotseatColumnSpan;
219 private int mHotseatWidthPx; // not used in vertical bar layout
Pat Manning26f70f72022-07-07 13:50:39 +0100220 public final boolean areNavButtonsInline;
Jon Miranda18751b62017-07-31 17:25:27 -0700221 // In portrait: size = height, in landscape: size = width
222 public int hotseatBarSizePx;
Thales Limab8c05952022-05-23 16:58:38 +0100223 public int hotseatBarBottomSpacePx;
Pat Manning26f70f72022-07-07 13:50:39 +0100224 public int hotseatBarEndOffset;
Thales Limab8c05952022-05-23 16:58:38 +0100225 public int hotseatQsbSpace;
mpodoliandfb48212024-09-13 17:43:11 -0700226 public int inlineNavButtonsEndSpacingPx;
227 public int navButtonsLayoutWidthPx;
Pat Manningde25c0d2022-04-05 19:11:26 +0100228 public int springLoadedHotseatBarTopMarginPx;
Thales Lima8e11d532023-08-31 13:40:26 +0000229 // These 2 values are only used for isVerticalBar
230 // Padding between edge of screen and hotseat
231 public final int mHotseatBarEdgePaddingPx;
232 // Space between hotseat and workspace (not used in responsive)
233 public final int mHotseatBarWorkspaceSpacePx;
Alex Chau206ede92022-08-01 17:46:12 +0100234 public int hotseatQsbWidth; // only used when isQsbInline
Sunny Goyal57b22792021-05-25 14:35:01 -0700235 public final int hotseatQsbHeight;
Thales Limab8c05952022-05-23 16:58:38 +0100236 public final int hotseatQsbVisualHeight;
237 private final int hotseatQsbShadowHeight;
Thales Limadd027342022-01-07 12:54:37 +0000238 public int hotseatBorderSpace;
Thales Limaffc68b02023-01-09 16:20:23 +0000239 private final int mMinHotseatIconSpacePx;
240 private final int mMinHotseatQsbWidthPx;
241 private final int mMaxHotseatIconSpacePx;
Liran Binyamina833af32023-08-02 16:30:27 -0400242 // Space required for the bubble bar between the hotseat and the edge of the screen. If there's
243 // not enough space, the hotseat will adjust itself for the bubble bar.
244 private final int mBubbleBarSpaceThresholdPx;
Adam Cohen2e6da152015-05-06 11:42:25 -0700245
Alex Chau3d2c0622022-09-01 21:28:14 +0100246 // Bottom sheets
247 public int bottomSheetTopPadding;
248 public int bottomSheetOpenDuration;
249 public int bottomSheetCloseDuration;
250 public float bottomSheetWorkspaceScale;
251 public float bottomSheetDepth;
252
Sunny Goyalc6205602015-05-21 20:46:33 -0700253 // All apps
Thales Lima85c942f2021-12-31 13:04:20 +0000254 public Point allAppsBorderSpacePx;
Alex Chaub8c22e12022-02-14 18:35:58 +0000255 public int allAppsShiftRange;
Thales Limab433c9c2023-10-30 12:24:05 +0000256 public Rect allAppsPadding = new Rect();
Alex Chau3d2c0622022-09-01 21:28:14 +0100257 public int allAppsOpenDuration;
258 public int allAppsCloseDuration;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700259 public int allAppsCellHeightPx;
Samuel Fufaf1424a32019-10-04 15:15:19 -0700260 public int allAppsCellWidthPx;
Winson1f064272016-07-18 17:18:02 -0700261 public int allAppsIconSizePx;
262 public int allAppsIconDrawablePaddingPx;
Alex Chau27b39b92022-01-14 18:02:18 +0000263 public int allAppsLeftRightMargin;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700264 public final int numShownAllAppsColumns;
Winson1f064272016-07-18 17:18:02 -0700265 public float allAppsIconTextSizePx;
266
Zak Cohen334efeb2021-03-19 16:42:07 -0700267 // Overview
Zak Cohen334efeb2021-03-19 16:42:07 -0700268 public int overviewTaskMarginPx;
Alex Chaudedbc8a2021-03-17 16:53:26 +0000269 public int overviewTaskIconSizePx;
Alex Chauac9df382021-08-02 19:08:41 +0100270 public int overviewTaskIconDrawableSizePx;
271 public int overviewTaskIconDrawableSizeGridPx;
Alex Chaudedbc8a2021-03-17 16:53:26 +0000272 public int overviewTaskThumbnailTopMarginPx;
Alex Chau19c6eca2022-03-10 20:12:56 +0000273 public final int overviewActionsHeight;
Alex Chaua2fc7642022-04-21 14:20:23 +0100274 public final int overviewActionsTopMarginPx;
Alex Chau1bf0fe12021-11-30 15:32:45 +0000275 public final int overviewActionsButtonSpacing;
Alex Chau5fd9d492021-07-22 17:27:11 +0100276 public int overviewPageSpacing;
277 public int overviewRowSpacing;
Alex Chau56bd2572021-11-03 18:48:18 +0000278 public int overviewGridSideMargin;
Zak Cohen334efeb2021-03-19 16:42:07 -0700279
Jeremy Sim0ac47082022-10-10 13:59:40 -0700280 // Split staging
281 public int splitPlaceholderInset;
282
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800283 // Widgets
Sihua Mae04aa202022-07-18 12:43:56 -0700284 private final ViewScaleProvider mViewScaleProvider;
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800285
Sunny Goyal47328fd2016-05-25 18:56:41 -0700286 // Drop Target
287 public int dropTargetBarSizePx;
Pat Manningde25c0d2022-04-05 19:11:26 +0100288 public int dropTargetBarTopMarginPx;
289 public int dropTargetBarBottomMarginPx;
Alex Chaua02eddc2021-04-29 00:36:06 +0100290 public int dropTargetDragPaddingPx;
291 public int dropTargetTextSizePx;
Pat Manningde25c0d2022-04-05 19:11:26 +0100292 public int dropTargetHorizontalPaddingPx;
293 public int dropTargetVerticalPaddingPx;
294 public int dropTargetGapPx;
Alex Chau5b019302022-05-23 10:42:25 +0100295 public int dropTargetButtonWorkspaceEdgeGapPx;
Adam Cohen4ae96ce2014-08-29 15:05:48 -0700296
Winson1f064272016-07-18 17:18:02 -0700297 // Insets
Sunny Goyal07b69292018-01-08 14:19:34 -0800298 private final Rect mInsets = new Rect();
299 public final Rect workspacePadding = new Rect();
Sunny Goyal6c304b12023-04-10 12:03:04 -0700300 // Additional padding added to the widget inside its cellSpace. It is applied outside
301 // the widgetView, such that the actual view size is same as the widget size.
302 public final Rect widgetPadding = new Rect();
303
Tony Wickhamf34bee82018-12-03 18:11:39 -0800304 // Notification dots
Sunny Goyal65190ae2022-08-02 14:16:26 -0700305 public final DotRenderer mDotRendererWorkSpace;
306 public final DotRenderer mDotRendererAllApps;
Tony Wickham9a8d11f2017-01-11 09:53:12 -0800307
Pierre Barbier de Reuille578deba2021-09-24 13:47:44 +0100308 // Taskbar
Tony Wickham15883892021-02-12 11:24:40 -0800309 public boolean isTaskbarPresent;
Tony Wickham635e1802021-07-22 14:28:04 -1000310 // Whether Taskbar will inset the bottom of apps by taskbarSize.
311 public boolean isTaskbarPresentInApps;
Jon Miranda9c478b62023-03-23 21:38:49 -0700312 public final int taskbarHeight;
313 public final int stashedTaskbarHeight;
314 public final int taskbarBottomMargin;
315 public final int taskbarIconSize;
Uwais Ashrafaa7fa882023-10-10 21:36:06 +0000316 private final int mTransientTaskbarClaimedSpace;
Jon Miranda04f05102023-04-04 12:16:31 -0700317 // If true, used to layout taskbar in 3 button navigation mode.
318 public final boolean startAlignTaskbar;
Thales Limae9566402023-08-30 16:35:12 +0100319 public final boolean isTransientTaskbar;
Alex Chaua02eddc2021-04-29 00:36:06 +0100320 // DragController
321 public int flingToDeleteThresholdVelocity;
322
Schneider Victor-tuliasf5035842024-07-17 16:35:17 -0400323 /** Used only as an alternative to mocking when null values cannot be used. */
324 @VisibleForTesting
325 public DeviceProfile() {
326 inv = null;
327 mInfo = null;
328 mMetrics = null;
329 mIconSizeSteps = null;
330 isTablet = false;
331 isPhone = false;
332 transposeLayoutWithOrientation = false;
333 isMultiDisplay = false;
334 isTwoPanels = false;
335 isPredictiveBackSwipe = false;
336 isQsbInline = false;
337 isLandscape = false;
338 isMultiWindowMode = false;
339 isGestureMode = false;
340 isLeftRightSplit = false;
341 windowX = 0;
342 windowY = 0;
343 widthPx = 0;
344 heightPx = 0;
345 availableWidthPx = 0;
346 availableHeightPx = 0;
347 rotationHint = 0;
348 aspectRatio = 1;
349 mIsScalableGrid = false;
350 mTypeIndex = 0;
351 mIsResponsiveGrid = false;
352 desiredWorkspaceHorizontalMarginOriginalPx = 0;
353 edgeMarginPx = 0;
354 workspaceContentScale = 0;
355 workspaceSpringLoadedMinNextPageVisiblePx = 0;
356 extraSpace = 0;
357 workspacePageIndicatorHeight = 0;
358 mWorkspacePageIndicatorOverlapWorkspace = 0;
359 numFolderRows = 0;
360 numFolderColumns = 0;
361 folderLabelTextScale = 0;
362 areNavButtonsInline = false;
363 mHotseatBarEdgePaddingPx = 0;
364 mHotseatBarWorkspaceSpacePx = 0;
365 hotseatQsbWidth = 0;
366 hotseatQsbHeight = 0;
367 hotseatQsbVisualHeight = 0;
368 hotseatQsbShadowHeight = 0;
369 hotseatBorderSpace = 0;
370 mMinHotseatIconSpacePx = 0;
371 mMinHotseatQsbWidthPx = 0;
372 mMaxHotseatIconSpacePx = 0;
373 inlineNavButtonsEndSpacingPx = 0;
374 mBubbleBarSpaceThresholdPx = 0;
375 numShownAllAppsColumns = 0;
376 overviewActionsHeight = 0;
377 overviewActionsTopMarginPx = 0;
378 overviewActionsButtonSpacing = 0;
379 mViewScaleProvider = null;
380 mDotRendererWorkSpace = null;
381 mDotRendererAllApps = null;
382 taskbarHeight = 0;
383 stashedTaskbarHeight = 0;
384 taskbarBottomMargin = 0;
385 taskbarIconSize = 0;
386 mTransientTaskbarClaimedSpace = 0;
387 startAlignTaskbar = false;
388 isTransientTaskbar = false;
389 }
390
Vinit Nayak17c4b332021-08-05 12:54:58 -0700391 /** TODO: Once we fully migrate to staged split, remove "isMultiWindowMode" */
Sunny Goyal19ff7282021-04-22 10:12:54 -0700392 DeviceProfile(Context context, InvariantDeviceProfile inv, Info info, WindowBounds windowBounds,
Sunny Goyal65190ae2022-08-02 14:16:26 -0700393 SparseArray<DotRenderer> dotRendererCache, boolean isMultiWindowMode,
Alex Chauab800f72022-12-13 17:46:06 +0000394 boolean transposeLayoutWithOrientation, boolean isMultiDisplay, boolean isGestureMode,
Jon Miranda2b25ded2023-02-02 14:48:45 -0800395 @NonNull final ViewScaleProvider viewScaleProvider,
Jagrut Desai3a7d1392023-09-06 15:56:19 -0700396 @NonNull final Consumer<DeviceProfile> dimensionOverrideProvider,
397 boolean isTransientTaskbar) {
Sunny Goyalfee35bb2015-05-11 11:38:19 -0700398
Adam Cohen2e6da152015-05-06 11:42:25 -0700399 this.inv = inv;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700400 this.isLandscape = windowBounds.isLandscape();
Sunny Goyald70e75a2018-02-22 10:07:32 -0800401 this.isMultiWindowMode = isMultiWindowMode;
Jon Mirandae126d722021-02-25 10:45:20 -0500402 this.transposeLayoutWithOrientation = transposeLayoutWithOrientation;
Alex Chauab800f72022-12-13 17:46:06 +0000403 this.isMultiDisplay = isMultiDisplay;
Alex Chau6ed408f2022-03-04 12:58:05 +0000404 this.isGestureMode = isGestureMode;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700405 windowX = windowBounds.bounds.left;
406 windowY = windowBounds.bounds.top;
Sunny Goyal187b16c2022-03-01 16:53:23 -0800407 this.rotationHint = windowBounds.rotationHint;
Alex Chaue0227552022-04-06 19:44:43 +0100408 mInsets.set(windowBounds.insets);
Winson Chungb3800242013-10-24 11:01:54 -0700409
Thales Limac98b7812023-04-14 15:04:23 +0100410 // TODO(b/241386436): shouldn't change any launcher behaviour
Thales Limaabfe3642023-05-24 18:08:53 +0100411 mIsResponsiveGrid = inv.workspaceSpecsId != INVALID_RESOURCE_HANDLE
Jordan Silva637f4eb2023-06-13 11:21:53 +0100412 && inv.allAppsSpecsId != INVALID_RESOURCE_HANDLE
Thales Limaf8bfb032023-07-24 15:08:05 +0100413 && inv.folderSpecsId != INVALID_RESOURCE_HANDLE
Jordan Silva999dd2a2023-11-17 19:31:43 +0000414 && inv.hotseatSpecsId != INVALID_RESOURCE_HANDLE
415 && inv.workspaceCellSpecsId != INVALID_RESOURCE_HANDLE
416 && inv.allAppsCellSpecsId != INVALID_RESOURCE_HANDLE;
Thales Limaec5abba2023-04-05 16:33:50 +0100417
Thales Lima79456492023-05-23 11:32:22 +0100418 mIsScalableGrid = inv.isScalable && !isVerticalBarLayout() && !isMultiWindowMode;
Alex Chaudfc8ddf2022-01-25 11:26:25 +0000419 // Determine device posture.
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700420 mInfo = info;
Alex Chau29983072021-11-19 15:14:20 +0000421 isTablet = info.isTablet(windowBounds);
Sunny Goyal19ff7282021-04-22 10:12:54 -0700422 isPhone = !isTablet;
Alex Chauab800f72022-12-13 17:46:06 +0000423 isTwoPanels = isTablet && isMultiDisplay;
Brian Isganitise1eaefd2024-05-21 15:38:08 -0400424 isTaskbarPresent = (isTablet || (enableTinyTaskbar() && isGestureMode))
Sunny Goyal11117d92024-03-25 16:12:10 -0700425 && WindowManagerProxy.INSTANCE.get(context).isTaskbarDrawnInProcess();
Adam Cohen2e6da152015-05-06 11:42:25 -0700426
Alex Chaudfc8ddf2022-01-25 11:26:25 +0000427 // Some more constants.
Alex Chau635b3ab2022-01-26 16:49:10 +0000428 context = getContext(context, info, isVerticalBarLayout() || (isTablet && isLandscape)
Brandon Dayauon07ca8842022-04-27 10:52:28 -0700429 ? Configuration.ORIENTATION_LANDSCAPE
430 : Configuration.ORIENTATION_PORTRAIT,
Alex Chaua6907dc2022-03-18 15:24:07 +0000431 windowBounds);
Sunny Goyal1890f672020-04-30 12:28:00 -0700432 final Resources res = context.getResources();
Alex Chaudfc8ddf2022-01-25 11:26:25 +0000433 mMetrics = res.getDisplayMetrics();
434
Charlie Anderson7bb10972023-11-22 13:35:30 -0800435 mIconSizeSteps = new IconSizeSteps(res);
Thales Lima2759aa32023-06-05 16:25:45 +0100436
Alex Chaudfc8ddf2022-01-25 11:26:25 +0000437 // Determine sizes.
438 widthPx = windowBounds.bounds.width();
439 heightPx = windowBounds.bounds.height();
440 availableWidthPx = windowBounds.availableSize.x;
Thales Limab8c05952022-05-23 16:58:38 +0100441 availableHeightPx = windowBounds.availableSize.y;
Alex Chaudfc8ddf2022-01-25 11:26:25 +0000442
443 aspectRatio = ((float) Math.max(widthPx, heightPx)) / Math.min(widthPx, heightPx);
Thales Lima83bedbf2021-10-05 17:47:39 +0100444 if (isTwoPanels) {
445 if (isLandscape) {
Thales Lima12d0eff2022-03-25 17:06:11 +0000446 mTypeIndex = INDEX_TWO_PANEL_LANDSCAPE;
Thales Lima83bedbf2021-10-05 17:47:39 +0100447 } else {
Thales Lima12d0eff2022-03-25 17:06:11 +0000448 mTypeIndex = INDEX_TWO_PANEL_PORTRAIT;
Thales Lima83bedbf2021-10-05 17:47:39 +0100449 }
450 } else {
451 if (isLandscape) {
Thales Lima12d0eff2022-03-25 17:06:11 +0000452 mTypeIndex = INDEX_LANDSCAPE;
Thales Lima83bedbf2021-10-05 17:47:39 +0100453 } else {
Thales Lima12d0eff2022-03-25 17:06:11 +0000454 mTypeIndex = INDEX_DEFAULT;
Thales Lima83bedbf2021-10-05 17:47:39 +0100455 }
456 }
457
Jagrut Desai3a7d1392023-09-06 15:56:19 -0700458 this.isTransientTaskbar = isTransientTaskbar;
Uwais Ashrafaa7fa882023-10-10 21:36:06 +0000459 int transientTaskbarIconSize = pxFromDp(inv.transientTaskbarIconSize[mTypeIndex], mMetrics);
460 int transientTaskbarBottomMargin =
461 res.getDimensionPixelSize(R.dimen.transient_taskbar_bottom_margin);
462 int transientTaskbarHeight =
463 Math.round((transientTaskbarIconSize * ICON_VISIBLE_AREA_FACTOR)
Jordan Silvaf2402e22023-10-26 19:53:16 +0100464 + (2 * res.getDimensionPixelSize(R.dimen.transient_taskbar_padding)));
Uwais Ashrafaa7fa882023-10-10 21:36:06 +0000465 mTransientTaskbarClaimedSpace = transientTaskbarHeight + 2 * transientTaskbarBottomMargin;
466
Uwais Ashraf3602d172023-09-15 11:36:32 +0000467 if (!isTaskbarPresent) {
468 taskbarIconSize = taskbarHeight = stashedTaskbarHeight = taskbarBottomMargin = 0;
469 startAlignTaskbar = false;
470 } else if (isTransientTaskbar) {
Uwais Ashrafaa7fa882023-10-10 21:36:06 +0000471 taskbarIconSize = transientTaskbarIconSize;
472 taskbarHeight = transientTaskbarHeight;
Jon Miranda9c478b62023-03-23 21:38:49 -0700473 stashedTaskbarHeight =
474 res.getDimensionPixelSize(R.dimen.transient_taskbar_stashed_height);
Uwais Ashrafaa7fa882023-10-10 21:36:06 +0000475 taskbarBottomMargin = transientTaskbarBottomMargin;
Jon Miranda04f05102023-04-04 12:16:31 -0700476 startAlignTaskbar = false;
Jon Miranda9c478b62023-03-23 21:38:49 -0700477 } else {
478 taskbarIconSize = pxFromDp(ResourcesCompat.getFloat(res, R.dimen.taskbar_icon_size),
479 mMetrics);
480 taskbarHeight = res.getDimensionPixelSize(R.dimen.taskbar_size);
481 stashedTaskbarHeight = res.getDimensionPixelSize(R.dimen.taskbar_stashed_size);
482 taskbarBottomMargin = 0;
Jon Miranda04f05102023-04-04 12:16:31 -0700483 startAlignTaskbar = inv.startAlignTaskbar[mTypeIndex];
Tony Wickham15883892021-02-12 11:24:40 -0800484 }
Tony Wickham15883892021-02-12 11:24:40 -0800485
Winson Chungb3800242013-10-24 11:01:54 -0700486 edgeMarginPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_edge_margin);
Alex Chau0c4e11b2022-07-08 18:41:36 +0100487 workspaceContentScale = res.getFloat(R.dimen.workspace_content_scale);
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700488
Alex Chau51da2192022-05-20 13:32:10 +0100489 gridVisualizationPaddingX = res.getDimensionPixelSize(
490 R.dimen.grid_visualization_horizontal_cell_spacing);
491 gridVisualizationPaddingY = res.getDimensionPixelSize(
492 R.dimen.grid_visualization_vertical_cell_spacing);
Samuel Fufaee9aff92021-04-05 13:30:40 -0500493
Shamali P5fbb0cc2024-02-06 23:05:35 +0000494 {
495 // In large screens, in portrait mode, a bottom sheet can appear too elongated, so, we
496 // apply additional padding.
497 final boolean applyExtraTopPadding = isTablet
498 && !isLandscape
499 && (aspectRatio > MIN_ASPECT_RATIO_FOR_EXTRA_TOP_PADDING);
500 final int derivedTopPadding = heightPx / 6;
501 bottomSheetTopPadding = mInsets.top // statusbar height
502 + (applyExtraTopPadding ? derivedTopPadding : 0)
503 + (isTablet ? 0 : edgeMarginPx); // phones need edgeMarginPx additional padding
504 }
505
Alex Chau3d2c0622022-09-01 21:28:14 +0100506 bottomSheetOpenDuration = res.getInteger(R.integer.config_bottomSheetOpenDuration);
507 bottomSheetCloseDuration = res.getInteger(R.integer.config_bottomSheetCloseDuration);
508 if (isTablet) {
509 bottomSheetWorkspaceScale = workspaceContentScale;
Sunny Goyal35dc8752024-08-30 12:23:16 -0700510 if (isMultiDisplay) {
Alex Chauab800f72022-12-13 17:46:06 +0000511 // TODO(b/259893832): Revert to use maxWallpaperScale to calculate bottomSheetDepth
512 // when screen recorder bug is fixed.
Luca Zuccarinic9cbc9d2024-03-11 14:29:48 +0000513 if (enableScalingRevealHomeAnimation()) {
514 bottomSheetDepth = 0.3f;
515 } else {
516 bottomSheetDepth = 1f;
517 }
Alex Chauab800f72022-12-13 17:46:06 +0000518 } else {
519 // The goal is to set wallpaper to zoom at workspaceContentScale when in AllApps.
520 // When depth is 0, wallpaper zoom is set to maxWallpaperScale.
521 // When depth is 1, wallpaper zoom is set to 1.
522 // For depth to achieve zoom set to maxWallpaperScale * workspaceContentScale:
523 float maxWallpaperScale = res.getFloat(R.dimen.config_wallpaperMaxScale);
524 bottomSheetDepth = Utilities.mapToRange(maxWallpaperScale * workspaceContentScale,
525 maxWallpaperScale, 1f, 0f, 1f, LINEAR);
526 }
Alex Chau3d2c0622022-09-01 21:28:14 +0100527 } else {
528 bottomSheetWorkspaceScale = 1f;
529 bottomSheetDepth = 0f;
530 }
Andras Kloczl142b0542022-03-09 21:26:02 +0000531
Jon Mirandae126d722021-02-25 10:45:20 -0500532 folderLabelTextScale = res.getFloat(R.dimen.folder_label_text_scale);
Thales Lima1faa4ed2023-12-01 16:48:19 +0000533 numFolderRows = inv.numFolderRows[mTypeIndex];
534 numFolderColumns = inv.numFolderColumns[mTypeIndex];
Thales Limab35faed2022-09-05 16:30:01 -0300535
Thales Lima79456492023-05-23 11:32:22 +0100536 if (mIsScalableGrid && inv.folderStyle != INVALID_RESOURCE_HANDLE) {
Thales Limab35faed2022-09-05 16:30:01 -0300537 TypedArray folderStyle = context.obtainStyledAttributes(inv.folderStyle,
Thales Limad852d652023-01-17 14:01:13 +0000538 R.styleable.FolderStyle);
Thales Limab35faed2022-09-05 16:30:01 -0300539 // These are re-set in #updateFolderCellSize if the grid is not scalable
540 folderCellHeightPx = folderStyle.getDimensionPixelSize(
Thales Limad852d652023-01-17 14:01:13 +0000541 R.styleable.FolderStyle_folderCellHeight, 0);
Thales Limab35faed2022-09-05 16:30:01 -0300542 folderCellWidthPx = folderStyle.getDimensionPixelSize(
Thales Limad852d652023-01-17 14:01:13 +0000543 R.styleable.FolderStyle_folderCellWidth, 0);
Thales Limab35faed2022-09-05 16:30:01 -0300544
545 folderContentPaddingTop = folderStyle.getDimensionPixelSize(
Thales Limad852d652023-01-17 14:01:13 +0000546 R.styleable.FolderStyle_folderTopPadding, 0);
Jordan Silva637f4eb2023-06-13 11:21:53 +0100547
548 int gutter = folderStyle.getDimensionPixelSize(
Thales Limad852d652023-01-17 14:01:13 +0000549 R.styleable.FolderStyle_folderBorderSpace, 0);
Jordan Silva637f4eb2023-06-13 11:21:53 +0100550 folderCellLayoutBorderSpacePx = new Point(gutter, gutter);
Thales Limab35faed2022-09-05 16:30:01 -0300551 folderFooterHeightPx = folderStyle.getDimensionPixelSize(
Thales Limad852d652023-01-17 14:01:13 +0000552 R.styleable.FolderStyle_folderFooterHeight, 0);
Thales Limab35faed2022-09-05 16:30:01 -0300553 folderStyle.recycle();
Jordan Silva637f4eb2023-06-13 11:21:53 +0100554 } else if (!mIsResponsiveGrid) {
555 folderCellLayoutBorderSpacePx = new Point(0, 0);
Thales Lima7eee74b2023-03-16 16:00:55 -0300556 folderFooterHeightPx = res.getDimensionPixelSize(R.dimen.folder_footer_height_default);
Thales Limab35faed2022-09-05 16:30:01 -0300557 folderContentPaddingTop = res.getDimensionPixelSize(R.dimen.folder_top_padding_default);
558 }
Jon Mirandae126d722021-02-25 10:45:20 -0500559
Thales Lima85c942f2021-12-31 13:04:20 +0000560 allAppsBorderSpacePx = new Point(
Thales Limabb7d3882021-12-22 12:56:29 +0000561 pxFromDp(inv.allAppsBorderSpaces[mTypeIndex].x, mMetrics),
562 pxFromDp(inv.allAppsBorderSpaces[mTypeIndex].y, mMetrics));
Thales Limae9273ea2023-01-26 12:33:52 +0000563 setupAllAppsStyle(context);
Jon Mirandae126d722021-02-25 10:45:20 -0500564
Tony Wickham5edf9e22020-03-27 20:06:52 -0700565 workspacePageIndicatorHeight = res.getDimensionPixelSize(
566 R.dimen.workspace_page_indicator_height);
567 mWorkspacePageIndicatorOverlapWorkspace =
568 res.getDimensionPixelSize(R.dimen.workspace_page_indicator_overlap_workspace);
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700569
Jordan Silva999dd2a2023-11-17 19:31:43 +0000570 if (!mIsResponsiveGrid) {
571 TypedArray cellStyle;
572 if (inv.cellStyle != INVALID_RESOURCE_HANDLE) {
573 cellStyle = context.obtainStyledAttributes(inv.cellStyle,
574 R.styleable.CellStyle);
575 } else {
576 cellStyle = context.obtainStyledAttributes(R.style.CellStyleDefault,
577 R.styleable.CellStyle);
578 }
579 mIconDrawablePaddingOriginalPx = cellStyle.getDimensionPixelSize(
580 R.styleable.CellStyle_iconDrawablePadding, 0);
581 cellStyle.recycle();
Thales Limad852d652023-01-17 14:01:13 +0000582 }
Alex Chaua02eddc2021-04-29 00:36:06 +0100583
Sunny Goyal47328fd2016-05-25 18:56:41 -0700584 dropTargetBarSizePx = res.getDimensionPixelSize(R.dimen.dynamic_grid_drop_target_size);
fbaron3bb6d4b2024-02-23 10:54:13 -0800585 // Some foldable portrait modes are too wide in terms of aspect ratio so we need to tweak
586 // the dimensions for edit state.
587 final boolean shouldApplyWidePortraitDimens = isTablet
588 && !isLandscape
589 && aspectRatio < MAX_ASPECT_RATIO_FOR_ALTERNATE_EDIT_STATE;
590 dropTargetBarTopMarginPx = shouldApplyWidePortraitDimens
591 ? 0
592 : res.getDimensionPixelSize(R.dimen.drop_target_top_margin);
593 dropTargetBarBottomMarginPx = shouldApplyWidePortraitDimens
594 ? res.getDimensionPixelSize(R.dimen.drop_target_bottom_margin_wide_portrait)
595 : res.getDimensionPixelSize(R.dimen.drop_target_bottom_margin);
Alex Chaua02eddc2021-04-29 00:36:06 +0100596 dropTargetDragPaddingPx = res.getDimensionPixelSize(R.dimen.drop_target_drag_padding);
597 dropTargetTextSizePx = res.getDimensionPixelSize(R.dimen.drop_target_text_size);
Pat Manningde25c0d2022-04-05 19:11:26 +0100598 dropTargetHorizontalPaddingPx = res.getDimensionPixelSize(
599 R.dimen.drop_target_button_drawable_horizontal_padding);
600 dropTargetVerticalPaddingPx = res.getDimensionPixelSize(
601 R.dimen.drop_target_button_drawable_vertical_padding);
602 dropTargetGapPx = res.getDimensionPixelSize(R.dimen.drop_target_button_gap);
Alex Chau5b019302022-05-23 10:42:25 +0100603 dropTargetButtonWorkspaceEdgeGapPx = res.getDimensionPixelSize(
604 R.dimen.drop_target_button_workspace_edge_gap);
Alex Chaua02eddc2021-04-29 00:36:06 +0100605
Alex Chau906d8822022-05-23 10:42:25 +0100606 workspaceSpringLoadedMinNextPageVisiblePx = res.getDimensionPixelSize(
607 R.dimen.dynamic_grid_spring_loaded_min_next_space_visible);
Sunny Goyald5190522017-04-24 03:06:54 -0700608
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700609 workspaceCellPaddingXPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_cell_padding_x);
Jon Miranda09660722017-06-14 14:20:14 -0700610
Thales Limaa1012902022-01-13 17:58:42 +0000611 hotseatQsbHeight = res.getDimensionPixelSize(R.dimen.qsb_widget_height);
Thales Limab8c05952022-05-23 16:58:38 +0100612 hotseatQsbShadowHeight = res.getDimensionPixelSize(R.dimen.qsb_shadow_height);
613 hotseatQsbVisualHeight = hotseatQsbHeight - 2 * hotseatQsbShadowHeight;
614
Thales Lima12d0eff2022-03-25 17:06:11 +0000615 // Whether QSB might be inline in appropriate orientation (e.g. landscape).
616 boolean canQsbInline = (isTwoPanels ? inv.inlineQsb[INDEX_TWO_PANEL_PORTRAIT]
617 || inv.inlineQsb[INDEX_TWO_PANEL_LANDSCAPE]
618 : inv.inlineQsb[INDEX_DEFAULT] || inv.inlineQsb[INDEX_LANDSCAPE])
619 && hotseatQsbHeight > 0;
Thales Lima79456492023-05-23 11:32:22 +0100620 isQsbInline = mIsScalableGrid && inv.inlineQsb[mTypeIndex] && canQsbInline;
Alex Chau6ed408f2022-03-04 12:58:05 +0000621
Thales Lima425f6822022-05-10 13:44:58 -0300622 areNavButtonsInline = isTaskbarPresent && !isGestureMode;
Thales Lima9938c2f2022-07-25 14:38:16 +0100623 numShownHotseatIcons =
624 isTwoPanels ? inv.numDatabaseHotseatIcons : inv.numShownHotseatIcons;
fbarone4b0b712024-03-29 14:31:17 -0700625 mHotseatColumnSpan = inv.numColumns;
Alex Chau6ed408f2022-03-04 12:58:05 +0000626
Sunny Goyal19ff7282021-04-22 10:12:54 -0700627 numShownAllAppsColumns =
628 isTwoPanels ? inv.numDatabaseAllAppsColumns : inv.numAllAppsColumns;
Thales Limab8c05952022-05-23 16:58:38 +0100629
Thales Lima8e11d532023-08-31 13:40:26 +0000630 int hotseatBarBottomSpace;
Thales Limab8c05952022-05-23 16:58:38 +0100631 int minQsbMargin = res.getDimensionPixelSize(R.dimen.min_qsb_margin);
Thales Limaf8bfb032023-07-24 15:08:05 +0100632
633 if (mIsResponsiveGrid) {
Jordan Silvaf2402e22023-10-26 19:53:16 +0100634 float responsiveAspectRatio = (float) widthPx / heightPx;
635 HotseatSpecsProvider hotseatSpecsProvider =
636 HotseatSpecsProvider.create(new ResourceHelper(context,
Thales Limaf8bfb032023-07-24 15:08:05 +0100637 isTwoPanels ? inv.hotseatSpecsTwoPanelId : inv.hotseatSpecsId));
Thales Lima8e11d532023-08-31 13:40:26 +0000638 mResponsiveHotseatSpec =
Jordan Silvaf2402e22023-10-26 19:53:16 +0100639 isVerticalBarLayout() ? hotseatSpecsProvider.getCalculatedSpec(
640 responsiveAspectRatio, DimensionType.WIDTH, widthPx)
641 : hotseatSpecsProvider.getCalculatedSpec(responsiveAspectRatio,
642 DimensionType.HEIGHT, heightPx);
Thales Limaf8bfb032023-07-24 15:08:05 +0100643 hotseatQsbSpace = mResponsiveHotseatSpec.getHotseatQsbSpace();
Thales Lima8e11d532023-08-31 13:40:26 +0000644 hotseatBarBottomSpace =
645 isVerticalBarLayout() ? 0 : mResponsiveHotseatSpec.getEdgePadding();
646 mHotseatBarEdgePaddingPx =
647 isVerticalBarLayout() ? mResponsiveHotseatSpec.getEdgePadding() : 0;
648 mHotseatBarWorkspaceSpacePx = 0;
Jordan Silva999dd2a2023-11-17 19:31:43 +0000649
650 ResponsiveCellSpecsProvider workspaceCellSpecs = ResponsiveCellSpecsProvider.create(
651 new ResourceHelper(context,
652 isTwoPanels ? inv.workspaceCellSpecsTwoPanelId
653 : inv.workspaceCellSpecsId));
654 mResponsiveWorkspaceCellSpec = workspaceCellSpecs.getCalculatedSpec(
655 responsiveAspectRatio, heightPx);
Thales Limaf8bfb032023-07-24 15:08:05 +0100656 } else {
657 hotseatQsbSpace = pxFromDp(inv.hotseatQsbSpace[mTypeIndex], mMetrics);
Thales Lima8e11d532023-08-31 13:40:26 +0000658 hotseatBarBottomSpace = pxFromDp(inv.hotseatBarBottomSpace[mTypeIndex], mMetrics);
659 mHotseatBarEdgePaddingPx =
660 isVerticalBarLayout() ? workspacePageIndicatorHeight : 0;
661 mHotseatBarWorkspaceSpacePx =
662 res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_side_padding);
Thales Limaf8bfb032023-07-24 15:08:05 +0100663 }
664
Thales Lima8e11d532023-08-31 13:40:26 +0000665 if (!isVerticalBarLayout()) {
666 // Have a little space between the inset and the QSB
667 if (mInsets.bottom + minQsbMargin > hotseatBarBottomSpace) {
668 int availableSpace = hotseatQsbSpace - (mInsets.bottom - hotseatBarBottomSpace);
Thales Limab8c05952022-05-23 16:58:38 +0100669
Thales Lima8e11d532023-08-31 13:40:26 +0000670 // Only change the spaces if there is space
671 if (availableSpace > 0) {
672 // Make sure there is enough space between hotseat/QSB and QSB/navBar
673 if (availableSpace < minQsbMargin * 2) {
674 minQsbMargin = availableSpace / 2;
675 hotseatQsbSpace = minQsbMargin;
676 } else {
677 hotseatQsbSpace -= minQsbMargin;
678 }
Thales Limab8c05952022-05-23 16:58:38 +0100679 }
Thales Lima8e11d532023-08-31 13:40:26 +0000680 hotseatBarBottomSpacePx = mInsets.bottom + minQsbMargin;
Thales Limab8c05952022-05-23 16:58:38 +0100681
Thales Lima8e11d532023-08-31 13:40:26 +0000682 } else {
683 hotseatBarBottomSpacePx = hotseatBarBottomSpace;
684 }
Thales Limaa1012902022-01-13 17:58:42 +0000685 }
Thales Lima425f6822022-05-10 13:44:58 -0300686
fbaron3bb6d4b2024-02-23 10:54:13 -0800687 springLoadedHotseatBarTopMarginPx = shouldApplyWidePortraitDimens
688 ? res.getDimensionPixelSize(R.dimen.spring_loaded_hotseat_top_margin_wide_portrait)
689 : res.getDimensionPixelSize(R.dimen.spring_loaded_hotseat_top_margin);
Jordan Silva999dd2a2023-11-17 19:31:43 +0000690
691 if (mIsResponsiveGrid) {
692 updateHotseatSizes(mResponsiveWorkspaceCellSpec.getIconSize());
693 } else {
694 updateHotseatSizes(pxFromDp(inv.iconSize[mTypeIndex], mMetrics));
695 }
696
Vinit Nayak8a3d0552022-08-05 10:43:29 -0700697 if (areNavButtonsInline && !isPhone) {
Jon Mirandae17a9492023-03-08 16:42:20 -0800698 inlineNavButtonsEndSpacingPx =
Thales Limaffc68b02023-01-09 16:20:23 +0000699 res.getDimensionPixelSize(inv.inlineNavButtonsEndSpacing);
mpodoliandfb48212024-09-13 17:43:11 -0700700 /* 3 nav buttons + Spacing between nav buttons */
701 navButtonsLayoutWidthPx = 3 * res.getDimensionPixelSize(
702 R.dimen.taskbar_nav_buttons_size)
703 + 2 * res.getDimensionPixelSize(R.dimen.taskbar_button_space_inbetween);
704 /* nav buttons layout width + Space at the end for contextual buttons */
705 hotseatBarEndOffset = navButtonsLayoutWidthPx + inlineNavButtonsEndSpacingPx;
Pat Manning26f70f72022-07-07 13:50:39 +0100706 }
Jon Miranda8bdb2222021-06-23 18:10:10 -0700707
Liran Binyamina833af32023-08-02 16:30:27 -0400708 mBubbleBarSpaceThresholdPx =
709 res.getDimensionPixelSize(R.dimen.bubblebar_hotseat_adjustment_threshold);
710
Thales Lima79456492023-05-23 11:32:22 +0100711 // Needs to be calculated after hotseatBarSizePx is correct,
712 // for the available height to be correct
713 if (mIsResponsiveGrid) {
Thales Lima2759aa32023-06-05 16:25:45 +0100714 int availableResponsiveWidth =
715 availableWidthPx - (isVerticalBarLayout() ? hotseatBarSizePx : 0);
Jordan Silva376036a2023-11-08 15:56:40 +0000716 int numWorkspaceColumns = getPanelCount() * inv.numColumns;
Thales Lima8e11d532023-08-31 13:40:26 +0000717 // don't use availableHeightPx because it subtracts mInsets.bottom
718 int availableResponsiveHeight = heightPx - mInsets.top
Jordan Silvaf2402e22023-10-26 19:53:16 +0100719 - (isVerticalBarLayout() ? 0 : hotseatBarSizePx);
720 float responsiveAspectRatio = (float) widthPx / heightPx;
Thales Limaabfe3642023-05-24 18:08:53 +0100721
Jordan Silvaf2402e22023-10-26 19:53:16 +0100722 ResponsiveSpecsProvider workspaceSpecs = ResponsiveSpecsProvider.create(
Jordan Silva575c3bd2023-07-21 12:00:43 +0100723 new ResourceHelper(context,
Jordan Silvaf2402e22023-10-26 19:53:16 +0100724 isTwoPanels ? inv.workspaceSpecsTwoPanelId : inv.workspaceSpecsId),
725 ResponsiveSpecType.Workspace);
Jordan Silva8f7986a2023-11-08 12:11:25 +0000726 mResponsiveWorkspaceWidthSpec = workspaceSpecs.getCalculatedSpec(responsiveAspectRatio,
Jordan Silva376036a2023-11-08 15:56:40 +0000727 DimensionType.WIDTH, numWorkspaceColumns, availableResponsiveWidth);
Jordan Silva8f7986a2023-11-08 12:11:25 +0000728 mResponsiveWorkspaceHeightSpec = workspaceSpecs.getCalculatedSpec(responsiveAspectRatio,
Jordan Silvaf2402e22023-10-26 19:53:16 +0100729 DimensionType.HEIGHT, inv.numRows, availableResponsiveHeight);
Jordan Silva637f4eb2023-06-13 11:21:53 +0100730
Jordan Silvaf2402e22023-10-26 19:53:16 +0100731 ResponsiveSpecsProvider allAppsSpecs = ResponsiveSpecsProvider.create(
Jordan Silva575c3bd2023-07-21 12:00:43 +0100732 new ResourceHelper(context,
Jordan Silvaf2402e22023-10-26 19:53:16 +0100733 isTwoPanels ? inv.allAppsSpecsTwoPanelId : inv.allAppsSpecsId),
734 ResponsiveSpecType.AllApps);
Jordan Silva8f7986a2023-11-08 12:11:25 +0000735 mResponsiveAllAppsWidthSpec = allAppsSpecs.getCalculatedSpec(responsiveAspectRatio,
Jordan Silva8b3fa142023-11-13 21:31:38 +0000736 DimensionType.WIDTH, numShownAllAppsColumns, availableWidthPx,
Jordan Silva8f7986a2023-11-08 12:11:25 +0000737 mResponsiveWorkspaceWidthSpec);
738 mResponsiveAllAppsHeightSpec = allAppsSpecs.getCalculatedSpec(responsiveAspectRatio,
Jordan Silva2de6a272024-01-04 14:44:20 -0300739 DimensionType.HEIGHT, inv.numAllAppsRowsForCellHeightCalculation,
740 heightPx - mInsets.top, mResponsiveWorkspaceHeightSpec);
Jordan Silvaf2402e22023-10-26 19:53:16 +0100741
742 ResponsiveSpecsProvider folderSpecs = ResponsiveSpecsProvider.create(
743 new ResourceHelper(context,
744 isTwoPanels ? inv.folderSpecsTwoPanelId : inv.folderSpecsId),
745 ResponsiveSpecType.Folder);
746 mResponsiveFolderWidthSpec = folderSpecs.getCalculatedSpec(responsiveAspectRatio,
Thales Lima1faa4ed2023-12-01 16:48:19 +0000747 DimensionType.WIDTH, numFolderColumns,
Jordan Silva8f7986a2023-11-08 12:11:25 +0000748 mResponsiveWorkspaceWidthSpec.getAvailableSpace(),
749 mResponsiveWorkspaceWidthSpec);
Jordan Silvaf2402e22023-10-26 19:53:16 +0100750 mResponsiveFolderHeightSpec = folderSpecs.getCalculatedSpec(responsiveAspectRatio,
Thales Lima1faa4ed2023-12-01 16:48:19 +0000751 DimensionType.HEIGHT, numFolderRows,
Jordan Silva8f7986a2023-11-08 12:11:25 +0000752 mResponsiveWorkspaceHeightSpec.getAvailableSpace(),
753 mResponsiveWorkspaceHeightSpec);
Jordan Silva999dd2a2023-11-17 19:31:43 +0000754
755 ResponsiveCellSpecsProvider allAppsCellSpecs = ResponsiveCellSpecsProvider.create(
756 new ResourceHelper(context,
757 isTwoPanels ? inv.allAppsCellSpecsTwoPanelId
758 : inv.allAppsCellSpecsId));
759 mResponsiveAllAppsCellSpec = allAppsCellSpecs.getCalculatedSpec(
760 responsiveAspectRatio,
761 mResponsiveAllAppsHeightSpec.getAvailableSpace(),
762 mResponsiveWorkspaceCellSpec);
Thales Lima79456492023-05-23 11:32:22 +0100763 }
764
765 desiredWorkspaceHorizontalMarginPx = getHorizontalMarginPx(inv, res);
766 desiredWorkspaceHorizontalMarginOriginalPx = desiredWorkspaceHorizontalMarginPx;
767
Alex Chau635b3ab2022-01-26 16:49:10 +0000768 overviewTaskMarginPx = res.getDimensionPixelSize(R.dimen.overview_task_margin);
Pat Manning1695cc72023-07-05 11:45:13 +0100769 overviewTaskIconSizePx = enableOverviewIconMenu() ? res.getDimensionPixelSize(
770 R.dimen.task_thumbnail_icon_menu_drawable_touch_size) : res.getDimensionPixelSize(
771 R.dimen.task_thumbnail_icon_size);
Alex Chauac9df382021-08-02 19:08:41 +0100772 overviewTaskIconDrawableSizePx =
773 res.getDimensionPixelSize(R.dimen.task_thumbnail_icon_drawable_size);
774 overviewTaskIconDrawableSizeGridPx =
775 res.getDimensionPixelSize(R.dimen.task_thumbnail_icon_drawable_size_grid);
Pat Manning1695cc72023-07-05 11:45:13 +0100776 overviewTaskThumbnailTopMarginPx =
777 enableOverviewIconMenu() ? 0 : overviewTaskIconSizePx + overviewTaskMarginPx;
Andy Wickhambc3bac42023-08-07 16:02:23 -0700778 // Don't add margin with floating search bar to minimize risk of overlapping.
Andy Wickhamcfafb552024-06-10 15:30:51 -0700779 overviewActionsTopMarginPx = Flags.floatingSearchBar() ? 0
Andy Wickhambc3bac42023-08-07 16:02:23 -0700780 : res.getDimensionPixelSize(R.dimen.overview_actions_top_margin);
Alex Chau635b3ab2022-01-26 16:49:10 +0000781 overviewPageSpacing = res.getDimensionPixelSize(R.dimen.overview_page_spacing);
782 overviewActionsButtonSpacing = res.getDimensionPixelSize(
783 R.dimen.overview_actions_button_spacing);
Andy Wickhambc3bac42023-08-07 16:02:23 -0700784 overviewActionsHeight = res.getDimensionPixelSize(R.dimen.overview_actions_height);
Jeremy Sim1cfe6d42022-07-15 14:40:38 -0700785 overviewRowSpacing = res.getDimensionPixelSize(R.dimen.overview_grid_row_spacing);
Alex Chau635b3ab2022-01-26 16:49:10 +0000786 overviewGridSideMargin = res.getDimensionPixelSize(R.dimen.overview_grid_side_margin);
Zak Cohen334efeb2021-03-19 16:42:07 -0700787
Jeremy Sim0ac47082022-10-10 13:59:40 -0700788 splitPlaceholderInset = res.getDimensionPixelSize(R.dimen.split_placeholder_inset);
Winson Chung104a4c82023-11-08 18:56:15 +0000789 // We need to use the full window bounds for split determination because on near-square
790 // devices, the available bounds (bounds minus insets) may actually be in landscape while
791 // actually portrait
792 int leftRightSplitPortraitResId = Resources.getSystem().getIdentifier(
793 "config_leftRightSplitInPortrait", "bool", "android");
794 boolean allowLeftRightSplitInPortrait =
795 com.android.wm.shell.Flags.enableLeftRightSplitInPortrait()
796 && leftRightSplitPortraitResId > 0
797 && res.getBoolean(leftRightSplitPortraitResId);
798 if (allowLeftRightSplitInPortrait && isTablet) {
799 isLeftRightSplit = !isLandscape;
800 } else {
801 isLeftRightSplit = isLandscape;
802 }
Jeremy Sim0ac47082022-10-10 13:59:40 -0700803
Jon Miranda2ed276e2017-06-29 11:36:34 -0700804 // Calculate all of the remaining variables.
Brandon Dayauon5787a272023-12-14 13:47:17 -0800805 extraSpace = updateAvailableDimensions(context);
Jon Miranda80cddbc2021-07-22 13:51:16 -0700806
Thales Lima79456492023-05-23 11:32:22 +0100807 calculateAndSetWorkspaceVerticalPadding(context, inv, extraSpace);
Pat Manning08610ca2022-04-05 21:03:16 +0100808
809 int cellLayoutPadding =
810 isTwoPanels ? cellLayoutBorderSpacePx.x / 2 : res.getDimensionPixelSize(
811 R.dimen.cell_layout_padding);
812 cellLayoutPaddingPx = new Rect(cellLayoutPadding, cellLayoutPadding, cellLayoutPadding,
813 cellLayoutPadding);
Sunny Goyal07b69292018-01-08 14:19:34 -0800814 updateWorkspacePadding();
Tony Wickham1237df02017-02-24 08:59:36 -0800815
Thales Lima7eee74b2023-03-16 16:00:55 -0300816 // Folder scaling requires correct workspace paddings
817 updateAvailableFolderCellDimensions(res);
818
Thales Limaffc68b02023-01-09 16:20:23 +0000819 mMinHotseatIconSpacePx = res.getDimensionPixelSize(R.dimen.min_hotseat_icon_space);
820 mMinHotseatQsbWidthPx = res.getDimensionPixelSize(R.dimen.min_hotseat_qsb_width);
821 mMaxHotseatIconSpacePx = areNavButtonsInline
Thales Lima6a590062022-11-22 15:52:49 +0000822 ? res.getDimensionPixelSize(R.dimen.max_hotseat_icon_space) : Integer.MAX_VALUE;
Thales Lima425f6822022-05-10 13:44:58 -0300823 // Hotseat and QSB width depends on updated cellSize and workspace padding
Thales Lima6a590062022-11-22 15:52:49 +0000824 recalculateHotseatWidthAndBorderSpace();
Alex Chau206ede92022-08-01 17:46:12 +0100825
Jordan Silva3646a1b2023-08-02 13:52:52 +0100826 if (mIsResponsiveGrid && isVerticalBarLayout()) {
827 hotseatBorderSpace = cellLayoutBorderSpacePx.y;
828 }
829
Alex Chau206ede92022-08-01 17:46:12 +0100830 if (isTablet) {
Andy Wickham99d7d4f2023-11-15 08:09:09 +0000831 allAppsPadding.top = mInsets.top;
832 allAppsShiftRange = heightPx;
Alex Chau206ede92022-08-01 17:46:12 +0100833 } else {
Thales Limab433c9c2023-10-30 12:24:05 +0000834 allAppsPadding.top = 0;
Alex Chau206ede92022-08-01 17:46:12 +0100835 allAppsShiftRange =
836 res.getDimensionPixelSize(R.dimen.all_apps_starting_vertical_translate);
837 }
Alex Chau3d2c0622022-09-01 21:28:14 +0100838 allAppsOpenDuration = res.getInteger(R.integer.config_allAppsOpenDuration);
839 allAppsCloseDuration = res.getInteger(R.integer.config_allAppsCloseDuration);
Thales Lima425f6822022-05-10 13:44:58 -0300840
Alex Chaua02eddc2021-04-29 00:36:06 +0100841 flingToDeleteThresholdVelocity = res.getDimensionPixelSize(
842 R.dimen.drag_flingToDeleteMinVelocity);
843
Sihua Mae04aa202022-07-18 12:43:56 -0700844 mViewScaleProvider = viewScaleProvider;
845
Jon Miranda2b25ded2023-02-02 14:48:45 -0800846 dimensionOverrideProvider.accept(this);
847
Tony Wickham1237df02017-02-24 08:59:36 -0800848 // This is done last, after iconSizePx is calculated above.
Sunny Goyal799e1202023-02-09 10:54:28 -0800849 mDotRendererWorkSpace = createDotRenderer(context, iconSizePx, dotRendererCache);
850 mDotRendererAllApps = createDotRenderer(context, allAppsIconSizePx, dotRendererCache);
Sunny Goyal65190ae2022-08-02 14:16:26 -0700851 }
852
853 private static DotRenderer createDotRenderer(
Sunny Goyal799e1202023-02-09 10:54:28 -0800854 @NonNull Context context, int size, @NonNull SparseArray<DotRenderer> cache) {
Sunny Goyal65190ae2022-08-02 14:16:26 -0700855 DotRenderer renderer = cache.get(size);
856 if (renderer == null) {
Sunny Goyal799e1202023-02-09 10:54:28 -0800857 renderer = new DotRenderer(size, getShapePath(context, DEFAULT_DOT_SIZE),
858 DEFAULT_DOT_SIZE);
Sunny Goyal65190ae2022-08-02 14:16:26 -0700859 cache.put(size, renderer);
860 }
861 return renderer;
Adam Cohen63f1ec02014-08-12 09:23:13 -0700862 }
863
Thales Lima425f6822022-05-10 13:44:58 -0300864 /**
Fengjiang Li6c590822023-09-25 15:04:57 -0700865 * Return maximum of all apps row count displayed on screen. Note that 1) Partially displayed
866 * row is counted as 1 row, and 2) we don't exclude the space of floating search bar. This
867 * method is used for calculating number of {@link BubbleTextView} we need to pre-inflate. Thus
868 * reasonable over estimation is fine.
869 */
870 public int getMaxAllAppsRowCount() {
Thales Limab433c9c2023-10-30 12:24:05 +0000871 return (int) (Math.ceil((availableHeightPx - allAppsPadding.top)
Fengjiang Li6c590822023-09-25 15:04:57 -0700872 / (float) allAppsCellHeightPx));
873 }
874
875 /**
Thales Lima425f6822022-05-10 13:44:58 -0300876 * QSB width is always calculated because when in 3 button nav the width doesn't follow the
877 * width of the hotseat.
878 */
Thales Lima9938c2f2022-07-25 14:38:16 +0100879 private int calculateQsbWidth(int hotseatBorderSpace) {
fbarone69b6f42023-12-18 13:20:34 -0800880 int iconExtraSpacePx = iconSizePx - getIconVisibleSizePx(iconSizePx);
Thales Lima425f6822022-05-10 13:44:58 -0300881 if (isQsbInline) {
Alex Chau906d8822022-05-23 10:42:25 +0100882 int columns = getPanelCount() * inv.numColumns;
Thales Lima425f6822022-05-10 13:44:58 -0300883 return getIconToIconWidthForColumns(columns)
884 - iconSizePx * numShownHotseatIcons
fbarone69b6f42023-12-18 13:20:34 -0800885 - hotseatBorderSpace * numShownHotseatIcons
886 - iconExtraSpacePx;
Thales Lima425f6822022-05-10 13:44:58 -0300887 } else {
fbarone4b0b712024-03-29 14:31:17 -0700888 return getIconToIconWidthForColumns(mHotseatColumnSpan) - iconExtraSpacePx;
Thales Lima425f6822022-05-10 13:44:58 -0300889 }
890 }
Thales Lima2903a622022-03-17 13:52:19 +0000891
Thales Lima425f6822022-05-10 13:44:58 -0300892 private int getIconToIconWidthForColumns(int columns) {
893 return columns * getCellSize().x
894 + (columns - 1) * cellLayoutBorderSpacePx.x
Thales Lima1e8b45f2022-08-25 11:50:59 -0400895 - getCellHorizontalSpace();
Thales Limaa1012902022-01-13 17:58:42 +0000896 }
897
Thales Limad90faab2021-09-21 17:18:47 +0100898 private int getHorizontalMarginPx(InvariantDeviceProfile idp, Resources res) {
Thales Lima79456492023-05-23 11:32:22 +0100899 if (mIsResponsiveGrid) {
Jordan Silva8f7986a2023-11-08 12:11:25 +0000900 return mResponsiveWorkspaceWidthSpec.getStartPaddingPx();
Thales Lima79456492023-05-23 11:32:22 +0100901 }
902
Thales Limad90faab2021-09-21 17:18:47 +0100903 if (isVerticalBarLayout()) {
904 return 0;
905 }
906
Thales Lima79456492023-05-23 11:32:22 +0100907 return mIsScalableGrid
Thales Lima83bedbf2021-10-05 17:47:39 +0100908 ? pxFromDp(idp.horizontalMargin[mTypeIndex], mMetrics)
909 : res.getDimensionPixelSize(R.dimen.dynamic_grid_left_right_margin);
Thales Limad90faab2021-09-21 17:18:47 +0100910 }
911
Thales Lima79456492023-05-23 11:32:22 +0100912 private void calculateAndSetWorkspaceVerticalPadding(Context context,
913 InvariantDeviceProfile inv,
914 int extraSpace) {
915 if (mIsResponsiveGrid) {
Jordan Silva8f7986a2023-11-08 12:11:25 +0000916 workspaceTopPadding = mResponsiveWorkspaceHeightSpec.getStartPaddingPx();
917 workspaceBottomPadding = mResponsiveWorkspaceHeightSpec.getEndPaddingPx();
Thales Lima79456492023-05-23 11:32:22 +0100918 } else if (mIsScalableGrid && inv.devicePaddingId != INVALID_RESOURCE_HANDLE) {
919 // Paddings were created assuming no scaling, so we first unscale the extra space.
920 int unscaledExtraSpace = (int) (extraSpace / cellScaleToFit);
921 DevicePaddings devicePaddings = new DevicePaddings(context, inv.devicePaddingId);
922 DevicePadding padding = devicePaddings.getDevicePadding(unscaledExtraSpace);
923 maxEmptySpace = padding.getMaxEmptySpacePx();
924
925 int paddingWorkspaceTop = padding.getWorkspaceTopPadding(unscaledExtraSpace);
926 int paddingWorkspaceBottom = padding.getWorkspaceBottomPadding(unscaledExtraSpace);
927
928 workspaceTopPadding = Math.round(paddingWorkspaceTop * cellScaleToFit);
929 workspaceBottomPadding = Math.round(paddingWorkspaceBottom * cellScaleToFit);
930 }
931 }
932
Thales Limab8c05952022-05-23 16:58:38 +0100933 /** Updates hotseatCellHeightPx and hotseatBarSizePx */
934 private void updateHotseatSizes(int hotseatIconSizePx) {
Jon Miranda92c1b5d2021-07-20 13:57:16 -0700935 // Ensure there is enough space for folder icons, which have a slightly larger radius.
Jordan Silva3646a1b2023-08-02 13:52:52 +0100936 hotseatCellHeightPx = getIconSizeWithOverlap(hotseatIconSizePx);
Thales Limab8c05952022-05-23 16:58:38 +0100937
Jon Miranda0d284852021-06-22 14:50:55 -0700938 if (isVerticalBarLayout()) {
Thales Lima8e11d532023-08-31 13:40:26 +0000939 hotseatBarSizePx = hotseatIconSizePx + mHotseatBarEdgePaddingPx
940 + mHotseatBarWorkspaceSpacePx;
Thales Limab8c05952022-05-23 16:58:38 +0100941 } else if (isQsbInline) {
942 hotseatBarSizePx = Math.max(hotseatIconSizePx, hotseatQsbVisualHeight)
943 + hotseatBarBottomSpacePx;
Jon Miranda0d284852021-06-22 14:50:55 -0700944 } else {
Thales Limab8c05952022-05-23 16:58:38 +0100945 hotseatBarSizePx = hotseatIconSizePx
946 + hotseatQsbSpace
947 + hotseatQsbVisualHeight
948 + hotseatBarBottomSpacePx;
Jon Miranda0d284852021-06-22 14:50:55 -0700949 }
950 }
951
Thales Lima6a590062022-11-22 15:52:49 +0000952 /**
953 * Calculates the width of the hotseat, changing spaces between the icons and removing icons if
954 * necessary.
955 */
956 public void recalculateHotseatWidthAndBorderSpace() {
Thales Lima79456492023-05-23 11:32:22 +0100957 if (!mIsScalableGrid) return;
Thales Lima6a590062022-11-22 15:52:49 +0000958
fbarone4b0b712024-03-29 14:31:17 -0700959 updateHotseatWidthAndBorderSpace(inv.numColumns);
960 int numWorkspaceColumns = getPanelCount() * inv.numColumns;
961 if (isTwoPanels) {
962 updateHotseatWidthAndBorderSpace(inv.numDatabaseHotseatIcons);
963 // If hotseat doesn't fit with current width, increase column span to fit by multiple
964 // of 2.
965 while (hotseatBorderSpace < mMinHotseatIconSpacePx
966 && mHotseatColumnSpan < numWorkspaceColumns) {
967 updateHotseatWidthAndBorderSpace(mHotseatColumnSpan + 2);
968 }
969 }
970 if (isQsbInline) {
971 // If QSB is inline, reduce column span until it fits.
972 int maxHotseatWidthAllowedPx = getIconToIconWidthForColumns(numWorkspaceColumns);
973 int minHotseatWidthRequiredPx =
974 mMinHotseatQsbWidthPx + hotseatBorderSpace + mHotseatWidthPx;
975 while (minHotseatWidthRequiredPx > maxHotseatWidthAllowedPx
976 && mHotseatColumnSpan > 1) {
977 updateHotseatWidthAndBorderSpace(mHotseatColumnSpan - 1);
978 minHotseatWidthRequiredPx =
979 mMinHotseatQsbWidthPx + hotseatBorderSpace + mHotseatWidthPx;
980 }
981 }
Thales Lima9938c2f2022-07-25 14:38:16 +0100982 hotseatQsbWidth = calculateQsbWidth(hotseatBorderSpace);
fbarone4b0b712024-03-29 14:31:17 -0700983
Thales Lima6a590062022-11-22 15:52:49 +0000984 // Spaces should be correct when the nav buttons are not inline
Thales Lima9938c2f2022-07-25 14:38:16 +0100985 if (!areNavButtonsInline) {
986 return;
987 }
988
Thales Lima6a590062022-11-22 15:52:49 +0000989 // The side space with inline buttons should be what is defined in InvariantDeviceProfile
Jon Mirandae17a9492023-03-08 16:42:20 -0800990 int sideSpacePx = inlineNavButtonsEndSpacingPx;
Thales Limaffc68b02023-01-09 16:20:23 +0000991 int maxHotseatWidthPx = availableWidthPx - sideSpacePx - hotseatBarEndOffset;
992 int maxHotseatIconsWidthPx = maxHotseatWidthPx - (isQsbInline ? hotseatQsbWidth : 0);
993 hotseatBorderSpace = calculateHotseatBorderSpace(maxHotseatIconsWidthPx,
Thales Lima6a590062022-11-22 15:52:49 +0000994 (isQsbInline ? 1 : 0) + /* border between nav buttons and first icon */ 1);
Thales Lima9938c2f2022-07-25 14:38:16 +0100995
Thales Limaffc68b02023-01-09 16:20:23 +0000996 if (hotseatBorderSpace >= mMinHotseatIconSpacePx) {
Thales Lima9938c2f2022-07-25 14:38:16 +0100997 return;
998 }
999
1000 // Border space can't be less than the minimum
Thales Limaffc68b02023-01-09 16:20:23 +00001001 hotseatBorderSpace = mMinHotseatIconSpacePx;
Thales Lima6a590062022-11-22 15:52:49 +00001002 int requiredWidth = getHotseatRequiredWidth();
Thales Lima9938c2f2022-07-25 14:38:16 +01001003
1004 // If there is an inline qsb, change its size
1005 if (isQsbInline) {
Thales Limaffc68b02023-01-09 16:20:23 +00001006 hotseatQsbWidth -= requiredWidth - maxHotseatWidthPx;
1007 if (hotseatQsbWidth >= mMinHotseatQsbWidthPx) {
Thales Lima9938c2f2022-07-25 14:38:16 +01001008 return;
1009 }
1010
1011 // QSB can't be less than the minimum
Thales Limaffc68b02023-01-09 16:20:23 +00001012 hotseatQsbWidth = mMinHotseatQsbWidthPx;
Thales Lima9938c2f2022-07-25 14:38:16 +01001013 }
1014
Thales Limaffc68b02023-01-09 16:20:23 +00001015 maxHotseatIconsWidthPx = maxHotseatWidthPx - (isQsbInline ? hotseatQsbWidth : 0);
Thales Lima6a590062022-11-22 15:52:49 +00001016
Thales Lima9938c2f2022-07-25 14:38:16 +01001017 // If it still doesn't fit, start removing icons
1018 do {
1019 numShownHotseatIcons--;
Thales Limaffc68b02023-01-09 16:20:23 +00001020 hotseatBorderSpace = calculateHotseatBorderSpace(maxHotseatIconsWidthPx,
Thales Lima6a590062022-11-22 15:52:49 +00001021 (isQsbInline ? 1 : 0) + /* border between nav buttons and first icon */ 1);
Thales Limaffc68b02023-01-09 16:20:23 +00001022 } while (hotseatBorderSpace < mMinHotseatIconSpacePx && numShownHotseatIcons > 1);
Thales Lima9938c2f2022-07-25 14:38:16 +01001023 }
1024
fbarone4b0b712024-03-29 14:31:17 -07001025 private void updateHotseatWidthAndBorderSpace(int columns) {
1026 mHotseatColumnSpan = columns;
1027 mHotseatWidthPx = getIconToIconWidthForColumns(mHotseatColumnSpan);
1028 hotseatBorderSpace = calculateHotseatBorderSpace(mHotseatWidthPx, /* numExtraBorder= */ 0);
1029 }
1030
Thales Lima78d00ad2021-09-30 11:29:06 +01001031 private Point getCellLayoutBorderSpace(InvariantDeviceProfile idp) {
Thales Lima080d8902022-03-28 15:30:29 +01001032 return getCellLayoutBorderSpace(idp, 1f);
Thales Lima080d8902022-03-28 15:30:29 +01001033 }
1034
1035 private Point getCellLayoutBorderSpace(InvariantDeviceProfile idp, float scale) {
Thales Lima79456492023-05-23 11:32:22 +01001036 int horizontalSpacePx = 0;
1037 int verticalSpacePx = 0;
Thales Lima78d00ad2021-09-30 11:29:06 +01001038
Thales Lima79456492023-05-23 11:32:22 +01001039 if (mIsResponsiveGrid) {
Jordan Silva8f7986a2023-11-08 12:11:25 +00001040 horizontalSpacePx = mResponsiveWorkspaceWidthSpec.getGutterPx();
1041 verticalSpacePx = mResponsiveWorkspaceHeightSpec.getGutterPx();
Thales Lima79456492023-05-23 11:32:22 +01001042 } else if (mIsScalableGrid) {
1043 horizontalSpacePx = pxFromDp(idp.borderSpaces[mTypeIndex].x, mMetrics, scale);
1044 verticalSpacePx = pxFromDp(idp.borderSpaces[mTypeIndex].y, mMetrics, scale);
1045 }
Thales Lima78d00ad2021-09-30 11:29:06 +01001046
1047 return new Point(horizontalSpacePx, verticalSpacePx);
1048 }
1049
Sunny Goyal69a8eec2021-07-22 10:02:50 -07001050 public Info getDisplayInfo() {
1051 return mInfo;
1052 }
1053
fbarone4b0b712024-03-29 14:31:17 -07001054 @VisibleForTesting
1055 public int getHotseatColumnSpan() {
1056 return mHotseatColumnSpan;
1057 }
1058
fbarone4b0b712024-03-29 14:31:17 -07001059 public int getHotseatWidthPx() {
1060 return mHotseatWidthPx;
1061 }
1062
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001063 public Builder toBuilder(Context context) {
Sunny Goyal187b16c2022-03-01 16:53:23 -08001064 WindowBounds bounds = new WindowBounds(
1065 widthPx, heightPx, availableWidthPx, availableHeightPx, rotationHint);
Sunny Goyal19ff7282021-04-22 10:12:54 -07001066 bounds.bounds.offsetTo(windowX, windowY);
Alex Chaue0227552022-04-06 19:44:43 +01001067 bounds.insets.set(mInsets);
Sunny Goyal65190ae2022-08-02 14:16:26 -07001068
1069 SparseArray<DotRenderer> dotRendererCache = new SparseArray<>();
1070 dotRendererCache.put(iconSizePx, mDotRendererWorkSpace);
1071 dotRendererCache.put(allAppsIconSizePx, mDotRendererAllApps);
1072
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001073 return new Builder(context, inv, mInfo)
Sunny Goyal19ff7282021-04-22 10:12:54 -07001074 .setWindowBounds(bounds)
Alex Chauab800f72022-12-13 17:46:06 +00001075 .setIsMultiDisplay(isMultiDisplay)
Alex Chau6ed408f2022-03-04 12:58:05 +00001076 .setMultiWindowMode(isMultiWindowMode)
Sunny Goyal65190ae2022-08-02 14:16:26 -07001077 .setDotRendererCache(dotRendererCache)
Alex Chau6ed408f2022-03-04 12:58:05 +00001078 .setGestureMode(isGestureMode);
Sunny Goyal1a52ef52018-01-11 10:15:03 -08001079 }
1080
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001081 public DeviceProfile copy(Context context) {
1082 return toBuilder(context).build();
1083 }
1084
1085 /**
1086 * TODO: Move this to the builder as part of setMultiWindowMode
1087 */
Sunny Goyalb46703d2020-05-27 17:52:03 -07001088 public DeviceProfile getMultiWindowProfile(Context context, WindowBounds windowBounds) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001089 DeviceProfile profile = toBuilder(context)
Sunny Goyal19ff7282021-04-22 10:12:54 -07001090 .setWindowBounds(windowBounds)
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001091 .setMultiWindowMode(true)
1092 .build();
Jon Miranda93e1f042016-11-11 14:13:04 -08001093
Jon Miranda7ae64ff2016-11-21 16:18:46 -08001094 // We use these scales to measure and layout the widgets using their full invariant profile
1095 // sizes and then draw them scaled and centered to fit in their multi-window mode cellspans.
1096 float appWidgetScaleX = (float) profile.getCellSize().x / getCellSize().x;
1097 float appWidgetScaleY = (float) profile.getCellSize().y / getCellSize().y;
Sihua Mae04aa202022-07-18 12:43:56 -07001098 if (appWidgetScaleX != 1 || appWidgetScaleY != 1) {
1099 final PointF p = new PointF(appWidgetScaleX, appWidgetScaleY);
1100 profile = profile.toBuilder(context)
1101 .setViewScaleProvider(i -> p)
1102 .build();
1103 }
1104
1105 profile.hideWorkspaceLabelsIfNotEnoughSpace();
Jon Miranda7ae64ff2016-11-21 16:18:46 -08001106
Jon Miranda93e1f042016-11-11 14:13:04 -08001107 return profile;
Jon Mirandacc42c5b2016-10-27 17:15:27 -07001108 }
1109
Adam Cohen63f1ec02014-08-12 09:23:13 -07001110 /**
Jon Miranda941375e2021-03-31 13:10:45 -04001111 * Checks if there is enough space for labels on the workspace.
1112 * If there is not, labels on the Workspace are hidden.
Jon Miranda1091e532017-07-21 13:31:50 -07001113 * It is important to call this method after the All Apps variables have been set.
1114 */
Jon Miranda941375e2021-03-31 13:10:45 -04001115 private void hideWorkspaceLabelsIfNotEnoughSpace() {
1116 float iconTextHeight = Utilities.calculateTextHeight(iconTextSizePx);
1117 float workspaceCellPaddingY = getCellSize().y - iconSizePx - iconDrawablePaddingPx
1118 - iconTextHeight;
1119
1120 // We want enough space so that the text is closer to its corresponding icon.
1121 if (workspaceCellPaddingY < iconTextHeight) {
1122 iconTextSizePx = 0;
1123 iconDrawablePaddingPx = 0;
Jordan Silva3646a1b2023-08-02 13:52:52 +01001124 cellHeightPx = getIconSizeWithOverlap(iconSizePx);
Jon Miranda941375e2021-03-31 13:10:45 -04001125 autoResizeAllAppsCells();
1126 }
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001127 }
Jon Miranda1091e532017-07-21 13:31:50 -07001128
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001129 /**
Jon Miranda228877d2021-02-09 11:05:00 -05001130 * Returns the amount of extra (or unused) vertical space.
1131 */
Brandon Dayauon5787a272023-12-14 13:47:17 -08001132 private int updateAvailableDimensions(Context context) {
fbaronfc6bbcf2024-01-29 10:35:17 -08001133 iconCenterVertically = (mIsScalableGrid || mIsResponsiveGrid) && isVerticalBarLayout();
Jordan Silva999dd2a2023-11-17 19:31:43 +00001134
1135 if (mIsResponsiveGrid) {
Jordan Silva15cacd52023-11-28 14:32:05 +00001136 iconSizePx = mResponsiveWorkspaceCellSpec.getIconSize();
1137 iconTextSizePx = mResponsiveWorkspaceCellSpec.getIconTextSize();
1138 mIconDrawablePaddingOriginalPx = mResponsiveWorkspaceCellSpec.getIconDrawablePadding();
Brandon Dayauon5787a272023-12-14 13:47:17 -08001139 updateIconSize(1f, context);
Jordan Silva999dd2a2023-11-17 19:31:43 +00001140 updateWorkspacePadding();
1141 return 0;
1142 }
1143
Alex Chaua68164d2022-12-15 16:16:03 +00001144 float invIconSizeDp = inv.iconSize[mTypeIndex];
1145 float invIconTextSizeSp = inv.iconTextSize[mTypeIndex];
1146 iconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mMetrics));
1147 iconTextSizePx = pxFromSp(invIconTextSizeSp, mMetrics);
1148
Brandon Dayauon5787a272023-12-14 13:47:17 -08001149 updateIconSize(1f, context);
Pat Manning08610ca2022-04-05 21:03:16 +01001150 updateWorkspacePadding();
Jon Mirandae126d722021-02-25 10:45:20 -05001151
1152 // Check to see if the icons fit within the available height.
Pat Manninga2e14992022-04-22 11:29:17 +01001153 float usedHeight = getCellLayoutHeightSpecification();
Pat Manning25d53342022-05-10 09:58:49 +00001154 final int maxHeight = getCellLayoutHeight();
Jon Miranda228877d2021-02-09 11:05:00 -05001155 float extraHeight = Math.max(0, maxHeight - usedHeight);
Jon Mirandae126d722021-02-25 10:45:20 -05001156 float scaleY = maxHeight / usedHeight;
1157 boolean shouldScale = scaleY < 1f;
1158
1159 float scaleX = 1f;
Thales Lima79456492023-05-23 11:32:22 +01001160 if (mIsScalableGrid) {
Jon Mirandae126d722021-02-25 10:45:20 -05001161 // We scale to fit the cellWidth and cellHeight in the available space.
1162 // The benefit of scalable grids is that we can get consistent aspect ratios between
1163 // devices.
Pat Manninga2e14992022-04-22 11:29:17 +01001164 float usedWidth =
1165 getCellLayoutWidthSpecification() + (desiredWorkspaceHorizontalMarginPx * 2);
Jon Mirandae126d722021-02-25 10:45:20 -05001166 // We do not subtract padding here, as we also scale the workspace padding if needed.
1167 scaleX = availableWidthPx / usedWidth;
1168 shouldScale = true;
Winson Chungb3800242013-10-24 11:01:54 -07001169 }
Jon Mirandae126d722021-02-25 10:45:20 -05001170
1171 if (shouldScale) {
1172 float scale = Math.min(scaleX, scaleY);
Brandon Dayauon5787a272023-12-14 13:47:17 -08001173 updateIconSize(scale, context);
Pat Manninga2e14992022-04-22 11:29:17 +01001174 extraHeight = Math.max(0, maxHeight - getCellLayoutHeightSpecification());
Jon Mirandae126d722021-02-25 10:45:20 -05001175 }
1176
Jon Miranda228877d2021-02-09 11:05:00 -05001177 return Math.round(extraHeight);
Winson Chungb3800242013-10-24 11:01:54 -07001178 }
1179
Pat Manninga2e14992022-04-22 11:29:17 +01001180 private int getCellLayoutHeightSpecification() {
Pat Manning08610ca2022-04-05 21:03:16 +01001181 return (cellHeightPx * inv.numRows) + (cellLayoutBorderSpacePx.y * (inv.numRows - 1))
1182 + cellLayoutPaddingPx.top + cellLayoutPaddingPx.bottom;
1183 }
1184
Pat Manninga2e14992022-04-22 11:29:17 +01001185 private int getCellLayoutWidthSpecification() {
Pat Manning25d53342022-05-10 09:58:49 +00001186 int numColumns = getPanelCount() * inv.numColumns;
Pat Manning08610ca2022-04-05 21:03:16 +01001187 return (cellWidthPx * numColumns) + (cellLayoutBorderSpacePx.x * (numColumns - 1))
1188 + cellLayoutPaddingPx.left + cellLayoutPaddingPx.right;
Jon Mirandae126d722021-02-25 10:45:20 -05001189 }
1190
Jordan Silva376036a2023-11-08 15:56:40 +00001191 private int getNormalizedIconDrawablePadding(int iconSizePx, int iconDrawablePadding) {
fbarone69b6f42023-12-18 13:20:34 -08001192 return Math.max(0, iconDrawablePadding
1193 - ((iconSizePx - getIconVisibleSizePx(iconSizePx)) / 2));
Jordan Silva376036a2023-11-08 15:56:40 +00001194 }
1195
1196 private int getNormalizedIconDrawablePadding() {
1197 return getNormalizedIconDrawablePadding(iconSizePx, mIconDrawablePaddingOriginalPx);
Thales Lima93ee8fc2023-06-05 17:07:11 +01001198 }
1199
1200 private int getNormalizedFolderChildDrawablePaddingPx(int textHeight) {
1201 // TODO(b/235886078): workaround needed because of this bug
1202 // Icons are 10% larger on XML than their visual size,
1203 // so remove that extra space to get labels closer to the correct padding
1204 int drawablePadding = (folderCellHeightPx - folderChildIconSizePx - textHeight) / 3;
1205
fbarone69b6f42023-12-18 13:20:34 -08001206 int iconSizeDiff = folderChildIconSizePx - getIconVisibleSizePx(folderChildIconSizePx);
Thales Lima93ee8fc2023-06-05 17:07:11 +01001207 return Math.max(0, drawablePadding - iconSizeDiff / 2);
1208 }
1209
Jordan Silva3646a1b2023-08-02 13:52:52 +01001210 private int getIconSizeWithOverlap(int iconSize) {
1211 return (int) Math.ceil(iconSize * ICON_OVERLAP_FACTOR);
1212 }
1213
Jon Miranda6f7e9702019-09-16 14:44:14 -07001214 /**
1215 * Updating the iconSize affects many aspects of the launcher layout, such as: iconSizePx,
1216 * iconTextSizePx, iconDrawablePaddingPx, cellWidth/Height, allApps* variants,
1217 * hotseat sizes, workspaceSpringLoadedShrinkFactor, folderIconSizePx, and folderIconOffsetYPx.
1218 */
Brandon Dayauon5787a272023-12-14 13:47:17 -08001219 public void updateIconSize(float scale, Context context) {
Jon Mirandaab3c6812021-06-28 15:42:28 -07001220 // Icon scale should never exceed 1, otherwise pixellation may occur.
1221 iconScale = Math.min(1f, scale);
1222 cellScaleToFit = scale;
1223
Jon Miranda18751b62017-07-31 17:25:27 -07001224 // Workspace
Sunny Goyal07b69292018-01-08 14:19:34 -08001225 final boolean isVerticalLayout = isVerticalBarLayout();
Thales Lima080d8902022-03-28 15:30:29 +01001226 cellLayoutBorderSpacePx = getCellLayoutBorderSpace(inv, scale);
Jon Mirandae126d722021-02-25 10:45:20 -05001227
Thales Lima79456492023-05-23 11:32:22 +01001228 if (mIsResponsiveGrid) {
Jordan Silva8f7986a2023-11-08 12:11:25 +00001229 cellWidthPx = mResponsiveWorkspaceWidthSpec.getCellSizePx();
1230 cellHeightPx = mResponsiveWorkspaceHeightSpec.getCellSizePx();
Thales Lima79456492023-05-23 11:32:22 +01001231
Thales Lima2759aa32023-06-05 16:25:45 +01001232 if (cellWidthPx < iconSizePx) {
1233 // get a smaller icon size
1234 iconSizePx = mIconSizeSteps.getIconSmallerThan(cellWidthPx);
Thales Lima2759aa32023-06-05 16:25:45 +01001235 }
1236
Jordan Silvadd612682024-01-08 11:38:13 -03001237 if (isVerticalLayout) {
1238 iconDrawablePaddingPx = 0;
1239 iconTextSizePx = 0;
1240 } else {
1241 iconDrawablePaddingPx = getNormalizedIconDrawablePadding();
1242 }
Thales Lima93ee8fc2023-06-05 17:07:11 +01001243
Thales Lima24ceca62023-09-25 16:21:17 -07001244 CellContentDimensions cellContentDimensions = new CellContentDimensions(iconSizePx,
1245 iconDrawablePaddingPx,
1246 iconTextSizePx);
Jordan Silvadd612682024-01-08 11:38:13 -03001247 int cellContentHeight = cellContentDimensions.resizeToFitCellHeight(cellHeightPx,
1248 mIconSizeSteps);
Thales Lima24ceca62023-09-25 16:21:17 -07001249 iconSizePx = cellContentDimensions.getIconSizePx();
1250 iconDrawablePaddingPx = cellContentDimensions.getIconDrawablePaddingPx();
1251 iconTextSizePx = cellContentDimensions.getIconTextSizePx();
Thales Lima2759aa32023-06-05 16:25:45 +01001252
Jordan Silvadd612682024-01-08 11:38:13 -03001253 if (isVerticalLayout) {
1254 cellYPaddingPx = Math.max(0, getCellSize().y - getIconSizeWithOverlap(iconSizePx))
1255 / 2;
1256 } else {
1257 cellYPaddingPx = Math.max(0, cellHeightPx - cellContentHeight) / 2;
1258 }
Thales Lima79456492023-05-23 11:32:22 +01001259 } else if (mIsScalableGrid) {
Thales Lima93ee8fc2023-06-05 17:07:11 +01001260 iconDrawablePaddingPx = (int) (getNormalizedIconDrawablePadding() * iconScale);
Thales Lima83bedbf2021-10-05 17:47:39 +01001261 cellWidthPx = pxFromDp(inv.minCellSize[mTypeIndex].x, mMetrics, scale);
1262 cellHeightPx = pxFromDp(inv.minCellSize[mTypeIndex].y, mMetrics, scale);
Alex Chaube753132022-12-09 16:46:54 +00001263
1264 if (cellWidthPx < iconSizePx) {
1265 // If cellWidth no longer fit iconSize, reduce borderSpace to make cellWidth bigger.
1266 int numColumns = getPanelCount() * inv.numColumns;
1267 int numBorders = numColumns - 1;
1268 int extraWidthRequired = (iconSizePx - cellWidthPx) * numColumns;
1269 if (cellLayoutBorderSpacePx.x * numBorders >= extraWidthRequired) {
1270 cellWidthPx = iconSizePx;
1271 cellLayoutBorderSpacePx.x -= extraWidthRequired / numBorders;
1272 } else {
1273 // If it still doesn't fit, set borderSpace to 0 and distribute the space for
1274 // cellWidth, and reduce iconSize.
1275 cellWidthPx = (cellWidthPx * numColumns
1276 + cellLayoutBorderSpacePx.x * numBorders) / numColumns;
1277 iconSizePx = Math.min(iconSizePx, cellWidthPx);
1278 cellLayoutBorderSpacePx.x = 0;
1279 }
1280 }
1281
Thales Lima93ee8fc2023-06-05 17:07:11 +01001282 int cellTextAndPaddingHeight =
1283 iconDrawablePaddingPx + Utilities.calculateTextHeight(iconTextSizePx);
Alex Chaube753132022-12-09 16:46:54 +00001284 int cellContentHeight = iconSizePx + cellTextAndPaddingHeight;
1285 if (cellHeightPx < cellContentHeight) {
1286 // If cellHeight no longer fit iconSize, reduce borderSpace to make cellHeight
1287 // bigger.
1288 int numBorders = inv.numRows - 1;
1289 int extraHeightRequired = (cellContentHeight - cellHeightPx) * inv.numRows;
1290 if (cellLayoutBorderSpacePx.y * numBorders >= extraHeightRequired) {
1291 cellHeightPx = cellContentHeight;
1292 cellLayoutBorderSpacePx.y -= extraHeightRequired / numBorders;
1293 } else {
Alex Chau06f36e82023-01-06 10:50:54 +00001294 // If it still doesn't fit, set borderSpace to 0 to recover space.
Alex Chaube753132022-12-09 16:46:54 +00001295 cellHeightPx = (cellHeightPx * inv.numRows
1296 + cellLayoutBorderSpacePx.y * numBorders) / inv.numRows;
Alex Chaube753132022-12-09 16:46:54 +00001297 cellLayoutBorderSpacePx.y = 0;
Alex Chau06f36e82023-01-06 10:50:54 +00001298 // Reduce iconDrawablePaddingPx to make cellContentHeight smaller.
1299 int cellContentWithoutPadding = cellContentHeight - iconDrawablePaddingPx;
1300 if (cellContentWithoutPadding <= cellHeightPx) {
1301 iconDrawablePaddingPx = cellContentHeight - cellHeightPx;
1302 } else {
1303 // If it still doesn't fit, set iconDrawablePaddingPx to 0 to recover space,
1304 // then proportional reduce iconSizePx and iconTextSizePx to fit.
1305 iconDrawablePaddingPx = 0;
1306 float ratio = cellHeightPx / (float) cellContentWithoutPadding;
1307 iconSizePx = (int) (iconSizePx * ratio);
1308 iconTextSizePx = (int) (iconTextSizePx * ratio);
1309 }
1310 cellTextAndPaddingHeight =
1311 iconDrawablePaddingPx + Utilities.calculateTextHeight(iconTextSizePx);
Alex Chaube753132022-12-09 16:46:54 +00001312 }
1313 cellContentHeight = iconSizePx + cellTextAndPaddingHeight;
1314 }
Jon Mirandae126d722021-02-25 10:45:20 -05001315 cellYPaddingPx = Math.max(0, cellHeightPx - cellContentHeight) / 2;
Thales Limad90faab2021-09-21 17:18:47 +01001316 desiredWorkspaceHorizontalMarginPx =
1317 (int) (desiredWorkspaceHorizontalMarginOriginalPx * scale);
Jon Miranda228877d2021-02-09 11:05:00 -05001318 } else {
Thales Lima93ee8fc2023-06-05 17:07:11 +01001319 iconDrawablePaddingPx = (int) (getNormalizedIconDrawablePadding() * iconScale);
Jon Mirandae126d722021-02-25 10:45:20 -05001320 cellWidthPx = iconSizePx + iconDrawablePaddingPx;
Jordan Silva3646a1b2023-08-02 13:52:52 +01001321 cellHeightPx = getIconSizeWithOverlap(iconSizePx)
Jon Miranda92c1b5d2021-07-20 13:57:16 -07001322 + iconDrawablePaddingPx
Jon Miranda228877d2021-02-09 11:05:00 -05001323 + Utilities.calculateTextHeight(iconTextSizePx);
1324 int cellPaddingY = (getCellSize().y - cellHeightPx) / 2;
1325 if (iconDrawablePaddingPx > cellPaddingY && !isVerticalLayout
1326 && !isMultiWindowMode) {
1327 // Ensures that the label is closer to its corresponding icon. This is not an issue
1328 // with vertical bar layout or multi-window mode since the issue is handled
1329 // separately with their calls to {@link #adjustToHideWorkspaceLabels}.
1330 cellHeightPx -= (iconDrawablePaddingPx - cellPaddingY);
1331 iconDrawablePaddingPx = cellPaddingY;
1332 }
Jon Miranda846455e2017-10-02 14:58:52 -07001333 }
Jon Miranda18751b62017-07-31 17:25:27 -07001334
Sunny Goyalae190ff2020-04-14 00:19:01 +00001335 // All apps
Thales Limaabfe3642023-05-24 18:08:53 +01001336 if (mIsResponsiveGrid) {
Jordan Silva999dd2a2023-11-17 19:31:43 +00001337 updateAllAppsWithResponsiveMeasures();
Thales Limaabfe3642023-05-24 18:08:53 +01001338 } else {
Brandon Dayauon5787a272023-12-14 13:47:17 -08001339 updateAllAppsIconSize(scale, context.getResources());
Thales Limaabfe3642023-05-24 18:08:53 +01001340 }
1341 updateAllAppsContainerWidth();
Jordan Silvadd612682024-01-08 11:38:13 -03001342 if (isVerticalLayout && !mIsResponsiveGrid) {
Thales Limaabfe3642023-05-24 18:08:53 +01001343 hideWorkspaceLabelsIfNotEnoughSpace();
1344 }
Brandon Dayauon68c18232024-03-07 10:14:44 -08001345 if ((Flags.enableTwolineToggle()
1346 && LauncherPrefs.ENABLE_TWOLINE_ALLAPPS_TOGGLE.get(context))) {
Brandon Dayauon3cdb32c2023-08-22 21:26:37 -07001347 // Add extra textHeight to the existing allAppsCellHeight.
1348 allAppsCellHeightPx += Utilities.calculateTextHeight(allAppsIconTextSizePx);
1349 }
Winson Chungb3800242013-10-24 11:01:54 -07001350
Thales Limab8c05952022-05-23 16:58:38 +01001351 updateHotseatSizes(iconSizePx);
Winson Chungb3800242013-10-24 11:01:54 -07001352
Sunny Goyalbaec6ff2016-09-14 11:26:21 -07001353 // Folder icon
Jon Miranda591e3602018-03-28 11:37:00 -07001354 folderIconSizePx = IconNormalizer.getNormalizedCircleSize(iconSizePx);
1355 folderIconOffsetYPx = (iconSizePx - folderIconSizePx) / 2;
Sunny Goyal6c304b12023-04-10 12:03:04 -07001356
1357 // Update widget padding:
1358 float minSpacing = pxFromDp(MIN_WIDGET_PADDING_DP, mMetrics);
1359 if (cellLayoutBorderSpacePx.x < minSpacing
1360 || cellLayoutBorderSpacePx.y < minSpacing) {
1361 widgetPadding.left = widgetPadding.right =
1362 Math.round(Math.max(0, minSpacing - cellLayoutBorderSpacePx.x));
1363 widgetPadding.top = widgetPadding.bottom =
1364 Math.round(Math.max(0, minSpacing - cellLayoutBorderSpacePx.y));
1365 } else {
1366 widgetPadding.setEmpty();
1367 }
Winson Chung0f785722015-04-08 10:27:49 -07001368 }
1369
Thales Lima425f6822022-05-10 13:44:58 -03001370 /**
Thales Lima6a590062022-11-22 15:52:49 +00001371 * This method calculates the space between the icons to achieve a certain width.
Thales Lima425f6822022-05-10 13:44:58 -03001372 */
Thales Lima6a590062022-11-22 15:52:49 +00001373 private int calculateHotseatBorderSpace(float hotseatWidthPx, int numExtraBorder) {
Jordan Silvad9227182023-08-17 15:53:59 +01001374 int numBorders = (numShownHotseatIcons - 1 + numExtraBorder);
1375 if (numBorders <= 0) return 0;
1376
Thales Lima9938c2f2022-07-25 14:38:16 +01001377 float hotseatIconsTotalPx = iconSizePx * numShownHotseatIcons;
Jordan Silvad9227182023-08-17 15:53:59 +01001378 int hotseatBorderSpacePx = (int) (hotseatWidthPx - hotseatIconsTotalPx) / numBorders;
Thales Limaffc68b02023-01-09 16:20:23 +00001379 return Math.min(hotseatBorderSpacePx, mMaxHotseatIconSpacePx);
Thales Lima425f6822022-05-10 13:44:58 -03001380 }
1381
Brian Isganitis25b2ac82022-01-28 16:25:13 -05001382 /**
1383 * Updates the iconSize for allApps* variants.
1384 */
Brian Isganitisa9a78112022-05-23 18:11:47 -07001385 private void updateAllAppsIconSize(float scale, Resources res) {
Thales Lima080d8902022-03-28 15:30:29 +01001386 allAppsBorderSpacePx = new Point(
1387 pxFromDp(inv.allAppsBorderSpaces[mTypeIndex].x, mMetrics, scale),
1388 pxFromDp(inv.allAppsBorderSpaces[mTypeIndex].y, mMetrics, scale));
Brandon Dayauon07ca8842022-04-27 10:52:28 -07001389 // AllApps cells don't have real space between cells,
1390 // so we add the border space to the cell height
Alex Chaube753132022-12-09 16:46:54 +00001391 allAppsCellHeightPx = pxFromDp(inv.allAppsCellSize[mTypeIndex].y, mMetrics)
Brandon Dayauon07ca8842022-04-27 10:52:28 -07001392 + allAppsBorderSpacePx.y;
1393 // but width is just the cell,
1394 // the border is added in #updateAllAppsContainerWidth
Thales Lima79456492023-05-23 11:32:22 +01001395 if (mIsScalableGrid) {
Alex Chaube753132022-12-09 16:46:54 +00001396 allAppsIconSizePx = pxFromDp(inv.allAppsIconSize[mTypeIndex], mMetrics);
1397 allAppsIconTextSizePx = pxFromSp(inv.allAppsIconTextSize[mTypeIndex], mMetrics);
Thales Lima93ee8fc2023-06-05 17:07:11 +01001398 allAppsIconDrawablePaddingPx = getNormalizedIconDrawablePadding();
Brandon Dayauon7a8a9ed2022-06-06 14:32:22 -07001399 allAppsCellWidthPx = pxFromDp(inv.allAppsCellSize[mTypeIndex].x, mMetrics, scale);
Alex Chaube753132022-12-09 16:46:54 +00001400
1401 if (allAppsCellWidthPx < allAppsIconSizePx) {
1402 // If allAppsCellWidth no longer fit allAppsIconSize, reduce allAppsBorderSpace to
1403 // make allAppsCellWidth bigger.
1404 int numBorders = inv.numAllAppsColumns - 1;
1405 int extraWidthRequired =
1406 (allAppsIconSizePx - allAppsCellWidthPx) * inv.numAllAppsColumns;
1407 if (allAppsBorderSpacePx.x * numBorders >= extraWidthRequired) {
1408 allAppsCellWidthPx = allAppsIconSizePx;
1409 allAppsBorderSpacePx.x -= extraWidthRequired / numBorders;
1410 } else {
1411 // If it still doesn't fit, set allAppsBorderSpace to 0 and distribute the space
1412 // for allAppsCellWidth, and reduce allAppsIconSize.
1413 allAppsCellWidthPx = (allAppsCellWidthPx * inv.numAllAppsColumns
1414 + allAppsBorderSpacePx.x * numBorders) / inv.numAllAppsColumns;
1415 allAppsIconSizePx = Math.min(allAppsIconSizePx, allAppsCellWidthPx);
1416 allAppsBorderSpacePx.x = 0;
1417 }
1418 }
1419
1420 int cellContentHeight = allAppsIconSizePx
1421 + Utilities.calculateTextHeight(allAppsIconTextSizePx) + allAppsBorderSpacePx.y;
1422 if (allAppsCellHeightPx < cellContentHeight) {
1423 // Increase allAppsCellHeight to fit its content.
1424 allAppsCellHeightPx = cellContentHeight;
1425 }
Brian Isganitis25b2ac82022-01-28 16:25:13 -05001426 } else {
Brandon Dayauon07ca8842022-04-27 10:52:28 -07001427 float invIconSizeDp = inv.allAppsIconSize[mTypeIndex];
1428 float invIconTextSizeSp = inv.allAppsIconTextSize[mTypeIndex];
Brian Isganitis25b2ac82022-01-28 16:25:13 -05001429 allAppsIconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mMetrics, scale));
1430 allAppsIconTextSizePx = (int) (pxFromSp(invIconTextSizeSp, mMetrics) * scale);
Brandon Dayauon07ca8842022-04-27 10:52:28 -07001431 allAppsIconDrawablePaddingPx =
1432 res.getDimensionPixelSize(R.dimen.all_apps_icon_drawable_padding);
Brandon Dayauon7a8a9ed2022-06-06 14:32:22 -07001433 allAppsCellWidthPx = allAppsIconSizePx + (2 * allAppsIconDrawablePaddingPx);
Brian Isganitis25b2ac82022-01-28 16:25:13 -05001434 }
Thales Limaabfe3642023-05-24 18:08:53 +01001435 }
Brian Isganitis25b2ac82022-01-28 16:25:13 -05001436
Jordan Silva999dd2a2023-11-17 19:31:43 +00001437 private void updateAllAppsWithResponsiveMeasures() {
1438 allAppsIconSizePx = mResponsiveAllAppsCellSpec.getIconSize();
1439 allAppsIconTextSizePx = mResponsiveAllAppsCellSpec.getIconTextSize();
1440 allAppsIconDrawablePaddingPx = getNormalizedIconDrawablePadding(allAppsIconSizePx,
1441 mResponsiveAllAppsCellSpec.getIconDrawablePadding());
Thales Limaabfe3642023-05-24 18:08:53 +01001442 allAppsBorderSpacePx = new Point(
Jordan Silva8f7986a2023-11-08 12:11:25 +00001443 mResponsiveAllAppsWidthSpec.getGutterPx(),
1444 mResponsiveAllAppsHeightSpec.getGutterPx()
Thales Limaabfe3642023-05-24 18:08:53 +01001445 );
Jordan Silva999dd2a2023-11-17 19:31:43 +00001446 allAppsCellHeightPx = mResponsiveAllAppsHeightSpec.getCellSizePx();
Jordan Silva8f7986a2023-11-08 12:11:25 +00001447 allAppsCellWidthPx = mResponsiveAllAppsWidthSpec.getCellSizePx();
Thales Limaa25cd902023-11-01 12:00:32 +00001448
1449 // This workaround is needed to align AllApps icons with Workspace icons
1450 // since AllApps doesn't have borders between cells
1451 int halfBorder = allAppsBorderSpacePx.x / 2;
Jordan Silva8f7986a2023-11-08 12:11:25 +00001452 allAppsPadding.left = mResponsiveAllAppsWidthSpec.getStartPaddingPx() - halfBorder;
1453 allAppsPadding.right = mResponsiveAllAppsWidthSpec.getEndPaddingPx() - halfBorder;
Jordan Silva376036a2023-11-08 15:56:40 +00001454
Jordan Silva376036a2023-11-08 15:56:40 +00001455
1456 // Reduce the size of the app icon if it doesn't fit
1457 if (allAppsCellWidthPx < allAppsIconSizePx) {
1458 // get a smaller icon size
1459 allAppsIconSizePx = mIconSizeSteps.getIconSmallerThan(allAppsCellWidthPx);
1460 }
1461
1462 CellContentDimensions cellContentDimensions = new CellContentDimensions(
1463 allAppsIconSizePx, allAppsIconDrawablePaddingPx, (int) allAppsIconTextSizePx);
1464
1465 if (allAppsCellHeightPx < cellContentDimensions.getCellContentHeight()) {
1466 if (isVerticalBarLayout()) {
Jordan Silva2de6a272024-01-04 14:44:20 -03001467 if (allAppsCellHeightPx < allAppsIconSizePx) {
Jordan Silva376036a2023-11-08 15:56:40 +00001468 cellContentDimensions.setIconSizePx(
1469 mIconSizeSteps.getIconSmallerThan(allAppsCellHeightPx));
1470 }
1471 } else {
1472 cellContentDimensions.resizeToFitCellHeight(allAppsCellHeightPx,
1473 mIconSizeSteps);
1474 }
1475 allAppsIconSizePx = cellContentDimensions.getIconSizePx();
1476 allAppsIconDrawablePaddingPx = cellContentDimensions.getIconDrawablePaddingPx();
1477 allAppsIconTextSizePx = cellContentDimensions.getIconTextSizePx();
1478 }
Jordan Silva999dd2a2023-11-17 19:31:43 +00001479
1480 allAppsCellHeightPx += mResponsiveAllAppsHeightSpec.getGutterPx();
Jordan Silvadd612682024-01-08 11:38:13 -03001481
1482 if (isVerticalBarLayout()) {
1483 autoResizeAllAppsCells();
1484 }
Thales Limaabfe3642023-05-24 18:08:53 +01001485 }
1486
1487 /**
1488 * Re-computes the all-apps cell size to be independent of workspace
1489 */
1490 public void autoResizeAllAppsCells() {
1491 int textHeight = Utilities.calculateTextHeight(allAppsIconTextSizePx);
1492 int topBottomPadding = textHeight;
1493 allAppsCellHeightPx = allAppsIconSizePx + allAppsIconDrawablePaddingPx
1494 + textHeight + (topBottomPadding * 2);
1495 }
1496
1497 private void updateAllAppsContainerWidth() {
1498 int cellLayoutHorizontalPadding =
1499 (cellLayoutPaddingPx.left + cellLayoutPaddingPx.right) / 2;
1500 if (isTablet) {
1501 int usedWidth = (allAppsCellWidthPx * numShownAllAppsColumns)
1502 + (allAppsBorderSpacePx.x * (numShownAllAppsColumns - 1))
Thales Limab433c9c2023-10-30 12:24:05 +00001503 + allAppsPadding.left + allAppsPadding.right;
Thales Limaabfe3642023-05-24 18:08:53 +01001504 allAppsLeftRightMargin = Math.max(1, (availableWidthPx - usedWidth) / 2);
Thales Limaa25cd902023-11-01 12:00:32 +00001505 } else if (!mIsResponsiveGrid) {
Thales Limab433c9c2023-10-30 12:24:05 +00001506 allAppsPadding.left = allAppsPadding.right =
Thales Limaabfe3642023-05-24 18:08:53 +01001507 Math.max(0, desiredWorkspaceHorizontalMarginPx + cellLayoutHorizontalPadding
1508 - (allAppsBorderSpacePx.x / 2));
Brian Isganitis25b2ac82022-01-28 16:25:13 -05001509 }
1510 }
1511
Thales Limaabfe3642023-05-24 18:08:53 +01001512 private void setupAllAppsStyle(Context context) {
1513 TypedArray allAppsStyle = context.obtainStyledAttributes(
1514 inv.allAppsStyle != INVALID_RESOURCE_HANDLE ? inv.allAppsStyle
1515 : R.style.AllAppsStyleDefault, R.styleable.AllAppsStyle);
1516
Thales Limab433c9c2023-10-30 12:24:05 +00001517 allAppsPadding.left = allAppsPadding.right = allAppsStyle.getDimensionPixelSize(
Thales Limaabfe3642023-05-24 18:08:53 +01001518 R.styleable.AllAppsStyle_horizontalPadding, 0);
1519 allAppsStyle.recycle();
1520 }
1521
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001522 private void updateAvailableFolderCellDimensions(Resources res) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001523 updateFolderCellSize(1f, res);
Jon Mirandabf7d8122016-11-03 15:29:29 -07001524
Jordan Silva637f4eb2023-06-13 11:21:53 +01001525 // Responsive grid doesn't need to scale the folder
1526 if (mIsResponsiveGrid) return;
1527
Thales Lima7eee74b2023-03-16 16:00:55 -03001528 // For usability we can't have the folder use the whole width of the screen
Sunny Goyal07b69292018-01-08 14:19:34 -08001529 Point totalWorkspacePadding = getTotalWorkspacePadding();
Jon Mirandac1b23992016-12-13 08:57:36 -08001530
Thales Lima7eee74b2023-03-16 16:00:55 -03001531 // Check if the folder fit within the available height.
Thales Lima1faa4ed2023-12-01 16:48:19 +00001532 float contentUsedHeight = folderCellHeightPx * numFolderRows
1533 + ((numFolderRows - 1) * folderCellLayoutBorderSpacePx.y)
Thales Lima7eee74b2023-03-16 16:00:55 -03001534 + folderFooterHeightPx
1535 + folderContentPaddingTop;
1536 int contentMaxHeight = availableHeightPx - totalWorkspacePadding.y;
Samuel Fufa1c8d90a2019-11-12 17:54:58 -08001537 float scaleY = contentMaxHeight / contentUsedHeight;
Jon Mirandac1b23992016-12-13 08:57:36 -08001538
Thales Lima7eee74b2023-03-16 16:00:55 -03001539 // Check if the folder fit within the available width.
Thales Lima1faa4ed2023-12-01 16:48:19 +00001540 float contentUsedWidth = folderCellWidthPx * numFolderColumns
1541 + ((numFolderColumns - 1) * folderCellLayoutBorderSpacePx.x)
Thales Lima7eee74b2023-03-16 16:00:55 -03001542 + folderContentPaddingLeftRight * 2;
1543 int contentMaxWidth = availableWidthPx - totalWorkspacePadding.x;
Samuel Fufa1c8d90a2019-11-12 17:54:58 -08001544 float scaleX = contentMaxWidth / contentUsedWidth;
Jon Mirandac1b23992016-12-13 08:57:36 -08001545
1546 float scale = Math.min(scaleX, scaleY);
1547 if (scale < 1f) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001548 updateFolderCellSize(scale, res);
Jon Mirandabf7d8122016-11-03 15:29:29 -07001549 }
1550 }
1551
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001552 private void updateFolderCellSize(float scale, Resources res) {
Jordan Silva999dd2a2023-11-17 19:31:43 +00001553 int minLabelTextSize = pxFromSp(MIN_FOLDER_TEXT_SIZE_SP, mMetrics, scale);
Jordan Silva637f4eb2023-06-13 11:21:53 +01001554 if (mIsResponsiveGrid) {
Jordan Silva999dd2a2023-11-17 19:31:43 +00001555 folderChildIconSizePx = mResponsiveWorkspaceCellSpec.getIconSize();
1556 folderChildTextSizePx = mResponsiveWorkspaceCellSpec.getIconTextSize();
1557 folderLabelTextSizePx = Math.max(minLabelTextSize,
1558 (int) (folderChildTextSizePx * folderLabelTextScale));
1559 int textHeight = Utilities.calculateTextHeight(folderChildTextSizePx);
1560
Jordan Silva637f4eb2023-06-13 11:21:53 +01001561 folderCellWidthPx = mResponsiveFolderWidthSpec.getCellSizePx();
Jordan Silva637f4eb2023-06-13 11:21:53 +01001562 folderCellHeightPx = mResponsiveFolderHeightSpec.getCellSizePx();
1563 folderContentPaddingTop = mResponsiveFolderHeightSpec.getStartPaddingPx();
1564 folderFooterHeightPx = mResponsiveFolderHeightSpec.getEndPaddingPx();
1565
1566 folderCellLayoutBorderSpacePx = new Point(mResponsiveFolderWidthSpec.getGutterPx(),
Thales Lima4cfd9502023-07-10 14:01:28 +01001567 mResponsiveFolderHeightSpec.getGutterPx());
Jordan Silva637f4eb2023-06-13 11:21:53 +01001568
1569 folderContentPaddingLeftRight = mResponsiveFolderWidthSpec.getStartPaddingPx();
Jordan Silva12fae112023-06-26 12:51:01 +01001570
1571 // Reduce icon width if it's wider than the expected folder cell width
1572 if (folderCellWidthPx < folderChildIconSizePx) {
1573 folderChildIconSizePx = mIconSizeSteps.getIconSmallerThan(folderCellWidthPx);
1574 }
1575
1576 // Recalculating padding and cell height
Jordan Silva3e5688a2023-12-05 15:12:29 -03001577 folderChildDrawablePaddingPx = mResponsiveWorkspaceCellSpec.getIconDrawablePadding();
Jordan Silva12fae112023-06-26 12:51:01 +01001578
Thales Limae9b5e142023-11-04 17:10:13 +00001579 CellContentDimensions cellContentDimensions = new CellContentDimensions(
1580 folderChildIconSizePx,
1581 folderChildDrawablePaddingPx,
1582 folderChildTextSizePx);
1583 cellContentDimensions.resizeToFitCellHeight(folderCellHeightPx, mIconSizeSteps);
1584 folderChildIconSizePx = cellContentDimensions.getIconSizePx();
1585 folderChildDrawablePaddingPx = cellContentDimensions.getIconDrawablePaddingPx();
1586 folderChildTextSizePx = cellContentDimensions.getIconTextSizePx();
Jordan Silva999dd2a2023-11-17 19:31:43 +00001587 folderLabelTextSizePx = Math.max(minLabelTextSize,
Jordan Silva9a3bd8f2023-11-16 18:33:28 +00001588 (int) (folderChildTextSizePx * folderLabelTextScale));
Jordan Silva999dd2a2023-11-17 19:31:43 +00001589 return;
1590 }
1591
1592 float invIconSizeDp = inv.iconSize[mTypeIndex];
1593 float invIconTextSizeDp = inv.iconTextSize[mTypeIndex];
1594 folderChildIconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mMetrics, scale));
1595 folderChildTextSizePx = pxFromSp(invIconTextSizeDp, mMetrics, scale);
1596 folderLabelTextSizePx = Math.max(minLabelTextSize,
1597 (int) (folderChildTextSizePx * folderLabelTextScale));
1598 int textHeight = Utilities.calculateTextHeight(folderChildTextSizePx);
1599
1600 if (mIsScalableGrid) {
Thales Limab35faed2022-09-05 16:30:01 -03001601 if (inv.folderStyle == INVALID_RESOURCE_HANDLE) {
Thales Lima7eee74b2023-03-16 16:00:55 -03001602 folderCellWidthPx = roundPxValueFromFloat(getCellSize().x * scale);
1603 folderCellHeightPx = roundPxValueFromFloat(getCellSize().y * scale);
1604 } else {
1605 folderCellWidthPx = roundPxValueFromFloat(folderCellWidthPx * scale);
1606 folderCellHeightPx = roundPxValueFromFloat(folderCellHeightPx * scale);
Thales Limab35faed2022-09-05 16:30:01 -03001607 }
Charlie Anderson7bb10972023-11-22 13:35:30 -08001608 // Recalculating padding and cell height
1609 folderChildDrawablePaddingPx = getNormalizedFolderChildDrawablePaddingPx(textHeight);
1610
1611 CellContentDimensions cellContentDimensions = new CellContentDimensions(
1612 folderChildIconSizePx,
1613 folderChildDrawablePaddingPx,
1614 folderChildTextSizePx);
1615 cellContentDimensions.resizeToFitCellHeight(folderCellHeightPx, mIconSizeSteps);
1616 folderChildIconSizePx = cellContentDimensions.getIconSizePx();
1617 folderChildDrawablePaddingPx = cellContentDimensions.getIconDrawablePaddingPx();
1618 folderChildTextSizePx = cellContentDimensions.getIconTextSizePx();
Jon Mirandaf33f5b32021-07-22 17:15:31 -07001619
Thales Lima7eee74b2023-03-16 16:00:55 -03001620 folderContentPaddingTop = roundPxValueFromFloat(folderContentPaddingTop * scale);
Jordan Silva637f4eb2023-06-13 11:21:53 +01001621 folderCellLayoutBorderSpacePx = new Point(
1622 roundPxValueFromFloat(folderCellLayoutBorderSpacePx.x * scale),
1623 roundPxValueFromFloat(folderCellLayoutBorderSpacePx.y * scale)
1624 );
Thales Lima7eee74b2023-03-16 16:00:55 -03001625 folderFooterHeightPx = roundPxValueFromFloat(folderFooterHeightPx * scale);
Jordan Silva637f4eb2023-06-13 11:21:53 +01001626 folderContentPaddingLeftRight = folderCellLayoutBorderSpacePx.x;
Jon Miranda823da222021-03-23 08:08:45 -04001627 } else {
1628 int cellPaddingX = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_x_padding)
1629 * scale);
1630 int cellPaddingY = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_y_padding)
1631 * scale);
1632
1633 folderCellWidthPx = folderChildIconSizePx + 2 * cellPaddingX;
1634 folderCellHeightPx = folderChildIconSizePx + 2 * cellPaddingY + textHeight;
Thales Lima7eee74b2023-03-16 16:00:55 -03001635 folderContentPaddingTop = roundPxValueFromFloat(folderContentPaddingTop * scale);
Thales Limab35faed2022-09-05 16:30:01 -03001636 folderContentPaddingLeftRight =
1637 res.getDimensionPixelSize(R.dimen.folder_content_padding_left_right);
1638 folderFooterHeightPx =
Thales Lima7eee74b2023-03-16 16:00:55 -03001639 roundPxValueFromFloat(
1640 res.getDimensionPixelSize(R.dimen.folder_footer_height_default)
1641 * scale);
1642
Jordan Silva12fae112023-06-26 12:51:01 +01001643 folderChildDrawablePaddingPx = getNormalizedFolderChildDrawablePaddingPx(textHeight);
Jon Miranda823da222021-03-23 08:08:45 -04001644 }
Jon Mirandabf7d8122016-11-03 15:29:29 -07001645 }
1646
Winson1f064272016-07-18 17:18:02 -07001647 public void updateInsets(Rect insets) {
1648 mInsets.set(insets);
1649 }
1650
Sunny Goyalae6e3182019-04-30 12:04:37 -07001651 /**
1652 * The current device insets. This is generally same as the insets being dispatched to
1653 * {@link Insettable} elements, but can differ if the element is using a different profile.
1654 */
Sunny Goyal1a52ef52018-01-11 10:15:03 -08001655 public Rect getInsets() {
1656 return mInsets;
1657 }
1658
Sunny Goyal756cd262015-08-20 12:33:21 -07001659 public Point getCellSize() {
Sunny Goyal19ff7282021-04-22 10:12:54 -07001660 return getCellSize(null);
Jon Miranda6f7e9702019-09-16 14:44:14 -07001661 }
1662
Sunny Goyal19ff7282021-04-22 10:12:54 -07001663 public Point getCellSize(Point result) {
1664 if (result == null) {
1665 result = new Point();
1666 }
Thales Limad1df5fc2021-09-03 18:37:19 +01001667
Pat Manning25d53342022-05-10 09:58:49 +00001668 int shortcutAndWidgetContainerWidth =
1669 getCellLayoutWidth() - (cellLayoutPaddingPx.left + cellLayoutPaddingPx.right);
1670 result.x = calculateCellWidth(shortcutAndWidgetContainerWidth, cellLayoutBorderSpacePx.x,
1671 inv.numColumns);
1672 int shortcutAndWidgetContainerHeight =
1673 getCellLayoutHeight() - (cellLayoutPaddingPx.top + cellLayoutPaddingPx.bottom);
1674 result.y = calculateCellHeight(shortcutAndWidgetContainerHeight, cellLayoutBorderSpacePx.y,
1675 inv.numRows);
Sunny Goyal3e8a04b2022-05-09 19:31:45 +00001676 return result;
Pat Manningb45d6c42022-05-03 14:32:06 +01001677 }
1678
1679 /**
Thales Lima1e8b45f2022-08-25 11:50:59 -04001680 * Returns the left and right space on the cell, which is the cell width - icon size
1681 */
1682 public int getCellHorizontalSpace() {
1683 return getCellSize().x - iconSizePx;
1684 }
1685
1686 /**
Pat Manning25d53342022-05-10 09:58:49 +00001687 * Gets the number of panels within the workspace.
1688 */
1689 public int getPanelCount() {
1690 return isTwoPanels ? 2 : 1;
1691 }
1692
1693 /**
Pat Manningde25c0d2022-04-05 19:11:26 +01001694 * Gets the space in px from the bottom of last item in the vertical-bar hotseat to the
1695 * bottom of the screen.
1696 */
Pat Manning5f74bfd2022-07-20 12:08:54 +01001697 private int getVerticalHotseatLastItemBottomOffset(Context context) {
1698 Rect hotseatBarPadding = getHotseatLayoutPadding(context);
Pat Manningde25c0d2022-04-05 19:11:26 +01001699 int cellHeight = calculateCellHeight(
Pat Manning5f74bfd2022-07-20 12:08:54 +01001700 heightPx - hotseatBarPadding.top - hotseatBarPadding.bottom, hotseatBorderSpace,
Pat Manningde25c0d2022-04-05 19:11:26 +01001701 numShownHotseatIcons);
Pat Manningde25c0d2022-04-05 19:11:26 +01001702 int extraIconEndSpacing = (cellHeight - iconSizePx) / 2;
Pat Manning5f74bfd2022-07-20 12:08:54 +01001703 return extraIconEndSpacing + hotseatBarPadding.bottom;
Pat Manningde25c0d2022-04-05 19:11:26 +01001704 }
1705
1706 /**
1707 * Gets the scaled top of the workspace in px for the spring-loaded edit state.
1708 */
Pat Manning25d53342022-05-10 09:58:49 +00001709 public float getCellLayoutSpringLoadShrunkTop() {
Pat Manning5f74bfd2022-07-20 12:08:54 +01001710 return mInsets.top + dropTargetBarTopMarginPx + dropTargetBarSizePx
Pat Manningde25c0d2022-04-05 19:11:26 +01001711 + dropTargetBarBottomMarginPx;
Pat Manningde25c0d2022-04-05 19:11:26 +01001712 }
1713
1714 /**
1715 * Gets the scaled bottom of the workspace in px for the spring-loaded edit state.
1716 */
Pat Manning5f74bfd2022-07-20 12:08:54 +01001717 public float getCellLayoutSpringLoadShrunkBottom(Context context) {
Pat Manningde25c0d2022-04-05 19:11:26 +01001718 int topOfHotseat = hotseatBarSizePx + springLoadedHotseatBarTopMarginPx;
Pat Manning5f74bfd2022-07-20 12:08:54 +01001719 return heightPx - (isVerticalBarLayout()
1720 ? getVerticalHotseatLastItemBottomOffset(context) : topOfHotseat);
Pat Manningde25c0d2022-04-05 19:11:26 +01001721 }
1722
Pat Manningea5c1d22022-04-14 10:58:16 +01001723 /**
Pat Manninga2e14992022-04-22 11:29:17 +01001724 * Gets the scale of the workspace for the spring-loaded edit state.
1725 */
Pat Manning5f74bfd2022-07-20 12:08:54 +01001726 public float getWorkspaceSpringLoadScale(Context context) {
1727 float scale =
1728 (getCellLayoutSpringLoadShrunkBottom(context) - getCellLayoutSpringLoadShrunkTop())
1729 / getCellLayoutHeight();
Pat Manninga2e14992022-04-22 11:29:17 +01001730 scale = Math.min(scale, 1f);
1731
Pat Manninge63dd252022-08-02 16:15:29 +01001732 // Reduce scale if next pages would not be visible after scaling the workspace.
Pat Manning25d53342022-05-10 09:58:49 +00001733 int workspaceWidth = availableWidthPx;
Pat Manninga2e14992022-04-22 11:29:17 +01001734 float scaledWorkspaceWidth = workspaceWidth * scale;
Alex Chau906d8822022-05-23 10:42:25 +01001735 float maxAvailableWidth = workspaceWidth - (2 * workspaceSpringLoadedMinNextPageVisiblePx);
Pat Manninga2e14992022-04-22 11:29:17 +01001736 if (scaledWorkspaceWidth > maxAvailableWidth) {
1737 scale *= maxAvailableWidth / scaledWorkspaceWidth;
1738 }
1739 return scale;
1740 }
1741
Pat Manning25d53342022-05-10 09:58:49 +00001742 /**
1743 * Gets the width of a single Cell Layout, aka a single panel within a Workspace.
1744 *
1745 * <p>This is the width of a Workspace, less its horizontal padding. Note that two-panel
1746 * layouts have two Cell Layouts per workspace.
1747 */
1748 public int getCellLayoutWidth() {
1749 return (availableWidthPx - getTotalWorkspacePadding().x) / getPanelCount();
Alex Chau60953332021-11-24 12:41:07 +00001750 }
1751
Pat Manning25d53342022-05-10 09:58:49 +00001752 /**
1753 * Gets the height of a single Cell Layout, aka a single panel within a Workspace.
1754 *
1755 * <p>This is the height of a Workspace, less its vertical padding.
1756 */
1757 public int getCellLayoutHeight() {
1758 return availableHeightPx - getTotalWorkspacePadding().y;
Pat Manning08610ca2022-04-05 21:03:16 +01001759 }
1760
Sunny Goyal6c2975e2016-07-06 09:47:56 -07001761 public Point getTotalWorkspacePadding() {
Sunny Goyal07b69292018-01-08 14:19:34 -08001762 return new Point(workspacePadding.left + workspacePadding.right,
1763 workspacePadding.top + workspacePadding.bottom);
Sunny Goyal6c2975e2016-07-06 09:47:56 -07001764 }
1765
1766 /**
Sunny Goyal07b69292018-01-08 14:19:34 -08001767 * Updates {@link #workspacePadding} as a result of any internal value change to reflect the
1768 * new workspace padding
Sunny Goyal6c2975e2016-07-06 09:47:56 -07001769 */
Sunny Goyal07b69292018-01-08 14:19:34 -08001770 private void updateWorkspacePadding() {
1771 Rect padding = workspacePadding;
Tony Wickham3a3517f2015-10-06 11:27:04 -07001772 if (isVerticalBarLayout()) {
Jordan Silva3646a1b2023-08-02 13:52:52 +01001773 if (mIsResponsiveGrid) {
Jordan Silva8f7986a2023-11-08 12:11:25 +00001774 padding.top = mResponsiveWorkspaceHeightSpec.getStartPaddingPx();
Thales Lima8e11d532023-08-31 13:40:26 +00001775 padding.bottom = Math.max(0,
Jordan Silva8f7986a2023-11-08 12:11:25 +00001776 mResponsiveWorkspaceHeightSpec.getEndPaddingPx() - mInsets.bottom);
Jordan Silva3646a1b2023-08-02 13:52:52 +01001777 if (isSeascape()) {
Jordan Silva8f7986a2023-11-08 12:11:25 +00001778 padding.left =
1779 hotseatBarSizePx + mResponsiveWorkspaceWidthSpec.getEndPaddingPx();
1780 padding.right = mResponsiveWorkspaceWidthSpec.getStartPaddingPx();
Jordan Silva3646a1b2023-08-02 13:52:52 +01001781 } else {
Jordan Silva8f7986a2023-11-08 12:11:25 +00001782 padding.left = mResponsiveWorkspaceWidthSpec.getStartPaddingPx();
1783 padding.right =
1784 hotseatBarSizePx + mResponsiveWorkspaceWidthSpec.getEndPaddingPx();
Jordan Silva3646a1b2023-08-02 13:52:52 +01001785 }
Winson1f064272016-07-18 17:18:02 -07001786 } else {
Jordan Silva3646a1b2023-08-02 13:52:52 +01001787 padding.top = 0;
1788 padding.bottom = edgeMarginPx;
1789 if (isSeascape()) {
1790 padding.left = hotseatBarSizePx;
Thales Lima8e11d532023-08-31 13:40:26 +00001791 padding.right = mHotseatBarEdgePaddingPx;
Jordan Silva3646a1b2023-08-02 13:52:52 +01001792 } else {
Thales Lima8e11d532023-08-31 13:40:26 +00001793 padding.left = mHotseatBarEdgePaddingPx;
Jordan Silva3646a1b2023-08-02 13:52:52 +01001794 padding.right = hotseatBarSizePx;
1795 }
Winson1f064272016-07-18 17:18:02 -07001796 }
Winson Chungb3800242013-10-24 11:01:54 -07001797 } else {
Thales Limab8c05952022-05-23 16:58:38 +01001798 // Pad the bottom of the workspace with hotseat bar
1799 // and leave a bit of space in case a widget go all the way down
Thales Lima79456492023-05-23 11:32:22 +01001800 int paddingBottom = hotseatBarSizePx + workspaceBottomPadding - mInsets.bottom;
1801 if (!mIsResponsiveGrid) {
1802 paddingBottom +=
1803 workspacePageIndicatorHeight - mWorkspacePageIndicatorOverlapWorkspace;
1804 }
1805 int paddingTop = workspaceTopPadding + (mIsScalableGrid ? 0 : edgeMarginPx);
Pat Manning08610ca2022-04-05 21:03:16 +01001806 int paddingSide = desiredWorkspaceHorizontalMarginPx;
Andras Kloczl8e57cce2021-02-11 23:51:19 +01001807
Pat Manning08610ca2022-04-05 21:03:16 +01001808 padding.set(paddingSide, paddingTop, paddingSide, paddingBottom);
Winson Chungb3800242013-10-24 11:01:54 -07001809 }
Pat Manning08610ca2022-04-05 21:03:16 +01001810 insetPadding(workspacePadding, cellLayoutPaddingPx);
1811 }
1812
1813 private void insetPadding(Rect paddings, Rect insets) {
1814 insets.left = Math.min(insets.left, paddings.left);
1815 paddings.left -= insets.left;
1816
1817 insets.top = Math.min(insets.top, paddings.top);
1818 paddings.top -= insets.top;
1819
1820 insets.right = Math.min(insets.right, paddings.right);
1821 paddings.right -= insets.right;
1822
1823 insets.bottom = Math.min(insets.bottom, paddings.bottom);
1824 paddings.bottom -= insets.bottom;
Winson Chungb3800242013-10-24 11:01:54 -07001825 }
1826
Liran Binyamina833af32023-08-02 16:30:27 -04001827
1828 /**
1829 * Returns the new border space that should be used between hotseat icons after adjusting it to
1830 * the bubble bar.
1831 *
1832 * <p>If there's no adjustment needed, this method returns {@code 0}.
1833 */
1834 public float getHotseatAdjustedBorderSpaceForBubbleBar(Context context) {
1835 // only need to adjust when QSB is on top of the hotseat.
1836 if (isQsbInline) {
1837 return 0;
1838 }
1839
1840 // no need to adjust if there's enough space for the bubble bar to the right of the hotseat.
1841 if (getHotseatLayoutPadding(context).right > mBubbleBarSpaceThresholdPx) {
1842 return 0;
1843 }
1844
1845 // The adjustment is shrinking the hotseat's width by 1 icon on either side.
1846 int iconsWidth =
1847 iconSizePx * numShownHotseatIcons + hotseatBorderSpace * (numShownHotseatIcons - 1);
1848 int newWidth = iconsWidth - 2 * iconSizePx;
1849 // Evenly space the icons within the boundaries of the new width.
1850 return (float) (newWidth - iconSizePx * numShownHotseatIcons) / (numShownHotseatIcons - 1);
1851 }
1852
Sunny Goyal57b22792021-05-25 14:35:01 -07001853 /**
1854 * Returns the padding for hotseat view
1855 */
1856 public Rect getHotseatLayoutPadding(Context context) {
Pat Manning5f74bfd2022-07-20 12:08:54 +01001857 Rect hotseatBarPadding = new Rect();
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001858 if (isVerticalBarLayout()) {
Sihua Ma38bb3b02022-03-21 22:20:14 -07001859 // The hotseat icons will be placed in the middle of the hotseat cells.
1860 // Changing the hotseatCellHeightPx is not affecting hotseat icon positions
1861 // in vertical bar layout.
fbaronfc6bbcf2024-01-29 10:35:17 -08001862 int paddingTop = Math.max((int) (mInsets.top + cellLayoutPaddingPx.top), 0);
1863 int paddingBottom = Math.max((int) (mInsets.bottom + cellLayoutPaddingPx.bottom), 0);
Sihua Ma38bb3b02022-03-21 22:20:14 -07001864
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001865 if (isSeascape()) {
Thales Lima8e11d532023-08-31 13:40:26 +00001866 hotseatBarPadding.set(mInsets.left + mHotseatBarEdgePaddingPx, paddingTop,
1867 mHotseatBarWorkspaceSpacePx, paddingBottom);
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001868 } else {
Thales Lima8e11d532023-08-31 13:40:26 +00001869 hotseatBarPadding.set(mHotseatBarWorkspaceSpacePx, paddingTop,
1870 mInsets.right + mHotseatBarEdgePaddingPx, paddingBottom);
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001871 }
Sunny Goyal57b22792021-05-25 14:35:01 -07001872 } else if (isTaskbarPresent) {
Alex Chau51da2192022-05-20 13:32:10 +01001873 // Center the QSB vertically with hotseat
Thales Limab8c05952022-05-23 16:58:38 +01001874 int hotseatBarBottomPadding = getHotseatBarBottomPadding();
1875 int hotseatBarTopPadding =
1876 hotseatBarSizePx - hotseatBarBottomPadding - hotseatCellHeightPx;
Alex Chau51da2192022-05-20 13:32:10 +01001877
Thales Lima6a590062022-11-22 15:52:49 +00001878 int hotseatWidth = getHotseatRequiredWidth();
Helen Cheuke76291f2023-02-14 17:11:05 +00001879 int startSpacing;
1880 int endSpacing;
Thales Lima6a590062022-11-22 15:52:49 +00001881 // Hotseat aligns to the left with nav buttons
1882 if (hotseatBarEndOffset > 0) {
Jon Mirandae17a9492023-03-08 16:42:20 -08001883 startSpacing = inlineNavButtonsEndSpacingPx;
Helen Cheuke76291f2023-02-14 17:11:05 +00001884 endSpacing = availableWidthPx - hotseatWidth - startSpacing + hotseatBorderSpace;
1885 } else {
1886 startSpacing = (availableWidthPx - hotseatWidth) / 2;
1887 endSpacing = startSpacing;
Thales Lima6a590062022-11-22 15:52:49 +00001888 }
Helen Cheuke76291f2023-02-14 17:11:05 +00001889 startSpacing += getAdditionalQsbSpace();
Thales Lima612230d2022-03-31 18:04:37 +01001890
Helen Cheuke76291f2023-02-14 17:11:05 +00001891 hotseatBarPadding.top = hotseatBarTopPadding;
1892 hotseatBarPadding.bottom = hotseatBarBottomPadding;
Alex Chau51da2192022-05-20 13:32:10 +01001893 boolean isRtl = Utilities.isRtl(context.getResources());
Thales Lima612230d2022-03-31 18:04:37 +01001894 if (isRtl) {
Helen Cheuke76291f2023-02-14 17:11:05 +00001895 hotseatBarPadding.left = endSpacing;
1896 hotseatBarPadding.right = startSpacing;
Thales Lima612230d2022-03-31 18:04:37 +01001897 } else {
Helen Cheuke76291f2023-02-14 17:11:05 +00001898 hotseatBarPadding.left = startSpacing;
1899 hotseatBarPadding.right = endSpacing;
Thales Lima612230d2022-03-31 18:04:37 +01001900 }
Helen Cheuke76291f2023-02-14 17:11:05 +00001901
Thales Lima79456492023-05-23 11:32:22 +01001902 } else if (mIsScalableGrid) {
fbarone69b6f42023-12-18 13:20:34 -08001903 int iconExtraSpacePx = iconSizePx - getIconVisibleSizePx(iconSizePx);
1904 int sideSpacing = (availableWidthPx - (hotseatQsbWidth + iconExtraSpacePx)) / 2;
Pat Manning5f74bfd2022-07-20 12:08:54 +01001905 hotseatBarPadding.set(sideSpacing,
Thales Limab8c05952022-05-23 16:58:38 +01001906 0,
Thales Lima425f6822022-05-10 13:44:58 -03001907 sideSpacing,
Thales Limab8c05952022-05-23 16:58:38 +01001908 getHotseatBarBottomPadding());
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001909 } else {
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001910 // We want the edges of the hotseat to line up with the edges of the workspace, but the
1911 // icons in the hotseat are a different size, and so don't line up perfectly. To account
1912 // for this, we pad the left and right of the hotseat with half of the difference of a
1913 // workspace cell vs a hotseat cell.
1914 float workspaceCellWidth = (float) widthPx / inv.numColumns;
Sunny Goyal19ff7282021-04-22 10:12:54 -07001915 float hotseatCellWidth = (float) widthPx / numShownHotseatIcons;
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001916 int hotseatAdjustment = Math.round((workspaceCellWidth - hotseatCellWidth) / 2);
Pat Manning5f74bfd2022-07-20 12:08:54 +01001917 hotseatBarPadding.set(
Thales Limab8c05952022-05-23 16:58:38 +01001918 hotseatAdjustment + workspacePadding.left + cellLayoutPaddingPx.left
1919 + mInsets.left,
1920 0,
Pat Manning08610ca2022-04-05 21:03:16 +01001921 hotseatAdjustment + workspacePadding.right + cellLayoutPaddingPx.right
Sunny Goyal786940a2020-06-02 02:31:31 -07001922 + mInsets.right,
Thales Limab8c05952022-05-23 16:58:38 +01001923 getHotseatBarBottomPadding());
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001924 }
Pat Manning5f74bfd2022-07-20 12:08:54 +01001925 return hotseatBarPadding;
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001926 }
1927
Andy Wickhambd9a1802023-06-08 16:33:15 -07001928 /** The margin between the edge of all apps and the edge of the first icon. */
Thales Limab433c9c2023-10-30 12:24:05 +00001929 public int getAllAppsIconStartMargin(Context context) {
Andy Wickhambd9a1802023-06-08 16:33:15 -07001930 int allAppsSpacing;
1931 if (isVerticalBarLayout()) {
1932 // On phones, the landscape layout uses a different setup.
1933 allAppsSpacing = workspacePadding.left + workspacePadding.right;
1934 } else {
Thales Limab433c9c2023-10-30 12:24:05 +00001935 allAppsSpacing =
1936 allAppsPadding.left + allAppsPadding.right + allAppsLeftRightMargin * 2;
Andy Wickhambd9a1802023-06-08 16:33:15 -07001937 }
1938
1939 int cellWidth = DeviceProfile.calculateCellWidth(
1940 availableWidthPx - allAppsSpacing,
1941 0 /* borderSpace */,
1942 numShownAllAppsColumns);
fbarone69b6f42023-12-18 13:20:34 -08001943 int iconAlignmentMargin = (cellWidth - getIconVisibleSizePx(allAppsIconSizePx)) / 2;
Thales Limab433c9c2023-10-30 12:24:05 +00001944
1945 return (Utilities.isRtl(context.getResources()) ? allAppsPadding.right
1946 : allAppsPadding.left) + iconAlignmentMargin;
Andy Wickhambd9a1802023-06-08 16:33:15 -07001947 }
1948
fbarone69b6f42023-12-18 13:20:34 -08001949 /**
1950 * TODO(b/235886078): workaround needed because of this bug
1951 * Icons are 10% larger on XML than their visual size, so remove that extra space to get
1952 * some dimensions correct.
1953 *
1954 * When this bug is resolved this method will no longer be needed and we would be able to
1955 * replace all instances where this method is called with iconSizePx.
1956 */
1957 private int getIconVisibleSizePx(int iconSizePx) {
1958 return Math.round(ICON_VISIBLE_AREA_FACTOR * iconSizePx);
1959 }
1960
Thales Lima9938c2f2022-07-25 14:38:16 +01001961 private int getAdditionalQsbSpace() {
1962 return isQsbInline ? hotseatQsbWidth + hotseatBorderSpace : 0;
1963 }
1964
1965 /**
1966 * Calculate how much space the hotseat needs to be shown completely
1967 */
1968 private int getHotseatRequiredWidth() {
1969 int additionalQsbSpace = getAdditionalQsbSpace();
1970 return iconSizePx * numShownHotseatIcons
Thales Lima6a590062022-11-22 15:52:49 +00001971 + hotseatBorderSpace * (numShownHotseatIcons - (areNavButtonsInline ? 0 : 1))
Thales Lima9938c2f2022-07-25 14:38:16 +01001972 + additionalQsbSpace;
1973 }
1974
Winsonfadbe8f2016-07-22 16:35:37 -07001975 /**
Sunny Goyal57b22792021-05-25 14:35:01 -07001976 * Returns the number of pixels the QSB is translated from the bottom of the screen.
1977 */
1978 public int getQsbOffsetY() {
Thales Limaa1012902022-01-13 17:58:42 +00001979 if (isQsbInline) {
Thales Limab8c05952022-05-23 16:58:38 +01001980 return getHotseatBarBottomPadding() - ((hotseatQsbHeight - hotseatCellHeightPx) / 2);
1981 } else if (isTaskbarPresent) { // QSB on top
1982 return hotseatBarSizePx - hotseatQsbHeight + hotseatQsbShadowHeight;
Jonathan Miranda8f16a772021-07-23 23:10:37 +00001983 } else {
Thales Limab8c05952022-05-23 16:58:38 +01001984 return hotseatBarBottomSpacePx - hotseatQsbShadowHeight;
Jonathan Miranda7a273e22021-06-24 21:29:10 +00001985 }
Sunny Goyal57b22792021-05-25 14:35:01 -07001986 }
1987
Thales Limab8c05952022-05-23 16:58:38 +01001988 /**
1989 * Returns the number of pixels the hotseat is translated from the bottom of the screen.
1990 */
1991 private int getHotseatBarBottomPadding() {
1992 if (isTaskbarPresent) { // QSB on top or inline
1993 return hotseatBarBottomSpacePx - (Math.abs(hotseatCellHeightPx - iconSizePx) / 2);
Thales Limaa1012902022-01-13 17:58:42 +00001994 } else {
Thales Limab8c05952022-05-23 16:58:38 +01001995 return hotseatBarSizePx - hotseatCellHeightPx;
Thales Limaa1012902022-01-13 17:58:42 +00001996 }
Sunny Goyal57b22792021-05-25 14:35:01 -07001997 }
1998
1999 /**
Alex Chau51da2192022-05-20 13:32:10 +01002000 * Returns the number of pixels the taskbar is translated from the bottom of the screen.
2001 */
2002 public int getTaskbarOffsetY() {
Jon Miranda9c478b62023-03-23 21:38:49 -07002003 int taskbarIconBottomSpace = (taskbarHeight - iconSizePx) / 2;
Alex Chau51da2192022-05-20 13:32:10 +01002004 int launcherIconBottomSpace =
2005 Math.min((hotseatCellHeightPx - iconSizePx) / 2, gridVisualizationPaddingY);
Thales Limab8c05952022-05-23 16:58:38 +01002006 return getHotseatBarBottomPadding() + launcherIconBottomSpace - taskbarIconBottomSpace;
Alex Chau51da2192022-05-20 13:32:10 +01002007 }
2008
Uwais Ashrafaa7fa882023-10-10 21:36:06 +00002009 /** Returns the number of pixels required below OverviewActions. */
Alex Chaua2fc7642022-04-21 14:20:23 +01002010 public int getOverviewActionsClaimedSpaceBelow() {
Uwais Ashrafaa7fa882023-10-10 21:36:06 +00002011 return isTaskbarPresent ? mTransientTaskbarClaimedSpace : mInsets.bottom;
Alex Chaua2fc7642022-04-21 14:20:23 +01002012 }
2013
2014 /** Gets the space that the overview actions will take, including bottom margin. */
2015 public int getOverviewActionsClaimedSpace() {
Alex Chau4989f4f2023-10-11 14:08:22 +00002016 int overviewActionsSpace = isTablet && Flags.enableGridOnlyOverview()
Pat Manning7b8f7662023-01-18 14:48:30 +00002017 ? 0
2018 : (overviewActionsTopMarginPx + overviewActionsHeight);
2019 return overviewActionsSpace + getOverviewActionsClaimedSpaceBelow();
Alex Chaua2fc7642022-04-21 14:20:23 +01002020 }
2021
2022 /**
Sihua Mae04aa202022-07-18 12:43:56 -07002023 * Takes the View and return the scales of width and height depending on the DeviceProfile
2024 * specifications
2025 *
2026 * @param itemInfo The tag of the widget view
2027 * @return A PointF instance with the x set to be the scale of width, and y being the scale of
2028 * height
2029 */
2030 @NonNull
2031 public PointF getAppWidgetScale(@Nullable final ItemInfo itemInfo) {
2032 return mViewScaleProvider.getScaleFromItemInfo(itemInfo);
2033 }
2034
2035 /**
Winsonfadbe8f2016-07-22 16:35:37 -07002036 * @return the bounds for which the open folders should be contained within
2037 */
2038 public Rect getAbsoluteOpenFolderBounds() {
2039 if (isVerticalBarLayout()) {
2040 // Folders should only appear right of the drop target bar and left of the hotseat
2041 return new Rect(mInsets.left + dropTargetBarSizePx + edgeMarginPx,
2042 mInsets.top,
Jon Miranda18751b62017-07-31 17:25:27 -07002043 mInsets.left + availableWidthPx - hotseatBarSizePx - edgeMarginPx,
Winsonfadbe8f2016-07-22 16:35:37 -07002044 mInsets.top + availableHeightPx);
2045 } else {
2046 // Folders should only appear below the drop target bar and above the hotseat
Jon Miranda9c478b62023-03-23 21:38:49 -07002047 int hotseatTop = isTaskbarPresent ? taskbarHeight : hotseatBarSizePx;
Tony Wickhamb4b7e202018-01-12 17:39:24 -08002048 return new Rect(mInsets.left + edgeMarginPx,
Winsonfadbe8f2016-07-22 16:35:37 -07002049 mInsets.top + dropTargetBarSizePx + edgeMarginPx,
Tony Wickhamb4b7e202018-01-12 17:39:24 -08002050 mInsets.left + availableWidthPx - edgeMarginPx,
Tony Wickhamae72b462021-03-10 16:18:40 -08002051 mInsets.top + availableHeightPx - hotseatTop
Tony Wickham5edf9e22020-03-27 20:06:52 -07002052 - workspacePageIndicatorHeight - edgeMarginPx);
Winsonfadbe8f2016-07-22 16:35:37 -07002053 }
2054 }
2055
Jon Miranda228877d2021-02-09 11:05:00 -05002056 public static int calculateCellWidth(int width, int borderSpacing, int countX) {
2057 return (width - ((countX - 1) * borderSpacing)) / countX;
Winson Chungb3800242013-10-24 11:01:54 -07002058 }
Pierre Barbier de Reuille578deba2021-09-24 13:47:44 +01002059
Jon Miranda228877d2021-02-09 11:05:00 -05002060 public static int calculateCellHeight(int height, int borderSpacing, int countY) {
2061 return (height - ((countY - 1) * borderSpacing)) / countY;
Winson Chungb3800242013-10-24 11:01:54 -07002062 }
2063
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -07002064 /**
Tony Wickham55616cd2015-09-23 14:55:17 -07002065 * When {@code true}, the device is in landscape mode and the hotseat is on the right column.
2066 * When {@code false}, either device is in portrait mode or the device is in landscape mode and
2067 * the hotseat is on the bottom row.
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -07002068 */
Tony Wickhamab946a12015-09-16 15:38:16 -07002069 public boolean isVerticalBarLayout() {
Winson Chungb3800242013-10-24 11:01:54 -07002070 return isLandscape && transposeLayoutWithOrientation;
2071 }
2072
Sunny Goyal7e2e67f2018-01-26 13:40:08 -08002073 public boolean isSeascape() {
Riddle Hsua3c17fc2024-08-01 16:36:39 +08002074 return rotationHint == Surface.ROTATION_270 && isVerticalBarLayout();
Sunny Goyal7e2e67f2018-01-26 13:40:08 -08002075 }
2076
Sunny Goyal07b69292018-01-08 14:19:34 -08002077 public boolean shouldFadeAdjacentWorkspaceScreens() {
Sunny Goyal19ff7282021-04-22 10:12:54 -07002078 return isVerticalBarLayout();
Winson Chungb3800242013-10-24 11:01:54 -07002079 }
2080
Jon Miranda92c1b5d2021-07-20 13:57:16 -07002081 public int getCellContentHeight(@ContainerType int containerType) {
Sunny Goyalc13403c2016-11-18 23:44:48 -08002082 switch (containerType) {
2083 case CellLayout.WORKSPACE:
2084 return cellHeightPx;
2085 case CellLayout.FOLDER:
2086 return folderCellHeightPx;
2087 case CellLayout.HOTSEAT:
Jon Miranda92c1b5d2021-07-20 13:57:16 -07002088 // The hotseat is the only container where the cell height is going to be
2089 // different from the content within that cell.
2090 return iconSizePx;
Sunny Goyalc13403c2016-11-18 23:44:48 -08002091 default:
2092 // ??
2093 return 0;
2094 }
2095 }
Sunny Goyal13178ac2016-04-04 16:35:22 -07002096
Jon Miranda58561d42021-03-17 10:51:54 -04002097 private String pxToDpStr(String name, float value) {
Sunny Goyal35c7b192021-04-20 16:51:10 -07002098 return "\t" + name + ": " + value + "px (" + dpiFromPx(value, mMetrics.densityDpi) + "dp)";
Jon Miranda58561d42021-03-17 10:51:54 -04002099 }
2100
Alex Chaue818bcb2022-09-02 17:27:11 +01002101 private String dpPointFToString(String name, PointF value) {
2102 return String.format(Locale.ENGLISH, "\t%s: PointF(%.1f, %.1f)dp", name, value.x, value.y);
2103 }
2104
Pat Manning5f74bfd2022-07-20 12:08:54 +01002105 /** Dumps various DeviceProfile variables to the specified writer. */
2106 public void dump(Context context, String prefix, PrintWriter writer) {
Jon Miranda58561d42021-03-17 10:51:54 -04002107 writer.println(prefix + "DeviceProfile:");
Sunny Goyal35c7b192021-04-20 16:51:10 -07002108 writer.println(prefix + "\t1 dp = " + mMetrics.density + " px");
Jon Miranda58561d42021-03-17 10:51:54 -04002109
2110 writer.println(prefix + "\tisTablet:" + isTablet);
Jon Miranda58561d42021-03-17 10:51:54 -04002111 writer.println(prefix + "\tisPhone:" + isPhone);
2112 writer.println(prefix + "\ttransposeLayoutWithOrientation:"
2113 + transposeLayoutWithOrientation);
Alex Chau6ed408f2022-03-04 12:58:05 +00002114 writer.println(prefix + "\tisGestureMode:" + isGestureMode);
Jon Miranda58561d42021-03-17 10:51:54 -04002115
2116 writer.println(prefix + "\tisLandscape:" + isLandscape);
2117 writer.println(prefix + "\tisMultiWindowMode:" + isMultiWindowMode);
Sunny Goyal19ff7282021-04-22 10:12:54 -07002118 writer.println(prefix + "\tisTwoPanels:" + isTwoPanels);
Winson Chung104a4c82023-11-08 18:56:15 +00002119 writer.println(prefix + "\tisLeftRightSplit:" + isLeftRightSplit);
Jon Miranda58561d42021-03-17 10:51:54 -04002120
2121 writer.println(prefix + pxToDpStr("windowX", windowX));
2122 writer.println(prefix + pxToDpStr("windowY", windowY));
2123 writer.println(prefix + pxToDpStr("widthPx", widthPx));
2124 writer.println(prefix + pxToDpStr("heightPx", heightPx));
Jon Miranda58561d42021-03-17 10:51:54 -04002125 writer.println(prefix + pxToDpStr("availableWidthPx", availableWidthPx));
2126 writer.println(prefix + pxToDpStr("availableHeightPx", availableHeightPx));
Alex Chaue0227552022-04-06 19:44:43 +01002127 writer.println(prefix + pxToDpStr("mInsets.left", mInsets.left));
2128 writer.println(prefix + pxToDpStr("mInsets.top", mInsets.top));
2129 writer.println(prefix + pxToDpStr("mInsets.right", mInsets.right));
2130 writer.println(prefix + pxToDpStr("mInsets.bottom", mInsets.bottom));
Jon Miranda58561d42021-03-17 10:51:54 -04002131
2132 writer.println(prefix + "\taspectRatio:" + aspectRatio);
2133
Thales Limac98b7812023-04-14 15:04:23 +01002134 writer.println(prefix + "\tisResponsiveGrid:" + mIsResponsiveGrid);
Thales Lima79456492023-05-23 11:32:22 +01002135 writer.println(prefix + "\tisScalableGrid:" + mIsScalableGrid);
Jon Miranda58561d42021-03-17 10:51:54 -04002136
Thales Lima83bedbf2021-10-05 17:47:39 +01002137 writer.println(prefix + "\tinv.numRows: " + inv.numRows);
Alex Chau9fee3fd2021-12-01 18:43:10 +00002138 writer.println(prefix + "\tinv.numColumns: " + inv.numColumns);
2139 writer.println(prefix + "\tinv.numSearchContainerColumns: "
2140 + inv.numSearchContainerColumns);
Jon Miranda58561d42021-03-17 10:51:54 -04002141
Alex Chaue818bcb2022-09-02 17:27:11 +01002142 writer.println(prefix + dpPointFToString("minCellSize", inv.minCellSize[mTypeIndex]));
Jon Mirandaab3c6812021-06-28 15:42:28 -07002143
Jon Miranda58561d42021-03-17 10:51:54 -04002144 writer.println(prefix + pxToDpStr("cellWidthPx", cellWidthPx));
2145 writer.println(prefix + pxToDpStr("cellHeightPx", cellHeightPx));
2146
2147 writer.println(prefix + pxToDpStr("getCellSize().x", getCellSize().x));
2148 writer.println(prefix + pxToDpStr("getCellSize().y", getCellSize().y));
2149
Thales Lima83bedbf2021-10-05 17:47:39 +01002150 writer.println(prefix + pxToDpStr("cellLayoutBorderSpacePx Horizontal",
2151 cellLayoutBorderSpacePx.x));
2152 writer.println(prefix + pxToDpStr("cellLayoutBorderSpacePx Vertical",
2153 cellLayoutBorderSpacePx.y));
Pat Manning5f74bfd2022-07-20 12:08:54 +01002154 writer.println(
2155 prefix + pxToDpStr("cellLayoutPaddingPx.left", cellLayoutPaddingPx.left));
2156 writer.println(
2157 prefix + pxToDpStr("cellLayoutPaddingPx.top", cellLayoutPaddingPx.top));
2158 writer.println(
2159 prefix + pxToDpStr("cellLayoutPaddingPx.right", cellLayoutPaddingPx.right));
Pat Manning08610ca2022-04-05 21:03:16 +01002160 writer.println(
2161 prefix + pxToDpStr("cellLayoutPaddingPx.bottom", cellLayoutPaddingPx.bottom));
Thales Lima83bedbf2021-10-05 17:47:39 +01002162
Jon Miranda58561d42021-03-17 10:51:54 -04002163 writer.println(prefix + pxToDpStr("iconSizePx", iconSizePx));
2164 writer.println(prefix + pxToDpStr("iconTextSizePx", iconTextSizePx));
2165 writer.println(prefix + pxToDpStr("iconDrawablePaddingPx", iconDrawablePaddingPx));
2166
Thales Lima1faa4ed2023-12-01 16:48:19 +00002167 writer.println(prefix + "\tnumFolderRows: " + numFolderRows);
2168 writer.println(prefix + "\tnumFolderColumns: " + numFolderColumns);
Jon Miranda58561d42021-03-17 10:51:54 -04002169 writer.println(prefix + pxToDpStr("folderCellWidthPx", folderCellWidthPx));
2170 writer.println(prefix + pxToDpStr("folderCellHeightPx", folderCellHeightPx));
2171 writer.println(prefix + pxToDpStr("folderChildIconSizePx", folderChildIconSizePx));
2172 writer.println(prefix + pxToDpStr("folderChildTextSizePx", folderChildTextSizePx));
2173 writer.println(prefix + pxToDpStr("folderChildDrawablePaddingPx",
2174 folderChildDrawablePaddingPx));
Jordan Silva637f4eb2023-06-13 11:21:53 +01002175 writer.println(prefix + pxToDpStr("folderCellLayoutBorderSpacePx.x",
2176 folderCellLayoutBorderSpacePx.x));
2177 writer.println(prefix + pxToDpStr("folderCellLayoutBorderSpacePx.y",
2178 folderCellLayoutBorderSpacePx.y));
Thales Limaa08a4432022-08-09 09:55:17 +01002179 writer.println(prefix + pxToDpStr("folderContentPaddingLeftRight",
2180 folderContentPaddingLeftRight));
2181 writer.println(prefix + pxToDpStr("folderTopPadding", folderContentPaddingTop));
Thales Limab35faed2022-09-05 16:30:01 -03002182 writer.println(prefix + pxToDpStr("folderFooterHeight", folderFooterHeightPx));
Jon Miranda58561d42021-03-17 10:51:54 -04002183
Alex Chaue0227552022-04-06 19:44:43 +01002184 writer.println(prefix + pxToDpStr("bottomSheetTopPadding", bottomSheetTopPadding));
Alex Chau3d2c0622022-09-01 21:28:14 +01002185 writer.println(prefix + "\tbottomSheetOpenDuration: " + bottomSheetOpenDuration);
2186 writer.println(prefix + "\tbottomSheetCloseDuration: " + bottomSheetCloseDuration);
2187 writer.println(prefix + "\tbottomSheetWorkspaceScale: " + bottomSheetWorkspaceScale);
2188 writer.println(prefix + "\tbottomSheetDepth: " + bottomSheetDepth);
Alex Chaue0227552022-04-06 19:44:43 +01002189
2190 writer.println(prefix + pxToDpStr("allAppsShiftRange", allAppsShiftRange));
Alex Chau3d2c0622022-09-01 21:28:14 +01002191 writer.println(prefix + "\tallAppsOpenDuration: " + allAppsOpenDuration);
2192 writer.println(prefix + "\tallAppsCloseDuration: " + allAppsCloseDuration);
Jon Miranda58561d42021-03-17 10:51:54 -04002193 writer.println(prefix + pxToDpStr("allAppsIconSizePx", allAppsIconSizePx));
2194 writer.println(prefix + pxToDpStr("allAppsIconTextSizePx", allAppsIconTextSizePx));
2195 writer.println(prefix + pxToDpStr("allAppsIconDrawablePaddingPx",
2196 allAppsIconDrawablePaddingPx));
2197 writer.println(prefix + pxToDpStr("allAppsCellHeightPx", allAppsCellHeightPx));
Alex Chau27b39b92022-01-14 18:02:18 +00002198 writer.println(prefix + pxToDpStr("allAppsCellWidthPx", allAppsCellWidthPx));
Pat Manning26f70f72022-07-07 13:50:39 +01002199 writer.println(prefix + pxToDpStr("allAppsBorderSpacePxX", allAppsBorderSpacePx.x));
2200 writer.println(prefix + pxToDpStr("allAppsBorderSpacePxY", allAppsBorderSpacePx.y));
Sunny Goyal19ff7282021-04-22 10:12:54 -07002201 writer.println(prefix + "\tnumShownAllAppsColumns: " + numShownAllAppsColumns);
Thales Limab433c9c2023-10-30 12:24:05 +00002202 writer.println(prefix + pxToDpStr("allAppsPadding.top", allAppsPadding.top));
2203 writer.println(prefix + pxToDpStr("allAppsPadding.left", allAppsPadding.left));
2204 writer.println(prefix + pxToDpStr("allAppsPadding.right", allAppsPadding.right));
Alex Chau27b39b92022-01-14 18:02:18 +00002205 writer.println(prefix + pxToDpStr("allAppsLeftRightMargin", allAppsLeftRightMargin));
Jon Miranda58561d42021-03-17 10:51:54 -04002206
2207 writer.println(prefix + pxToDpStr("hotseatBarSizePx", hotseatBarSizePx));
fbarone4b0b712024-03-29 14:31:17 -07002208 writer.println(prefix + "\tmHotseatColumnSpan: " + mHotseatColumnSpan);
2209 writer.println(prefix + pxToDpStr("mHotseatWidthPx", mHotseatWidthPx));
Jon Miranda58561d42021-03-17 10:51:54 -04002210 writer.println(prefix + pxToDpStr("hotseatCellHeightPx", hotseatCellHeightPx));
Alex Chau62572c02022-07-25 18:36:37 +00002211 writer.println(prefix + pxToDpStr("hotseatBarBottomSpacePx", hotseatBarBottomSpacePx));
Thales Lima8e11d532023-08-31 13:40:26 +00002212 writer.println(prefix + pxToDpStr("mHotseatBarEdgePaddingPx",
2213 mHotseatBarEdgePaddingPx));
2214 writer.println(prefix + pxToDpStr("mHotseatBarWorkspaceSpacePx",
2215 mHotseatBarWorkspaceSpacePx));
Pat Manning26f70f72022-07-07 13:50:39 +01002216 writer.println(prefix + pxToDpStr("hotseatBarEndOffset", hotseatBarEndOffset));
Thales Limab8c05952022-05-23 16:58:38 +01002217 writer.println(prefix + pxToDpStr("hotseatQsbSpace", hotseatQsbSpace));
2218 writer.println(prefix + pxToDpStr("hotseatQsbHeight", hotseatQsbHeight));
Pat Manningde25c0d2022-04-05 19:11:26 +01002219 writer.println(prefix + pxToDpStr("springLoadedHotseatBarTopMarginPx",
2220 springLoadedHotseatBarTopMarginPx));
Pat Manning5f74bfd2022-07-20 12:08:54 +01002221 Rect hotseatLayoutPadding = getHotseatLayoutPadding(context);
2222 writer.println(prefix + pxToDpStr("getHotseatLayoutPadding(context).top",
2223 hotseatLayoutPadding.top));
2224 writer.println(prefix + pxToDpStr("getHotseatLayoutPadding(context).bottom",
2225 hotseatLayoutPadding.bottom));
2226 writer.println(prefix + pxToDpStr("getHotseatLayoutPadding(context).left",
2227 hotseatLayoutPadding.left));
2228 writer.println(prefix + pxToDpStr("getHotseatLayoutPadding(context).right",
2229 hotseatLayoutPadding.right));
Sunny Goyal19ff7282021-04-22 10:12:54 -07002230 writer.println(prefix + "\tnumShownHotseatIcons: " + numShownHotseatIcons);
Thales Lima116b51a2022-02-03 16:19:47 +00002231 writer.println(prefix + pxToDpStr("hotseatBorderSpace", hotseatBorderSpace));
Thales Limaa1012902022-01-13 17:58:42 +00002232 writer.println(prefix + "\tisQsbInline: " + isQsbInline);
Alex Chau206ede92022-08-01 17:46:12 +01002233 writer.println(prefix + pxToDpStr("hotseatQsbWidth", hotseatQsbWidth));
Jon Miranda58561d42021-03-17 10:51:54 -04002234
2235 writer.println(prefix + "\tisTaskbarPresent:" + isTaskbarPresent);
Tony Wickham635e1802021-07-22 14:28:04 -10002236 writer.println(prefix + "\tisTaskbarPresentInApps:" + isTaskbarPresentInApps);
Jon Miranda9c478b62023-03-23 21:38:49 -07002237 writer.println(prefix + pxToDpStr("taskbarHeight", taskbarHeight));
2238 writer.println(prefix + pxToDpStr("stashedTaskbarHeight", stashedTaskbarHeight));
2239 writer.println(prefix + pxToDpStr("taskbarBottomMargin", taskbarBottomMargin));
2240 writer.println(prefix + pxToDpStr("taskbarIconSize", taskbarIconSize));
Jon Miranda58561d42021-03-17 10:51:54 -04002241
Thales Lima83bedbf2021-10-05 17:47:39 +01002242 writer.println(prefix + pxToDpStr("desiredWorkspaceHorizontalMarginPx",
2243 desiredWorkspaceHorizontalMarginPx));
Jon Miranda58561d42021-03-17 10:51:54 -04002244 writer.println(prefix + pxToDpStr("workspacePadding.left", workspacePadding.left));
2245 writer.println(prefix + pxToDpStr("workspacePadding.top", workspacePadding.top));
2246 writer.println(prefix + pxToDpStr("workspacePadding.right", workspacePadding.right));
Alex Chau62572c02022-07-25 18:36:37 +00002247 writer.println(prefix + pxToDpStr("workspacePadding.bottom", workspacePadding.bottom));
Jon Miranda58561d42021-03-17 10:51:54 -04002248
Jon Mirandaab3c6812021-06-28 15:42:28 -07002249 writer.println(prefix + pxToDpStr("iconScale", iconScale));
2250 writer.println(prefix + pxToDpStr("cellScaleToFit ", cellScaleToFit));
Jon Miranda58561d42021-03-17 10:51:54 -04002251 writer.println(prefix + pxToDpStr("extraSpace", extraSpace));
Alex Chau62572c02022-07-25 18:36:37 +00002252 writer.println(prefix + pxToDpStr("unscaled extraSpace", extraSpace / iconScale));
Jon Mirandac9e69fa2021-03-22 17:13:34 -04002253
Thales Lima171ee662022-11-22 15:52:49 +00002254 writer.println(prefix + pxToDpStr("maxEmptySpace", maxEmptySpace));
Jon Miranda58561d42021-03-17 10:51:54 -04002255 writer.println(prefix + pxToDpStr("workspaceTopPadding", workspaceTopPadding));
2256 writer.println(prefix + pxToDpStr("workspaceBottomPadding", workspaceBottomPadding));
Alex Chau635b3ab2022-01-26 16:49:10 +00002257
2258 writer.println(prefix + pxToDpStr("overviewTaskMarginPx", overviewTaskMarginPx));
Alex Chau635b3ab2022-01-26 16:49:10 +00002259 writer.println(prefix + pxToDpStr("overviewTaskIconSizePx", overviewTaskIconSizePx));
2260 writer.println(prefix + pxToDpStr("overviewTaskIconDrawableSizePx",
2261 overviewTaskIconDrawableSizePx));
2262 writer.println(prefix + pxToDpStr("overviewTaskIconDrawableSizeGridPx",
2263 overviewTaskIconDrawableSizeGridPx));
2264 writer.println(prefix + pxToDpStr("overviewTaskThumbnailTopMarginPx",
2265 overviewTaskThumbnailTopMarginPx));
Alex Chaua2fc7642022-04-21 14:20:23 +01002266 writer.println(prefix + pxToDpStr("overviewActionsTopMarginPx",
2267 overviewActionsTopMarginPx));
2268 writer.println(prefix + pxToDpStr("overviewActionsHeight",
2269 overviewActionsHeight));
Alex Chau1b276a12022-12-19 14:01:36 +00002270 writer.println(prefix + pxToDpStr("overviewActionsClaimedSpaceBelow",
2271 getOverviewActionsClaimedSpaceBelow()));
Alex Chau635b3ab2022-01-26 16:49:10 +00002272 writer.println(prefix + pxToDpStr("overviewActionsButtonSpacing",
2273 overviewActionsButtonSpacing));
2274 writer.println(prefix + pxToDpStr("overviewPageSpacing", overviewPageSpacing));
2275 writer.println(prefix + pxToDpStr("overviewRowSpacing", overviewRowSpacing));
2276 writer.println(prefix + pxToDpStr("overviewGridSideMargin", overviewGridSideMargin));
Pat Manningde25c0d2022-04-05 19:11:26 +01002277
Alex Chau62572c02022-07-25 18:36:37 +00002278 writer.println(prefix + pxToDpStr("dropTargetBarTopMarginPx", dropTargetBarTopMarginPx));
Pat Manningde25c0d2022-04-05 19:11:26 +01002279 writer.println(prefix + pxToDpStr("dropTargetBarSizePx", dropTargetBarSizePx));
Alex Chau62572c02022-07-25 18:36:37 +00002280 writer.println(
2281 prefix + pxToDpStr("dropTargetBarBottomMarginPx", dropTargetBarBottomMarginPx));
Pat Manningde25c0d2022-04-05 19:11:26 +01002282
Pat Manning5f74bfd2022-07-20 12:08:54 +01002283 writer.println(prefix + pxToDpStr("getCellLayoutSpringLoadShrunkTop()",
2284 getCellLayoutSpringLoadShrunkTop()));
2285 writer.println(prefix + pxToDpStr("getCellLayoutSpringLoadShrunkBottom()",
2286 getCellLayoutSpringLoadShrunkBottom(context)));
Alex Chau906d8822022-05-23 10:42:25 +01002287 writer.println(prefix + pxToDpStr("workspaceSpringLoadedMinNextPageVisiblePx",
2288 workspaceSpringLoadedMinNextPageVisiblePx));
Pat Manning5f74bfd2022-07-20 12:08:54 +01002289 writer.println(prefix + pxToDpStr("getWorkspaceSpringLoadScale()",
2290 getWorkspaceSpringLoadScale(context)));
Thales Limab8c05952022-05-23 16:58:38 +01002291 writer.println(prefix + pxToDpStr("getCellLayoutHeight()", getCellLayoutHeight()));
2292 writer.println(prefix + pxToDpStr("getCellLayoutWidth()", getCellLayoutWidth()));
Thales Lima79456492023-05-23 11:32:22 +01002293 if (mIsResponsiveGrid) {
Jordan Silva8f7986a2023-11-08 12:11:25 +00002294 writer.println(prefix + "\tmResponsiveWorkspaceHeightSpec:"
2295 + mResponsiveWorkspaceHeightSpec.toString());
2296 writer.println(prefix + "\tmResponsiveWorkspaceWidthSpec:"
2297 + mResponsiveWorkspaceWidthSpec.toString());
2298 writer.println(prefix + "\tmResponsiveAllAppsHeightSpec:"
2299 + mResponsiveAllAppsHeightSpec.toString());
2300 writer.println(prefix + "\tmResponsiveAllAppsWidthSpec:"
2301 + mResponsiveAllAppsWidthSpec.toString());
Jordan Silva637f4eb2023-06-13 11:21:53 +01002302 writer.println(prefix + "\tmResponsiveFolderHeightSpec:" + mResponsiveFolderHeightSpec);
2303 writer.println(prefix + "\tmResponsiveFolderWidthSpec:" + mResponsiveFolderWidthSpec);
Thales Limaf8bfb032023-07-24 15:08:05 +01002304 writer.println(prefix + "\tmResponsiveHotseatSpec:" + mResponsiveHotseatSpec);
Jordan Silva999dd2a2023-11-17 19:31:43 +00002305 writer.println(prefix + "\tmResponsiveWorkspaceCellSpec:"
2306 + mResponsiveWorkspaceCellSpec);
2307 writer.println(prefix + "\tmResponsiveAllAppsCellSpec:" + mResponsiveAllAppsCellSpec);
Thales Lima79456492023-05-23 11:32:22 +01002308 }
Jon Miranda58561d42021-03-17 10:51:54 -04002309 }
2310
Nicolo' Mazzucatocb7bd502023-01-16 19:46:30 +00002311 /** Returns a reduced representation of this DeviceProfile. */
2312 public String toSmallString() {
2313 return "isTablet:" + isTablet + ", "
2314 + "isMultiDisplay:" + isMultiDisplay + ", "
2315 + "widthPx:" + widthPx + ", "
2316 + "heightPx:" + heightPx + ", "
2317 + "insets:" + mInsets + ", "
2318 + "rotationHint:" + rotationHint;
2319 }
2320
Alex Chaua6907dc2022-03-18 15:24:07 +00002321 private static Context getContext(Context c, Info info, int orientation, WindowBounds bounds) {
Sunny Goyal1890f672020-04-30 12:28:00 -07002322 Configuration config = new Configuration(c.getResources().getConfiguration());
2323 config.orientation = orientation;
Thales Lima425f6822022-05-10 13:44:58 -03002324 config.densityDpi = info.getDensityDpi();
Alex Chaua6907dc2022-03-18 15:24:07 +00002325 config.smallestScreenWidthDp = (int) info.smallestSizeDp(bounds);
Sunny Goyal1890f672020-04-30 12:28:00 -07002326 return c.createConfigurationContext(config);
Jon Mirandab28c4fc2017-06-20 10:58:36 -07002327 }
Sunny Goyalfde55052018-02-01 14:46:13 -08002328
2329 /**
mpodoliandfb48212024-09-13 17:43:11 -07002330 * Returns whether Taskbar and Hotseat should adjust horizontally on bubble bar location update.
2331 */
2332 public boolean shouldAdjustHotseatOnBubblesLocationUpdate(Context context) {
2333 return enableBubbleBar()
2334 && enableBubbleBarInPersistentTaskBar()
2335 && DisplayController.getNavigationMode(context)
2336 == NavigationMode.THREE_BUTTONS;
2337 }
2338
2339 /** Returns hotseat translation X for the bubble bar position. */
2340 public int getHotseatTranslationXForBubbleBar(boolean isNavbarOnRight) {
2341 if (isNavbarOnRight) {
2342 return 0;
2343 } else {
2344 return navButtonsLayoutWidthPx;
2345 }
2346 }
2347
2348 /**
Sunny Goyalfde55052018-02-01 14:46:13 -08002349 * Callback when a component changes the DeviceProfile associated with it, as a result of
2350 * configuration change
2351 */
2352 public interface OnDeviceProfileChangeListener {
2353
2354 /**
2355 * Called when the device profile is reassigned. Note that for layout and measurements, it
2356 * is sufficient to listen for inset changes. Use this callback when you need to perform
2357 * a one time operation.
2358 */
2359 void onDeviceProfileChanged(DeviceProfile dp);
2360 }
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002361
Sihua Mae04aa202022-07-18 12:43:56 -07002362 /**
2363 * Handler that deals with ItemInfo of the views for the DeviceProfile
2364 */
2365 @FunctionalInterface
2366 public interface ViewScaleProvider {
2367 /**
2368 * Get the scales from the view
2369 *
2370 * @param itemInfo The tag of the widget view
2371 * @return PointF instance containing the scale information, or null if using the default
2372 * app widget scale of this device profile.
2373 */
2374 @NonNull
2375 PointF getScaleFromItemInfo(@Nullable ItemInfo itemInfo);
2376 }
2377
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002378 public static class Builder {
2379 private Context mContext;
2380 private InvariantDeviceProfile mInv;
Sunny Goyalfd58da62020-08-11 12:06:49 -07002381 private Info mInfo;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002382
Sunny Goyal19ff7282021-04-22 10:12:54 -07002383 private WindowBounds mWindowBounds;
Alex Chauab800f72022-12-13 17:46:06 +00002384 private boolean mIsMultiDisplay;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002385
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002386 private boolean mIsMultiWindowMode = false;
Sunny Goyal19ff7282021-04-22 10:12:54 -07002387 private Boolean mTransposeLayoutWithOrientation;
Alex Chau6ed408f2022-03-04 12:58:05 +00002388 private Boolean mIsGestureMode;
Sihua Mae04aa202022-07-18 12:43:56 -07002389 private ViewScaleProvider mViewScaleProvider = null;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002390
Sunny Goyal65190ae2022-08-02 14:16:26 -07002391 private SparseArray<DotRenderer> mDotRendererCache;
2392
Jon Miranda2b25ded2023-02-02 14:48:45 -08002393 private Consumer<DeviceProfile> mOverrideProvider;
2394
Jagrut Desai3a7d1392023-09-06 15:56:19 -07002395 private boolean mIsTransientTaskbar;
2396
Sunny Goyalfd58da62020-08-11 12:06:49 -07002397 public Builder(Context context, InvariantDeviceProfile inv, Info info) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002398 mContext = context;
2399 mInv = inv;
2400 mInfo = info;
Jagrut Desai3a7d1392023-09-06 15:56:19 -07002401 mIsTransientTaskbar = info.isTransientTaskbar();
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002402 }
2403
2404 public Builder setMultiWindowMode(boolean isMultiWindowMode) {
2405 mIsMultiWindowMode = isMultiWindowMode;
2406 return this;
2407 }
2408
Alex Chauab800f72022-12-13 17:46:06 +00002409 public Builder setIsMultiDisplay(boolean isMultiDisplay) {
2410 mIsMultiDisplay = isMultiDisplay;
Sunny Goyal19ff7282021-04-22 10:12:54 -07002411 return this;
2412 }
2413
Sunny Goyal65190ae2022-08-02 14:16:26 -07002414 public Builder setDotRendererCache(SparseArray<DotRenderer> dotRendererCache) {
2415 mDotRendererCache = dotRendererCache;
2416 return this;
2417 }
Sunny Goyal19ff7282021-04-22 10:12:54 -07002418
2419 public Builder setWindowBounds(WindowBounds bounds) {
2420 mWindowBounds = bounds;
Sunny Goyal0addbf02020-04-28 14:17:35 -07002421 return this;
2422 }
2423
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002424 public Builder setTransposeLayoutWithOrientation(boolean transposeLayoutWithOrientation) {
2425 mTransposeLayoutWithOrientation = transposeLayoutWithOrientation;
2426 return this;
2427 }
2428
Alex Chau6ed408f2022-03-04 12:58:05 +00002429 public Builder setGestureMode(boolean isGestureMode) {
2430 mIsGestureMode = isGestureMode;
2431 return this;
2432 }
2433
Jon Miranda2b25ded2023-02-02 14:48:45 -08002434 public Builder withDimensionsOverride(Consumer<DeviceProfile> overrideProvider) {
2435 mOverrideProvider = overrideProvider;
2436 return this;
2437 }
2438
Sihua Mae04aa202022-07-18 12:43:56 -07002439 /**
2440 * Set the viewScaleProvider for the builder
2441 *
2442 * @param viewScaleProvider The viewScaleProvider to be set for the
Thales Limae9273ea2023-01-26 12:33:52 +00002443 * DeviceProfile
Sihua Mae04aa202022-07-18 12:43:56 -07002444 * @return This builder
2445 */
2446 @NonNull
2447 public Builder setViewScaleProvider(@Nullable ViewScaleProvider viewScaleProvider) {
2448 mViewScaleProvider = viewScaleProvider;
2449 return this;
2450 }
2451
Jagrut Desai3a7d1392023-09-06 15:56:19 -07002452 /**
2453 * Set the isTransientTaskbar for the builder
2454 * @return This Builder
2455 */
2456 public Builder setIsTransientTaskbar(boolean isTransientTaskbar) {
2457 mIsTransientTaskbar = isTransientTaskbar;
2458 return this;
2459 }
2460
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002461 public DeviceProfile build() {
Sunny Goyal19ff7282021-04-22 10:12:54 -07002462 if (mWindowBounds == null) {
2463 throw new IllegalArgumentException("Window bounds not set");
2464 }
2465 if (mTransposeLayoutWithOrientation == null) {
2466 mTransposeLayoutWithOrientation = !mInfo.isTablet(mWindowBounds);
2467 }
Alex Chau6ed408f2022-03-04 12:58:05 +00002468 if (mIsGestureMode == null) {
Sunny Goyal97ceed42024-05-23 16:09:45 -07002469 mIsGestureMode = mInfo.getNavigationMode().hasGestures;
Alex Chau6ed408f2022-03-04 12:58:05 +00002470 }
Sunny Goyal65190ae2022-08-02 14:16:26 -07002471 if (mDotRendererCache == null) {
2472 mDotRendererCache = new SparseArray<>();
2473 }
Sihua Mae04aa202022-07-18 12:43:56 -07002474 if (mViewScaleProvider == null) {
2475 mViewScaleProvider = DEFAULT_PROVIDER;
2476 }
Jon Miranda2b25ded2023-02-02 14:48:45 -08002477 if (mOverrideProvider == null) {
2478 mOverrideProvider = DEFAULT_DIMENSION_PROVIDER;
2479 }
Sunny Goyal65190ae2022-08-02 14:16:26 -07002480 return new DeviceProfile(mContext, mInv, mInfo, mWindowBounds, mDotRendererCache,
Alex Chauab800f72022-12-13 17:46:06 +00002481 mIsMultiWindowMode, mTransposeLayoutWithOrientation, mIsMultiDisplay,
Jagrut Desai3a7d1392023-09-06 15:56:19 -07002482 mIsGestureMode, mViewScaleProvider, mOverrideProvider, mIsTransientTaskbar);
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002483 }
2484 }
Winson Chungb3800242013-10-24 11:01:54 -07002485}