blob: 6cb33a8c294eb4a557e3a73b5a09bdab7ef75843 [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;
Alex Chauab800f72022-12-13 17:46:06 +000028import static com.android.launcher3.config.FeatureFlags.ENABLE_MULTI_DISPLAY_PARTIAL_DEPTH;
Jon Miranda92c1b5d2021-07-20 13:57:16 -070029import static com.android.launcher3.folder.ClippedFolderIconLayoutRule.ICON_OVERLAP_FACTOR;
Sunny Goyal65190ae2022-08-02 14:16:26 -070030import static com.android.launcher3.icons.GraphicsUtils.getShapePath;
Jon Miranda95f44722023-06-06 19:48:19 -070031import static com.android.launcher3.icons.IconNormalizer.ICON_VISIBLE_AREA_FACTOR;
Thales Limab35faed2022-09-05 16:30:01 -030032import static com.android.launcher3.testing.shared.ResourceUtils.INVALID_RESOURCE_HANDLE;
Pat Manning5f74bfd2022-07-20 12:08:54 +010033import static com.android.launcher3.testing.shared.ResourceUtils.pxFromDp;
Thales Lima7eee74b2023-03-16 16:00:55 -030034import static com.android.launcher3.testing.shared.ResourceUtils.roundPxValueFromFloat;
Jon Miranda228877d2021-02-09 11:05:00 -050035
Sunny Goyal35c7b192021-04-20 16:51:10 -070036import android.annotation.SuppressLint;
Winson Chungb3800242013-10-24 11:01:54 -070037import android.content.Context;
Jon Mirandab28c4fc2017-06-20 10:58:36 -070038import android.content.res.Configuration;
Winson Chungb3800242013-10-24 11:01:54 -070039import android.content.res.Resources;
Thales Limab35faed2022-09-05 16:30:01 -030040import android.content.res.TypedArray;
Winson Chungb3800242013-10-24 11:01:54 -070041import android.graphics.Point;
Jon Miranda7ae64ff2016-11-21 16:18:46 -080042import android.graphics.PointF;
Winson Chungb3800242013-10-24 11:01:54 -070043import android.graphics.Rect;
Sunny Goyal35c7b192021-04-20 16:51:10 -070044import android.util.DisplayMetrics;
Sunny Goyal65190ae2022-08-02 14:16:26 -070045import android.util.SparseArray;
Sunny Goyal59d086c2018-05-07 17:31:40 -070046import android.view.Surface;
Winson Chungb3800242013-10-24 11:01:54 -070047
Sunny Goyal65190ae2022-08-02 14:16:26 -070048import androidx.annotation.NonNull;
Sihua Mae04aa202022-07-18 12:43:56 -070049import androidx.annotation.Nullable;
Jon Miranda9c478b62023-03-23 21:38:49 -070050import androidx.core.content.res.ResourcesCompat;
Sunny Goyal65190ae2022-08-02 14:16:26 -070051
Sunny Goyalc13403c2016-11-18 23:44:48 -080052import com.android.launcher3.CellLayout.ContainerType;
Jon Miranda228877d2021-02-09 11:05:00 -050053import com.android.launcher3.DevicePaddings.DevicePadding;
Alex Chaud67ddc42022-09-30 18:15:56 +010054import com.android.launcher3.config.FeatureFlags;
Tony Wickham8912b042018-11-29 15:28:53 -080055import com.android.launcher3.icons.DotRenderer;
Hyunyoung Song48cb7bc2018-09-25 17:03:34 -070056import com.android.launcher3.icons.IconNormalizer;
Sihua Mae04aa202022-07-18 12:43:56 -070057import com.android.launcher3.model.data.ItemInfo;
Jordan Silva999dd2a2023-11-17 19:31:43 +000058import com.android.launcher3.responsive.CalculatedCellSpec;
Thales Limaf8bfb032023-07-24 15:08:05 +010059import com.android.launcher3.responsive.CalculatedHotseatSpec;
Jordan Silvaf2402e22023-10-26 19:53:16 +010060import com.android.launcher3.responsive.CalculatedResponsiveSpec;
61import com.android.launcher3.responsive.HotseatSpecsProvider;
Jordan Silva999dd2a2023-11-17 19:31:43 +000062import com.android.launcher3.responsive.ResponsiveCellSpecsProvider;
Jordan Silvaf2402e22023-10-26 19:53:16 +010063import com.android.launcher3.responsive.ResponsiveSpec.Companion.ResponsiveSpecType;
64import com.android.launcher3.responsive.ResponsiveSpec.DimensionType;
65import com.android.launcher3.responsive.ResponsiveSpecsProvider;
Thales Lima24ceca62023-09-25 16:21:17 -070066import com.android.launcher3.util.CellContentDimensions;
Sunny Goyalfd58da62020-08-11 12:06:49 -070067import com.android.launcher3.util.DisplayController;
68import com.android.launcher3.util.DisplayController.Info;
Thales Lima2759aa32023-06-05 16:25:45 +010069import com.android.launcher3.util.IconSizeSteps;
Thales Limac98b7812023-04-14 15:04:23 +010070import com.android.launcher3.util.ResourceHelper;
Sunny Goyalb46703d2020-05-27 17:52:03 -070071import com.android.launcher3.util.WindowBounds;
Sunny Goyal11117d92024-03-25 16:12:10 -070072import com.android.launcher3.util.window.WindowManagerProxy;
Winson1f064272016-07-18 17:18:02 -070073
Jon Miranda58561d42021-03-17 10:51:54 -040074import java.io.PrintWriter;
Alex Chaue818bcb2022-09-02 17:27:11 +010075import java.util.Locale;
Jon Miranda2b25ded2023-02-02 14:48:45 -080076import java.util.function.Consumer;
Jon Miranda58561d42021-03-17 10:51:54 -040077
Sunny Goyal35c7b192021-04-20 16:51:10 -070078@SuppressLint("NewApi")
Winson Chungb3800242013-10-24 11:01:54 -070079public class DeviceProfile {
Adam Cohen2e6da152015-05-06 11:42:25 -070080
Sunny Goyal8b9919d2021-04-07 14:45:17 -070081 private static final int DEFAULT_DOT_SIZE = 100;
Thales Limab35faed2022-09-05 16:30:01 -030082 private static final float MIN_FOLDER_TEXT_SIZE_SP = 16f;
Sunny Goyal6c304b12023-04-10 12:03:04 -070083 private static final float MIN_WIDGET_PADDING_DP = 6f;
Alex Chau206ede92022-08-01 17:46:12 +010084
Shamali Pbe55f822024-01-16 15:07:19 +000085 // Minimum aspect ratio beyond which an extra top padding may be applied to a bottom sheet.
86 private static final float MIN_ASPECT_RATIO_FOR_EXTRA_TOP_PADDING = 1.5f;
fbaron3bb6d4b2024-02-23 10:54:13 -080087 private static final float MAX_ASPECT_RATIO_FOR_ALTERNATE_EDIT_STATE = 1.5f;
Shamali Pbe55f822024-01-16 15:07:19 +000088
Sihua Mae04aa202022-07-18 12:43:56 -070089 public static final PointF DEFAULT_SCALE = new PointF(1.0f, 1.0f);
90 public static final ViewScaleProvider DEFAULT_PROVIDER = itemInfo -> DEFAULT_SCALE;
Jordan Silvaf2402e22023-10-26 19:53:16 +010091 public static final Consumer<DeviceProfile> DEFAULT_DIMENSION_PROVIDER = dp -> {
92 };
Sihua Mae04aa202022-07-18 12:43:56 -070093
Adam Cohen2e6da152015-05-06 11:42:25 -070094 public final InvariantDeviceProfile inv;
Sunny Goyalfd58da62020-08-11 12:06:49 -070095 private final Info mInfo;
Sunny Goyal35c7b192021-04-20 16:51:10 -070096 private final DisplayMetrics mMetrics;
Thales Lima2759aa32023-06-05 16:25:45 +010097 private final IconSizeSteps mIconSizeSteps;
Winson Chungbe876472014-05-14 14:15:20 -070098
Sunny Goyalc6205602015-05-21 20:46:33 -070099 // Device properties
100 public final boolean isTablet;
Sunny Goyalc6205602015-05-21 20:46:33 -0700101 public final boolean isPhone;
102 public final boolean transposeLayoutWithOrientation;
Alex Chauab800f72022-12-13 17:46:06 +0000103 public final boolean isMultiDisplay;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700104 public final boolean isTwoPanels;
Fengjiang Lie90f0982024-03-12 09:36:54 -0700105 public boolean isPredictiveBackSwipe;
Thales Limaa1012902022-01-13 17:58:42 +0000106 public final boolean isQsbInline;
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -0700107
Sunny Goyalc6205602015-05-21 20:46:33 -0700108 // Device properties in current orientation
Sunny Goyald792a772018-04-05 13:37:46 -0700109 public final boolean isLandscape;
Sunny Goyald70e75a2018-02-22 10:07:32 -0800110 public final boolean isMultiWindowMode;
Alex Chau6ed408f2022-03-04 12:58:05 +0000111 public final boolean isGestureMode;
Sunny Goyald70e75a2018-02-22 10:07:32 -0800112
Winson Chung104a4c82023-11-08 18:56:15 +0000113 public final boolean isLeftRightSplit;
114
Sunny Goyal0addbf02020-04-28 14:17:35 -0700115 public final int windowX;
116 public final int windowY;
Sunny Goyalc6205602015-05-21 20:46:33 -0700117 public final int widthPx;
118 public final int heightPx;
119 public final int availableWidthPx;
120 public final int availableHeightPx;
Sunny Goyal187b16c2022-03-01 16:53:23 -0800121 public final int rotationHint;
Jon Mirandabba64512019-03-27 10:54:17 -0700122
123 public final float aspectRatio;
124
Thales Lima79456492023-05-23 11:32:22 +0100125 private final boolean mIsScalableGrid;
Thales Lima83bedbf2021-10-05 17:47:39 +0100126 private final int mTypeIndex;
Jon Mirandae126d722021-02-25 10:45:20 -0500127
Thales Limac98b7812023-04-14 15:04:23 +0100128 // Responsive grid
129 private final boolean mIsResponsiveGrid;
Jordan Silva8f7986a2023-11-08 12:11:25 +0000130 private CalculatedResponsiveSpec mResponsiveWorkspaceWidthSpec;
131 private CalculatedResponsiveSpec mResponsiveWorkspaceHeightSpec;
132 private CalculatedResponsiveSpec mResponsiveAllAppsWidthSpec;
133 private CalculatedResponsiveSpec mResponsiveAllAppsHeightSpec;
Jordan Silvaf2402e22023-10-26 19:53:16 +0100134 private CalculatedResponsiveSpec mResponsiveFolderWidthSpec;
135 private CalculatedResponsiveSpec mResponsiveFolderHeightSpec;
Thales Limaf8bfb032023-07-24 15:08:05 +0100136 private CalculatedHotseatSpec mResponsiveHotseatSpec;
Jordan Silva999dd2a2023-11-17 19:31:43 +0000137 private CalculatedCellSpec mResponsiveWorkspaceCellSpec;
138 private CalculatedCellSpec mResponsiveAllAppsCellSpec;
Thales Limac98b7812023-04-14 15:04:23 +0100139
Tony Wickhamd6b40372015-09-23 18:37:57 -0700140 /**
141 * The maximum amount of left/right workspace padding as a percentage of the screen width.
142 * To be clear, this means that up to 7% of the screen width can be used as left padding, and
143 * 7% of the screen width can be used as right padding.
144 */
145 private static final float MAX_HORIZONTAL_PADDING_PERCENT = 0.14f;
Winson Chungb3800242013-10-24 11:01:54 -0700146
Jon Miranda3f9bab22017-07-28 14:50:17 -0700147 private static final float TALL_DEVICE_ASPECT_RATIO_THRESHOLD = 2.0f;
Jon Miranda80cddbc2021-07-22 13:51:16 -0700148 private static final float TALLER_DEVICE_ASPECT_RATIO_THRESHOLD = 2.15f;
Jon Miranda80dda302021-07-28 14:14:59 -0700149 private static final float TALL_DEVICE_EXTRA_SPACE_THRESHOLD_DP = 252;
150 private static final float TALL_DEVICE_MORE_EXTRA_SPACE_THRESHOLD_DP = 268;
Jon Miranda30d0aa22017-07-25 15:55:29 -0700151
Sunny Goyalc6205602015-05-21 20:46:33 -0700152 // Workspace
Thales Limad90faab2021-09-21 17:18:47 +0100153 public final int desiredWorkspaceHorizontalMarginOriginalPx;
154 public int desiredWorkspaceHorizontalMarginPx;
Alex Chau51da2192022-05-20 13:32:10 +0100155 public int gridVisualizationPaddingX;
156 public int gridVisualizationPaddingY;
Thales Lima78d00ad2021-09-30 11:29:06 +0100157 public Point cellLayoutBorderSpaceOriginalPx;
158 public Point cellLayoutBorderSpacePx;
Pat Manning08610ca2022-04-05 21:03:16 +0100159 public Rect cellLayoutPaddingPx = new Rect();
160
Sunny Goyalc6205602015-05-21 20:46:33 -0700161 public final int edgeMarginPx;
Alex Chau0c4e11b2022-07-08 18:41:36 +0100162 public final float workspaceContentScale;
Alex Chau906d8822022-05-23 10:42:25 +0100163 public final int workspaceSpringLoadedMinNextPageVisiblePx;
Sunny Goyalc6205602015-05-21 20:46:33 -0700164
Jon Miranda58561d42021-03-17 10:51:54 -0400165 private final int extraSpace;
Thales Lima171ee662022-11-22 15:52:49 +0000166 private int maxEmptySpace;
Jon Miranda228877d2021-02-09 11:05:00 -0500167 public int workspaceTopPadding;
168 public int workspaceBottomPadding;
169
Tony Wickham5edf9e22020-03-27 20:06:52 -0700170 // Workspace page indicator
171 public final int workspacePageIndicatorHeight;
172 private final int mWorkspacePageIndicatorOverlapWorkspace;
Winson1f064272016-07-18 17:18:02 -0700173
Sunny Goyalc6205602015-05-21 20:46:33 -0700174 // Workspace icons
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400175 public float iconScale;
Sunny Goyalc6205602015-05-21 20:46:33 -0700176 public int iconSizePx;
177 public int iconTextSizePx;
178 public int iconDrawablePaddingPx;
Jordan Silva999dd2a2023-11-17 19:31:43 +0000179 private int mIconDrawablePaddingOriginalPx;
Thales Lima79456492023-05-23 11:32:22 +0100180 public boolean iconCenterVertically;
Winson Chungb3800242013-10-24 11:01:54 -0700181
Jon Mirandaab3c6812021-06-28 15:42:28 -0700182 public float cellScaleToFit;
Adam Cohen59400422014-03-05 18:07:04 -0800183 public int cellWidthPx;
184 public int cellHeightPx;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700185 public int workspaceCellPaddingXPx;
Adam Cohen59400422014-03-05 18:07:04 -0800186
Thales Lima79456492023-05-23 11:32:22 +0100187 public int cellYPaddingPx = -1;
Jon Mirandae126d722021-02-25 10:45:20 -0500188
Sunny Goyalc6205602015-05-21 20:46:33 -0700189 // Folder
Thales Lima1faa4ed2023-12-01 16:48:19 +0000190 public final int numFolderRows;
191 public final int numFolderColumns;
Jordan Silva999dd2a2023-11-17 19:31:43 +0000192 public final float folderLabelTextScale;
Jon Mirandae126d722021-02-25 10:45:20 -0500193 public int folderLabelTextSizePx;
Thales Limab35faed2022-09-05 16:30:01 -0300194 public int folderFooterHeightPx;
Sunny Goyalc6205602015-05-21 20:46:33 -0700195 public int folderIconSizePx;
Jon Miranda591e3602018-03-28 11:37:00 -0700196 public int folderIconOffsetYPx;
Jon Mirandabf7d8122016-11-03 15:29:29 -0700197
Jon Mirandae126d722021-02-25 10:45:20 -0500198 // Folder content
Jordan Silva637f4eb2023-06-13 11:21:53 +0100199 public Point folderCellLayoutBorderSpacePx;
Jon Mirandae126d722021-02-25 10:45:20 -0500200 public int folderContentPaddingLeftRight;
201 public int folderContentPaddingTop;
202
Jon Mirandabf7d8122016-11-03 15:29:29 -0700203 // Folder cell
Sunny Goyalc6205602015-05-21 20:46:33 -0700204 public int folderCellWidthPx;
205 public int folderCellHeightPx;
Jon Mirandabf7d8122016-11-03 15:29:29 -0700206
207 // Folder child
208 public int folderChildIconSizePx;
209 public int folderChildTextSizePx;
Sunny Goyalbaec6ff2016-09-14 11:26:21 -0700210 public int folderChildDrawablePaddingPx;
Winson Chungb3800242013-10-24 11:01:54 -0700211
Sunny Goyalc6205602015-05-21 20:46:33 -0700212 // Hotseat
Thales Lima9938c2f2022-07-25 14:38:16 +0100213 public int numShownHotseatIcons;
Sunny Goyalc6205602015-05-21 20:46:33 -0700214 public int hotseatCellHeightPx;
Pat Manning26f70f72022-07-07 13:50:39 +0100215 public final boolean areNavButtonsInline;
Jon Miranda18751b62017-07-31 17:25:27 -0700216 // In portrait: size = height, in landscape: size = width
217 public int hotseatBarSizePx;
Thales Limab8c05952022-05-23 16:58:38 +0100218 public int hotseatBarBottomSpacePx;
Pat Manning26f70f72022-07-07 13:50:39 +0100219 public int hotseatBarEndOffset;
Thales Limab8c05952022-05-23 16:58:38 +0100220 public int hotseatQsbSpace;
Pat Manningde25c0d2022-04-05 19:11:26 +0100221 public int springLoadedHotseatBarTopMarginPx;
Thales Lima8e11d532023-08-31 13:40:26 +0000222 // These 2 values are only used for isVerticalBar
223 // Padding between edge of screen and hotseat
224 public final int mHotseatBarEdgePaddingPx;
225 // Space between hotseat and workspace (not used in responsive)
226 public final int mHotseatBarWorkspaceSpacePx;
Alex Chau206ede92022-08-01 17:46:12 +0100227 public int hotseatQsbWidth; // only used when isQsbInline
Sunny Goyal57b22792021-05-25 14:35:01 -0700228 public final int hotseatQsbHeight;
Thales Limab8c05952022-05-23 16:58:38 +0100229 public final int hotseatQsbVisualHeight;
230 private final int hotseatQsbShadowHeight;
Thales Limadd027342022-01-07 12:54:37 +0000231 public int hotseatBorderSpace;
Thales Limaffc68b02023-01-09 16:20:23 +0000232 private final int mMinHotseatIconSpacePx;
233 private final int mMinHotseatQsbWidthPx;
234 private final int mMaxHotseatIconSpacePx;
Jon Mirandae17a9492023-03-08 16:42:20 -0800235 public final int inlineNavButtonsEndSpacingPx;
Liran Binyamina833af32023-08-02 16:30:27 -0400236 // Space required for the bubble bar between the hotseat and the edge of the screen. If there's
237 // not enough space, the hotseat will adjust itself for the bubble bar.
238 private final int mBubbleBarSpaceThresholdPx;
Adam Cohen2e6da152015-05-06 11:42:25 -0700239
Alex Chau3d2c0622022-09-01 21:28:14 +0100240 // Bottom sheets
241 public int bottomSheetTopPadding;
242 public int bottomSheetOpenDuration;
243 public int bottomSheetCloseDuration;
244 public float bottomSheetWorkspaceScale;
245 public float bottomSheetDepth;
246
Sunny Goyalc6205602015-05-21 20:46:33 -0700247 // All apps
Thales Lima85c942f2021-12-31 13:04:20 +0000248 public Point allAppsBorderSpacePx;
Alex Chaub8c22e12022-02-14 18:35:58 +0000249 public int allAppsShiftRange;
Thales Limab433c9c2023-10-30 12:24:05 +0000250 public Rect allAppsPadding = new Rect();
Alex Chau3d2c0622022-09-01 21:28:14 +0100251 public int allAppsOpenDuration;
252 public int allAppsCloseDuration;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700253 public int allAppsCellHeightPx;
Samuel Fufaf1424a32019-10-04 15:15:19 -0700254 public int allAppsCellWidthPx;
Winson1f064272016-07-18 17:18:02 -0700255 public int allAppsIconSizePx;
256 public int allAppsIconDrawablePaddingPx;
Alex Chau27b39b92022-01-14 18:02:18 +0000257 public int allAppsLeftRightMargin;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700258 public final int numShownAllAppsColumns;
Winson1f064272016-07-18 17:18:02 -0700259 public float allAppsIconTextSizePx;
260
Zak Cohen334efeb2021-03-19 16:42:07 -0700261 // Overview
Zak Cohen334efeb2021-03-19 16:42:07 -0700262 public int overviewTaskMarginPx;
Alex Chaudedbc8a2021-03-17 16:53:26 +0000263 public int overviewTaskIconSizePx;
Alex Chauac9df382021-08-02 19:08:41 +0100264 public int overviewTaskIconDrawableSizePx;
265 public int overviewTaskIconDrawableSizeGridPx;
Alex Chaudedbc8a2021-03-17 16:53:26 +0000266 public int overviewTaskThumbnailTopMarginPx;
Alex Chau19c6eca2022-03-10 20:12:56 +0000267 public final int overviewActionsHeight;
Alex Chaua2fc7642022-04-21 14:20:23 +0100268 public final int overviewActionsTopMarginPx;
Alex Chau1bf0fe12021-11-30 15:32:45 +0000269 public final int overviewActionsButtonSpacing;
Alex Chau5fd9d492021-07-22 17:27:11 +0100270 public int overviewPageSpacing;
271 public int overviewRowSpacing;
Alex Chau56bd2572021-11-03 18:48:18 +0000272 public int overviewGridSideMargin;
Zak Cohen334efeb2021-03-19 16:42:07 -0700273
Jeremy Sim0ac47082022-10-10 13:59:40 -0700274 // Split staging
275 public int splitPlaceholderInset;
276
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800277 // Widgets
Sihua Mae04aa202022-07-18 12:43:56 -0700278 private final ViewScaleProvider mViewScaleProvider;
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800279
Sunny Goyal47328fd2016-05-25 18:56:41 -0700280 // Drop Target
281 public int dropTargetBarSizePx;
Pat Manningde25c0d2022-04-05 19:11:26 +0100282 public int dropTargetBarTopMarginPx;
283 public int dropTargetBarBottomMarginPx;
Alex Chaua02eddc2021-04-29 00:36:06 +0100284 public int dropTargetDragPaddingPx;
285 public int dropTargetTextSizePx;
Pat Manningde25c0d2022-04-05 19:11:26 +0100286 public int dropTargetHorizontalPaddingPx;
287 public int dropTargetVerticalPaddingPx;
288 public int dropTargetGapPx;
Alex Chau5b019302022-05-23 10:42:25 +0100289 public int dropTargetButtonWorkspaceEdgeGapPx;
Adam Cohen4ae96ce2014-08-29 15:05:48 -0700290
Winson1f064272016-07-18 17:18:02 -0700291 // Insets
Sunny Goyal07b69292018-01-08 14:19:34 -0800292 private final Rect mInsets = new Rect();
293 public final Rect workspacePadding = new Rect();
Sunny Goyal6c304b12023-04-10 12:03:04 -0700294 // Additional padding added to the widget inside its cellSpace. It is applied outside
295 // the widgetView, such that the actual view size is same as the widget size.
296 public final Rect widgetPadding = new Rect();
297
Jon Miranda0bd63d12019-03-06 17:29:29 -0800298 // When true, nav bar is on the left side of the screen.
Sunny Goyal59d086c2018-05-07 17:31:40 -0700299 private boolean mIsSeascape;
Winson1f064272016-07-18 17:18:02 -0700300
Tony Wickhamf34bee82018-12-03 18:11:39 -0800301 // Notification dots
Sunny Goyal65190ae2022-08-02 14:16:26 -0700302 public final DotRenderer mDotRendererWorkSpace;
303 public final DotRenderer mDotRendererAllApps;
Tony Wickham9a8d11f2017-01-11 09:53:12 -0800304
Pierre Barbier de Reuille578deba2021-09-24 13:47:44 +0100305 // Taskbar
Tony Wickham15883892021-02-12 11:24:40 -0800306 public boolean isTaskbarPresent;
Tony Wickham635e1802021-07-22 14:28:04 -1000307 // Whether Taskbar will inset the bottom of apps by taskbarSize.
308 public boolean isTaskbarPresentInApps;
Jon Miranda9c478b62023-03-23 21:38:49 -0700309 public final int taskbarHeight;
310 public final int stashedTaskbarHeight;
311 public final int taskbarBottomMargin;
312 public final int taskbarIconSize;
Uwais Ashrafaa7fa882023-10-10 21:36:06 +0000313 private final int mTransientTaskbarClaimedSpace;
Jon Miranda04f05102023-04-04 12:16:31 -0700314 // If true, used to layout taskbar in 3 button navigation mode.
315 public final boolean startAlignTaskbar;
Thales Limae9566402023-08-30 16:35:12 +0100316 public final boolean isTransientTaskbar;
Alex Chaua02eddc2021-04-29 00:36:06 +0100317 // DragController
318 public int flingToDeleteThresholdVelocity;
319
Vinit Nayak17c4b332021-08-05 12:54:58 -0700320 /** TODO: Once we fully migrate to staged split, remove "isMultiWindowMode" */
Sunny Goyal19ff7282021-04-22 10:12:54 -0700321 DeviceProfile(Context context, InvariantDeviceProfile inv, Info info, WindowBounds windowBounds,
Sunny Goyal65190ae2022-08-02 14:16:26 -0700322 SparseArray<DotRenderer> dotRendererCache, boolean isMultiWindowMode,
Alex Chauab800f72022-12-13 17:46:06 +0000323 boolean transposeLayoutWithOrientation, boolean isMultiDisplay, boolean isGestureMode,
Jon Miranda2b25ded2023-02-02 14:48:45 -0800324 @NonNull final ViewScaleProvider viewScaleProvider,
Jagrut Desai3a7d1392023-09-06 15:56:19 -0700325 @NonNull final Consumer<DeviceProfile> dimensionOverrideProvider,
326 boolean isTransientTaskbar) {
Sunny Goyalfee35bb2015-05-11 11:38:19 -0700327
Adam Cohen2e6da152015-05-06 11:42:25 -0700328 this.inv = inv;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700329 this.isLandscape = windowBounds.isLandscape();
Sunny Goyald70e75a2018-02-22 10:07:32 -0800330 this.isMultiWindowMode = isMultiWindowMode;
Jon Mirandae126d722021-02-25 10:45:20 -0500331 this.transposeLayoutWithOrientation = transposeLayoutWithOrientation;
Alex Chauab800f72022-12-13 17:46:06 +0000332 this.isMultiDisplay = isMultiDisplay;
Alex Chau6ed408f2022-03-04 12:58:05 +0000333 this.isGestureMode = isGestureMode;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700334 windowX = windowBounds.bounds.left;
335 windowY = windowBounds.bounds.top;
Sunny Goyal187b16c2022-03-01 16:53:23 -0800336 this.rotationHint = windowBounds.rotationHint;
Alex Chaue0227552022-04-06 19:44:43 +0100337 mInsets.set(windowBounds.insets);
Winson Chungb3800242013-10-24 11:01:54 -0700338
Thales Limac98b7812023-04-14 15:04:23 +0100339 // TODO(b/241386436): shouldn't change any launcher behaviour
Thales Limaabfe3642023-05-24 18:08:53 +0100340 mIsResponsiveGrid = inv.workspaceSpecsId != INVALID_RESOURCE_HANDLE
Jordan Silva637f4eb2023-06-13 11:21:53 +0100341 && inv.allAppsSpecsId != INVALID_RESOURCE_HANDLE
Thales Limaf8bfb032023-07-24 15:08:05 +0100342 && inv.folderSpecsId != INVALID_RESOURCE_HANDLE
Jordan Silva999dd2a2023-11-17 19:31:43 +0000343 && inv.hotseatSpecsId != INVALID_RESOURCE_HANDLE
344 && inv.workspaceCellSpecsId != INVALID_RESOURCE_HANDLE
345 && inv.allAppsCellSpecsId != INVALID_RESOURCE_HANDLE;
Thales Limaec5abba2023-04-05 16:33:50 +0100346
Thales Lima79456492023-05-23 11:32:22 +0100347 mIsScalableGrid = inv.isScalable && !isVerticalBarLayout() && !isMultiWindowMode;
Alex Chaudfc8ddf2022-01-25 11:26:25 +0000348 // Determine device posture.
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700349 mInfo = info;
Alex Chau29983072021-11-19 15:14:20 +0000350 isTablet = info.isTablet(windowBounds);
Sunny Goyal19ff7282021-04-22 10:12:54 -0700351 isPhone = !isTablet;
Alex Chauab800f72022-12-13 17:46:06 +0000352 isTwoPanels = isTablet && isMultiDisplay;
Sunny Goyal11117d92024-03-25 16:12:10 -0700353 isTaskbarPresent = isTablet
354 && WindowManagerProxy.INSTANCE.get(context).isTaskbarDrawnInProcess();
Adam Cohen2e6da152015-05-06 11:42:25 -0700355
Alex Chaudfc8ddf2022-01-25 11:26:25 +0000356 // Some more constants.
Alex Chau635b3ab2022-01-26 16:49:10 +0000357 context = getContext(context, info, isVerticalBarLayout() || (isTablet && isLandscape)
Brandon Dayauon07ca8842022-04-27 10:52:28 -0700358 ? Configuration.ORIENTATION_LANDSCAPE
359 : Configuration.ORIENTATION_PORTRAIT,
Alex Chaua6907dc2022-03-18 15:24:07 +0000360 windowBounds);
Sunny Goyal1890f672020-04-30 12:28:00 -0700361 final Resources res = context.getResources();
Alex Chaudfc8ddf2022-01-25 11:26:25 +0000362 mMetrics = res.getDisplayMetrics();
363
Charlie Anderson7bb10972023-11-22 13:35:30 -0800364 mIconSizeSteps = new IconSizeSteps(res);
Thales Lima2759aa32023-06-05 16:25:45 +0100365
Alex Chaudfc8ddf2022-01-25 11:26:25 +0000366 // Determine sizes.
367 widthPx = windowBounds.bounds.width();
368 heightPx = windowBounds.bounds.height();
369 availableWidthPx = windowBounds.availableSize.x;
Thales Limab8c05952022-05-23 16:58:38 +0100370 availableHeightPx = windowBounds.availableSize.y;
Alex Chaudfc8ddf2022-01-25 11:26:25 +0000371
372 aspectRatio = ((float) Math.max(widthPx, heightPx)) / Math.min(widthPx, heightPx);
Thales Lima83bedbf2021-10-05 17:47:39 +0100373 if (isTwoPanels) {
374 if (isLandscape) {
Thales Lima12d0eff2022-03-25 17:06:11 +0000375 mTypeIndex = INDEX_TWO_PANEL_LANDSCAPE;
Thales Lima83bedbf2021-10-05 17:47:39 +0100376 } else {
Thales Lima12d0eff2022-03-25 17:06:11 +0000377 mTypeIndex = INDEX_TWO_PANEL_PORTRAIT;
Thales Lima83bedbf2021-10-05 17:47:39 +0100378 }
379 } else {
380 if (isLandscape) {
Thales Lima12d0eff2022-03-25 17:06:11 +0000381 mTypeIndex = INDEX_LANDSCAPE;
Thales Lima83bedbf2021-10-05 17:47:39 +0100382 } else {
Thales Lima12d0eff2022-03-25 17:06:11 +0000383 mTypeIndex = INDEX_DEFAULT;
Thales Lima83bedbf2021-10-05 17:47:39 +0100384 }
385 }
386
Jagrut Desai3a7d1392023-09-06 15:56:19 -0700387 this.isTransientTaskbar = isTransientTaskbar;
Uwais Ashrafaa7fa882023-10-10 21:36:06 +0000388 int transientTaskbarIconSize = pxFromDp(inv.transientTaskbarIconSize[mTypeIndex], mMetrics);
389 int transientTaskbarBottomMargin =
390 res.getDimensionPixelSize(R.dimen.transient_taskbar_bottom_margin);
391 int transientTaskbarHeight =
392 Math.round((transientTaskbarIconSize * ICON_VISIBLE_AREA_FACTOR)
Jordan Silvaf2402e22023-10-26 19:53:16 +0100393 + (2 * res.getDimensionPixelSize(R.dimen.transient_taskbar_padding)));
Uwais Ashrafaa7fa882023-10-10 21:36:06 +0000394 mTransientTaskbarClaimedSpace = transientTaskbarHeight + 2 * transientTaskbarBottomMargin;
395
Uwais Ashraf3602d172023-09-15 11:36:32 +0000396 if (!isTaskbarPresent) {
397 taskbarIconSize = taskbarHeight = stashedTaskbarHeight = taskbarBottomMargin = 0;
398 startAlignTaskbar = false;
399 } else if (isTransientTaskbar) {
Uwais Ashrafaa7fa882023-10-10 21:36:06 +0000400 taskbarIconSize = transientTaskbarIconSize;
401 taskbarHeight = transientTaskbarHeight;
Jon Miranda9c478b62023-03-23 21:38:49 -0700402 stashedTaskbarHeight =
403 res.getDimensionPixelSize(R.dimen.transient_taskbar_stashed_height);
Uwais Ashrafaa7fa882023-10-10 21:36:06 +0000404 taskbarBottomMargin = transientTaskbarBottomMargin;
Jon Miranda04f05102023-04-04 12:16:31 -0700405 startAlignTaskbar = false;
Jon Miranda9c478b62023-03-23 21:38:49 -0700406 } else {
407 taskbarIconSize = pxFromDp(ResourcesCompat.getFloat(res, R.dimen.taskbar_icon_size),
408 mMetrics);
409 taskbarHeight = res.getDimensionPixelSize(R.dimen.taskbar_size);
410 stashedTaskbarHeight = res.getDimensionPixelSize(R.dimen.taskbar_stashed_size);
411 taskbarBottomMargin = 0;
Jon Miranda04f05102023-04-04 12:16:31 -0700412 startAlignTaskbar = inv.startAlignTaskbar[mTypeIndex];
Tony Wickham15883892021-02-12 11:24:40 -0800413 }
Tony Wickham15883892021-02-12 11:24:40 -0800414
Winson Chungb3800242013-10-24 11:01:54 -0700415 edgeMarginPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_edge_margin);
Alex Chau0c4e11b2022-07-08 18:41:36 +0100416 workspaceContentScale = res.getFloat(R.dimen.workspace_content_scale);
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700417
Alex Chau51da2192022-05-20 13:32:10 +0100418 gridVisualizationPaddingX = res.getDimensionPixelSize(
419 R.dimen.grid_visualization_horizontal_cell_spacing);
420 gridVisualizationPaddingY = res.getDimensionPixelSize(
421 R.dimen.grid_visualization_vertical_cell_spacing);
Samuel Fufaee9aff92021-04-05 13:30:40 -0500422
Shamali P5fbb0cc2024-02-06 23:05:35 +0000423 {
424 // In large screens, in portrait mode, a bottom sheet can appear too elongated, so, we
425 // apply additional padding.
426 final boolean applyExtraTopPadding = isTablet
427 && !isLandscape
428 && (aspectRatio > MIN_ASPECT_RATIO_FOR_EXTRA_TOP_PADDING);
429 final int derivedTopPadding = heightPx / 6;
430 bottomSheetTopPadding = mInsets.top // statusbar height
431 + (applyExtraTopPadding ? derivedTopPadding : 0)
432 + (isTablet ? 0 : edgeMarginPx); // phones need edgeMarginPx additional padding
433 }
434
Alex Chau3d2c0622022-09-01 21:28:14 +0100435 bottomSheetOpenDuration = res.getInteger(R.integer.config_bottomSheetOpenDuration);
436 bottomSheetCloseDuration = res.getInteger(R.integer.config_bottomSheetCloseDuration);
437 if (isTablet) {
438 bottomSheetWorkspaceScale = workspaceContentScale;
Alex Chauab800f72022-12-13 17:46:06 +0000439 if (isMultiDisplay && !ENABLE_MULTI_DISPLAY_PARTIAL_DEPTH.get()) {
440 // TODO(b/259893832): Revert to use maxWallpaperScale to calculate bottomSheetDepth
441 // when screen recorder bug is fixed.
Luca Zuccarinic9cbc9d2024-03-11 14:29:48 +0000442 if (enableScalingRevealHomeAnimation()) {
443 bottomSheetDepth = 0.3f;
444 } else {
445 bottomSheetDepth = 1f;
446 }
Alex Chauab800f72022-12-13 17:46:06 +0000447 } else {
448 // The goal is to set wallpaper to zoom at workspaceContentScale when in AllApps.
449 // When depth is 0, wallpaper zoom is set to maxWallpaperScale.
450 // When depth is 1, wallpaper zoom is set to 1.
451 // For depth to achieve zoom set to maxWallpaperScale * workspaceContentScale:
452 float maxWallpaperScale = res.getFloat(R.dimen.config_wallpaperMaxScale);
453 bottomSheetDepth = Utilities.mapToRange(maxWallpaperScale * workspaceContentScale,
454 maxWallpaperScale, 1f, 0f, 1f, LINEAR);
455 }
Alex Chau3d2c0622022-09-01 21:28:14 +0100456 } else {
457 bottomSheetWorkspaceScale = 1f;
458 bottomSheetDepth = 0f;
459 }
Andras Kloczl142b0542022-03-09 21:26:02 +0000460
Jon Mirandae126d722021-02-25 10:45:20 -0500461 folderLabelTextScale = res.getFloat(R.dimen.folder_label_text_scale);
Thales Lima1faa4ed2023-12-01 16:48:19 +0000462 numFolderRows = inv.numFolderRows[mTypeIndex];
463 numFolderColumns = inv.numFolderColumns[mTypeIndex];
Thales Limab35faed2022-09-05 16:30:01 -0300464
Thales Lima79456492023-05-23 11:32:22 +0100465 if (mIsScalableGrid && inv.folderStyle != INVALID_RESOURCE_HANDLE) {
Thales Limab35faed2022-09-05 16:30:01 -0300466 TypedArray folderStyle = context.obtainStyledAttributes(inv.folderStyle,
Thales Limad852d652023-01-17 14:01:13 +0000467 R.styleable.FolderStyle);
Thales Limab35faed2022-09-05 16:30:01 -0300468 // These are re-set in #updateFolderCellSize if the grid is not scalable
469 folderCellHeightPx = folderStyle.getDimensionPixelSize(
Thales Limad852d652023-01-17 14:01:13 +0000470 R.styleable.FolderStyle_folderCellHeight, 0);
Thales Limab35faed2022-09-05 16:30:01 -0300471 folderCellWidthPx = folderStyle.getDimensionPixelSize(
Thales Limad852d652023-01-17 14:01:13 +0000472 R.styleable.FolderStyle_folderCellWidth, 0);
Thales Limab35faed2022-09-05 16:30:01 -0300473
474 folderContentPaddingTop = folderStyle.getDimensionPixelSize(
Thales Limad852d652023-01-17 14:01:13 +0000475 R.styleable.FolderStyle_folderTopPadding, 0);
Jordan Silva637f4eb2023-06-13 11:21:53 +0100476
477 int gutter = folderStyle.getDimensionPixelSize(
Thales Limad852d652023-01-17 14:01:13 +0000478 R.styleable.FolderStyle_folderBorderSpace, 0);
Jordan Silva637f4eb2023-06-13 11:21:53 +0100479 folderCellLayoutBorderSpacePx = new Point(gutter, gutter);
Thales Limab35faed2022-09-05 16:30:01 -0300480 folderFooterHeightPx = folderStyle.getDimensionPixelSize(
Thales Limad852d652023-01-17 14:01:13 +0000481 R.styleable.FolderStyle_folderFooterHeight, 0);
Thales Limab35faed2022-09-05 16:30:01 -0300482 folderStyle.recycle();
Jordan Silva637f4eb2023-06-13 11:21:53 +0100483 } else if (!mIsResponsiveGrid) {
484 folderCellLayoutBorderSpacePx = new Point(0, 0);
Thales Lima7eee74b2023-03-16 16:00:55 -0300485 folderFooterHeightPx = res.getDimensionPixelSize(R.dimen.folder_footer_height_default);
Thales Limab35faed2022-09-05 16:30:01 -0300486 folderContentPaddingTop = res.getDimensionPixelSize(R.dimen.folder_top_padding_default);
487 }
Jon Mirandae126d722021-02-25 10:45:20 -0500488
Thales Lima85c942f2021-12-31 13:04:20 +0000489 allAppsBorderSpacePx = new Point(
Thales Limabb7d3882021-12-22 12:56:29 +0000490 pxFromDp(inv.allAppsBorderSpaces[mTypeIndex].x, mMetrics),
491 pxFromDp(inv.allAppsBorderSpaces[mTypeIndex].y, mMetrics));
Thales Limae9273ea2023-01-26 12:33:52 +0000492 setupAllAppsStyle(context);
Jon Mirandae126d722021-02-25 10:45:20 -0500493
Tony Wickham5edf9e22020-03-27 20:06:52 -0700494 workspacePageIndicatorHeight = res.getDimensionPixelSize(
495 R.dimen.workspace_page_indicator_height);
496 mWorkspacePageIndicatorOverlapWorkspace =
497 res.getDimensionPixelSize(R.dimen.workspace_page_indicator_overlap_workspace);
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700498
Jordan Silva999dd2a2023-11-17 19:31:43 +0000499 if (!mIsResponsiveGrid) {
500 TypedArray cellStyle;
501 if (inv.cellStyle != INVALID_RESOURCE_HANDLE) {
502 cellStyle = context.obtainStyledAttributes(inv.cellStyle,
503 R.styleable.CellStyle);
504 } else {
505 cellStyle = context.obtainStyledAttributes(R.style.CellStyleDefault,
506 R.styleable.CellStyle);
507 }
508 mIconDrawablePaddingOriginalPx = cellStyle.getDimensionPixelSize(
509 R.styleable.CellStyle_iconDrawablePadding, 0);
510 cellStyle.recycle();
Thales Limad852d652023-01-17 14:01:13 +0000511 }
Alex Chaua02eddc2021-04-29 00:36:06 +0100512
Sunny Goyal47328fd2016-05-25 18:56:41 -0700513 dropTargetBarSizePx = res.getDimensionPixelSize(R.dimen.dynamic_grid_drop_target_size);
fbaron3bb6d4b2024-02-23 10:54:13 -0800514 // Some foldable portrait modes are too wide in terms of aspect ratio so we need to tweak
515 // the dimensions for edit state.
516 final boolean shouldApplyWidePortraitDimens = isTablet
517 && !isLandscape
518 && aspectRatio < MAX_ASPECT_RATIO_FOR_ALTERNATE_EDIT_STATE;
519 dropTargetBarTopMarginPx = shouldApplyWidePortraitDimens
520 ? 0
521 : res.getDimensionPixelSize(R.dimen.drop_target_top_margin);
522 dropTargetBarBottomMarginPx = shouldApplyWidePortraitDimens
523 ? res.getDimensionPixelSize(R.dimen.drop_target_bottom_margin_wide_portrait)
524 : res.getDimensionPixelSize(R.dimen.drop_target_bottom_margin);
Alex Chaua02eddc2021-04-29 00:36:06 +0100525 dropTargetDragPaddingPx = res.getDimensionPixelSize(R.dimen.drop_target_drag_padding);
526 dropTargetTextSizePx = res.getDimensionPixelSize(R.dimen.drop_target_text_size);
Pat Manningde25c0d2022-04-05 19:11:26 +0100527 dropTargetHorizontalPaddingPx = res.getDimensionPixelSize(
528 R.dimen.drop_target_button_drawable_horizontal_padding);
529 dropTargetVerticalPaddingPx = res.getDimensionPixelSize(
530 R.dimen.drop_target_button_drawable_vertical_padding);
531 dropTargetGapPx = res.getDimensionPixelSize(R.dimen.drop_target_button_gap);
Alex Chau5b019302022-05-23 10:42:25 +0100532 dropTargetButtonWorkspaceEdgeGapPx = res.getDimensionPixelSize(
533 R.dimen.drop_target_button_workspace_edge_gap);
Alex Chaua02eddc2021-04-29 00:36:06 +0100534
Alex Chau906d8822022-05-23 10:42:25 +0100535 workspaceSpringLoadedMinNextPageVisiblePx = res.getDimensionPixelSize(
536 R.dimen.dynamic_grid_spring_loaded_min_next_space_visible);
Sunny Goyald5190522017-04-24 03:06:54 -0700537
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700538 workspaceCellPaddingXPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_cell_padding_x);
Jon Miranda09660722017-06-14 14:20:14 -0700539
Thales Limaa1012902022-01-13 17:58:42 +0000540 hotseatQsbHeight = res.getDimensionPixelSize(R.dimen.qsb_widget_height);
Thales Limab8c05952022-05-23 16:58:38 +0100541 hotseatQsbShadowHeight = res.getDimensionPixelSize(R.dimen.qsb_shadow_height);
542 hotseatQsbVisualHeight = hotseatQsbHeight - 2 * hotseatQsbShadowHeight;
543
Thales Lima12d0eff2022-03-25 17:06:11 +0000544 // Whether QSB might be inline in appropriate orientation (e.g. landscape).
545 boolean canQsbInline = (isTwoPanels ? inv.inlineQsb[INDEX_TWO_PANEL_PORTRAIT]
546 || inv.inlineQsb[INDEX_TWO_PANEL_LANDSCAPE]
547 : inv.inlineQsb[INDEX_DEFAULT] || inv.inlineQsb[INDEX_LANDSCAPE])
548 && hotseatQsbHeight > 0;
Thales Lima79456492023-05-23 11:32:22 +0100549 isQsbInline = mIsScalableGrid && inv.inlineQsb[mTypeIndex] && canQsbInline;
Alex Chau6ed408f2022-03-04 12:58:05 +0000550
Thales Lima425f6822022-05-10 13:44:58 -0300551 areNavButtonsInline = isTaskbarPresent && !isGestureMode;
Thales Lima9938c2f2022-07-25 14:38:16 +0100552 numShownHotseatIcons =
553 isTwoPanels ? inv.numDatabaseHotseatIcons : inv.numShownHotseatIcons;
Alex Chau6ed408f2022-03-04 12:58:05 +0000554
Sunny Goyal19ff7282021-04-22 10:12:54 -0700555 numShownAllAppsColumns =
556 isTwoPanels ? inv.numDatabaseAllAppsColumns : inv.numAllAppsColumns;
Thales Limab8c05952022-05-23 16:58:38 +0100557
Thales Lima8e11d532023-08-31 13:40:26 +0000558 int hotseatBarBottomSpace;
Thales Limab8c05952022-05-23 16:58:38 +0100559 int minQsbMargin = res.getDimensionPixelSize(R.dimen.min_qsb_margin);
Thales Limaf8bfb032023-07-24 15:08:05 +0100560
561 if (mIsResponsiveGrid) {
Jordan Silvaf2402e22023-10-26 19:53:16 +0100562 float responsiveAspectRatio = (float) widthPx / heightPx;
563 HotseatSpecsProvider hotseatSpecsProvider =
564 HotseatSpecsProvider.create(new ResourceHelper(context,
Thales Limaf8bfb032023-07-24 15:08:05 +0100565 isTwoPanels ? inv.hotseatSpecsTwoPanelId : inv.hotseatSpecsId));
Thales Lima8e11d532023-08-31 13:40:26 +0000566 mResponsiveHotseatSpec =
Jordan Silvaf2402e22023-10-26 19:53:16 +0100567 isVerticalBarLayout() ? hotseatSpecsProvider.getCalculatedSpec(
568 responsiveAspectRatio, DimensionType.WIDTH, widthPx)
569 : hotseatSpecsProvider.getCalculatedSpec(responsiveAspectRatio,
570 DimensionType.HEIGHT, heightPx);
Thales Limaf8bfb032023-07-24 15:08:05 +0100571 hotseatQsbSpace = mResponsiveHotseatSpec.getHotseatQsbSpace();
Thales Lima8e11d532023-08-31 13:40:26 +0000572 hotseatBarBottomSpace =
573 isVerticalBarLayout() ? 0 : mResponsiveHotseatSpec.getEdgePadding();
574 mHotseatBarEdgePaddingPx =
575 isVerticalBarLayout() ? mResponsiveHotseatSpec.getEdgePadding() : 0;
576 mHotseatBarWorkspaceSpacePx = 0;
Jordan Silva999dd2a2023-11-17 19:31:43 +0000577
578 ResponsiveCellSpecsProvider workspaceCellSpecs = ResponsiveCellSpecsProvider.create(
579 new ResourceHelper(context,
580 isTwoPanels ? inv.workspaceCellSpecsTwoPanelId
581 : inv.workspaceCellSpecsId));
582 mResponsiveWorkspaceCellSpec = workspaceCellSpecs.getCalculatedSpec(
583 responsiveAspectRatio, heightPx);
Thales Limaf8bfb032023-07-24 15:08:05 +0100584 } else {
585 hotseatQsbSpace = pxFromDp(inv.hotseatQsbSpace[mTypeIndex], mMetrics);
Thales Lima8e11d532023-08-31 13:40:26 +0000586 hotseatBarBottomSpace = pxFromDp(inv.hotseatBarBottomSpace[mTypeIndex], mMetrics);
587 mHotseatBarEdgePaddingPx =
588 isVerticalBarLayout() ? workspacePageIndicatorHeight : 0;
589 mHotseatBarWorkspaceSpacePx =
590 res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_side_padding);
Thales Limaf8bfb032023-07-24 15:08:05 +0100591 }
592
Thales Lima8e11d532023-08-31 13:40:26 +0000593 if (!isVerticalBarLayout()) {
594 // Have a little space between the inset and the QSB
595 if (mInsets.bottom + minQsbMargin > hotseatBarBottomSpace) {
596 int availableSpace = hotseatQsbSpace - (mInsets.bottom - hotseatBarBottomSpace);
Thales Limab8c05952022-05-23 16:58:38 +0100597
Thales Lima8e11d532023-08-31 13:40:26 +0000598 // Only change the spaces if there is space
599 if (availableSpace > 0) {
600 // Make sure there is enough space between hotseat/QSB and QSB/navBar
601 if (availableSpace < minQsbMargin * 2) {
602 minQsbMargin = availableSpace / 2;
603 hotseatQsbSpace = minQsbMargin;
604 } else {
605 hotseatQsbSpace -= minQsbMargin;
606 }
Thales Limab8c05952022-05-23 16:58:38 +0100607 }
Thales Lima8e11d532023-08-31 13:40:26 +0000608 hotseatBarBottomSpacePx = mInsets.bottom + minQsbMargin;
Thales Limab8c05952022-05-23 16:58:38 +0100609
Thales Lima8e11d532023-08-31 13:40:26 +0000610 } else {
611 hotseatBarBottomSpacePx = hotseatBarBottomSpace;
612 }
Thales Limaa1012902022-01-13 17:58:42 +0000613 }
Thales Lima425f6822022-05-10 13:44:58 -0300614
fbaron3bb6d4b2024-02-23 10:54:13 -0800615 springLoadedHotseatBarTopMarginPx = shouldApplyWidePortraitDimens
616 ? res.getDimensionPixelSize(R.dimen.spring_loaded_hotseat_top_margin_wide_portrait)
617 : res.getDimensionPixelSize(R.dimen.spring_loaded_hotseat_top_margin);
Jordan Silva999dd2a2023-11-17 19:31:43 +0000618
619 if (mIsResponsiveGrid) {
620 updateHotseatSizes(mResponsiveWorkspaceCellSpec.getIconSize());
621 } else {
622 updateHotseatSizes(pxFromDp(inv.iconSize[mTypeIndex], mMetrics));
623 }
624
Vinit Nayak8a3d0552022-08-05 10:43:29 -0700625 if (areNavButtonsInline && !isPhone) {
Jon Mirandae17a9492023-03-08 16:42:20 -0800626 inlineNavButtonsEndSpacingPx =
Thales Limaffc68b02023-01-09 16:20:23 +0000627 res.getDimensionPixelSize(inv.inlineNavButtonsEndSpacing);
Pat Manning26f70f72022-07-07 13:50:39 +0100628 /*
629 * 3 nav buttons +
Vinit Nayakc7293172022-07-18 16:41:50 -0700630 * Spacing between nav buttons +
Thales Lima6a590062022-11-22 15:52:49 +0000631 * Space at the end for contextual buttons
Pat Manning26f70f72022-07-07 13:50:39 +0100632 */
633 hotseatBarEndOffset = 3 * res.getDimensionPixelSize(R.dimen.taskbar_nav_buttons_size)
Vinit Nayakc7293172022-07-18 16:41:50 -0700634 + 2 * res.getDimensionPixelSize(R.dimen.taskbar_button_space_inbetween)
Jon Mirandae17a9492023-03-08 16:42:20 -0800635 + inlineNavButtonsEndSpacingPx;
Pat Manning26f70f72022-07-07 13:50:39 +0100636 } else {
Jon Mirandae17a9492023-03-08 16:42:20 -0800637 inlineNavButtonsEndSpacingPx = 0;
Pat Manning26f70f72022-07-07 13:50:39 +0100638 hotseatBarEndOffset = 0;
639 }
Jon Miranda8bdb2222021-06-23 18:10:10 -0700640
Liran Binyamina833af32023-08-02 16:30:27 -0400641 mBubbleBarSpaceThresholdPx =
642 res.getDimensionPixelSize(R.dimen.bubblebar_hotseat_adjustment_threshold);
643
Thales Lima79456492023-05-23 11:32:22 +0100644 // Needs to be calculated after hotseatBarSizePx is correct,
645 // for the available height to be correct
646 if (mIsResponsiveGrid) {
Thales Lima2759aa32023-06-05 16:25:45 +0100647 int availableResponsiveWidth =
648 availableWidthPx - (isVerticalBarLayout() ? hotseatBarSizePx : 0);
Jordan Silva376036a2023-11-08 15:56:40 +0000649 int numWorkspaceColumns = getPanelCount() * inv.numColumns;
Thales Lima8e11d532023-08-31 13:40:26 +0000650 // don't use availableHeightPx because it subtracts mInsets.bottom
651 int availableResponsiveHeight = heightPx - mInsets.top
Jordan Silvaf2402e22023-10-26 19:53:16 +0100652 - (isVerticalBarLayout() ? 0 : hotseatBarSizePx);
653 float responsiveAspectRatio = (float) widthPx / heightPx;
Thales Limaabfe3642023-05-24 18:08:53 +0100654
Jordan Silvaf2402e22023-10-26 19:53:16 +0100655 ResponsiveSpecsProvider workspaceSpecs = ResponsiveSpecsProvider.create(
Jordan Silva575c3bd2023-07-21 12:00:43 +0100656 new ResourceHelper(context,
Jordan Silvaf2402e22023-10-26 19:53:16 +0100657 isTwoPanels ? inv.workspaceSpecsTwoPanelId : inv.workspaceSpecsId),
658 ResponsiveSpecType.Workspace);
Jordan Silva8f7986a2023-11-08 12:11:25 +0000659 mResponsiveWorkspaceWidthSpec = workspaceSpecs.getCalculatedSpec(responsiveAspectRatio,
Jordan Silva376036a2023-11-08 15:56:40 +0000660 DimensionType.WIDTH, numWorkspaceColumns, availableResponsiveWidth);
Jordan Silva8f7986a2023-11-08 12:11:25 +0000661 mResponsiveWorkspaceHeightSpec = workspaceSpecs.getCalculatedSpec(responsiveAspectRatio,
Jordan Silvaf2402e22023-10-26 19:53:16 +0100662 DimensionType.HEIGHT, inv.numRows, availableResponsiveHeight);
Jordan Silva637f4eb2023-06-13 11:21:53 +0100663
Jordan Silvaf2402e22023-10-26 19:53:16 +0100664 ResponsiveSpecsProvider allAppsSpecs = ResponsiveSpecsProvider.create(
Jordan Silva575c3bd2023-07-21 12:00:43 +0100665 new ResourceHelper(context,
Jordan Silvaf2402e22023-10-26 19:53:16 +0100666 isTwoPanels ? inv.allAppsSpecsTwoPanelId : inv.allAppsSpecsId),
667 ResponsiveSpecType.AllApps);
Jordan Silva8f7986a2023-11-08 12:11:25 +0000668 mResponsiveAllAppsWidthSpec = allAppsSpecs.getCalculatedSpec(responsiveAspectRatio,
Jordan Silva8b3fa142023-11-13 21:31:38 +0000669 DimensionType.WIDTH, numShownAllAppsColumns, availableWidthPx,
Jordan Silva8f7986a2023-11-08 12:11:25 +0000670 mResponsiveWorkspaceWidthSpec);
671 mResponsiveAllAppsHeightSpec = allAppsSpecs.getCalculatedSpec(responsiveAspectRatio,
Jordan Silva2de6a272024-01-04 14:44:20 -0300672 DimensionType.HEIGHT, inv.numAllAppsRowsForCellHeightCalculation,
673 heightPx - mInsets.top, mResponsiveWorkspaceHeightSpec);
Jordan Silvaf2402e22023-10-26 19:53:16 +0100674
675 ResponsiveSpecsProvider folderSpecs = ResponsiveSpecsProvider.create(
676 new ResourceHelper(context,
677 isTwoPanels ? inv.folderSpecsTwoPanelId : inv.folderSpecsId),
678 ResponsiveSpecType.Folder);
679 mResponsiveFolderWidthSpec = folderSpecs.getCalculatedSpec(responsiveAspectRatio,
Thales Lima1faa4ed2023-12-01 16:48:19 +0000680 DimensionType.WIDTH, numFolderColumns,
Jordan Silva8f7986a2023-11-08 12:11:25 +0000681 mResponsiveWorkspaceWidthSpec.getAvailableSpace(),
682 mResponsiveWorkspaceWidthSpec);
Jordan Silvaf2402e22023-10-26 19:53:16 +0100683 mResponsiveFolderHeightSpec = folderSpecs.getCalculatedSpec(responsiveAspectRatio,
Thales Lima1faa4ed2023-12-01 16:48:19 +0000684 DimensionType.HEIGHT, numFolderRows,
Jordan Silva8f7986a2023-11-08 12:11:25 +0000685 mResponsiveWorkspaceHeightSpec.getAvailableSpace(),
686 mResponsiveWorkspaceHeightSpec);
Jordan Silva999dd2a2023-11-17 19:31:43 +0000687
688 ResponsiveCellSpecsProvider allAppsCellSpecs = ResponsiveCellSpecsProvider.create(
689 new ResourceHelper(context,
690 isTwoPanels ? inv.allAppsCellSpecsTwoPanelId
691 : inv.allAppsCellSpecsId));
692 mResponsiveAllAppsCellSpec = allAppsCellSpecs.getCalculatedSpec(
693 responsiveAspectRatio,
694 mResponsiveAllAppsHeightSpec.getAvailableSpace(),
695 mResponsiveWorkspaceCellSpec);
Thales Lima79456492023-05-23 11:32:22 +0100696 }
697
698 desiredWorkspaceHorizontalMarginPx = getHorizontalMarginPx(inv, res);
699 desiredWorkspaceHorizontalMarginOriginalPx = desiredWorkspaceHorizontalMarginPx;
700
Alex Chau635b3ab2022-01-26 16:49:10 +0000701 overviewTaskMarginPx = res.getDimensionPixelSize(R.dimen.overview_task_margin);
Pat Manning1695cc72023-07-05 11:45:13 +0100702 overviewTaskIconSizePx = enableOverviewIconMenu() ? res.getDimensionPixelSize(
703 R.dimen.task_thumbnail_icon_menu_drawable_touch_size) : res.getDimensionPixelSize(
704 R.dimen.task_thumbnail_icon_size);
Alex Chauac9df382021-08-02 19:08:41 +0100705 overviewTaskIconDrawableSizePx =
706 res.getDimensionPixelSize(R.dimen.task_thumbnail_icon_drawable_size);
707 overviewTaskIconDrawableSizeGridPx =
708 res.getDimensionPixelSize(R.dimen.task_thumbnail_icon_drawable_size_grid);
Pat Manning1695cc72023-07-05 11:45:13 +0100709 overviewTaskThumbnailTopMarginPx =
710 enableOverviewIconMenu() ? 0 : overviewTaskIconSizePx + overviewTaskMarginPx;
Andy Wickhambc3bac42023-08-07 16:02:23 -0700711 // Don't add margin with floating search bar to minimize risk of overlapping.
712 overviewActionsTopMarginPx = FeatureFlags.ENABLE_FLOATING_SEARCH_BAR.get() ? 0
713 : res.getDimensionPixelSize(R.dimen.overview_actions_top_margin);
Alex Chau635b3ab2022-01-26 16:49:10 +0000714 overviewPageSpacing = res.getDimensionPixelSize(R.dimen.overview_page_spacing);
715 overviewActionsButtonSpacing = res.getDimensionPixelSize(
716 R.dimen.overview_actions_button_spacing);
Andy Wickhambc3bac42023-08-07 16:02:23 -0700717 overviewActionsHeight = res.getDimensionPixelSize(R.dimen.overview_actions_height);
Jeremy Sim1cfe6d42022-07-15 14:40:38 -0700718 overviewRowSpacing = res.getDimensionPixelSize(R.dimen.overview_grid_row_spacing);
Alex Chau635b3ab2022-01-26 16:49:10 +0000719 overviewGridSideMargin = res.getDimensionPixelSize(R.dimen.overview_grid_side_margin);
Zak Cohen334efeb2021-03-19 16:42:07 -0700720
Jeremy Sim0ac47082022-10-10 13:59:40 -0700721 splitPlaceholderInset = res.getDimensionPixelSize(R.dimen.split_placeholder_inset);
Winson Chung104a4c82023-11-08 18:56:15 +0000722 // We need to use the full window bounds for split determination because on near-square
723 // devices, the available bounds (bounds minus insets) may actually be in landscape while
724 // actually portrait
725 int leftRightSplitPortraitResId = Resources.getSystem().getIdentifier(
726 "config_leftRightSplitInPortrait", "bool", "android");
727 boolean allowLeftRightSplitInPortrait =
728 com.android.wm.shell.Flags.enableLeftRightSplitInPortrait()
729 && leftRightSplitPortraitResId > 0
730 && res.getBoolean(leftRightSplitPortraitResId);
731 if (allowLeftRightSplitInPortrait && isTablet) {
732 isLeftRightSplit = !isLandscape;
733 } else {
734 isLeftRightSplit = isLandscape;
735 }
Jeremy Sim0ac47082022-10-10 13:59:40 -0700736
Jon Miranda2ed276e2017-06-29 11:36:34 -0700737 // Calculate all of the remaining variables.
Brandon Dayauon5787a272023-12-14 13:47:17 -0800738 extraSpace = updateAvailableDimensions(context);
Jon Miranda80cddbc2021-07-22 13:51:16 -0700739
Thales Lima79456492023-05-23 11:32:22 +0100740 calculateAndSetWorkspaceVerticalPadding(context, inv, extraSpace);
Pat Manning08610ca2022-04-05 21:03:16 +0100741
742 int cellLayoutPadding =
743 isTwoPanels ? cellLayoutBorderSpacePx.x / 2 : res.getDimensionPixelSize(
744 R.dimen.cell_layout_padding);
745 cellLayoutPaddingPx = new Rect(cellLayoutPadding, cellLayoutPadding, cellLayoutPadding,
746 cellLayoutPadding);
Sunny Goyal07b69292018-01-08 14:19:34 -0800747 updateWorkspacePadding();
Tony Wickham1237df02017-02-24 08:59:36 -0800748
Thales Lima7eee74b2023-03-16 16:00:55 -0300749 // Folder scaling requires correct workspace paddings
750 updateAvailableFolderCellDimensions(res);
751
Thales Limaffc68b02023-01-09 16:20:23 +0000752 mMinHotseatIconSpacePx = res.getDimensionPixelSize(R.dimen.min_hotseat_icon_space);
753 mMinHotseatQsbWidthPx = res.getDimensionPixelSize(R.dimen.min_hotseat_qsb_width);
754 mMaxHotseatIconSpacePx = areNavButtonsInline
Thales Lima6a590062022-11-22 15:52:49 +0000755 ? res.getDimensionPixelSize(R.dimen.max_hotseat_icon_space) : Integer.MAX_VALUE;
Thales Lima425f6822022-05-10 13:44:58 -0300756 // Hotseat and QSB width depends on updated cellSize and workspace padding
Thales Lima6a590062022-11-22 15:52:49 +0000757 recalculateHotseatWidthAndBorderSpace();
Alex Chau206ede92022-08-01 17:46:12 +0100758
Jordan Silva3646a1b2023-08-02 13:52:52 +0100759 if (mIsResponsiveGrid && isVerticalBarLayout()) {
760 hotseatBorderSpace = cellLayoutBorderSpacePx.y;
761 }
762
Alex Chau206ede92022-08-01 17:46:12 +0100763 if (isTablet) {
Andy Wickham99d7d4f2023-11-15 08:09:09 +0000764 allAppsPadding.top = mInsets.top;
765 allAppsShiftRange = heightPx;
Alex Chau206ede92022-08-01 17:46:12 +0100766 } else {
Thales Limab433c9c2023-10-30 12:24:05 +0000767 allAppsPadding.top = 0;
Alex Chau206ede92022-08-01 17:46:12 +0100768 allAppsShiftRange =
769 res.getDimensionPixelSize(R.dimen.all_apps_starting_vertical_translate);
770 }
Alex Chau3d2c0622022-09-01 21:28:14 +0100771 allAppsOpenDuration = res.getInteger(R.integer.config_allAppsOpenDuration);
772 allAppsCloseDuration = res.getInteger(R.integer.config_allAppsCloseDuration);
Thales Lima425f6822022-05-10 13:44:58 -0300773
Alex Chaua02eddc2021-04-29 00:36:06 +0100774 flingToDeleteThresholdVelocity = res.getDimensionPixelSize(
775 R.dimen.drag_flingToDeleteMinVelocity);
776
Sihua Mae04aa202022-07-18 12:43:56 -0700777 mViewScaleProvider = viewScaleProvider;
778
Jon Miranda2b25ded2023-02-02 14:48:45 -0800779 dimensionOverrideProvider.accept(this);
780
Tony Wickham1237df02017-02-24 08:59:36 -0800781 // This is done last, after iconSizePx is calculated above.
Sunny Goyal799e1202023-02-09 10:54:28 -0800782 mDotRendererWorkSpace = createDotRenderer(context, iconSizePx, dotRendererCache);
783 mDotRendererAllApps = createDotRenderer(context, allAppsIconSizePx, dotRendererCache);
Sunny Goyal65190ae2022-08-02 14:16:26 -0700784 }
785
786 private static DotRenderer createDotRenderer(
Sunny Goyal799e1202023-02-09 10:54:28 -0800787 @NonNull Context context, int size, @NonNull SparseArray<DotRenderer> cache) {
Sunny Goyal65190ae2022-08-02 14:16:26 -0700788 DotRenderer renderer = cache.get(size);
789 if (renderer == null) {
Sunny Goyal799e1202023-02-09 10:54:28 -0800790 renderer = new DotRenderer(size, getShapePath(context, DEFAULT_DOT_SIZE),
791 DEFAULT_DOT_SIZE);
Sunny Goyal65190ae2022-08-02 14:16:26 -0700792 cache.put(size, renderer);
793 }
794 return renderer;
Adam Cohen63f1ec02014-08-12 09:23:13 -0700795 }
796
Thales Lima425f6822022-05-10 13:44:58 -0300797 /**
Fengjiang Li6c590822023-09-25 15:04:57 -0700798 * Return maximum of all apps row count displayed on screen. Note that 1) Partially displayed
799 * row is counted as 1 row, and 2) we don't exclude the space of floating search bar. This
800 * method is used for calculating number of {@link BubbleTextView} we need to pre-inflate. Thus
801 * reasonable over estimation is fine.
802 */
803 public int getMaxAllAppsRowCount() {
Thales Limab433c9c2023-10-30 12:24:05 +0000804 return (int) (Math.ceil((availableHeightPx - allAppsPadding.top)
Fengjiang Li6c590822023-09-25 15:04:57 -0700805 / (float) allAppsCellHeightPx));
806 }
807
808 /**
Thales Lima425f6822022-05-10 13:44:58 -0300809 * QSB width is always calculated because when in 3 button nav the width doesn't follow the
810 * width of the hotseat.
811 */
Thales Lima9938c2f2022-07-25 14:38:16 +0100812 private int calculateQsbWidth(int hotseatBorderSpace) {
fbarone69b6f42023-12-18 13:20:34 -0800813 int iconExtraSpacePx = iconSizePx - getIconVisibleSizePx(iconSizePx);
Thales Lima425f6822022-05-10 13:44:58 -0300814 if (isQsbInline) {
Alex Chau906d8822022-05-23 10:42:25 +0100815 int columns = getPanelCount() * inv.numColumns;
Thales Lima425f6822022-05-10 13:44:58 -0300816 return getIconToIconWidthForColumns(columns)
817 - iconSizePx * numShownHotseatIcons
fbarone69b6f42023-12-18 13:20:34 -0800818 - hotseatBorderSpace * numShownHotseatIcons
819 - iconExtraSpacePx;
Thales Lima425f6822022-05-10 13:44:58 -0300820 } else {
821 int columns = inv.hotseatColumnSpan[mTypeIndex];
fbarone69b6f42023-12-18 13:20:34 -0800822 return getIconToIconWidthForColumns(columns) - iconExtraSpacePx;
Thales Lima425f6822022-05-10 13:44:58 -0300823 }
824 }
Thales Lima2903a622022-03-17 13:52:19 +0000825
Thales Lima425f6822022-05-10 13:44:58 -0300826 private int getIconToIconWidthForColumns(int columns) {
827 return columns * getCellSize().x
828 + (columns - 1) * cellLayoutBorderSpacePx.x
Thales Lima1e8b45f2022-08-25 11:50:59 -0400829 - getCellHorizontalSpace();
Thales Limaa1012902022-01-13 17:58:42 +0000830 }
831
Thales Limad90faab2021-09-21 17:18:47 +0100832 private int getHorizontalMarginPx(InvariantDeviceProfile idp, Resources res) {
Thales Lima79456492023-05-23 11:32:22 +0100833 if (mIsResponsiveGrid) {
Jordan Silva8f7986a2023-11-08 12:11:25 +0000834 return mResponsiveWorkspaceWidthSpec.getStartPaddingPx();
Thales Lima79456492023-05-23 11:32:22 +0100835 }
836
Thales Limad90faab2021-09-21 17:18:47 +0100837 if (isVerticalBarLayout()) {
838 return 0;
839 }
840
Thales Lima79456492023-05-23 11:32:22 +0100841 return mIsScalableGrid
Thales Lima83bedbf2021-10-05 17:47:39 +0100842 ? pxFromDp(idp.horizontalMargin[mTypeIndex], mMetrics)
843 : res.getDimensionPixelSize(R.dimen.dynamic_grid_left_right_margin);
Thales Limad90faab2021-09-21 17:18:47 +0100844 }
845
Thales Lima79456492023-05-23 11:32:22 +0100846 private void calculateAndSetWorkspaceVerticalPadding(Context context,
847 InvariantDeviceProfile inv,
848 int extraSpace) {
849 if (mIsResponsiveGrid) {
Jordan Silva8f7986a2023-11-08 12:11:25 +0000850 workspaceTopPadding = mResponsiveWorkspaceHeightSpec.getStartPaddingPx();
851 workspaceBottomPadding = mResponsiveWorkspaceHeightSpec.getEndPaddingPx();
Thales Lima79456492023-05-23 11:32:22 +0100852 } else if (mIsScalableGrid && inv.devicePaddingId != INVALID_RESOURCE_HANDLE) {
853 // Paddings were created assuming no scaling, so we first unscale the extra space.
854 int unscaledExtraSpace = (int) (extraSpace / cellScaleToFit);
855 DevicePaddings devicePaddings = new DevicePaddings(context, inv.devicePaddingId);
856 DevicePadding padding = devicePaddings.getDevicePadding(unscaledExtraSpace);
857 maxEmptySpace = padding.getMaxEmptySpacePx();
858
859 int paddingWorkspaceTop = padding.getWorkspaceTopPadding(unscaledExtraSpace);
860 int paddingWorkspaceBottom = padding.getWorkspaceBottomPadding(unscaledExtraSpace);
861
862 workspaceTopPadding = Math.round(paddingWorkspaceTop * cellScaleToFit);
863 workspaceBottomPadding = Math.round(paddingWorkspaceBottom * cellScaleToFit);
864 }
865 }
866
Thales Limab8c05952022-05-23 16:58:38 +0100867 /** Updates hotseatCellHeightPx and hotseatBarSizePx */
868 private void updateHotseatSizes(int hotseatIconSizePx) {
Jon Miranda92c1b5d2021-07-20 13:57:16 -0700869 // Ensure there is enough space for folder icons, which have a slightly larger radius.
Jordan Silva3646a1b2023-08-02 13:52:52 +0100870 hotseatCellHeightPx = getIconSizeWithOverlap(hotseatIconSizePx);
Thales Limab8c05952022-05-23 16:58:38 +0100871
Jon Miranda0d284852021-06-22 14:50:55 -0700872 if (isVerticalBarLayout()) {
Thales Lima8e11d532023-08-31 13:40:26 +0000873 hotseatBarSizePx = hotseatIconSizePx + mHotseatBarEdgePaddingPx
874 + mHotseatBarWorkspaceSpacePx;
Thales Limab8c05952022-05-23 16:58:38 +0100875 } else if (isQsbInline) {
876 hotseatBarSizePx = Math.max(hotseatIconSizePx, hotseatQsbVisualHeight)
877 + hotseatBarBottomSpacePx;
Jon Miranda0d284852021-06-22 14:50:55 -0700878 } else {
Thales Limab8c05952022-05-23 16:58:38 +0100879 hotseatBarSizePx = hotseatIconSizePx
880 + hotseatQsbSpace
881 + hotseatQsbVisualHeight
882 + hotseatBarBottomSpacePx;
Jon Miranda0d284852021-06-22 14:50:55 -0700883 }
884 }
885
Thales Lima6a590062022-11-22 15:52:49 +0000886 /**
887 * Calculates the width of the hotseat, changing spaces between the icons and removing icons if
888 * necessary.
889 */
890 public void recalculateHotseatWidthAndBorderSpace() {
Thales Lima79456492023-05-23 11:32:22 +0100891 if (!mIsScalableGrid) return;
Thales Lima6a590062022-11-22 15:52:49 +0000892
893 int columns = inv.hotseatColumnSpan[mTypeIndex];
894 float hotseatWidthPx = getIconToIconWidthForColumns(columns);
895 hotseatBorderSpace = calculateHotseatBorderSpace(hotseatWidthPx, /* numExtraBorder= */ 0);
Thales Lima9938c2f2022-07-25 14:38:16 +0100896 hotseatQsbWidth = calculateQsbWidth(hotseatBorderSpace);
Thales Lima6a590062022-11-22 15:52:49 +0000897 // Spaces should be correct when the nav buttons are not inline
Thales Lima9938c2f2022-07-25 14:38:16 +0100898 if (!areNavButtonsInline) {
899 return;
900 }
901
Thales Lima6a590062022-11-22 15:52:49 +0000902 // The side space with inline buttons should be what is defined in InvariantDeviceProfile
Jon Mirandae17a9492023-03-08 16:42:20 -0800903 int sideSpacePx = inlineNavButtonsEndSpacingPx;
Thales Limaffc68b02023-01-09 16:20:23 +0000904 int maxHotseatWidthPx = availableWidthPx - sideSpacePx - hotseatBarEndOffset;
905 int maxHotseatIconsWidthPx = maxHotseatWidthPx - (isQsbInline ? hotseatQsbWidth : 0);
906 hotseatBorderSpace = calculateHotseatBorderSpace(maxHotseatIconsWidthPx,
Thales Lima6a590062022-11-22 15:52:49 +0000907 (isQsbInline ? 1 : 0) + /* border between nav buttons and first icon */ 1);
Thales Lima9938c2f2022-07-25 14:38:16 +0100908
Thales Limaffc68b02023-01-09 16:20:23 +0000909 if (hotseatBorderSpace >= mMinHotseatIconSpacePx) {
Thales Lima9938c2f2022-07-25 14:38:16 +0100910 return;
911 }
912
913 // Border space can't be less than the minimum
Thales Limaffc68b02023-01-09 16:20:23 +0000914 hotseatBorderSpace = mMinHotseatIconSpacePx;
Thales Lima6a590062022-11-22 15:52:49 +0000915 int requiredWidth = getHotseatRequiredWidth();
Thales Lima9938c2f2022-07-25 14:38:16 +0100916
917 // If there is an inline qsb, change its size
918 if (isQsbInline) {
Thales Limaffc68b02023-01-09 16:20:23 +0000919 hotseatQsbWidth -= requiredWidth - maxHotseatWidthPx;
920 if (hotseatQsbWidth >= mMinHotseatQsbWidthPx) {
Thales Lima9938c2f2022-07-25 14:38:16 +0100921 return;
922 }
923
924 // QSB can't be less than the minimum
Thales Limaffc68b02023-01-09 16:20:23 +0000925 hotseatQsbWidth = mMinHotseatQsbWidthPx;
Thales Lima9938c2f2022-07-25 14:38:16 +0100926 }
927
Thales Limaffc68b02023-01-09 16:20:23 +0000928 maxHotseatIconsWidthPx = maxHotseatWidthPx - (isQsbInline ? hotseatQsbWidth : 0);
Thales Lima6a590062022-11-22 15:52:49 +0000929
Thales Lima9938c2f2022-07-25 14:38:16 +0100930 // If it still doesn't fit, start removing icons
931 do {
932 numShownHotseatIcons--;
Thales Limaffc68b02023-01-09 16:20:23 +0000933 hotseatBorderSpace = calculateHotseatBorderSpace(maxHotseatIconsWidthPx,
Thales Lima6a590062022-11-22 15:52:49 +0000934 (isQsbInline ? 1 : 0) + /* border between nav buttons and first icon */ 1);
Thales Limaffc68b02023-01-09 16:20:23 +0000935 } while (hotseatBorderSpace < mMinHotseatIconSpacePx && numShownHotseatIcons > 1);
Thales Lima9938c2f2022-07-25 14:38:16 +0100936 }
937
Thales Lima78d00ad2021-09-30 11:29:06 +0100938 private Point getCellLayoutBorderSpace(InvariantDeviceProfile idp) {
Thales Lima080d8902022-03-28 15:30:29 +0100939 return getCellLayoutBorderSpace(idp, 1f);
Thales Lima080d8902022-03-28 15:30:29 +0100940 }
941
942 private Point getCellLayoutBorderSpace(InvariantDeviceProfile idp, float scale) {
Thales Lima79456492023-05-23 11:32:22 +0100943 int horizontalSpacePx = 0;
944 int verticalSpacePx = 0;
Thales Lima78d00ad2021-09-30 11:29:06 +0100945
Thales Lima79456492023-05-23 11:32:22 +0100946 if (mIsResponsiveGrid) {
Jordan Silva8f7986a2023-11-08 12:11:25 +0000947 horizontalSpacePx = mResponsiveWorkspaceWidthSpec.getGutterPx();
948 verticalSpacePx = mResponsiveWorkspaceHeightSpec.getGutterPx();
Thales Lima79456492023-05-23 11:32:22 +0100949 } else if (mIsScalableGrid) {
950 horizontalSpacePx = pxFromDp(idp.borderSpaces[mTypeIndex].x, mMetrics, scale);
951 verticalSpacePx = pxFromDp(idp.borderSpaces[mTypeIndex].y, mMetrics, scale);
952 }
Thales Lima78d00ad2021-09-30 11:29:06 +0100953
954 return new Point(horizontalSpacePx, verticalSpacePx);
955 }
956
Sunny Goyal69a8eec2021-07-22 10:02:50 -0700957 public Info getDisplayInfo() {
958 return mInfo;
959 }
960
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700961 public Builder toBuilder(Context context) {
Sunny Goyal187b16c2022-03-01 16:53:23 -0800962 WindowBounds bounds = new WindowBounds(
963 widthPx, heightPx, availableWidthPx, availableHeightPx, rotationHint);
Sunny Goyal19ff7282021-04-22 10:12:54 -0700964 bounds.bounds.offsetTo(windowX, windowY);
Alex Chaue0227552022-04-06 19:44:43 +0100965 bounds.insets.set(mInsets);
Sunny Goyal65190ae2022-08-02 14:16:26 -0700966
967 SparseArray<DotRenderer> dotRendererCache = new SparseArray<>();
968 dotRendererCache.put(iconSizePx, mDotRendererWorkSpace);
969 dotRendererCache.put(allAppsIconSizePx, mDotRendererAllApps);
970
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700971 return new Builder(context, inv, mInfo)
Sunny Goyal19ff7282021-04-22 10:12:54 -0700972 .setWindowBounds(bounds)
Alex Chauab800f72022-12-13 17:46:06 +0000973 .setIsMultiDisplay(isMultiDisplay)
Alex Chau6ed408f2022-03-04 12:58:05 +0000974 .setMultiWindowMode(isMultiWindowMode)
Sunny Goyal65190ae2022-08-02 14:16:26 -0700975 .setDotRendererCache(dotRendererCache)
Alex Chau6ed408f2022-03-04 12:58:05 +0000976 .setGestureMode(isGestureMode);
Sunny Goyal1a52ef52018-01-11 10:15:03 -0800977 }
978
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700979 public DeviceProfile copy(Context context) {
980 return toBuilder(context).build();
981 }
982
983 /**
984 * TODO: Move this to the builder as part of setMultiWindowMode
985 */
Sunny Goyalb46703d2020-05-27 17:52:03 -0700986 public DeviceProfile getMultiWindowProfile(Context context, WindowBounds windowBounds) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700987 DeviceProfile profile = toBuilder(context)
Sunny Goyal19ff7282021-04-22 10:12:54 -0700988 .setWindowBounds(windowBounds)
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700989 .setMultiWindowMode(true)
990 .build();
Jon Miranda93e1f042016-11-11 14:13:04 -0800991
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800992 // We use these scales to measure and layout the widgets using their full invariant profile
993 // sizes and then draw them scaled and centered to fit in their multi-window mode cellspans.
994 float appWidgetScaleX = (float) profile.getCellSize().x / getCellSize().x;
995 float appWidgetScaleY = (float) profile.getCellSize().y / getCellSize().y;
Sihua Mae04aa202022-07-18 12:43:56 -0700996 if (appWidgetScaleX != 1 || appWidgetScaleY != 1) {
997 final PointF p = new PointF(appWidgetScaleX, appWidgetScaleY);
998 profile = profile.toBuilder(context)
999 .setViewScaleProvider(i -> p)
1000 .build();
1001 }
1002
1003 profile.hideWorkspaceLabelsIfNotEnoughSpace();
Jon Miranda7ae64ff2016-11-21 16:18:46 -08001004
Jon Miranda93e1f042016-11-11 14:13:04 -08001005 return profile;
Jon Mirandacc42c5b2016-10-27 17:15:27 -07001006 }
1007
Adam Cohen63f1ec02014-08-12 09:23:13 -07001008 /**
Jon Miranda941375e2021-03-31 13:10:45 -04001009 * Checks if there is enough space for labels on the workspace.
1010 * If there is not, labels on the Workspace are hidden.
Jon Miranda1091e532017-07-21 13:31:50 -07001011 * It is important to call this method after the All Apps variables have been set.
1012 */
Jon Miranda941375e2021-03-31 13:10:45 -04001013 private void hideWorkspaceLabelsIfNotEnoughSpace() {
1014 float iconTextHeight = Utilities.calculateTextHeight(iconTextSizePx);
1015 float workspaceCellPaddingY = getCellSize().y - iconSizePx - iconDrawablePaddingPx
1016 - iconTextHeight;
1017
1018 // We want enough space so that the text is closer to its corresponding icon.
1019 if (workspaceCellPaddingY < iconTextHeight) {
1020 iconTextSizePx = 0;
1021 iconDrawablePaddingPx = 0;
Jordan Silva3646a1b2023-08-02 13:52:52 +01001022 cellHeightPx = getIconSizeWithOverlap(iconSizePx);
Jon Miranda941375e2021-03-31 13:10:45 -04001023 autoResizeAllAppsCells();
1024 }
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001025 }
Jon Miranda1091e532017-07-21 13:31:50 -07001026
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001027 /**
Jon Miranda228877d2021-02-09 11:05:00 -05001028 * Returns the amount of extra (or unused) vertical space.
1029 */
Brandon Dayauon5787a272023-12-14 13:47:17 -08001030 private int updateAvailableDimensions(Context context) {
fbaronfc6bbcf2024-01-29 10:35:17 -08001031 iconCenterVertically = (mIsScalableGrid || mIsResponsiveGrid) && isVerticalBarLayout();
Jordan Silva999dd2a2023-11-17 19:31:43 +00001032
1033 if (mIsResponsiveGrid) {
Jordan Silva15cacd52023-11-28 14:32:05 +00001034 iconSizePx = mResponsiveWorkspaceCellSpec.getIconSize();
1035 iconTextSizePx = mResponsiveWorkspaceCellSpec.getIconTextSize();
1036 mIconDrawablePaddingOriginalPx = mResponsiveWorkspaceCellSpec.getIconDrawablePadding();
Brandon Dayauon5787a272023-12-14 13:47:17 -08001037 updateIconSize(1f, context);
Jordan Silva999dd2a2023-11-17 19:31:43 +00001038 updateWorkspacePadding();
1039 return 0;
1040 }
1041
Alex Chaua68164d2022-12-15 16:16:03 +00001042 float invIconSizeDp = inv.iconSize[mTypeIndex];
1043 float invIconTextSizeSp = inv.iconTextSize[mTypeIndex];
1044 iconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mMetrics));
1045 iconTextSizePx = pxFromSp(invIconTextSizeSp, mMetrics);
1046
Brandon Dayauon5787a272023-12-14 13:47:17 -08001047 updateIconSize(1f, context);
Pat Manning08610ca2022-04-05 21:03:16 +01001048 updateWorkspacePadding();
Jon Mirandae126d722021-02-25 10:45:20 -05001049
1050 // Check to see if the icons fit within the available height.
Pat Manninga2e14992022-04-22 11:29:17 +01001051 float usedHeight = getCellLayoutHeightSpecification();
Pat Manning25d53342022-05-10 09:58:49 +00001052 final int maxHeight = getCellLayoutHeight();
Jon Miranda228877d2021-02-09 11:05:00 -05001053 float extraHeight = Math.max(0, maxHeight - usedHeight);
Jon Mirandae126d722021-02-25 10:45:20 -05001054 float scaleY = maxHeight / usedHeight;
1055 boolean shouldScale = scaleY < 1f;
1056
1057 float scaleX = 1f;
Thales Lima79456492023-05-23 11:32:22 +01001058 if (mIsScalableGrid) {
Jon Mirandae126d722021-02-25 10:45:20 -05001059 // We scale to fit the cellWidth and cellHeight in the available space.
1060 // The benefit of scalable grids is that we can get consistent aspect ratios between
1061 // devices.
Pat Manninga2e14992022-04-22 11:29:17 +01001062 float usedWidth =
1063 getCellLayoutWidthSpecification() + (desiredWorkspaceHorizontalMarginPx * 2);
Jon Mirandae126d722021-02-25 10:45:20 -05001064 // We do not subtract padding here, as we also scale the workspace padding if needed.
1065 scaleX = availableWidthPx / usedWidth;
1066 shouldScale = true;
Winson Chungb3800242013-10-24 11:01:54 -07001067 }
Jon Mirandae126d722021-02-25 10:45:20 -05001068
1069 if (shouldScale) {
1070 float scale = Math.min(scaleX, scaleY);
Brandon Dayauon5787a272023-12-14 13:47:17 -08001071 updateIconSize(scale, context);
Pat Manninga2e14992022-04-22 11:29:17 +01001072 extraHeight = Math.max(0, maxHeight - getCellLayoutHeightSpecification());
Jon Mirandae126d722021-02-25 10:45:20 -05001073 }
1074
Jon Miranda228877d2021-02-09 11:05:00 -05001075 return Math.round(extraHeight);
Winson Chungb3800242013-10-24 11:01:54 -07001076 }
1077
Pat Manninga2e14992022-04-22 11:29:17 +01001078 private int getCellLayoutHeightSpecification() {
Pat Manning08610ca2022-04-05 21:03:16 +01001079 return (cellHeightPx * inv.numRows) + (cellLayoutBorderSpacePx.y * (inv.numRows - 1))
1080 + cellLayoutPaddingPx.top + cellLayoutPaddingPx.bottom;
1081 }
1082
Pat Manninga2e14992022-04-22 11:29:17 +01001083 private int getCellLayoutWidthSpecification() {
Pat Manning25d53342022-05-10 09:58:49 +00001084 int numColumns = getPanelCount() * inv.numColumns;
Pat Manning08610ca2022-04-05 21:03:16 +01001085 return (cellWidthPx * numColumns) + (cellLayoutBorderSpacePx.x * (numColumns - 1))
1086 + cellLayoutPaddingPx.left + cellLayoutPaddingPx.right;
Jon Mirandae126d722021-02-25 10:45:20 -05001087 }
1088
Jordan Silva376036a2023-11-08 15:56:40 +00001089 private int getNormalizedIconDrawablePadding(int iconSizePx, int iconDrawablePadding) {
fbarone69b6f42023-12-18 13:20:34 -08001090 return Math.max(0, iconDrawablePadding
1091 - ((iconSizePx - getIconVisibleSizePx(iconSizePx)) / 2));
Jordan Silva376036a2023-11-08 15:56:40 +00001092 }
1093
1094 private int getNormalizedIconDrawablePadding() {
1095 return getNormalizedIconDrawablePadding(iconSizePx, mIconDrawablePaddingOriginalPx);
Thales Lima93ee8fc2023-06-05 17:07:11 +01001096 }
1097
1098 private int getNormalizedFolderChildDrawablePaddingPx(int textHeight) {
1099 // TODO(b/235886078): workaround needed because of this bug
1100 // Icons are 10% larger on XML than their visual size,
1101 // so remove that extra space to get labels closer to the correct padding
1102 int drawablePadding = (folderCellHeightPx - folderChildIconSizePx - textHeight) / 3;
1103
fbarone69b6f42023-12-18 13:20:34 -08001104 int iconSizeDiff = folderChildIconSizePx - getIconVisibleSizePx(folderChildIconSizePx);
Thales Lima93ee8fc2023-06-05 17:07:11 +01001105 return Math.max(0, drawablePadding - iconSizeDiff / 2);
1106 }
1107
Jordan Silva3646a1b2023-08-02 13:52:52 +01001108 private int getIconSizeWithOverlap(int iconSize) {
1109 return (int) Math.ceil(iconSize * ICON_OVERLAP_FACTOR);
1110 }
1111
Jon Miranda6f7e9702019-09-16 14:44:14 -07001112 /**
1113 * Updating the iconSize affects many aspects of the launcher layout, such as: iconSizePx,
1114 * iconTextSizePx, iconDrawablePaddingPx, cellWidth/Height, allApps* variants,
1115 * hotseat sizes, workspaceSpringLoadedShrinkFactor, folderIconSizePx, and folderIconOffsetYPx.
1116 */
Brandon Dayauon5787a272023-12-14 13:47:17 -08001117 public void updateIconSize(float scale, Context context) {
Jon Mirandaab3c6812021-06-28 15:42:28 -07001118 // Icon scale should never exceed 1, otherwise pixellation may occur.
1119 iconScale = Math.min(1f, scale);
1120 cellScaleToFit = scale;
1121
Jon Miranda18751b62017-07-31 17:25:27 -07001122 // Workspace
Sunny Goyal07b69292018-01-08 14:19:34 -08001123 final boolean isVerticalLayout = isVerticalBarLayout();
Thales Lima080d8902022-03-28 15:30:29 +01001124 cellLayoutBorderSpacePx = getCellLayoutBorderSpace(inv, scale);
Jon Mirandae126d722021-02-25 10:45:20 -05001125
Thales Lima79456492023-05-23 11:32:22 +01001126 if (mIsResponsiveGrid) {
Jordan Silva8f7986a2023-11-08 12:11:25 +00001127 cellWidthPx = mResponsiveWorkspaceWidthSpec.getCellSizePx();
1128 cellHeightPx = mResponsiveWorkspaceHeightSpec.getCellSizePx();
Thales Lima79456492023-05-23 11:32:22 +01001129
Thales Lima2759aa32023-06-05 16:25:45 +01001130 if (cellWidthPx < iconSizePx) {
1131 // get a smaller icon size
1132 iconSizePx = mIconSizeSteps.getIconSmallerThan(cellWidthPx);
Thales Lima2759aa32023-06-05 16:25:45 +01001133 }
1134
Jordan Silvadd612682024-01-08 11:38:13 -03001135 if (isVerticalLayout) {
1136 iconDrawablePaddingPx = 0;
1137 iconTextSizePx = 0;
1138 } else {
1139 iconDrawablePaddingPx = getNormalizedIconDrawablePadding();
1140 }
Thales Lima93ee8fc2023-06-05 17:07:11 +01001141
Thales Lima24ceca62023-09-25 16:21:17 -07001142 CellContentDimensions cellContentDimensions = new CellContentDimensions(iconSizePx,
1143 iconDrawablePaddingPx,
1144 iconTextSizePx);
Jordan Silvadd612682024-01-08 11:38:13 -03001145 int cellContentHeight = cellContentDimensions.resizeToFitCellHeight(cellHeightPx,
1146 mIconSizeSteps);
Thales Lima24ceca62023-09-25 16:21:17 -07001147 iconSizePx = cellContentDimensions.getIconSizePx();
1148 iconDrawablePaddingPx = cellContentDimensions.getIconDrawablePaddingPx();
1149 iconTextSizePx = cellContentDimensions.getIconTextSizePx();
Thales Lima2759aa32023-06-05 16:25:45 +01001150
Jordan Silvadd612682024-01-08 11:38:13 -03001151 if (isVerticalLayout) {
1152 cellYPaddingPx = Math.max(0, getCellSize().y - getIconSizeWithOverlap(iconSizePx))
1153 / 2;
1154 } else {
1155 cellYPaddingPx = Math.max(0, cellHeightPx - cellContentHeight) / 2;
1156 }
Thales Lima79456492023-05-23 11:32:22 +01001157 } else if (mIsScalableGrid) {
Thales Lima93ee8fc2023-06-05 17:07:11 +01001158 iconDrawablePaddingPx = (int) (getNormalizedIconDrawablePadding() * iconScale);
Thales Lima83bedbf2021-10-05 17:47:39 +01001159 cellWidthPx = pxFromDp(inv.minCellSize[mTypeIndex].x, mMetrics, scale);
1160 cellHeightPx = pxFromDp(inv.minCellSize[mTypeIndex].y, mMetrics, scale);
Alex Chaube753132022-12-09 16:46:54 +00001161
1162 if (cellWidthPx < iconSizePx) {
1163 // If cellWidth no longer fit iconSize, reduce borderSpace to make cellWidth bigger.
1164 int numColumns = getPanelCount() * inv.numColumns;
1165 int numBorders = numColumns - 1;
1166 int extraWidthRequired = (iconSizePx - cellWidthPx) * numColumns;
1167 if (cellLayoutBorderSpacePx.x * numBorders >= extraWidthRequired) {
1168 cellWidthPx = iconSizePx;
1169 cellLayoutBorderSpacePx.x -= extraWidthRequired / numBorders;
1170 } else {
1171 // If it still doesn't fit, set borderSpace to 0 and distribute the space for
1172 // cellWidth, and reduce iconSize.
1173 cellWidthPx = (cellWidthPx * numColumns
1174 + cellLayoutBorderSpacePx.x * numBorders) / numColumns;
1175 iconSizePx = Math.min(iconSizePx, cellWidthPx);
1176 cellLayoutBorderSpacePx.x = 0;
1177 }
1178 }
1179
Thales Lima93ee8fc2023-06-05 17:07:11 +01001180 int cellTextAndPaddingHeight =
1181 iconDrawablePaddingPx + Utilities.calculateTextHeight(iconTextSizePx);
Alex Chaube753132022-12-09 16:46:54 +00001182 int cellContentHeight = iconSizePx + cellTextAndPaddingHeight;
1183 if (cellHeightPx < cellContentHeight) {
1184 // If cellHeight no longer fit iconSize, reduce borderSpace to make cellHeight
1185 // bigger.
1186 int numBorders = inv.numRows - 1;
1187 int extraHeightRequired = (cellContentHeight - cellHeightPx) * inv.numRows;
1188 if (cellLayoutBorderSpacePx.y * numBorders >= extraHeightRequired) {
1189 cellHeightPx = cellContentHeight;
1190 cellLayoutBorderSpacePx.y -= extraHeightRequired / numBorders;
1191 } else {
Alex Chau06f36e82023-01-06 10:50:54 +00001192 // If it still doesn't fit, set borderSpace to 0 to recover space.
Alex Chaube753132022-12-09 16:46:54 +00001193 cellHeightPx = (cellHeightPx * inv.numRows
1194 + cellLayoutBorderSpacePx.y * numBorders) / inv.numRows;
Alex Chaube753132022-12-09 16:46:54 +00001195 cellLayoutBorderSpacePx.y = 0;
Alex Chau06f36e82023-01-06 10:50:54 +00001196 // Reduce iconDrawablePaddingPx to make cellContentHeight smaller.
1197 int cellContentWithoutPadding = cellContentHeight - iconDrawablePaddingPx;
1198 if (cellContentWithoutPadding <= cellHeightPx) {
1199 iconDrawablePaddingPx = cellContentHeight - cellHeightPx;
1200 } else {
1201 // If it still doesn't fit, set iconDrawablePaddingPx to 0 to recover space,
1202 // then proportional reduce iconSizePx and iconTextSizePx to fit.
1203 iconDrawablePaddingPx = 0;
1204 float ratio = cellHeightPx / (float) cellContentWithoutPadding;
1205 iconSizePx = (int) (iconSizePx * ratio);
1206 iconTextSizePx = (int) (iconTextSizePx * ratio);
1207 }
1208 cellTextAndPaddingHeight =
1209 iconDrawablePaddingPx + Utilities.calculateTextHeight(iconTextSizePx);
Alex Chaube753132022-12-09 16:46:54 +00001210 }
1211 cellContentHeight = iconSizePx + cellTextAndPaddingHeight;
1212 }
Jon Mirandae126d722021-02-25 10:45:20 -05001213 cellYPaddingPx = Math.max(0, cellHeightPx - cellContentHeight) / 2;
Thales Limad90faab2021-09-21 17:18:47 +01001214 desiredWorkspaceHorizontalMarginPx =
1215 (int) (desiredWorkspaceHorizontalMarginOriginalPx * scale);
Jon Miranda228877d2021-02-09 11:05:00 -05001216 } else {
Thales Lima93ee8fc2023-06-05 17:07:11 +01001217 iconDrawablePaddingPx = (int) (getNormalizedIconDrawablePadding() * iconScale);
Jon Mirandae126d722021-02-25 10:45:20 -05001218 cellWidthPx = iconSizePx + iconDrawablePaddingPx;
Jordan Silva3646a1b2023-08-02 13:52:52 +01001219 cellHeightPx = getIconSizeWithOverlap(iconSizePx)
Jon Miranda92c1b5d2021-07-20 13:57:16 -07001220 + iconDrawablePaddingPx
Jon Miranda228877d2021-02-09 11:05:00 -05001221 + Utilities.calculateTextHeight(iconTextSizePx);
1222 int cellPaddingY = (getCellSize().y - cellHeightPx) / 2;
1223 if (iconDrawablePaddingPx > cellPaddingY && !isVerticalLayout
1224 && !isMultiWindowMode) {
1225 // Ensures that the label is closer to its corresponding icon. This is not an issue
1226 // with vertical bar layout or multi-window mode since the issue is handled
1227 // separately with their calls to {@link #adjustToHideWorkspaceLabels}.
1228 cellHeightPx -= (iconDrawablePaddingPx - cellPaddingY);
1229 iconDrawablePaddingPx = cellPaddingY;
1230 }
Jon Miranda846455e2017-10-02 14:58:52 -07001231 }
Jon Miranda18751b62017-07-31 17:25:27 -07001232
Sunny Goyalae190ff2020-04-14 00:19:01 +00001233 // All apps
Thales Limaabfe3642023-05-24 18:08:53 +01001234 if (mIsResponsiveGrid) {
Jordan Silva999dd2a2023-11-17 19:31:43 +00001235 updateAllAppsWithResponsiveMeasures();
Thales Limaabfe3642023-05-24 18:08:53 +01001236 } else {
Brandon Dayauon5787a272023-12-14 13:47:17 -08001237 updateAllAppsIconSize(scale, context.getResources());
Thales Limaabfe3642023-05-24 18:08:53 +01001238 }
1239 updateAllAppsContainerWidth();
Jordan Silvadd612682024-01-08 11:38:13 -03001240 if (isVerticalLayout && !mIsResponsiveGrid) {
Thales Limaabfe3642023-05-24 18:08:53 +01001241 hideWorkspaceLabelsIfNotEnoughSpace();
1242 }
Brandon Dayauon68c18232024-03-07 10:14:44 -08001243 if ((Flags.enableTwolineToggle()
1244 && LauncherPrefs.ENABLE_TWOLINE_ALLAPPS_TOGGLE.get(context))) {
Brandon Dayauon3cdb32c2023-08-22 21:26:37 -07001245 // Add extra textHeight to the existing allAppsCellHeight.
1246 allAppsCellHeightPx += Utilities.calculateTextHeight(allAppsIconTextSizePx);
1247 }
Winson Chungb3800242013-10-24 11:01:54 -07001248
Thales Limab8c05952022-05-23 16:58:38 +01001249 updateHotseatSizes(iconSizePx);
Winson Chungb3800242013-10-24 11:01:54 -07001250
Sunny Goyalbaec6ff2016-09-14 11:26:21 -07001251 // Folder icon
Jon Miranda591e3602018-03-28 11:37:00 -07001252 folderIconSizePx = IconNormalizer.getNormalizedCircleSize(iconSizePx);
1253 folderIconOffsetYPx = (iconSizePx - folderIconSizePx) / 2;
Sunny Goyal6c304b12023-04-10 12:03:04 -07001254
1255 // Update widget padding:
1256 float minSpacing = pxFromDp(MIN_WIDGET_PADDING_DP, mMetrics);
1257 if (cellLayoutBorderSpacePx.x < minSpacing
1258 || cellLayoutBorderSpacePx.y < minSpacing) {
1259 widgetPadding.left = widgetPadding.right =
1260 Math.round(Math.max(0, minSpacing - cellLayoutBorderSpacePx.x));
1261 widgetPadding.top = widgetPadding.bottom =
1262 Math.round(Math.max(0, minSpacing - cellLayoutBorderSpacePx.y));
1263 } else {
1264 widgetPadding.setEmpty();
1265 }
Winson Chung0f785722015-04-08 10:27:49 -07001266 }
1267
Thales Lima425f6822022-05-10 13:44:58 -03001268 /**
Thales Lima6a590062022-11-22 15:52:49 +00001269 * This method calculates the space between the icons to achieve a certain width.
Thales Lima425f6822022-05-10 13:44:58 -03001270 */
Thales Lima6a590062022-11-22 15:52:49 +00001271 private int calculateHotseatBorderSpace(float hotseatWidthPx, int numExtraBorder) {
Jordan Silvad9227182023-08-17 15:53:59 +01001272 int numBorders = (numShownHotseatIcons - 1 + numExtraBorder);
1273 if (numBorders <= 0) return 0;
1274
Thales Lima9938c2f2022-07-25 14:38:16 +01001275 float hotseatIconsTotalPx = iconSizePx * numShownHotseatIcons;
Jordan Silvad9227182023-08-17 15:53:59 +01001276 int hotseatBorderSpacePx = (int) (hotseatWidthPx - hotseatIconsTotalPx) / numBorders;
Thales Limaffc68b02023-01-09 16:20:23 +00001277 return Math.min(hotseatBorderSpacePx, mMaxHotseatIconSpacePx);
Thales Lima425f6822022-05-10 13:44:58 -03001278 }
1279
Brian Isganitis25b2ac82022-01-28 16:25:13 -05001280 /**
1281 * Updates the iconSize for allApps* variants.
1282 */
Brian Isganitisa9a78112022-05-23 18:11:47 -07001283 private void updateAllAppsIconSize(float scale, Resources res) {
Thales Lima080d8902022-03-28 15:30:29 +01001284 allAppsBorderSpacePx = new Point(
1285 pxFromDp(inv.allAppsBorderSpaces[mTypeIndex].x, mMetrics, scale),
1286 pxFromDp(inv.allAppsBorderSpaces[mTypeIndex].y, mMetrics, scale));
Brandon Dayauon07ca8842022-04-27 10:52:28 -07001287 // AllApps cells don't have real space between cells,
1288 // so we add the border space to the cell height
Alex Chaube753132022-12-09 16:46:54 +00001289 allAppsCellHeightPx = pxFromDp(inv.allAppsCellSize[mTypeIndex].y, mMetrics)
Brandon Dayauon07ca8842022-04-27 10:52:28 -07001290 + allAppsBorderSpacePx.y;
1291 // but width is just the cell,
1292 // the border is added in #updateAllAppsContainerWidth
Thales Lima79456492023-05-23 11:32:22 +01001293 if (mIsScalableGrid) {
Alex Chaube753132022-12-09 16:46:54 +00001294 allAppsIconSizePx = pxFromDp(inv.allAppsIconSize[mTypeIndex], mMetrics);
1295 allAppsIconTextSizePx = pxFromSp(inv.allAppsIconTextSize[mTypeIndex], mMetrics);
Thales Lima93ee8fc2023-06-05 17:07:11 +01001296 allAppsIconDrawablePaddingPx = getNormalizedIconDrawablePadding();
Brandon Dayauon7a8a9ed2022-06-06 14:32:22 -07001297 allAppsCellWidthPx = pxFromDp(inv.allAppsCellSize[mTypeIndex].x, mMetrics, scale);
Alex Chaube753132022-12-09 16:46:54 +00001298
1299 if (allAppsCellWidthPx < allAppsIconSizePx) {
1300 // If allAppsCellWidth no longer fit allAppsIconSize, reduce allAppsBorderSpace to
1301 // make allAppsCellWidth bigger.
1302 int numBorders = inv.numAllAppsColumns - 1;
1303 int extraWidthRequired =
1304 (allAppsIconSizePx - allAppsCellWidthPx) * inv.numAllAppsColumns;
1305 if (allAppsBorderSpacePx.x * numBorders >= extraWidthRequired) {
1306 allAppsCellWidthPx = allAppsIconSizePx;
1307 allAppsBorderSpacePx.x -= extraWidthRequired / numBorders;
1308 } else {
1309 // If it still doesn't fit, set allAppsBorderSpace to 0 and distribute the space
1310 // for allAppsCellWidth, and reduce allAppsIconSize.
1311 allAppsCellWidthPx = (allAppsCellWidthPx * inv.numAllAppsColumns
1312 + allAppsBorderSpacePx.x * numBorders) / inv.numAllAppsColumns;
1313 allAppsIconSizePx = Math.min(allAppsIconSizePx, allAppsCellWidthPx);
1314 allAppsBorderSpacePx.x = 0;
1315 }
1316 }
1317
1318 int cellContentHeight = allAppsIconSizePx
1319 + Utilities.calculateTextHeight(allAppsIconTextSizePx) + allAppsBorderSpacePx.y;
1320 if (allAppsCellHeightPx < cellContentHeight) {
1321 // Increase allAppsCellHeight to fit its content.
1322 allAppsCellHeightPx = cellContentHeight;
1323 }
Brian Isganitis25b2ac82022-01-28 16:25:13 -05001324 } else {
Brandon Dayauon07ca8842022-04-27 10:52:28 -07001325 float invIconSizeDp = inv.allAppsIconSize[mTypeIndex];
1326 float invIconTextSizeSp = inv.allAppsIconTextSize[mTypeIndex];
Brian Isganitis25b2ac82022-01-28 16:25:13 -05001327 allAppsIconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mMetrics, scale));
1328 allAppsIconTextSizePx = (int) (pxFromSp(invIconTextSizeSp, mMetrics) * scale);
Brandon Dayauon07ca8842022-04-27 10:52:28 -07001329 allAppsIconDrawablePaddingPx =
1330 res.getDimensionPixelSize(R.dimen.all_apps_icon_drawable_padding);
Brandon Dayauon7a8a9ed2022-06-06 14:32:22 -07001331 allAppsCellWidthPx = allAppsIconSizePx + (2 * allAppsIconDrawablePaddingPx);
Brian Isganitis25b2ac82022-01-28 16:25:13 -05001332 }
Thales Limaabfe3642023-05-24 18:08:53 +01001333 }
Brian Isganitis25b2ac82022-01-28 16:25:13 -05001334
Jordan Silva999dd2a2023-11-17 19:31:43 +00001335 private void updateAllAppsWithResponsiveMeasures() {
1336 allAppsIconSizePx = mResponsiveAllAppsCellSpec.getIconSize();
1337 allAppsIconTextSizePx = mResponsiveAllAppsCellSpec.getIconTextSize();
1338 allAppsIconDrawablePaddingPx = getNormalizedIconDrawablePadding(allAppsIconSizePx,
1339 mResponsiveAllAppsCellSpec.getIconDrawablePadding());
Thales Limaabfe3642023-05-24 18:08:53 +01001340 allAppsBorderSpacePx = new Point(
Jordan Silva8f7986a2023-11-08 12:11:25 +00001341 mResponsiveAllAppsWidthSpec.getGutterPx(),
1342 mResponsiveAllAppsHeightSpec.getGutterPx()
Thales Limaabfe3642023-05-24 18:08:53 +01001343 );
Jordan Silva999dd2a2023-11-17 19:31:43 +00001344 allAppsCellHeightPx = mResponsiveAllAppsHeightSpec.getCellSizePx();
Jordan Silva8f7986a2023-11-08 12:11:25 +00001345 allAppsCellWidthPx = mResponsiveAllAppsWidthSpec.getCellSizePx();
Thales Limaa25cd902023-11-01 12:00:32 +00001346
1347 // This workaround is needed to align AllApps icons with Workspace icons
1348 // since AllApps doesn't have borders between cells
1349 int halfBorder = allAppsBorderSpacePx.x / 2;
Jordan Silva8f7986a2023-11-08 12:11:25 +00001350 allAppsPadding.left = mResponsiveAllAppsWidthSpec.getStartPaddingPx() - halfBorder;
1351 allAppsPadding.right = mResponsiveAllAppsWidthSpec.getEndPaddingPx() - halfBorder;
Jordan Silva376036a2023-11-08 15:56:40 +00001352
Jordan Silva376036a2023-11-08 15:56:40 +00001353
1354 // Reduce the size of the app icon if it doesn't fit
1355 if (allAppsCellWidthPx < allAppsIconSizePx) {
1356 // get a smaller icon size
1357 allAppsIconSizePx = mIconSizeSteps.getIconSmallerThan(allAppsCellWidthPx);
1358 }
1359
1360 CellContentDimensions cellContentDimensions = new CellContentDimensions(
1361 allAppsIconSizePx, allAppsIconDrawablePaddingPx, (int) allAppsIconTextSizePx);
1362
1363 if (allAppsCellHeightPx < cellContentDimensions.getCellContentHeight()) {
1364 if (isVerticalBarLayout()) {
Jordan Silva2de6a272024-01-04 14:44:20 -03001365 if (allAppsCellHeightPx < allAppsIconSizePx) {
Jordan Silva376036a2023-11-08 15:56:40 +00001366 cellContentDimensions.setIconSizePx(
1367 mIconSizeSteps.getIconSmallerThan(allAppsCellHeightPx));
1368 }
1369 } else {
1370 cellContentDimensions.resizeToFitCellHeight(allAppsCellHeightPx,
1371 mIconSizeSteps);
1372 }
1373 allAppsIconSizePx = cellContentDimensions.getIconSizePx();
1374 allAppsIconDrawablePaddingPx = cellContentDimensions.getIconDrawablePaddingPx();
1375 allAppsIconTextSizePx = cellContentDimensions.getIconTextSizePx();
1376 }
Jordan Silva999dd2a2023-11-17 19:31:43 +00001377
1378 allAppsCellHeightPx += mResponsiveAllAppsHeightSpec.getGutterPx();
Jordan Silvadd612682024-01-08 11:38:13 -03001379
1380 if (isVerticalBarLayout()) {
1381 autoResizeAllAppsCells();
1382 }
Thales Limaabfe3642023-05-24 18:08:53 +01001383 }
1384
1385 /**
1386 * Re-computes the all-apps cell size to be independent of workspace
1387 */
1388 public void autoResizeAllAppsCells() {
1389 int textHeight = Utilities.calculateTextHeight(allAppsIconTextSizePx);
1390 int topBottomPadding = textHeight;
1391 allAppsCellHeightPx = allAppsIconSizePx + allAppsIconDrawablePaddingPx
1392 + textHeight + (topBottomPadding * 2);
1393 }
1394
1395 private void updateAllAppsContainerWidth() {
1396 int cellLayoutHorizontalPadding =
1397 (cellLayoutPaddingPx.left + cellLayoutPaddingPx.right) / 2;
1398 if (isTablet) {
1399 int usedWidth = (allAppsCellWidthPx * numShownAllAppsColumns)
1400 + (allAppsBorderSpacePx.x * (numShownAllAppsColumns - 1))
Thales Limab433c9c2023-10-30 12:24:05 +00001401 + allAppsPadding.left + allAppsPadding.right;
Thales Limaabfe3642023-05-24 18:08:53 +01001402 allAppsLeftRightMargin = Math.max(1, (availableWidthPx - usedWidth) / 2);
Thales Limaa25cd902023-11-01 12:00:32 +00001403 } else if (!mIsResponsiveGrid) {
Thales Limab433c9c2023-10-30 12:24:05 +00001404 allAppsPadding.left = allAppsPadding.right =
Thales Limaabfe3642023-05-24 18:08:53 +01001405 Math.max(0, desiredWorkspaceHorizontalMarginPx + cellLayoutHorizontalPadding
1406 - (allAppsBorderSpacePx.x / 2));
Brian Isganitis25b2ac82022-01-28 16:25:13 -05001407 }
1408 }
1409
Thales Limaabfe3642023-05-24 18:08:53 +01001410 private void setupAllAppsStyle(Context context) {
1411 TypedArray allAppsStyle = context.obtainStyledAttributes(
1412 inv.allAppsStyle != INVALID_RESOURCE_HANDLE ? inv.allAppsStyle
1413 : R.style.AllAppsStyleDefault, R.styleable.AllAppsStyle);
1414
Thales Limab433c9c2023-10-30 12:24:05 +00001415 allAppsPadding.left = allAppsPadding.right = allAppsStyle.getDimensionPixelSize(
Thales Limaabfe3642023-05-24 18:08:53 +01001416 R.styleable.AllAppsStyle_horizontalPadding, 0);
1417 allAppsStyle.recycle();
1418 }
1419
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001420 private void updateAvailableFolderCellDimensions(Resources res) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001421 updateFolderCellSize(1f, res);
Jon Mirandabf7d8122016-11-03 15:29:29 -07001422
Jordan Silva637f4eb2023-06-13 11:21:53 +01001423 // Responsive grid doesn't need to scale the folder
1424 if (mIsResponsiveGrid) return;
1425
Thales Lima7eee74b2023-03-16 16:00:55 -03001426 // For usability we can't have the folder use the whole width of the screen
Sunny Goyal07b69292018-01-08 14:19:34 -08001427 Point totalWorkspacePadding = getTotalWorkspacePadding();
Jon Mirandac1b23992016-12-13 08:57:36 -08001428
Thales Lima7eee74b2023-03-16 16:00:55 -03001429 // Check if the folder fit within the available height.
Thales Lima1faa4ed2023-12-01 16:48:19 +00001430 float contentUsedHeight = folderCellHeightPx * numFolderRows
1431 + ((numFolderRows - 1) * folderCellLayoutBorderSpacePx.y)
Thales Lima7eee74b2023-03-16 16:00:55 -03001432 + folderFooterHeightPx
1433 + folderContentPaddingTop;
1434 int contentMaxHeight = availableHeightPx - totalWorkspacePadding.y;
Samuel Fufa1c8d90a2019-11-12 17:54:58 -08001435 float scaleY = contentMaxHeight / contentUsedHeight;
Jon Mirandac1b23992016-12-13 08:57:36 -08001436
Thales Lima7eee74b2023-03-16 16:00:55 -03001437 // Check if the folder fit within the available width.
Thales Lima1faa4ed2023-12-01 16:48:19 +00001438 float contentUsedWidth = folderCellWidthPx * numFolderColumns
1439 + ((numFolderColumns - 1) * folderCellLayoutBorderSpacePx.x)
Thales Lima7eee74b2023-03-16 16:00:55 -03001440 + folderContentPaddingLeftRight * 2;
1441 int contentMaxWidth = availableWidthPx - totalWorkspacePadding.x;
Samuel Fufa1c8d90a2019-11-12 17:54:58 -08001442 float scaleX = contentMaxWidth / contentUsedWidth;
Jon Mirandac1b23992016-12-13 08:57:36 -08001443
1444 float scale = Math.min(scaleX, scaleY);
1445 if (scale < 1f) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001446 updateFolderCellSize(scale, res);
Jon Mirandabf7d8122016-11-03 15:29:29 -07001447 }
1448 }
1449
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001450 private void updateFolderCellSize(float scale, Resources res) {
Jordan Silva999dd2a2023-11-17 19:31:43 +00001451 int minLabelTextSize = pxFromSp(MIN_FOLDER_TEXT_SIZE_SP, mMetrics, scale);
Jordan Silva637f4eb2023-06-13 11:21:53 +01001452 if (mIsResponsiveGrid) {
Jordan Silva999dd2a2023-11-17 19:31:43 +00001453 folderChildIconSizePx = mResponsiveWorkspaceCellSpec.getIconSize();
1454 folderChildTextSizePx = mResponsiveWorkspaceCellSpec.getIconTextSize();
1455 folderLabelTextSizePx = Math.max(minLabelTextSize,
1456 (int) (folderChildTextSizePx * folderLabelTextScale));
1457 int textHeight = Utilities.calculateTextHeight(folderChildTextSizePx);
1458
Jordan Silva637f4eb2023-06-13 11:21:53 +01001459 folderCellWidthPx = mResponsiveFolderWidthSpec.getCellSizePx();
Jordan Silva637f4eb2023-06-13 11:21:53 +01001460 folderCellHeightPx = mResponsiveFolderHeightSpec.getCellSizePx();
1461 folderContentPaddingTop = mResponsiveFolderHeightSpec.getStartPaddingPx();
1462 folderFooterHeightPx = mResponsiveFolderHeightSpec.getEndPaddingPx();
1463
1464 folderCellLayoutBorderSpacePx = new Point(mResponsiveFolderWidthSpec.getGutterPx(),
Thales Lima4cfd9502023-07-10 14:01:28 +01001465 mResponsiveFolderHeightSpec.getGutterPx());
Jordan Silva637f4eb2023-06-13 11:21:53 +01001466
1467 folderContentPaddingLeftRight = mResponsiveFolderWidthSpec.getStartPaddingPx();
Jordan Silva12fae112023-06-26 12:51:01 +01001468
1469 // Reduce icon width if it's wider than the expected folder cell width
1470 if (folderCellWidthPx < folderChildIconSizePx) {
1471 folderChildIconSizePx = mIconSizeSteps.getIconSmallerThan(folderCellWidthPx);
1472 }
1473
1474 // Recalculating padding and cell height
Jordan Silva3e5688a2023-12-05 15:12:29 -03001475 folderChildDrawablePaddingPx = mResponsiveWorkspaceCellSpec.getIconDrawablePadding();
Jordan Silva12fae112023-06-26 12:51:01 +01001476
Thales Limae9b5e142023-11-04 17:10:13 +00001477 CellContentDimensions cellContentDimensions = new CellContentDimensions(
1478 folderChildIconSizePx,
1479 folderChildDrawablePaddingPx,
1480 folderChildTextSizePx);
1481 cellContentDimensions.resizeToFitCellHeight(folderCellHeightPx, mIconSizeSteps);
1482 folderChildIconSizePx = cellContentDimensions.getIconSizePx();
1483 folderChildDrawablePaddingPx = cellContentDimensions.getIconDrawablePaddingPx();
1484 folderChildTextSizePx = cellContentDimensions.getIconTextSizePx();
Jordan Silva999dd2a2023-11-17 19:31:43 +00001485 folderLabelTextSizePx = Math.max(minLabelTextSize,
Jordan Silva9a3bd8f2023-11-16 18:33:28 +00001486 (int) (folderChildTextSizePx * folderLabelTextScale));
Jordan Silva999dd2a2023-11-17 19:31:43 +00001487 return;
1488 }
1489
1490 float invIconSizeDp = inv.iconSize[mTypeIndex];
1491 float invIconTextSizeDp = inv.iconTextSize[mTypeIndex];
1492 folderChildIconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mMetrics, scale));
1493 folderChildTextSizePx = pxFromSp(invIconTextSizeDp, mMetrics, scale);
1494 folderLabelTextSizePx = Math.max(minLabelTextSize,
1495 (int) (folderChildTextSizePx * folderLabelTextScale));
1496 int textHeight = Utilities.calculateTextHeight(folderChildTextSizePx);
1497
1498 if (mIsScalableGrid) {
Thales Limab35faed2022-09-05 16:30:01 -03001499 if (inv.folderStyle == INVALID_RESOURCE_HANDLE) {
Thales Lima7eee74b2023-03-16 16:00:55 -03001500 folderCellWidthPx = roundPxValueFromFloat(getCellSize().x * scale);
1501 folderCellHeightPx = roundPxValueFromFloat(getCellSize().y * scale);
1502 } else {
1503 folderCellWidthPx = roundPxValueFromFloat(folderCellWidthPx * scale);
1504 folderCellHeightPx = roundPxValueFromFloat(folderCellHeightPx * scale);
Thales Limab35faed2022-09-05 16:30:01 -03001505 }
Charlie Anderson7bb10972023-11-22 13:35:30 -08001506 // Recalculating padding and cell height
1507 folderChildDrawablePaddingPx = getNormalizedFolderChildDrawablePaddingPx(textHeight);
1508
1509 CellContentDimensions cellContentDimensions = new CellContentDimensions(
1510 folderChildIconSizePx,
1511 folderChildDrawablePaddingPx,
1512 folderChildTextSizePx);
1513 cellContentDimensions.resizeToFitCellHeight(folderCellHeightPx, mIconSizeSteps);
1514 folderChildIconSizePx = cellContentDimensions.getIconSizePx();
1515 folderChildDrawablePaddingPx = cellContentDimensions.getIconDrawablePaddingPx();
1516 folderChildTextSizePx = cellContentDimensions.getIconTextSizePx();
Jon Mirandaf33f5b32021-07-22 17:15:31 -07001517
Thales Lima7eee74b2023-03-16 16:00:55 -03001518 folderContentPaddingTop = roundPxValueFromFloat(folderContentPaddingTop * scale);
Jordan Silva637f4eb2023-06-13 11:21:53 +01001519 folderCellLayoutBorderSpacePx = new Point(
1520 roundPxValueFromFloat(folderCellLayoutBorderSpacePx.x * scale),
1521 roundPxValueFromFloat(folderCellLayoutBorderSpacePx.y * scale)
1522 );
Thales Lima7eee74b2023-03-16 16:00:55 -03001523 folderFooterHeightPx = roundPxValueFromFloat(folderFooterHeightPx * scale);
Jordan Silva637f4eb2023-06-13 11:21:53 +01001524 folderContentPaddingLeftRight = folderCellLayoutBorderSpacePx.x;
Jon Miranda823da222021-03-23 08:08:45 -04001525 } else {
1526 int cellPaddingX = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_x_padding)
1527 * scale);
1528 int cellPaddingY = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_y_padding)
1529 * scale);
1530
1531 folderCellWidthPx = folderChildIconSizePx + 2 * cellPaddingX;
1532 folderCellHeightPx = folderChildIconSizePx + 2 * cellPaddingY + textHeight;
Thales Lima7eee74b2023-03-16 16:00:55 -03001533 folderContentPaddingTop = roundPxValueFromFloat(folderContentPaddingTop * scale);
Thales Limab35faed2022-09-05 16:30:01 -03001534 folderContentPaddingLeftRight =
1535 res.getDimensionPixelSize(R.dimen.folder_content_padding_left_right);
1536 folderFooterHeightPx =
Thales Lima7eee74b2023-03-16 16:00:55 -03001537 roundPxValueFromFloat(
1538 res.getDimensionPixelSize(R.dimen.folder_footer_height_default)
1539 * scale);
1540
Jordan Silva12fae112023-06-26 12:51:01 +01001541 folderChildDrawablePaddingPx = getNormalizedFolderChildDrawablePaddingPx(textHeight);
Jon Miranda823da222021-03-23 08:08:45 -04001542 }
Jon Mirandabf7d8122016-11-03 15:29:29 -07001543 }
1544
Winson1f064272016-07-18 17:18:02 -07001545 public void updateInsets(Rect insets) {
1546 mInsets.set(insets);
1547 }
1548
Sunny Goyalae6e3182019-04-30 12:04:37 -07001549 /**
1550 * The current device insets. This is generally same as the insets being dispatched to
1551 * {@link Insettable} elements, but can differ if the element is using a different profile.
1552 */
Sunny Goyal1a52ef52018-01-11 10:15:03 -08001553 public Rect getInsets() {
1554 return mInsets;
1555 }
1556
Sunny Goyal756cd262015-08-20 12:33:21 -07001557 public Point getCellSize() {
Sunny Goyal19ff7282021-04-22 10:12:54 -07001558 return getCellSize(null);
Jon Miranda6f7e9702019-09-16 14:44:14 -07001559 }
1560
Sunny Goyal19ff7282021-04-22 10:12:54 -07001561 public Point getCellSize(Point result) {
1562 if (result == null) {
1563 result = new Point();
1564 }
Thales Limad1df5fc2021-09-03 18:37:19 +01001565
Pat Manning25d53342022-05-10 09:58:49 +00001566 int shortcutAndWidgetContainerWidth =
1567 getCellLayoutWidth() - (cellLayoutPaddingPx.left + cellLayoutPaddingPx.right);
1568 result.x = calculateCellWidth(shortcutAndWidgetContainerWidth, cellLayoutBorderSpacePx.x,
1569 inv.numColumns);
1570 int shortcutAndWidgetContainerHeight =
1571 getCellLayoutHeight() - (cellLayoutPaddingPx.top + cellLayoutPaddingPx.bottom);
1572 result.y = calculateCellHeight(shortcutAndWidgetContainerHeight, cellLayoutBorderSpacePx.y,
1573 inv.numRows);
Sunny Goyal3e8a04b2022-05-09 19:31:45 +00001574 return result;
Pat Manningb45d6c42022-05-03 14:32:06 +01001575 }
1576
1577 /**
Thales Lima1e8b45f2022-08-25 11:50:59 -04001578 * Returns the left and right space on the cell, which is the cell width - icon size
1579 */
1580 public int getCellHorizontalSpace() {
1581 return getCellSize().x - iconSizePx;
1582 }
1583
1584 /**
Pat Manning25d53342022-05-10 09:58:49 +00001585 * Gets the number of panels within the workspace.
1586 */
1587 public int getPanelCount() {
1588 return isTwoPanels ? 2 : 1;
1589 }
1590
1591 /**
Pat Manningde25c0d2022-04-05 19:11:26 +01001592 * Gets the space in px from the bottom of last item in the vertical-bar hotseat to the
1593 * bottom of the screen.
1594 */
Pat Manning5f74bfd2022-07-20 12:08:54 +01001595 private int getVerticalHotseatLastItemBottomOffset(Context context) {
1596 Rect hotseatBarPadding = getHotseatLayoutPadding(context);
Pat Manningde25c0d2022-04-05 19:11:26 +01001597 int cellHeight = calculateCellHeight(
Pat Manning5f74bfd2022-07-20 12:08:54 +01001598 heightPx - hotseatBarPadding.top - hotseatBarPadding.bottom, hotseatBorderSpace,
Pat Manningde25c0d2022-04-05 19:11:26 +01001599 numShownHotseatIcons);
Pat Manningde25c0d2022-04-05 19:11:26 +01001600 int extraIconEndSpacing = (cellHeight - iconSizePx) / 2;
Pat Manning5f74bfd2022-07-20 12:08:54 +01001601 return extraIconEndSpacing + hotseatBarPadding.bottom;
Pat Manningde25c0d2022-04-05 19:11:26 +01001602 }
1603
1604 /**
1605 * Gets the scaled top of the workspace in px for the spring-loaded edit state.
1606 */
Pat Manning25d53342022-05-10 09:58:49 +00001607 public float getCellLayoutSpringLoadShrunkTop() {
Pat Manning5f74bfd2022-07-20 12:08:54 +01001608 return mInsets.top + dropTargetBarTopMarginPx + dropTargetBarSizePx
Pat Manningde25c0d2022-04-05 19:11:26 +01001609 + dropTargetBarBottomMarginPx;
Pat Manningde25c0d2022-04-05 19:11:26 +01001610 }
1611
1612 /**
1613 * Gets the scaled bottom of the workspace in px for the spring-loaded edit state.
1614 */
Pat Manning5f74bfd2022-07-20 12:08:54 +01001615 public float getCellLayoutSpringLoadShrunkBottom(Context context) {
Pat Manningde25c0d2022-04-05 19:11:26 +01001616 int topOfHotseat = hotseatBarSizePx + springLoadedHotseatBarTopMarginPx;
Pat Manning5f74bfd2022-07-20 12:08:54 +01001617 return heightPx - (isVerticalBarLayout()
1618 ? getVerticalHotseatLastItemBottomOffset(context) : topOfHotseat);
Pat Manningde25c0d2022-04-05 19:11:26 +01001619 }
1620
Pat Manningea5c1d22022-04-14 10:58:16 +01001621 /**
Pat Manninga2e14992022-04-22 11:29:17 +01001622 * Gets the scale of the workspace for the spring-loaded edit state.
1623 */
Pat Manning5f74bfd2022-07-20 12:08:54 +01001624 public float getWorkspaceSpringLoadScale(Context context) {
1625 float scale =
1626 (getCellLayoutSpringLoadShrunkBottom(context) - getCellLayoutSpringLoadShrunkTop())
1627 / getCellLayoutHeight();
Pat Manninga2e14992022-04-22 11:29:17 +01001628 scale = Math.min(scale, 1f);
1629
Pat Manninge63dd252022-08-02 16:15:29 +01001630 // Reduce scale if next pages would not be visible after scaling the workspace.
Pat Manning25d53342022-05-10 09:58:49 +00001631 int workspaceWidth = availableWidthPx;
Pat Manninga2e14992022-04-22 11:29:17 +01001632 float scaledWorkspaceWidth = workspaceWidth * scale;
Alex Chau906d8822022-05-23 10:42:25 +01001633 float maxAvailableWidth = workspaceWidth - (2 * workspaceSpringLoadedMinNextPageVisiblePx);
Pat Manninga2e14992022-04-22 11:29:17 +01001634 if (scaledWorkspaceWidth > maxAvailableWidth) {
1635 scale *= maxAvailableWidth / scaledWorkspaceWidth;
1636 }
1637 return scale;
1638 }
1639
Pat Manning25d53342022-05-10 09:58:49 +00001640 /**
1641 * Gets the width of a single Cell Layout, aka a single panel within a Workspace.
1642 *
1643 * <p>This is the width of a Workspace, less its horizontal padding. Note that two-panel
1644 * layouts have two Cell Layouts per workspace.
1645 */
1646 public int getCellLayoutWidth() {
1647 return (availableWidthPx - getTotalWorkspacePadding().x) / getPanelCount();
Alex Chau60953332021-11-24 12:41:07 +00001648 }
1649
Pat Manning25d53342022-05-10 09:58:49 +00001650 /**
1651 * Gets the height of a single Cell Layout, aka a single panel within a Workspace.
1652 *
1653 * <p>This is the height of a Workspace, less its vertical padding.
1654 */
1655 public int getCellLayoutHeight() {
1656 return availableHeightPx - getTotalWorkspacePadding().y;
Pat Manning08610ca2022-04-05 21:03:16 +01001657 }
1658
Sunny Goyal6c2975e2016-07-06 09:47:56 -07001659 public Point getTotalWorkspacePadding() {
Sunny Goyal07b69292018-01-08 14:19:34 -08001660 return new Point(workspacePadding.left + workspacePadding.right,
1661 workspacePadding.top + workspacePadding.bottom);
Sunny Goyal6c2975e2016-07-06 09:47:56 -07001662 }
1663
1664 /**
Sunny Goyal07b69292018-01-08 14:19:34 -08001665 * Updates {@link #workspacePadding} as a result of any internal value change to reflect the
1666 * new workspace padding
Sunny Goyal6c2975e2016-07-06 09:47:56 -07001667 */
Sunny Goyal07b69292018-01-08 14:19:34 -08001668 private void updateWorkspacePadding() {
1669 Rect padding = workspacePadding;
Tony Wickham3a3517f2015-10-06 11:27:04 -07001670 if (isVerticalBarLayout()) {
Jordan Silva3646a1b2023-08-02 13:52:52 +01001671 if (mIsResponsiveGrid) {
Jordan Silva8f7986a2023-11-08 12:11:25 +00001672 padding.top = mResponsiveWorkspaceHeightSpec.getStartPaddingPx();
Thales Lima8e11d532023-08-31 13:40:26 +00001673 padding.bottom = Math.max(0,
Jordan Silva8f7986a2023-11-08 12:11:25 +00001674 mResponsiveWorkspaceHeightSpec.getEndPaddingPx() - mInsets.bottom);
Jordan Silva3646a1b2023-08-02 13:52:52 +01001675 if (isSeascape()) {
Jordan Silva8f7986a2023-11-08 12:11:25 +00001676 padding.left =
1677 hotseatBarSizePx + mResponsiveWorkspaceWidthSpec.getEndPaddingPx();
1678 padding.right = mResponsiveWorkspaceWidthSpec.getStartPaddingPx();
Jordan Silva3646a1b2023-08-02 13:52:52 +01001679 } else {
Jordan Silva8f7986a2023-11-08 12:11:25 +00001680 padding.left = mResponsiveWorkspaceWidthSpec.getStartPaddingPx();
1681 padding.right =
1682 hotseatBarSizePx + mResponsiveWorkspaceWidthSpec.getEndPaddingPx();
Jordan Silva3646a1b2023-08-02 13:52:52 +01001683 }
Winson1f064272016-07-18 17:18:02 -07001684 } else {
Jordan Silva3646a1b2023-08-02 13:52:52 +01001685 padding.top = 0;
1686 padding.bottom = edgeMarginPx;
1687 if (isSeascape()) {
1688 padding.left = hotseatBarSizePx;
Thales Lima8e11d532023-08-31 13:40:26 +00001689 padding.right = mHotseatBarEdgePaddingPx;
Jordan Silva3646a1b2023-08-02 13:52:52 +01001690 } else {
Thales Lima8e11d532023-08-31 13:40:26 +00001691 padding.left = mHotseatBarEdgePaddingPx;
Jordan Silva3646a1b2023-08-02 13:52:52 +01001692 padding.right = hotseatBarSizePx;
1693 }
Winson1f064272016-07-18 17:18:02 -07001694 }
Winson Chungb3800242013-10-24 11:01:54 -07001695 } else {
Thales Limab8c05952022-05-23 16:58:38 +01001696 // Pad the bottom of the workspace with hotseat bar
1697 // and leave a bit of space in case a widget go all the way down
Thales Lima79456492023-05-23 11:32:22 +01001698 int paddingBottom = hotseatBarSizePx + workspaceBottomPadding - mInsets.bottom;
1699 if (!mIsResponsiveGrid) {
1700 paddingBottom +=
1701 workspacePageIndicatorHeight - mWorkspacePageIndicatorOverlapWorkspace;
1702 }
1703 int paddingTop = workspaceTopPadding + (mIsScalableGrid ? 0 : edgeMarginPx);
Pat Manning08610ca2022-04-05 21:03:16 +01001704 int paddingSide = desiredWorkspaceHorizontalMarginPx;
Andras Kloczl8e57cce2021-02-11 23:51:19 +01001705
Pat Manning08610ca2022-04-05 21:03:16 +01001706 padding.set(paddingSide, paddingTop, paddingSide, paddingBottom);
Winson Chungb3800242013-10-24 11:01:54 -07001707 }
Pat Manning08610ca2022-04-05 21:03:16 +01001708 insetPadding(workspacePadding, cellLayoutPaddingPx);
1709 }
1710
1711 private void insetPadding(Rect paddings, Rect insets) {
1712 insets.left = Math.min(insets.left, paddings.left);
1713 paddings.left -= insets.left;
1714
1715 insets.top = Math.min(insets.top, paddings.top);
1716 paddings.top -= insets.top;
1717
1718 insets.right = Math.min(insets.right, paddings.right);
1719 paddings.right -= insets.right;
1720
1721 insets.bottom = Math.min(insets.bottom, paddings.bottom);
1722 paddings.bottom -= insets.bottom;
Winson Chungb3800242013-10-24 11:01:54 -07001723 }
1724
Liran Binyamina833af32023-08-02 16:30:27 -04001725
1726 /**
1727 * Returns the new border space that should be used between hotseat icons after adjusting it to
1728 * the bubble bar.
1729 *
1730 * <p>If there's no adjustment needed, this method returns {@code 0}.
1731 */
1732 public float getHotseatAdjustedBorderSpaceForBubbleBar(Context context) {
1733 // only need to adjust when QSB is on top of the hotseat.
1734 if (isQsbInline) {
1735 return 0;
1736 }
1737
1738 // no need to adjust if there's enough space for the bubble bar to the right of the hotseat.
1739 if (getHotseatLayoutPadding(context).right > mBubbleBarSpaceThresholdPx) {
1740 return 0;
1741 }
1742
1743 // The adjustment is shrinking the hotseat's width by 1 icon on either side.
1744 int iconsWidth =
1745 iconSizePx * numShownHotseatIcons + hotseatBorderSpace * (numShownHotseatIcons - 1);
1746 int newWidth = iconsWidth - 2 * iconSizePx;
1747 // Evenly space the icons within the boundaries of the new width.
1748 return (float) (newWidth - iconSizePx * numShownHotseatIcons) / (numShownHotseatIcons - 1);
1749 }
1750
Sunny Goyal57b22792021-05-25 14:35:01 -07001751 /**
1752 * Returns the padding for hotseat view
1753 */
1754 public Rect getHotseatLayoutPadding(Context context) {
Pat Manning5f74bfd2022-07-20 12:08:54 +01001755 Rect hotseatBarPadding = new Rect();
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001756 if (isVerticalBarLayout()) {
Sihua Ma38bb3b02022-03-21 22:20:14 -07001757 // The hotseat icons will be placed in the middle of the hotseat cells.
1758 // Changing the hotseatCellHeightPx is not affecting hotseat icon positions
1759 // in vertical bar layout.
fbaronfc6bbcf2024-01-29 10:35:17 -08001760 int paddingTop = Math.max((int) (mInsets.top + cellLayoutPaddingPx.top), 0);
1761 int paddingBottom = Math.max((int) (mInsets.bottom + cellLayoutPaddingPx.bottom), 0);
Sihua Ma38bb3b02022-03-21 22:20:14 -07001762
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001763 if (isSeascape()) {
Thales Lima8e11d532023-08-31 13:40:26 +00001764 hotseatBarPadding.set(mInsets.left + mHotseatBarEdgePaddingPx, paddingTop,
1765 mHotseatBarWorkspaceSpacePx, paddingBottom);
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001766 } else {
Thales Lima8e11d532023-08-31 13:40:26 +00001767 hotseatBarPadding.set(mHotseatBarWorkspaceSpacePx, paddingTop,
1768 mInsets.right + mHotseatBarEdgePaddingPx, paddingBottom);
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001769 }
Sunny Goyal57b22792021-05-25 14:35:01 -07001770 } else if (isTaskbarPresent) {
Alex Chau51da2192022-05-20 13:32:10 +01001771 // Center the QSB vertically with hotseat
Thales Limab8c05952022-05-23 16:58:38 +01001772 int hotseatBarBottomPadding = getHotseatBarBottomPadding();
1773 int hotseatBarTopPadding =
1774 hotseatBarSizePx - hotseatBarBottomPadding - hotseatCellHeightPx;
Alex Chau51da2192022-05-20 13:32:10 +01001775
Thales Lima6a590062022-11-22 15:52:49 +00001776 int hotseatWidth = getHotseatRequiredWidth();
Helen Cheuke76291f2023-02-14 17:11:05 +00001777 int startSpacing;
1778 int endSpacing;
Thales Lima6a590062022-11-22 15:52:49 +00001779 // Hotseat aligns to the left with nav buttons
1780 if (hotseatBarEndOffset > 0) {
Jon Mirandae17a9492023-03-08 16:42:20 -08001781 startSpacing = inlineNavButtonsEndSpacingPx;
Helen Cheuke76291f2023-02-14 17:11:05 +00001782 endSpacing = availableWidthPx - hotseatWidth - startSpacing + hotseatBorderSpace;
1783 } else {
1784 startSpacing = (availableWidthPx - hotseatWidth) / 2;
1785 endSpacing = startSpacing;
Thales Lima6a590062022-11-22 15:52:49 +00001786 }
Helen Cheuke76291f2023-02-14 17:11:05 +00001787 startSpacing += getAdditionalQsbSpace();
Thales Lima612230d2022-03-31 18:04:37 +01001788
Helen Cheuke76291f2023-02-14 17:11:05 +00001789 hotseatBarPadding.top = hotseatBarTopPadding;
1790 hotseatBarPadding.bottom = hotseatBarBottomPadding;
Alex Chau51da2192022-05-20 13:32:10 +01001791 boolean isRtl = Utilities.isRtl(context.getResources());
Thales Lima612230d2022-03-31 18:04:37 +01001792 if (isRtl) {
Helen Cheuke76291f2023-02-14 17:11:05 +00001793 hotseatBarPadding.left = endSpacing;
1794 hotseatBarPadding.right = startSpacing;
Thales Lima612230d2022-03-31 18:04:37 +01001795 } else {
Helen Cheuke76291f2023-02-14 17:11:05 +00001796 hotseatBarPadding.left = startSpacing;
1797 hotseatBarPadding.right = endSpacing;
Thales Lima612230d2022-03-31 18:04:37 +01001798 }
Helen Cheuke76291f2023-02-14 17:11:05 +00001799
Thales Lima79456492023-05-23 11:32:22 +01001800 } else if (mIsScalableGrid) {
fbarone69b6f42023-12-18 13:20:34 -08001801 int iconExtraSpacePx = iconSizePx - getIconVisibleSizePx(iconSizePx);
1802 int sideSpacing = (availableWidthPx - (hotseatQsbWidth + iconExtraSpacePx)) / 2;
Pat Manning5f74bfd2022-07-20 12:08:54 +01001803 hotseatBarPadding.set(sideSpacing,
Thales Limab8c05952022-05-23 16:58:38 +01001804 0,
Thales Lima425f6822022-05-10 13:44:58 -03001805 sideSpacing,
Thales Limab8c05952022-05-23 16:58:38 +01001806 getHotseatBarBottomPadding());
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001807 } else {
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001808 // We want the edges of the hotseat to line up with the edges of the workspace, but the
1809 // icons in the hotseat are a different size, and so don't line up perfectly. To account
1810 // for this, we pad the left and right of the hotseat with half of the difference of a
1811 // workspace cell vs a hotseat cell.
1812 float workspaceCellWidth = (float) widthPx / inv.numColumns;
Sunny Goyal19ff7282021-04-22 10:12:54 -07001813 float hotseatCellWidth = (float) widthPx / numShownHotseatIcons;
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001814 int hotseatAdjustment = Math.round((workspaceCellWidth - hotseatCellWidth) / 2);
Pat Manning5f74bfd2022-07-20 12:08:54 +01001815 hotseatBarPadding.set(
Thales Limab8c05952022-05-23 16:58:38 +01001816 hotseatAdjustment + workspacePadding.left + cellLayoutPaddingPx.left
1817 + mInsets.left,
1818 0,
Pat Manning08610ca2022-04-05 21:03:16 +01001819 hotseatAdjustment + workspacePadding.right + cellLayoutPaddingPx.right
Sunny Goyal786940a2020-06-02 02:31:31 -07001820 + mInsets.right,
Thales Limab8c05952022-05-23 16:58:38 +01001821 getHotseatBarBottomPadding());
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001822 }
Pat Manning5f74bfd2022-07-20 12:08:54 +01001823 return hotseatBarPadding;
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001824 }
1825
Andy Wickhambd9a1802023-06-08 16:33:15 -07001826 /** The margin between the edge of all apps and the edge of the first icon. */
Thales Limab433c9c2023-10-30 12:24:05 +00001827 public int getAllAppsIconStartMargin(Context context) {
Andy Wickhambd9a1802023-06-08 16:33:15 -07001828 int allAppsSpacing;
1829 if (isVerticalBarLayout()) {
1830 // On phones, the landscape layout uses a different setup.
1831 allAppsSpacing = workspacePadding.left + workspacePadding.right;
1832 } else {
Thales Limab433c9c2023-10-30 12:24:05 +00001833 allAppsSpacing =
1834 allAppsPadding.left + allAppsPadding.right + allAppsLeftRightMargin * 2;
Andy Wickhambd9a1802023-06-08 16:33:15 -07001835 }
1836
1837 int cellWidth = DeviceProfile.calculateCellWidth(
1838 availableWidthPx - allAppsSpacing,
1839 0 /* borderSpace */,
1840 numShownAllAppsColumns);
fbarone69b6f42023-12-18 13:20:34 -08001841 int iconAlignmentMargin = (cellWidth - getIconVisibleSizePx(allAppsIconSizePx)) / 2;
Thales Limab433c9c2023-10-30 12:24:05 +00001842
1843 return (Utilities.isRtl(context.getResources()) ? allAppsPadding.right
1844 : allAppsPadding.left) + iconAlignmentMargin;
Andy Wickhambd9a1802023-06-08 16:33:15 -07001845 }
1846
fbarone69b6f42023-12-18 13:20:34 -08001847 /**
1848 * TODO(b/235886078): workaround needed because of this bug
1849 * Icons are 10% larger on XML than their visual size, so remove that extra space to get
1850 * some dimensions correct.
1851 *
1852 * When this bug is resolved this method will no longer be needed and we would be able to
1853 * replace all instances where this method is called with iconSizePx.
1854 */
1855 private int getIconVisibleSizePx(int iconSizePx) {
1856 return Math.round(ICON_VISIBLE_AREA_FACTOR * iconSizePx);
1857 }
1858
Thales Lima9938c2f2022-07-25 14:38:16 +01001859 private int getAdditionalQsbSpace() {
1860 return isQsbInline ? hotseatQsbWidth + hotseatBorderSpace : 0;
1861 }
1862
1863 /**
1864 * Calculate how much space the hotseat needs to be shown completely
1865 */
1866 private int getHotseatRequiredWidth() {
1867 int additionalQsbSpace = getAdditionalQsbSpace();
1868 return iconSizePx * numShownHotseatIcons
Thales Lima6a590062022-11-22 15:52:49 +00001869 + hotseatBorderSpace * (numShownHotseatIcons - (areNavButtonsInline ? 0 : 1))
Thales Lima9938c2f2022-07-25 14:38:16 +01001870 + additionalQsbSpace;
1871 }
1872
Winsonfadbe8f2016-07-22 16:35:37 -07001873 /**
Sunny Goyal57b22792021-05-25 14:35:01 -07001874 * Returns the number of pixels the QSB is translated from the bottom of the screen.
1875 */
1876 public int getQsbOffsetY() {
Thales Limaa1012902022-01-13 17:58:42 +00001877 if (isQsbInline) {
Thales Limab8c05952022-05-23 16:58:38 +01001878 return getHotseatBarBottomPadding() - ((hotseatQsbHeight - hotseatCellHeightPx) / 2);
1879 } else if (isTaskbarPresent) { // QSB on top
1880 return hotseatBarSizePx - hotseatQsbHeight + hotseatQsbShadowHeight;
Jonathan Miranda8f16a772021-07-23 23:10:37 +00001881 } else {
Thales Limab8c05952022-05-23 16:58:38 +01001882 return hotseatBarBottomSpacePx - hotseatQsbShadowHeight;
Jonathan Miranda7a273e22021-06-24 21:29:10 +00001883 }
Sunny Goyal57b22792021-05-25 14:35:01 -07001884 }
1885
Thales Limab8c05952022-05-23 16:58:38 +01001886 /**
1887 * Returns the number of pixels the hotseat is translated from the bottom of the screen.
1888 */
1889 private int getHotseatBarBottomPadding() {
1890 if (isTaskbarPresent) { // QSB on top or inline
1891 return hotseatBarBottomSpacePx - (Math.abs(hotseatCellHeightPx - iconSizePx) / 2);
Thales Limaa1012902022-01-13 17:58:42 +00001892 } else {
Thales Limab8c05952022-05-23 16:58:38 +01001893 return hotseatBarSizePx - hotseatCellHeightPx;
Thales Limaa1012902022-01-13 17:58:42 +00001894 }
Sunny Goyal57b22792021-05-25 14:35:01 -07001895 }
1896
1897 /**
Alex Chau51da2192022-05-20 13:32:10 +01001898 * Returns the number of pixels the taskbar is translated from the bottom of the screen.
1899 */
1900 public int getTaskbarOffsetY() {
Jon Miranda9c478b62023-03-23 21:38:49 -07001901 int taskbarIconBottomSpace = (taskbarHeight - iconSizePx) / 2;
Alex Chau51da2192022-05-20 13:32:10 +01001902 int launcherIconBottomSpace =
1903 Math.min((hotseatCellHeightPx - iconSizePx) / 2, gridVisualizationPaddingY);
Thales Limab8c05952022-05-23 16:58:38 +01001904 return getHotseatBarBottomPadding() + launcherIconBottomSpace - taskbarIconBottomSpace;
Alex Chau51da2192022-05-20 13:32:10 +01001905 }
1906
Uwais Ashrafaa7fa882023-10-10 21:36:06 +00001907 /** Returns the number of pixels required below OverviewActions. */
Alex Chaua2fc7642022-04-21 14:20:23 +01001908 public int getOverviewActionsClaimedSpaceBelow() {
Uwais Ashrafaa7fa882023-10-10 21:36:06 +00001909 return isTaskbarPresent ? mTransientTaskbarClaimedSpace : mInsets.bottom;
Alex Chaua2fc7642022-04-21 14:20:23 +01001910 }
1911
1912 /** Gets the space that the overview actions will take, including bottom margin. */
1913 public int getOverviewActionsClaimedSpace() {
Alex Chau4989f4f2023-10-11 14:08:22 +00001914 int overviewActionsSpace = isTablet && Flags.enableGridOnlyOverview()
Pat Manning7b8f7662023-01-18 14:48:30 +00001915 ? 0
1916 : (overviewActionsTopMarginPx + overviewActionsHeight);
1917 return overviewActionsSpace + getOverviewActionsClaimedSpaceBelow();
Alex Chaua2fc7642022-04-21 14:20:23 +01001918 }
1919
1920 /**
Sihua Mae04aa202022-07-18 12:43:56 -07001921 * Takes the View and return the scales of width and height depending on the DeviceProfile
1922 * specifications
1923 *
1924 * @param itemInfo The tag of the widget view
1925 * @return A PointF instance with the x set to be the scale of width, and y being the scale of
1926 * height
1927 */
1928 @NonNull
1929 public PointF getAppWidgetScale(@Nullable final ItemInfo itemInfo) {
1930 return mViewScaleProvider.getScaleFromItemInfo(itemInfo);
1931 }
1932
1933 /**
Winsonfadbe8f2016-07-22 16:35:37 -07001934 * @return the bounds for which the open folders should be contained within
1935 */
1936 public Rect getAbsoluteOpenFolderBounds() {
1937 if (isVerticalBarLayout()) {
1938 // Folders should only appear right of the drop target bar and left of the hotseat
1939 return new Rect(mInsets.left + dropTargetBarSizePx + edgeMarginPx,
1940 mInsets.top,
Jon Miranda18751b62017-07-31 17:25:27 -07001941 mInsets.left + availableWidthPx - hotseatBarSizePx - edgeMarginPx,
Winsonfadbe8f2016-07-22 16:35:37 -07001942 mInsets.top + availableHeightPx);
1943 } else {
1944 // Folders should only appear below the drop target bar and above the hotseat
Jon Miranda9c478b62023-03-23 21:38:49 -07001945 int hotseatTop = isTaskbarPresent ? taskbarHeight : hotseatBarSizePx;
Tony Wickhamb4b7e202018-01-12 17:39:24 -08001946 return new Rect(mInsets.left + edgeMarginPx,
Winsonfadbe8f2016-07-22 16:35:37 -07001947 mInsets.top + dropTargetBarSizePx + edgeMarginPx,
Tony Wickhamb4b7e202018-01-12 17:39:24 -08001948 mInsets.left + availableWidthPx - edgeMarginPx,
Tony Wickhamae72b462021-03-10 16:18:40 -08001949 mInsets.top + availableHeightPx - hotseatTop
Tony Wickham5edf9e22020-03-27 20:06:52 -07001950 - workspacePageIndicatorHeight - edgeMarginPx);
Winsonfadbe8f2016-07-22 16:35:37 -07001951 }
1952 }
1953
Jon Miranda228877d2021-02-09 11:05:00 -05001954 public static int calculateCellWidth(int width, int borderSpacing, int countX) {
1955 return (width - ((countX - 1) * borderSpacing)) / countX;
Winson Chungb3800242013-10-24 11:01:54 -07001956 }
Pierre Barbier de Reuille578deba2021-09-24 13:47:44 +01001957
Jon Miranda228877d2021-02-09 11:05:00 -05001958 public static int calculateCellHeight(int height, int borderSpacing, int countY) {
1959 return (height - ((countY - 1) * borderSpacing)) / countY;
Winson Chungb3800242013-10-24 11:01:54 -07001960 }
1961
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -07001962 /**
Tony Wickham55616cd2015-09-23 14:55:17 -07001963 * When {@code true}, the device is in landscape mode and the hotseat is on the right column.
1964 * When {@code false}, either device is in portrait mode or the device is in landscape mode and
1965 * the hotseat is on the bottom row.
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -07001966 */
Tony Wickhamab946a12015-09-16 15:38:16 -07001967 public boolean isVerticalBarLayout() {
Winson Chungb3800242013-10-24 11:01:54 -07001968 return isLandscape && transposeLayoutWithOrientation;
1969 }
1970
Sunny Goyal59d086c2018-05-07 17:31:40 -07001971 /**
1972 * Updates orientation information and returns true if it has changed from the previous value.
1973 */
Winson Chung13c1c2c2019-09-06 11:46:19 -07001974 public boolean updateIsSeascape(Context context) {
Sunny Goyal59d086c2018-05-07 17:31:40 -07001975 if (isVerticalBarLayout()) {
Sunny Goyal35c7b192021-04-20 16:51:10 -07001976 boolean isSeascape = DisplayController.INSTANCE.get(context)
1977 .getInfo().rotation == Surface.ROTATION_270;
Sunny Goyal59d086c2018-05-07 17:31:40 -07001978 if (mIsSeascape != isSeascape) {
1979 mIsSeascape = isSeascape;
Pat Manning08610ca2022-04-05 21:03:16 +01001980 // Hotseat changing sides requires updating workspace left/right paddings
1981 updateWorkspacePadding();
Sunny Goyal59d086c2018-05-07 17:31:40 -07001982 return true;
1983 }
1984 }
1985 return false;
1986 }
1987
Sunny Goyal7e2e67f2018-01-26 13:40:08 -08001988 public boolean isSeascape() {
Sunny Goyal59d086c2018-05-07 17:31:40 -07001989 return isVerticalBarLayout() && mIsSeascape;
Sunny Goyal7e2e67f2018-01-26 13:40:08 -08001990 }
1991
Sunny Goyal07b69292018-01-08 14:19:34 -08001992 public boolean shouldFadeAdjacentWorkspaceScreens() {
Sunny Goyal19ff7282021-04-22 10:12:54 -07001993 return isVerticalBarLayout();
Winson Chungb3800242013-10-24 11:01:54 -07001994 }
1995
Jon Miranda92c1b5d2021-07-20 13:57:16 -07001996 public int getCellContentHeight(@ContainerType int containerType) {
Sunny Goyalc13403c2016-11-18 23:44:48 -08001997 switch (containerType) {
1998 case CellLayout.WORKSPACE:
1999 return cellHeightPx;
2000 case CellLayout.FOLDER:
2001 return folderCellHeightPx;
2002 case CellLayout.HOTSEAT:
Jon Miranda92c1b5d2021-07-20 13:57:16 -07002003 // The hotseat is the only container where the cell height is going to be
2004 // different from the content within that cell.
2005 return iconSizePx;
Sunny Goyalc13403c2016-11-18 23:44:48 -08002006 default:
2007 // ??
2008 return 0;
2009 }
2010 }
Sunny Goyal13178ac2016-04-04 16:35:22 -07002011
Jon Miranda58561d42021-03-17 10:51:54 -04002012 private String pxToDpStr(String name, float value) {
Sunny Goyal35c7b192021-04-20 16:51:10 -07002013 return "\t" + name + ": " + value + "px (" + dpiFromPx(value, mMetrics.densityDpi) + "dp)";
Jon Miranda58561d42021-03-17 10:51:54 -04002014 }
2015
Alex Chaue818bcb2022-09-02 17:27:11 +01002016 private String dpPointFToString(String name, PointF value) {
2017 return String.format(Locale.ENGLISH, "\t%s: PointF(%.1f, %.1f)dp", name, value.x, value.y);
2018 }
2019
Pat Manning5f74bfd2022-07-20 12:08:54 +01002020 /** Dumps various DeviceProfile variables to the specified writer. */
2021 public void dump(Context context, String prefix, PrintWriter writer) {
Jon Miranda58561d42021-03-17 10:51:54 -04002022 writer.println(prefix + "DeviceProfile:");
Sunny Goyal35c7b192021-04-20 16:51:10 -07002023 writer.println(prefix + "\t1 dp = " + mMetrics.density + " px");
Jon Miranda58561d42021-03-17 10:51:54 -04002024
2025 writer.println(prefix + "\tisTablet:" + isTablet);
Jon Miranda58561d42021-03-17 10:51:54 -04002026 writer.println(prefix + "\tisPhone:" + isPhone);
2027 writer.println(prefix + "\ttransposeLayoutWithOrientation:"
2028 + transposeLayoutWithOrientation);
Alex Chau6ed408f2022-03-04 12:58:05 +00002029 writer.println(prefix + "\tisGestureMode:" + isGestureMode);
Jon Miranda58561d42021-03-17 10:51:54 -04002030
2031 writer.println(prefix + "\tisLandscape:" + isLandscape);
2032 writer.println(prefix + "\tisMultiWindowMode:" + isMultiWindowMode);
Sunny Goyal19ff7282021-04-22 10:12:54 -07002033 writer.println(prefix + "\tisTwoPanels:" + isTwoPanels);
Winson Chung104a4c82023-11-08 18:56:15 +00002034 writer.println(prefix + "\tisLeftRightSplit:" + isLeftRightSplit);
Jon Miranda58561d42021-03-17 10:51:54 -04002035
2036 writer.println(prefix + pxToDpStr("windowX", windowX));
2037 writer.println(prefix + pxToDpStr("windowY", windowY));
2038 writer.println(prefix + pxToDpStr("widthPx", widthPx));
2039 writer.println(prefix + pxToDpStr("heightPx", heightPx));
Jon Miranda58561d42021-03-17 10:51:54 -04002040 writer.println(prefix + pxToDpStr("availableWidthPx", availableWidthPx));
2041 writer.println(prefix + pxToDpStr("availableHeightPx", availableHeightPx));
Alex Chaue0227552022-04-06 19:44:43 +01002042 writer.println(prefix + pxToDpStr("mInsets.left", mInsets.left));
2043 writer.println(prefix + pxToDpStr("mInsets.top", mInsets.top));
2044 writer.println(prefix + pxToDpStr("mInsets.right", mInsets.right));
2045 writer.println(prefix + pxToDpStr("mInsets.bottom", mInsets.bottom));
Jon Miranda58561d42021-03-17 10:51:54 -04002046
2047 writer.println(prefix + "\taspectRatio:" + aspectRatio);
2048
Thales Limac98b7812023-04-14 15:04:23 +01002049 writer.println(prefix + "\tisResponsiveGrid:" + mIsResponsiveGrid);
Thales Lima79456492023-05-23 11:32:22 +01002050 writer.println(prefix + "\tisScalableGrid:" + mIsScalableGrid);
Jon Miranda58561d42021-03-17 10:51:54 -04002051
Thales Lima83bedbf2021-10-05 17:47:39 +01002052 writer.println(prefix + "\tinv.numRows: " + inv.numRows);
Alex Chau9fee3fd2021-12-01 18:43:10 +00002053 writer.println(prefix + "\tinv.numColumns: " + inv.numColumns);
2054 writer.println(prefix + "\tinv.numSearchContainerColumns: "
2055 + inv.numSearchContainerColumns);
Jon Miranda58561d42021-03-17 10:51:54 -04002056
Alex Chaue818bcb2022-09-02 17:27:11 +01002057 writer.println(prefix + dpPointFToString("minCellSize", inv.minCellSize[mTypeIndex]));
Jon Mirandaab3c6812021-06-28 15:42:28 -07002058
Jon Miranda58561d42021-03-17 10:51:54 -04002059 writer.println(prefix + pxToDpStr("cellWidthPx", cellWidthPx));
2060 writer.println(prefix + pxToDpStr("cellHeightPx", cellHeightPx));
2061
2062 writer.println(prefix + pxToDpStr("getCellSize().x", getCellSize().x));
2063 writer.println(prefix + pxToDpStr("getCellSize().y", getCellSize().y));
2064
Thales Lima83bedbf2021-10-05 17:47:39 +01002065 writer.println(prefix + pxToDpStr("cellLayoutBorderSpacePx Horizontal",
2066 cellLayoutBorderSpacePx.x));
2067 writer.println(prefix + pxToDpStr("cellLayoutBorderSpacePx Vertical",
2068 cellLayoutBorderSpacePx.y));
Pat Manning5f74bfd2022-07-20 12:08:54 +01002069 writer.println(
2070 prefix + pxToDpStr("cellLayoutPaddingPx.left", cellLayoutPaddingPx.left));
2071 writer.println(
2072 prefix + pxToDpStr("cellLayoutPaddingPx.top", cellLayoutPaddingPx.top));
2073 writer.println(
2074 prefix + pxToDpStr("cellLayoutPaddingPx.right", cellLayoutPaddingPx.right));
Pat Manning08610ca2022-04-05 21:03:16 +01002075 writer.println(
2076 prefix + pxToDpStr("cellLayoutPaddingPx.bottom", cellLayoutPaddingPx.bottom));
Thales Lima83bedbf2021-10-05 17:47:39 +01002077
Jon Miranda58561d42021-03-17 10:51:54 -04002078 writer.println(prefix + pxToDpStr("iconSizePx", iconSizePx));
2079 writer.println(prefix + pxToDpStr("iconTextSizePx", iconTextSizePx));
2080 writer.println(prefix + pxToDpStr("iconDrawablePaddingPx", iconDrawablePaddingPx));
2081
Thales Lima1faa4ed2023-12-01 16:48:19 +00002082 writer.println(prefix + "\tnumFolderRows: " + numFolderRows);
2083 writer.println(prefix + "\tnumFolderColumns: " + numFolderColumns);
Jon Miranda58561d42021-03-17 10:51:54 -04002084 writer.println(prefix + pxToDpStr("folderCellWidthPx", folderCellWidthPx));
2085 writer.println(prefix + pxToDpStr("folderCellHeightPx", folderCellHeightPx));
2086 writer.println(prefix + pxToDpStr("folderChildIconSizePx", folderChildIconSizePx));
2087 writer.println(prefix + pxToDpStr("folderChildTextSizePx", folderChildTextSizePx));
2088 writer.println(prefix + pxToDpStr("folderChildDrawablePaddingPx",
2089 folderChildDrawablePaddingPx));
Jordan Silva637f4eb2023-06-13 11:21:53 +01002090 writer.println(prefix + pxToDpStr("folderCellLayoutBorderSpacePx.x",
2091 folderCellLayoutBorderSpacePx.x));
2092 writer.println(prefix + pxToDpStr("folderCellLayoutBorderSpacePx.y",
2093 folderCellLayoutBorderSpacePx.y));
Thales Limaa08a4432022-08-09 09:55:17 +01002094 writer.println(prefix + pxToDpStr("folderContentPaddingLeftRight",
2095 folderContentPaddingLeftRight));
2096 writer.println(prefix + pxToDpStr("folderTopPadding", folderContentPaddingTop));
Thales Limab35faed2022-09-05 16:30:01 -03002097 writer.println(prefix + pxToDpStr("folderFooterHeight", folderFooterHeightPx));
Jon Miranda58561d42021-03-17 10:51:54 -04002098
Alex Chaue0227552022-04-06 19:44:43 +01002099 writer.println(prefix + pxToDpStr("bottomSheetTopPadding", bottomSheetTopPadding));
Alex Chau3d2c0622022-09-01 21:28:14 +01002100 writer.println(prefix + "\tbottomSheetOpenDuration: " + bottomSheetOpenDuration);
2101 writer.println(prefix + "\tbottomSheetCloseDuration: " + bottomSheetCloseDuration);
2102 writer.println(prefix + "\tbottomSheetWorkspaceScale: " + bottomSheetWorkspaceScale);
2103 writer.println(prefix + "\tbottomSheetDepth: " + bottomSheetDepth);
Alex Chaue0227552022-04-06 19:44:43 +01002104
2105 writer.println(prefix + pxToDpStr("allAppsShiftRange", allAppsShiftRange));
Alex Chau3d2c0622022-09-01 21:28:14 +01002106 writer.println(prefix + "\tallAppsOpenDuration: " + allAppsOpenDuration);
2107 writer.println(prefix + "\tallAppsCloseDuration: " + allAppsCloseDuration);
Jon Miranda58561d42021-03-17 10:51:54 -04002108 writer.println(prefix + pxToDpStr("allAppsIconSizePx", allAppsIconSizePx));
2109 writer.println(prefix + pxToDpStr("allAppsIconTextSizePx", allAppsIconTextSizePx));
2110 writer.println(prefix + pxToDpStr("allAppsIconDrawablePaddingPx",
2111 allAppsIconDrawablePaddingPx));
2112 writer.println(prefix + pxToDpStr("allAppsCellHeightPx", allAppsCellHeightPx));
Alex Chau27b39b92022-01-14 18:02:18 +00002113 writer.println(prefix + pxToDpStr("allAppsCellWidthPx", allAppsCellWidthPx));
Pat Manning26f70f72022-07-07 13:50:39 +01002114 writer.println(prefix + pxToDpStr("allAppsBorderSpacePxX", allAppsBorderSpacePx.x));
2115 writer.println(prefix + pxToDpStr("allAppsBorderSpacePxY", allAppsBorderSpacePx.y));
Sunny Goyal19ff7282021-04-22 10:12:54 -07002116 writer.println(prefix + "\tnumShownAllAppsColumns: " + numShownAllAppsColumns);
Thales Limab433c9c2023-10-30 12:24:05 +00002117 writer.println(prefix + pxToDpStr("allAppsPadding.top", allAppsPadding.top));
2118 writer.println(prefix + pxToDpStr("allAppsPadding.left", allAppsPadding.left));
2119 writer.println(prefix + pxToDpStr("allAppsPadding.right", allAppsPadding.right));
Alex Chau27b39b92022-01-14 18:02:18 +00002120 writer.println(prefix + pxToDpStr("allAppsLeftRightMargin", allAppsLeftRightMargin));
Jon Miranda58561d42021-03-17 10:51:54 -04002121
2122 writer.println(prefix + pxToDpStr("hotseatBarSizePx", hotseatBarSizePx));
Thales Lima425f6822022-05-10 13:44:58 -03002123 writer.println(prefix + "\tinv.hotseatColumnSpan: " + inv.hotseatColumnSpan[mTypeIndex]);
Jon Miranda58561d42021-03-17 10:51:54 -04002124 writer.println(prefix + pxToDpStr("hotseatCellHeightPx", hotseatCellHeightPx));
Alex Chau62572c02022-07-25 18:36:37 +00002125 writer.println(prefix + pxToDpStr("hotseatBarBottomSpacePx", hotseatBarBottomSpacePx));
Thales Lima8e11d532023-08-31 13:40:26 +00002126 writer.println(prefix + pxToDpStr("mHotseatBarEdgePaddingPx",
2127 mHotseatBarEdgePaddingPx));
2128 writer.println(prefix + pxToDpStr("mHotseatBarWorkspaceSpacePx",
2129 mHotseatBarWorkspaceSpacePx));
Pat Manning26f70f72022-07-07 13:50:39 +01002130 writer.println(prefix + pxToDpStr("hotseatBarEndOffset", hotseatBarEndOffset));
Thales Limab8c05952022-05-23 16:58:38 +01002131 writer.println(prefix + pxToDpStr("hotseatQsbSpace", hotseatQsbSpace));
2132 writer.println(prefix + pxToDpStr("hotseatQsbHeight", hotseatQsbHeight));
Pat Manningde25c0d2022-04-05 19:11:26 +01002133 writer.println(prefix + pxToDpStr("springLoadedHotseatBarTopMarginPx",
2134 springLoadedHotseatBarTopMarginPx));
Pat Manning5f74bfd2022-07-20 12:08:54 +01002135 Rect hotseatLayoutPadding = getHotseatLayoutPadding(context);
2136 writer.println(prefix + pxToDpStr("getHotseatLayoutPadding(context).top",
2137 hotseatLayoutPadding.top));
2138 writer.println(prefix + pxToDpStr("getHotseatLayoutPadding(context).bottom",
2139 hotseatLayoutPadding.bottom));
2140 writer.println(prefix + pxToDpStr("getHotseatLayoutPadding(context).left",
2141 hotseatLayoutPadding.left));
2142 writer.println(prefix + pxToDpStr("getHotseatLayoutPadding(context).right",
2143 hotseatLayoutPadding.right));
Sunny Goyal19ff7282021-04-22 10:12:54 -07002144 writer.println(prefix + "\tnumShownHotseatIcons: " + numShownHotseatIcons);
Thales Lima116b51a2022-02-03 16:19:47 +00002145 writer.println(prefix + pxToDpStr("hotseatBorderSpace", hotseatBorderSpace));
Thales Limaa1012902022-01-13 17:58:42 +00002146 writer.println(prefix + "\tisQsbInline: " + isQsbInline);
Alex Chau206ede92022-08-01 17:46:12 +01002147 writer.println(prefix + pxToDpStr("hotseatQsbWidth", hotseatQsbWidth));
Jon Miranda58561d42021-03-17 10:51:54 -04002148
2149 writer.println(prefix + "\tisTaskbarPresent:" + isTaskbarPresent);
Tony Wickham635e1802021-07-22 14:28:04 -10002150 writer.println(prefix + "\tisTaskbarPresentInApps:" + isTaskbarPresentInApps);
Jon Miranda9c478b62023-03-23 21:38:49 -07002151 writer.println(prefix + pxToDpStr("taskbarHeight", taskbarHeight));
2152 writer.println(prefix + pxToDpStr("stashedTaskbarHeight", stashedTaskbarHeight));
2153 writer.println(prefix + pxToDpStr("taskbarBottomMargin", taskbarBottomMargin));
2154 writer.println(prefix + pxToDpStr("taskbarIconSize", taskbarIconSize));
Jon Miranda58561d42021-03-17 10:51:54 -04002155
Thales Lima83bedbf2021-10-05 17:47:39 +01002156 writer.println(prefix + pxToDpStr("desiredWorkspaceHorizontalMarginPx",
2157 desiredWorkspaceHorizontalMarginPx));
Jon Miranda58561d42021-03-17 10:51:54 -04002158 writer.println(prefix + pxToDpStr("workspacePadding.left", workspacePadding.left));
2159 writer.println(prefix + pxToDpStr("workspacePadding.top", workspacePadding.top));
2160 writer.println(prefix + pxToDpStr("workspacePadding.right", workspacePadding.right));
Alex Chau62572c02022-07-25 18:36:37 +00002161 writer.println(prefix + pxToDpStr("workspacePadding.bottom", workspacePadding.bottom));
Jon Miranda58561d42021-03-17 10:51:54 -04002162
Jon Mirandaab3c6812021-06-28 15:42:28 -07002163 writer.println(prefix + pxToDpStr("iconScale", iconScale));
2164 writer.println(prefix + pxToDpStr("cellScaleToFit ", cellScaleToFit));
Jon Miranda58561d42021-03-17 10:51:54 -04002165 writer.println(prefix + pxToDpStr("extraSpace", extraSpace));
Alex Chau62572c02022-07-25 18:36:37 +00002166 writer.println(prefix + pxToDpStr("unscaled extraSpace", extraSpace / iconScale));
Jon Mirandac9e69fa2021-03-22 17:13:34 -04002167
Thales Lima171ee662022-11-22 15:52:49 +00002168 writer.println(prefix + pxToDpStr("maxEmptySpace", maxEmptySpace));
Jon Miranda58561d42021-03-17 10:51:54 -04002169 writer.println(prefix + pxToDpStr("workspaceTopPadding", workspaceTopPadding));
2170 writer.println(prefix + pxToDpStr("workspaceBottomPadding", workspaceBottomPadding));
Alex Chau635b3ab2022-01-26 16:49:10 +00002171
2172 writer.println(prefix + pxToDpStr("overviewTaskMarginPx", overviewTaskMarginPx));
Alex Chau635b3ab2022-01-26 16:49:10 +00002173 writer.println(prefix + pxToDpStr("overviewTaskIconSizePx", overviewTaskIconSizePx));
2174 writer.println(prefix + pxToDpStr("overviewTaskIconDrawableSizePx",
2175 overviewTaskIconDrawableSizePx));
2176 writer.println(prefix + pxToDpStr("overviewTaskIconDrawableSizeGridPx",
2177 overviewTaskIconDrawableSizeGridPx));
2178 writer.println(prefix + pxToDpStr("overviewTaskThumbnailTopMarginPx",
2179 overviewTaskThumbnailTopMarginPx));
Alex Chaua2fc7642022-04-21 14:20:23 +01002180 writer.println(prefix + pxToDpStr("overviewActionsTopMarginPx",
2181 overviewActionsTopMarginPx));
2182 writer.println(prefix + pxToDpStr("overviewActionsHeight",
2183 overviewActionsHeight));
Alex Chau1b276a12022-12-19 14:01:36 +00002184 writer.println(prefix + pxToDpStr("overviewActionsClaimedSpaceBelow",
2185 getOverviewActionsClaimedSpaceBelow()));
Alex Chau635b3ab2022-01-26 16:49:10 +00002186 writer.println(prefix + pxToDpStr("overviewActionsButtonSpacing",
2187 overviewActionsButtonSpacing));
2188 writer.println(prefix + pxToDpStr("overviewPageSpacing", overviewPageSpacing));
2189 writer.println(prefix + pxToDpStr("overviewRowSpacing", overviewRowSpacing));
2190 writer.println(prefix + pxToDpStr("overviewGridSideMargin", overviewGridSideMargin));
Pat Manningde25c0d2022-04-05 19:11:26 +01002191
Alex Chau62572c02022-07-25 18:36:37 +00002192 writer.println(prefix + pxToDpStr("dropTargetBarTopMarginPx", dropTargetBarTopMarginPx));
Pat Manningde25c0d2022-04-05 19:11:26 +01002193 writer.println(prefix + pxToDpStr("dropTargetBarSizePx", dropTargetBarSizePx));
Alex Chau62572c02022-07-25 18:36:37 +00002194 writer.println(
2195 prefix + pxToDpStr("dropTargetBarBottomMarginPx", dropTargetBarBottomMarginPx));
Pat Manningde25c0d2022-04-05 19:11:26 +01002196
Pat Manning5f74bfd2022-07-20 12:08:54 +01002197 writer.println(prefix + pxToDpStr("getCellLayoutSpringLoadShrunkTop()",
2198 getCellLayoutSpringLoadShrunkTop()));
2199 writer.println(prefix + pxToDpStr("getCellLayoutSpringLoadShrunkBottom()",
2200 getCellLayoutSpringLoadShrunkBottom(context)));
Alex Chau906d8822022-05-23 10:42:25 +01002201 writer.println(prefix + pxToDpStr("workspaceSpringLoadedMinNextPageVisiblePx",
2202 workspaceSpringLoadedMinNextPageVisiblePx));
Pat Manning5f74bfd2022-07-20 12:08:54 +01002203 writer.println(prefix + pxToDpStr("getWorkspaceSpringLoadScale()",
2204 getWorkspaceSpringLoadScale(context)));
Thales Limab8c05952022-05-23 16:58:38 +01002205 writer.println(prefix + pxToDpStr("getCellLayoutHeight()", getCellLayoutHeight()));
2206 writer.println(prefix + pxToDpStr("getCellLayoutWidth()", getCellLayoutWidth()));
Thales Lima79456492023-05-23 11:32:22 +01002207 if (mIsResponsiveGrid) {
Jordan Silva8f7986a2023-11-08 12:11:25 +00002208 writer.println(prefix + "\tmResponsiveWorkspaceHeightSpec:"
2209 + mResponsiveWorkspaceHeightSpec.toString());
2210 writer.println(prefix + "\tmResponsiveWorkspaceWidthSpec:"
2211 + mResponsiveWorkspaceWidthSpec.toString());
2212 writer.println(prefix + "\tmResponsiveAllAppsHeightSpec:"
2213 + mResponsiveAllAppsHeightSpec.toString());
2214 writer.println(prefix + "\tmResponsiveAllAppsWidthSpec:"
2215 + mResponsiveAllAppsWidthSpec.toString());
Jordan Silva637f4eb2023-06-13 11:21:53 +01002216 writer.println(prefix + "\tmResponsiveFolderHeightSpec:" + mResponsiveFolderHeightSpec);
2217 writer.println(prefix + "\tmResponsiveFolderWidthSpec:" + mResponsiveFolderWidthSpec);
Thales Limaf8bfb032023-07-24 15:08:05 +01002218 writer.println(prefix + "\tmResponsiveHotseatSpec:" + mResponsiveHotseatSpec);
Jordan Silva999dd2a2023-11-17 19:31:43 +00002219 writer.println(prefix + "\tmResponsiveWorkspaceCellSpec:"
2220 + mResponsiveWorkspaceCellSpec);
2221 writer.println(prefix + "\tmResponsiveAllAppsCellSpec:" + mResponsiveAllAppsCellSpec);
Thales Lima79456492023-05-23 11:32:22 +01002222 }
Jon Miranda58561d42021-03-17 10:51:54 -04002223 }
2224
Nicolo' Mazzucatocb7bd502023-01-16 19:46:30 +00002225 /** Returns a reduced representation of this DeviceProfile. */
2226 public String toSmallString() {
2227 return "isTablet:" + isTablet + ", "
2228 + "isMultiDisplay:" + isMultiDisplay + ", "
2229 + "widthPx:" + widthPx + ", "
2230 + "heightPx:" + heightPx + ", "
2231 + "insets:" + mInsets + ", "
2232 + "rotationHint:" + rotationHint;
2233 }
2234
Alex Chaua6907dc2022-03-18 15:24:07 +00002235 private static Context getContext(Context c, Info info, int orientation, WindowBounds bounds) {
Sunny Goyal1890f672020-04-30 12:28:00 -07002236 Configuration config = new Configuration(c.getResources().getConfiguration());
2237 config.orientation = orientation;
Thales Lima425f6822022-05-10 13:44:58 -03002238 config.densityDpi = info.getDensityDpi();
Alex Chaua6907dc2022-03-18 15:24:07 +00002239 config.smallestScreenWidthDp = (int) info.smallestSizeDp(bounds);
Sunny Goyal1890f672020-04-30 12:28:00 -07002240 return c.createConfigurationContext(config);
Jon Mirandab28c4fc2017-06-20 10:58:36 -07002241 }
Sunny Goyalfde55052018-02-01 14:46:13 -08002242
2243 /**
2244 * Callback when a component changes the DeviceProfile associated with it, as a result of
2245 * configuration change
2246 */
2247 public interface OnDeviceProfileChangeListener {
2248
2249 /**
2250 * Called when the device profile is reassigned. Note that for layout and measurements, it
2251 * is sufficient to listen for inset changes. Use this callback when you need to perform
2252 * a one time operation.
2253 */
2254 void onDeviceProfileChanged(DeviceProfile dp);
2255 }
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002256
Sihua Mae04aa202022-07-18 12:43:56 -07002257 /**
2258 * Handler that deals with ItemInfo of the views for the DeviceProfile
2259 */
2260 @FunctionalInterface
2261 public interface ViewScaleProvider {
2262 /**
2263 * Get the scales from the view
2264 *
2265 * @param itemInfo The tag of the widget view
2266 * @return PointF instance containing the scale information, or null if using the default
2267 * app widget scale of this device profile.
2268 */
2269 @NonNull
2270 PointF getScaleFromItemInfo(@Nullable ItemInfo itemInfo);
2271 }
2272
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002273 public static class Builder {
2274 private Context mContext;
2275 private InvariantDeviceProfile mInv;
Sunny Goyalfd58da62020-08-11 12:06:49 -07002276 private Info mInfo;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002277
Sunny Goyal19ff7282021-04-22 10:12:54 -07002278 private WindowBounds mWindowBounds;
Alex Chauab800f72022-12-13 17:46:06 +00002279 private boolean mIsMultiDisplay;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002280
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002281 private boolean mIsMultiWindowMode = false;
Sunny Goyal19ff7282021-04-22 10:12:54 -07002282 private Boolean mTransposeLayoutWithOrientation;
Alex Chau6ed408f2022-03-04 12:58:05 +00002283 private Boolean mIsGestureMode;
Sihua Mae04aa202022-07-18 12:43:56 -07002284 private ViewScaleProvider mViewScaleProvider = null;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002285
Sunny Goyal65190ae2022-08-02 14:16:26 -07002286 private SparseArray<DotRenderer> mDotRendererCache;
2287
Jon Miranda2b25ded2023-02-02 14:48:45 -08002288 private Consumer<DeviceProfile> mOverrideProvider;
2289
Jagrut Desai3a7d1392023-09-06 15:56:19 -07002290 private boolean mIsTransientTaskbar;
2291
Sunny Goyalfd58da62020-08-11 12:06:49 -07002292 public Builder(Context context, InvariantDeviceProfile inv, Info info) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002293 mContext = context;
2294 mInv = inv;
2295 mInfo = info;
Jagrut Desai3a7d1392023-09-06 15:56:19 -07002296 mIsTransientTaskbar = info.isTransientTaskbar();
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002297 }
2298
2299 public Builder setMultiWindowMode(boolean isMultiWindowMode) {
2300 mIsMultiWindowMode = isMultiWindowMode;
2301 return this;
2302 }
2303
Alex Chauab800f72022-12-13 17:46:06 +00002304 public Builder setIsMultiDisplay(boolean isMultiDisplay) {
2305 mIsMultiDisplay = isMultiDisplay;
Sunny Goyal19ff7282021-04-22 10:12:54 -07002306 return this;
2307 }
2308
Sunny Goyal65190ae2022-08-02 14:16:26 -07002309 public Builder setDotRendererCache(SparseArray<DotRenderer> dotRendererCache) {
2310 mDotRendererCache = dotRendererCache;
2311 return this;
2312 }
Sunny Goyal19ff7282021-04-22 10:12:54 -07002313
2314 public Builder setWindowBounds(WindowBounds bounds) {
2315 mWindowBounds = bounds;
Sunny Goyal0addbf02020-04-28 14:17:35 -07002316 return this;
2317 }
2318
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002319 public Builder setTransposeLayoutWithOrientation(boolean transposeLayoutWithOrientation) {
2320 mTransposeLayoutWithOrientation = transposeLayoutWithOrientation;
2321 return this;
2322 }
2323
Alex Chau6ed408f2022-03-04 12:58:05 +00002324 public Builder setGestureMode(boolean isGestureMode) {
2325 mIsGestureMode = isGestureMode;
2326 return this;
2327 }
2328
Jon Miranda2b25ded2023-02-02 14:48:45 -08002329 public Builder withDimensionsOverride(Consumer<DeviceProfile> overrideProvider) {
2330 mOverrideProvider = overrideProvider;
2331 return this;
2332 }
2333
Sihua Mae04aa202022-07-18 12:43:56 -07002334 /**
2335 * Set the viewScaleProvider for the builder
2336 *
2337 * @param viewScaleProvider The viewScaleProvider to be set for the
Thales Limae9273ea2023-01-26 12:33:52 +00002338 * DeviceProfile
Sihua Mae04aa202022-07-18 12:43:56 -07002339 * @return This builder
2340 */
2341 @NonNull
2342 public Builder setViewScaleProvider(@Nullable ViewScaleProvider viewScaleProvider) {
2343 mViewScaleProvider = viewScaleProvider;
2344 return this;
2345 }
2346
Jagrut Desai3a7d1392023-09-06 15:56:19 -07002347 /**
2348 * Set the isTransientTaskbar for the builder
2349 * @return This Builder
2350 */
2351 public Builder setIsTransientTaskbar(boolean isTransientTaskbar) {
2352 mIsTransientTaskbar = isTransientTaskbar;
2353 return this;
2354 }
2355
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002356 public DeviceProfile build() {
Sunny Goyal19ff7282021-04-22 10:12:54 -07002357 if (mWindowBounds == null) {
2358 throw new IllegalArgumentException("Window bounds not set");
2359 }
2360 if (mTransposeLayoutWithOrientation == null) {
2361 mTransposeLayoutWithOrientation = !mInfo.isTablet(mWindowBounds);
2362 }
Alex Chau6ed408f2022-03-04 12:58:05 +00002363 if (mIsGestureMode == null) {
Alex Chaue818bcb2022-09-02 17:27:11 +01002364 mIsGestureMode = mInfo.navigationMode.hasGestures;
Alex Chau6ed408f2022-03-04 12:58:05 +00002365 }
Sunny Goyal65190ae2022-08-02 14:16:26 -07002366 if (mDotRendererCache == null) {
2367 mDotRendererCache = new SparseArray<>();
2368 }
Sihua Mae04aa202022-07-18 12:43:56 -07002369 if (mViewScaleProvider == null) {
2370 mViewScaleProvider = DEFAULT_PROVIDER;
2371 }
Jon Miranda2b25ded2023-02-02 14:48:45 -08002372 if (mOverrideProvider == null) {
2373 mOverrideProvider = DEFAULT_DIMENSION_PROVIDER;
2374 }
Sunny Goyal65190ae2022-08-02 14:16:26 -07002375 return new DeviceProfile(mContext, mInv, mInfo, mWindowBounds, mDotRendererCache,
Alex Chauab800f72022-12-13 17:46:06 +00002376 mIsMultiWindowMode, mTransposeLayoutWithOrientation, mIsMultiDisplay,
Jagrut Desai3a7d1392023-09-06 15:56:19 -07002377 mIsGestureMode, mViewScaleProvider, mOverrideProvider, mIsTransientTaskbar);
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002378 }
2379 }
Winson Chungb3800242013-10-24 11:01:54 -07002380}