blob: 23b1a007409124600d7030b4cb5db220a7ecd5bb [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;
Thales Lima12d0eff2022-03-25 17:06:11 +000020import static com.android.launcher3.InvariantDeviceProfile.INDEX_DEFAULT;
21import static com.android.launcher3.InvariantDeviceProfile.INDEX_LANDSCAPE;
22import static com.android.launcher3.InvariantDeviceProfile.INDEX_TWO_PANEL_LANDSCAPE;
23import static com.android.launcher3.InvariantDeviceProfile.INDEX_TWO_PANEL_PORTRAIT;
Jon Miranda58561d42021-03-17 10:51:54 -040024import static com.android.launcher3.Utilities.dpiFromPx;
Jon Mirandaaf3aed02021-05-06 18:28:45 -070025import static com.android.launcher3.Utilities.pxFromSp;
Alex Chauab800f72022-12-13 17:46:06 +000026import static com.android.launcher3.config.FeatureFlags.ENABLE_MULTI_DISPLAY_PARTIAL_DEPTH;
Alex Chauc78c53c2023-10-03 18:57:45 +010027import static com.android.launcher3.Flags.enableOverviewIconMenu;
Jon Miranda92c1b5d2021-07-20 13:57:16 -070028import static com.android.launcher3.folder.ClippedFolderIconLayoutRule.ICON_OVERLAP_FACTOR;
Sunny Goyal65190ae2022-08-02 14:16:26 -070029import static com.android.launcher3.icons.GraphicsUtils.getShapePath;
Jon Miranda95f44722023-06-06 19:48:19 -070030import static com.android.launcher3.icons.IconNormalizer.ICON_VISIBLE_AREA_FACTOR;
Thales Limab35faed2022-09-05 16:30:01 -030031import static com.android.launcher3.testing.shared.ResourceUtils.INVALID_RESOURCE_HANDLE;
Pat Manning5f74bfd2022-07-20 12:08:54 +010032import static com.android.launcher3.testing.shared.ResourceUtils.pxFromDp;
Thales Lima7eee74b2023-03-16 16:00:55 -030033import static com.android.launcher3.testing.shared.ResourceUtils.roundPxValueFromFloat;
Jon Miranda228877d2021-02-09 11:05:00 -050034
Sunny Goyal35c7b192021-04-20 16:51:10 -070035import android.annotation.SuppressLint;
Winson Chungb3800242013-10-24 11:01:54 -070036import android.content.Context;
Jon Mirandab28c4fc2017-06-20 10:58:36 -070037import android.content.res.Configuration;
Winson Chungb3800242013-10-24 11:01:54 -070038import android.content.res.Resources;
Thales Limab35faed2022-09-05 16:30:01 -030039import android.content.res.TypedArray;
Winson Chungb3800242013-10-24 11:01:54 -070040import android.graphics.Point;
Jon Miranda7ae64ff2016-11-21 16:18:46 -080041import android.graphics.PointF;
Winson Chungb3800242013-10-24 11:01:54 -070042import android.graphics.Rect;
Sunny Goyal35c7b192021-04-20 16:51:10 -070043import android.util.DisplayMetrics;
Sunny Goyal65190ae2022-08-02 14:16:26 -070044import android.util.SparseArray;
Sunny Goyal59d086c2018-05-07 17:31:40 -070045import android.view.Surface;
Winson Chungb3800242013-10-24 11:01:54 -070046
Sunny Goyal65190ae2022-08-02 14:16:26 -070047import androidx.annotation.NonNull;
Sihua Mae04aa202022-07-18 12:43:56 -070048import androidx.annotation.Nullable;
Jon Miranda9c478b62023-03-23 21:38:49 -070049import androidx.core.content.res.ResourcesCompat;
Sunny Goyal65190ae2022-08-02 14:16:26 -070050
Sunny Goyalc13403c2016-11-18 23:44:48 -080051import com.android.launcher3.CellLayout.ContainerType;
Jon Miranda228877d2021-02-09 11:05:00 -050052import com.android.launcher3.DevicePaddings.DevicePadding;
Alex Chaud67ddc42022-09-30 18:15:56 +010053import com.android.launcher3.config.FeatureFlags;
Tony Wickham8912b042018-11-29 15:28:53 -080054import com.android.launcher3.icons.DotRenderer;
Hyunyoung Song48cb7bc2018-09-25 17:03:34 -070055import com.android.launcher3.icons.IconNormalizer;
Sihua Mae04aa202022-07-18 12:43:56 -070056import com.android.launcher3.model.data.ItemInfo;
Thales Limaabfe3642023-05-24 18:08:53 +010057import com.android.launcher3.responsive.AllAppsSpecs;
58import com.android.launcher3.responsive.CalculatedAllAppsSpec;
Jordan Silva637f4eb2023-06-13 11:21:53 +010059import com.android.launcher3.responsive.CalculatedFolderSpec;
Thales Limaf8bfb032023-07-24 15:08:05 +010060import com.android.launcher3.responsive.CalculatedHotseatSpec;
Jordan Silva8bd7af22023-06-21 15:35:03 +010061import com.android.launcher3.responsive.CalculatedWorkspaceSpec;
Jordan Silva637f4eb2023-06-13 11:21:53 +010062import com.android.launcher3.responsive.FolderSpecs;
Thales Limaf8bfb032023-07-24 15:08:05 +010063import com.android.launcher3.responsive.HotseatSpecs;
Jordan Silva8bd7af22023-06-21 15:35:03 +010064import com.android.launcher3.responsive.WorkspaceSpecs;
Sunny Goyal57b22792021-05-25 14:35:01 -070065import com.android.launcher3.uioverrides.ApiWrapper;
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;
Winson1f064272016-07-18 17:18:02 -070072
Jon Miranda58561d42021-03-17 10:51:54 -040073import java.io.PrintWriter;
Alex Chaue818bcb2022-09-02 17:27:11 +010074import java.util.Locale;
Jon Miranda2b25ded2023-02-02 14:48:45 -080075import java.util.function.Consumer;
Jon Miranda58561d42021-03-17 10:51:54 -040076
Sunny Goyal35c7b192021-04-20 16:51:10 -070077@SuppressLint("NewApi")
Winson Chungb3800242013-10-24 11:01:54 -070078public class DeviceProfile {
Adam Cohen2e6da152015-05-06 11:42:25 -070079
Sunny Goyal8b9919d2021-04-07 14:45:17 -070080 private static final int DEFAULT_DOT_SIZE = 100;
Alex Chau206ede92022-08-01 17:46:12 +010081 private static final float ALL_APPS_TABLET_MAX_ROWS = 5.5f;
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
Sihua Mae04aa202022-07-18 12:43:56 -070085 public static final PointF DEFAULT_SCALE = new PointF(1.0f, 1.0f);
86 public static final ViewScaleProvider DEFAULT_PROVIDER = itemInfo -> DEFAULT_SCALE;
Jordan Silva637f4eb2023-06-13 11:21:53 +010087 public static final Consumer<DeviceProfile> DEFAULT_DIMENSION_PROVIDER = dp -> {};
Sihua Mae04aa202022-07-18 12:43:56 -070088
Adam Cohen2e6da152015-05-06 11:42:25 -070089 public final InvariantDeviceProfile inv;
Sunny Goyalfd58da62020-08-11 12:06:49 -070090 private final Info mInfo;
Sunny Goyal35c7b192021-04-20 16:51:10 -070091 private final DisplayMetrics mMetrics;
Thales Lima2759aa32023-06-05 16:25:45 +010092 private final IconSizeSteps mIconSizeSteps;
Winson Chungbe876472014-05-14 14:15:20 -070093
Sunny Goyalc6205602015-05-21 20:46:33 -070094 // Device properties
95 public final boolean isTablet;
Sunny Goyalc6205602015-05-21 20:46:33 -070096 public final boolean isPhone;
97 public final boolean transposeLayoutWithOrientation;
Alex Chauab800f72022-12-13 17:46:06 +000098 public final boolean isMultiDisplay;
Sunny Goyal19ff7282021-04-22 10:12:54 -070099 public final boolean isTwoPanels;
Thales Limaa1012902022-01-13 17:58:42 +0000100 public final boolean isQsbInline;
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -0700101
Sunny Goyalc6205602015-05-21 20:46:33 -0700102 // Device properties in current orientation
Sunny Goyald792a772018-04-05 13:37:46 -0700103 public final boolean isLandscape;
Sunny Goyald70e75a2018-02-22 10:07:32 -0800104 public final boolean isMultiWindowMode;
Alex Chau6ed408f2022-03-04 12:58:05 +0000105 public final boolean isGestureMode;
Sunny Goyald70e75a2018-02-22 10:07:32 -0800106
Sunny Goyal0addbf02020-04-28 14:17:35 -0700107 public final int windowX;
108 public final int windowY;
Sunny Goyalc6205602015-05-21 20:46:33 -0700109 public final int widthPx;
110 public final int heightPx;
111 public final int availableWidthPx;
112 public final int availableHeightPx;
Sunny Goyal187b16c2022-03-01 16:53:23 -0800113 public final int rotationHint;
Jon Mirandabba64512019-03-27 10:54:17 -0700114
115 public final float aspectRatio;
116
Thales Lima79456492023-05-23 11:32:22 +0100117 private final boolean mIsScalableGrid;
Thales Lima83bedbf2021-10-05 17:47:39 +0100118 private final int mTypeIndex;
Jon Mirandae126d722021-02-25 10:45:20 -0500119
Thales Limac98b7812023-04-14 15:04:23 +0100120 // Responsive grid
121 private final boolean mIsResponsiveGrid;
Thales Limac98b7812023-04-14 15:04:23 +0100122 private CalculatedWorkspaceSpec mResponsiveWidthSpec;
123 private CalculatedWorkspaceSpec mResponsiveHeightSpec;
Thales Limaabfe3642023-05-24 18:08:53 +0100124 private CalculatedAllAppsSpec mAllAppsResponsiveWidthSpec;
125 private CalculatedAllAppsSpec mAllAppsResponsiveHeightSpec;
Jordan Silva637f4eb2023-06-13 11:21:53 +0100126 private CalculatedFolderSpec mResponsiveFolderWidthSpec;
127 private CalculatedFolderSpec mResponsiveFolderHeightSpec;
Thales Limaf8bfb032023-07-24 15:08:05 +0100128 private CalculatedHotseatSpec mResponsiveHotseatSpec;
Thales Limac98b7812023-04-14 15:04:23 +0100129
Tony Wickhamd6b40372015-09-23 18:37:57 -0700130 /**
131 * The maximum amount of left/right workspace padding as a percentage of the screen width.
132 * To be clear, this means that up to 7% of the screen width can be used as left padding, and
133 * 7% of the screen width can be used as right padding.
134 */
135 private static final float MAX_HORIZONTAL_PADDING_PERCENT = 0.14f;
Winson Chungb3800242013-10-24 11:01:54 -0700136
Jon Miranda3f9bab22017-07-28 14:50:17 -0700137 private static final float TALL_DEVICE_ASPECT_RATIO_THRESHOLD = 2.0f;
Jon Miranda80cddbc2021-07-22 13:51:16 -0700138 private static final float TALLER_DEVICE_ASPECT_RATIO_THRESHOLD = 2.15f;
Jon Miranda80dda302021-07-28 14:14:59 -0700139 private static final float TALL_DEVICE_EXTRA_SPACE_THRESHOLD_DP = 252;
140 private static final float TALL_DEVICE_MORE_EXTRA_SPACE_THRESHOLD_DP = 268;
Jon Miranda30d0aa22017-07-25 15:55:29 -0700141
Sunny Goyalc6205602015-05-21 20:46:33 -0700142 // Workspace
Thales Limad90faab2021-09-21 17:18:47 +0100143 public final int desiredWorkspaceHorizontalMarginOriginalPx;
144 public int desiredWorkspaceHorizontalMarginPx;
Alex Chau51da2192022-05-20 13:32:10 +0100145 public int gridVisualizationPaddingX;
146 public int gridVisualizationPaddingY;
Thales Lima78d00ad2021-09-30 11:29:06 +0100147 public Point cellLayoutBorderSpaceOriginalPx;
148 public Point cellLayoutBorderSpacePx;
Pat Manning08610ca2022-04-05 21:03:16 +0100149 public Rect cellLayoutPaddingPx = new Rect();
150
Sunny Goyalc6205602015-05-21 20:46:33 -0700151 public final int edgeMarginPx;
Alex Chau0c4e11b2022-07-08 18:41:36 +0100152 public final float workspaceContentScale;
Alex Chau906d8822022-05-23 10:42:25 +0100153 public final int workspaceSpringLoadedMinNextPageVisiblePx;
Sunny Goyalc6205602015-05-21 20:46:33 -0700154
Jon Miranda58561d42021-03-17 10:51:54 -0400155 private final int extraSpace;
Thales Lima171ee662022-11-22 15:52:49 +0000156 private int maxEmptySpace;
Jon Miranda228877d2021-02-09 11:05:00 -0500157 public int workspaceTopPadding;
158 public int workspaceBottomPadding;
159
Tony Wickham5edf9e22020-03-27 20:06:52 -0700160 // Workspace page indicator
161 public final int workspacePageIndicatorHeight;
162 private final int mWorkspacePageIndicatorOverlapWorkspace;
Winson1f064272016-07-18 17:18:02 -0700163
Sunny Goyalc6205602015-05-21 20:46:33 -0700164 // Workspace icons
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400165 public float iconScale;
Sunny Goyalc6205602015-05-21 20:46:33 -0700166 public int iconSizePx;
167 public int iconTextSizePx;
168 public int iconDrawablePaddingPx;
Thales Lima93ee8fc2023-06-05 17:07:11 +0100169 private final int mIconDrawablePaddingOriginalPx;
Thales Lima79456492023-05-23 11:32:22 +0100170 public boolean iconCenterVertically;
Winson Chungb3800242013-10-24 11:01:54 -0700171
Jon Mirandaab3c6812021-06-28 15:42:28 -0700172 public float cellScaleToFit;
Adam Cohen59400422014-03-05 18:07:04 -0800173 public int cellWidthPx;
174 public int cellHeightPx;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700175 public int workspaceCellPaddingXPx;
Adam Cohen59400422014-03-05 18:07:04 -0800176
Thales Lima79456492023-05-23 11:32:22 +0100177 public int cellYPaddingPx = -1;
Jon Mirandae126d722021-02-25 10:45:20 -0500178
Sunny Goyalc6205602015-05-21 20:46:33 -0700179 // Folder
Jon Mirandae126d722021-02-25 10:45:20 -0500180 public float folderLabelTextScale;
181 public int folderLabelTextSizePx;
Thales Limab35faed2022-09-05 16:30:01 -0300182 public int folderFooterHeightPx;
Sunny Goyalc6205602015-05-21 20:46:33 -0700183 public int folderIconSizePx;
Jon Miranda591e3602018-03-28 11:37:00 -0700184 public int folderIconOffsetYPx;
Jon Mirandabf7d8122016-11-03 15:29:29 -0700185
Jon Mirandae126d722021-02-25 10:45:20 -0500186 // Folder content
Jordan Silva637f4eb2023-06-13 11:21:53 +0100187 public Point folderCellLayoutBorderSpacePx;
Jon Mirandae126d722021-02-25 10:45:20 -0500188 public int folderContentPaddingLeftRight;
189 public int folderContentPaddingTop;
190
Jon Mirandabf7d8122016-11-03 15:29:29 -0700191 // Folder cell
Sunny Goyalc6205602015-05-21 20:46:33 -0700192 public int folderCellWidthPx;
193 public int folderCellHeightPx;
Jon Mirandabf7d8122016-11-03 15:29:29 -0700194
195 // Folder child
196 public int folderChildIconSizePx;
197 public int folderChildTextSizePx;
Sunny Goyalbaec6ff2016-09-14 11:26:21 -0700198 public int folderChildDrawablePaddingPx;
Winson Chungb3800242013-10-24 11:01:54 -0700199
Sunny Goyalc6205602015-05-21 20:46:33 -0700200 // Hotseat
Thales Lima9938c2f2022-07-25 14:38:16 +0100201 public int numShownHotseatIcons;
Sunny Goyalc6205602015-05-21 20:46:33 -0700202 public int hotseatCellHeightPx;
Pat Manning26f70f72022-07-07 13:50:39 +0100203 public final boolean areNavButtonsInline;
Jon Miranda18751b62017-07-31 17:25:27 -0700204 // In portrait: size = height, in landscape: size = width
205 public int hotseatBarSizePx;
Thales Limab8c05952022-05-23 16:58:38 +0100206 public int hotseatBarBottomSpacePx;
Pat Manning26f70f72022-07-07 13:50:39 +0100207 public int hotseatBarEndOffset;
Thales Limab8c05952022-05-23 16:58:38 +0100208 public int hotseatQsbSpace;
Pat Manningde25c0d2022-04-05 19:11:26 +0100209 public int springLoadedHotseatBarTopMarginPx;
Thales Lima8e11d532023-08-31 13:40:26 +0000210 // These 2 values are only used for isVerticalBar
211 // Padding between edge of screen and hotseat
212 public final int mHotseatBarEdgePaddingPx;
213 // Space between hotseat and workspace (not used in responsive)
214 public final int mHotseatBarWorkspaceSpacePx;
Alex Chau206ede92022-08-01 17:46:12 +0100215 public int hotseatQsbWidth; // only used when isQsbInline
Sunny Goyal57b22792021-05-25 14:35:01 -0700216 public final int hotseatQsbHeight;
Thales Limab8c05952022-05-23 16:58:38 +0100217 public final int hotseatQsbVisualHeight;
218 private final int hotseatQsbShadowHeight;
Thales Limadd027342022-01-07 12:54:37 +0000219 public int hotseatBorderSpace;
Thales Limaffc68b02023-01-09 16:20:23 +0000220 private final int mMinHotseatIconSpacePx;
221 private final int mMinHotseatQsbWidthPx;
222 private final int mMaxHotseatIconSpacePx;
Jon Mirandae17a9492023-03-08 16:42:20 -0800223 public final int inlineNavButtonsEndSpacingPx;
Liran Binyamina833af32023-08-02 16:30:27 -0400224 // Space required for the bubble bar between the hotseat and the edge of the screen. If there's
225 // not enough space, the hotseat will adjust itself for the bubble bar.
226 private final int mBubbleBarSpaceThresholdPx;
Adam Cohen2e6da152015-05-06 11:42:25 -0700227
Alex Chau3d2c0622022-09-01 21:28:14 +0100228 // Bottom sheets
229 public int bottomSheetTopPadding;
230 public int bottomSheetOpenDuration;
231 public int bottomSheetCloseDuration;
232 public float bottomSheetWorkspaceScale;
233 public float bottomSheetDepth;
234
Sunny Goyalc6205602015-05-21 20:46:33 -0700235 // All apps
Thales Lima85c942f2021-12-31 13:04:20 +0000236 public Point allAppsBorderSpacePx;
Alex Chaub8c22e12022-02-14 18:35:58 +0000237 public int allAppsShiftRange;
Thales Limab433c9c2023-10-30 12:24:05 +0000238 public Rect allAppsPadding = new Rect();
Alex Chau3d2c0622022-09-01 21:28:14 +0100239 public int allAppsOpenDuration;
240 public int allAppsCloseDuration;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700241 public int allAppsCellHeightPx;
Samuel Fufaf1424a32019-10-04 15:15:19 -0700242 public int allAppsCellWidthPx;
Winson1f064272016-07-18 17:18:02 -0700243 public int allAppsIconSizePx;
244 public int allAppsIconDrawablePaddingPx;
Alex Chau27b39b92022-01-14 18:02:18 +0000245 public int allAppsLeftRightMargin;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700246 public final int numShownAllAppsColumns;
Winson1f064272016-07-18 17:18:02 -0700247 public float allAppsIconTextSizePx;
248
Zak Cohen334efeb2021-03-19 16:42:07 -0700249 // Overview
Zak Cohen334efeb2021-03-19 16:42:07 -0700250 public int overviewTaskMarginPx;
Alex Chaudedbc8a2021-03-17 16:53:26 +0000251 public int overviewTaskIconSizePx;
Alex Chauac9df382021-08-02 19:08:41 +0100252 public int overviewTaskIconDrawableSizePx;
253 public int overviewTaskIconDrawableSizeGridPx;
Pat Manning1695cc72023-07-05 11:45:13 +0100254 public int overviewTaskIconAppChipMenuDrawableSizePx;
Alex Chaudedbc8a2021-03-17 16:53:26 +0000255 public int overviewTaskThumbnailTopMarginPx;
Alex Chau19c6eca2022-03-10 20:12:56 +0000256 public final int overviewActionsHeight;
Alex Chaua2fc7642022-04-21 14:20:23 +0100257 public final int overviewActionsTopMarginPx;
Alex Chau1bf0fe12021-11-30 15:32:45 +0000258 public final int overviewActionsButtonSpacing;
Alex Chau5fd9d492021-07-22 17:27:11 +0100259 public int overviewPageSpacing;
260 public int overviewRowSpacing;
Alex Chau56bd2572021-11-03 18:48:18 +0000261 public int overviewGridSideMargin;
Zak Cohen334efeb2021-03-19 16:42:07 -0700262
Jeremy Sim0ac47082022-10-10 13:59:40 -0700263 // Split staging
264 public int splitPlaceholderInset;
265
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800266 // Widgets
Sihua Mae04aa202022-07-18 12:43:56 -0700267 private final ViewScaleProvider mViewScaleProvider;
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800268
Sunny Goyal47328fd2016-05-25 18:56:41 -0700269 // Drop Target
270 public int dropTargetBarSizePx;
Pat Manningde25c0d2022-04-05 19:11:26 +0100271 public int dropTargetBarTopMarginPx;
272 public int dropTargetBarBottomMarginPx;
Alex Chaua02eddc2021-04-29 00:36:06 +0100273 public int dropTargetDragPaddingPx;
274 public int dropTargetTextSizePx;
Pat Manningde25c0d2022-04-05 19:11:26 +0100275 public int dropTargetHorizontalPaddingPx;
276 public int dropTargetVerticalPaddingPx;
277 public int dropTargetGapPx;
Alex Chau5b019302022-05-23 10:42:25 +0100278 public int dropTargetButtonWorkspaceEdgeGapPx;
Adam Cohen4ae96ce2014-08-29 15:05:48 -0700279
Winson1f064272016-07-18 17:18:02 -0700280 // Insets
Sunny Goyal07b69292018-01-08 14:19:34 -0800281 private final Rect mInsets = new Rect();
282 public final Rect workspacePadding = new Rect();
Sunny Goyal6c304b12023-04-10 12:03:04 -0700283 // Additional padding added to the widget inside its cellSpace. It is applied outside
284 // the widgetView, such that the actual view size is same as the widget size.
285 public final Rect widgetPadding = new Rect();
286
Jon Miranda0bd63d12019-03-06 17:29:29 -0800287 // When true, nav bar is on the left side of the screen.
Sunny Goyal59d086c2018-05-07 17:31:40 -0700288 private boolean mIsSeascape;
Winson1f064272016-07-18 17:18:02 -0700289
Tony Wickhamf34bee82018-12-03 18:11:39 -0800290 // Notification dots
Sunny Goyal65190ae2022-08-02 14:16:26 -0700291 public final DotRenderer mDotRendererWorkSpace;
292 public final DotRenderer mDotRendererAllApps;
Tony Wickham9a8d11f2017-01-11 09:53:12 -0800293
Pierre Barbier de Reuille578deba2021-09-24 13:47:44 +0100294 // Taskbar
Tony Wickham15883892021-02-12 11:24:40 -0800295 public boolean isTaskbarPresent;
Tony Wickham635e1802021-07-22 14:28:04 -1000296 // Whether Taskbar will inset the bottom of apps by taskbarSize.
297 public boolean isTaskbarPresentInApps;
Jon Miranda9c478b62023-03-23 21:38:49 -0700298 public final int taskbarHeight;
299 public final int stashedTaskbarHeight;
300 public final int taskbarBottomMargin;
301 public final int taskbarIconSize;
Uwais Ashrafaa7fa882023-10-10 21:36:06 +0000302 private final int mTransientTaskbarClaimedSpace;
Jon Miranda04f05102023-04-04 12:16:31 -0700303 // If true, used to layout taskbar in 3 button navigation mode.
304 public final boolean startAlignTaskbar;
Thales Limae9566402023-08-30 16:35:12 +0100305 public final boolean isTransientTaskbar;
Alex Chaua02eddc2021-04-29 00:36:06 +0100306 // DragController
307 public int flingToDeleteThresholdVelocity;
308
Vinit Nayak17c4b332021-08-05 12:54:58 -0700309 /** TODO: Once we fully migrate to staged split, remove "isMultiWindowMode" */
Sunny Goyal19ff7282021-04-22 10:12:54 -0700310 DeviceProfile(Context context, InvariantDeviceProfile inv, Info info, WindowBounds windowBounds,
Sunny Goyal65190ae2022-08-02 14:16:26 -0700311 SparseArray<DotRenderer> dotRendererCache, boolean isMultiWindowMode,
Alex Chauab800f72022-12-13 17:46:06 +0000312 boolean transposeLayoutWithOrientation, boolean isMultiDisplay, boolean isGestureMode,
Jon Miranda2b25ded2023-02-02 14:48:45 -0800313 @NonNull final ViewScaleProvider viewScaleProvider,
Jagrut Desai3a7d1392023-09-06 15:56:19 -0700314 @NonNull final Consumer<DeviceProfile> dimensionOverrideProvider,
315 boolean isTransientTaskbar) {
Sunny Goyalfee35bb2015-05-11 11:38:19 -0700316
Adam Cohen2e6da152015-05-06 11:42:25 -0700317 this.inv = inv;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700318 this.isLandscape = windowBounds.isLandscape();
Sunny Goyald70e75a2018-02-22 10:07:32 -0800319 this.isMultiWindowMode = isMultiWindowMode;
Jon Mirandae126d722021-02-25 10:45:20 -0500320 this.transposeLayoutWithOrientation = transposeLayoutWithOrientation;
Alex Chauab800f72022-12-13 17:46:06 +0000321 this.isMultiDisplay = isMultiDisplay;
Alex Chau6ed408f2022-03-04 12:58:05 +0000322 this.isGestureMode = isGestureMode;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700323 windowX = windowBounds.bounds.left;
324 windowY = windowBounds.bounds.top;
Sunny Goyal187b16c2022-03-01 16:53:23 -0800325 this.rotationHint = windowBounds.rotationHint;
Alex Chaue0227552022-04-06 19:44:43 +0100326 mInsets.set(windowBounds.insets);
Winson Chungb3800242013-10-24 11:01:54 -0700327
Thales Limac98b7812023-04-14 15:04:23 +0100328 // TODO(b/241386436): shouldn't change any launcher behaviour
Thales Limaabfe3642023-05-24 18:08:53 +0100329 mIsResponsiveGrid = inv.workspaceSpecsId != INVALID_RESOURCE_HANDLE
Jordan Silva637f4eb2023-06-13 11:21:53 +0100330 && inv.allAppsSpecsId != INVALID_RESOURCE_HANDLE
Thales Limaf8bfb032023-07-24 15:08:05 +0100331 && inv.folderSpecsId != INVALID_RESOURCE_HANDLE
332 && inv.hotseatSpecsId != INVALID_RESOURCE_HANDLE;
Thales Limaec5abba2023-04-05 16:33:50 +0100333
Thales Lima79456492023-05-23 11:32:22 +0100334 mIsScalableGrid = inv.isScalable && !isVerticalBarLayout() && !isMultiWindowMode;
Alex Chaudfc8ddf2022-01-25 11:26:25 +0000335 // Determine device posture.
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700336 mInfo = info;
Alex Chau29983072021-11-19 15:14:20 +0000337 isTablet = info.isTablet(windowBounds);
Sunny Goyal19ff7282021-04-22 10:12:54 -0700338 isPhone = !isTablet;
Alex Chauab800f72022-12-13 17:46:06 +0000339 isTwoPanels = isTablet && isMultiDisplay;
Vinit Nayak58c27cc2022-02-16 17:42:21 -0800340 isTaskbarPresent = isTablet && ApiWrapper.TASKBAR_DRAWN_IN_PROCESS;
Adam Cohen2e6da152015-05-06 11:42:25 -0700341
Alex Chaudfc8ddf2022-01-25 11:26:25 +0000342 // Some more constants.
Alex Chau635b3ab2022-01-26 16:49:10 +0000343 context = getContext(context, info, isVerticalBarLayout() || (isTablet && isLandscape)
Brandon Dayauon07ca8842022-04-27 10:52:28 -0700344 ? Configuration.ORIENTATION_LANDSCAPE
345 : Configuration.ORIENTATION_PORTRAIT,
Alex Chaua6907dc2022-03-18 15:24:07 +0000346 windowBounds);
Sunny Goyal1890f672020-04-30 12:28:00 -0700347 final Resources res = context.getResources();
Alex Chaudfc8ddf2022-01-25 11:26:25 +0000348 mMetrics = res.getDisplayMetrics();
349
Thales Lima2759aa32023-06-05 16:25:45 +0100350 mIconSizeSteps = mIsResponsiveGrid ? new IconSizeSteps(res) : null;
351
Alex Chaudfc8ddf2022-01-25 11:26:25 +0000352 // Determine sizes.
353 widthPx = windowBounds.bounds.width();
354 heightPx = windowBounds.bounds.height();
355 availableWidthPx = windowBounds.availableSize.x;
Thales Limab8c05952022-05-23 16:58:38 +0100356 availableHeightPx = windowBounds.availableSize.y;
Alex Chaudfc8ddf2022-01-25 11:26:25 +0000357
358 aspectRatio = ((float) Math.max(widthPx, heightPx)) / Math.min(widthPx, heightPx);
Thales Lima83bedbf2021-10-05 17:47:39 +0100359 if (isTwoPanels) {
360 if (isLandscape) {
Thales Lima12d0eff2022-03-25 17:06:11 +0000361 mTypeIndex = INDEX_TWO_PANEL_LANDSCAPE;
Thales Lima83bedbf2021-10-05 17:47:39 +0100362 } else {
Thales Lima12d0eff2022-03-25 17:06:11 +0000363 mTypeIndex = INDEX_TWO_PANEL_PORTRAIT;
Thales Lima83bedbf2021-10-05 17:47:39 +0100364 }
365 } else {
366 if (isLandscape) {
Thales Lima12d0eff2022-03-25 17:06:11 +0000367 mTypeIndex = INDEX_LANDSCAPE;
Thales Lima83bedbf2021-10-05 17:47:39 +0100368 } else {
Thales Lima12d0eff2022-03-25 17:06:11 +0000369 mTypeIndex = INDEX_DEFAULT;
Thales Lima83bedbf2021-10-05 17:47:39 +0100370 }
371 }
372
Jagrut Desai3a7d1392023-09-06 15:56:19 -0700373 this.isTransientTaskbar = isTransientTaskbar;
Uwais Ashrafaa7fa882023-10-10 21:36:06 +0000374 int transientTaskbarIconSize = pxFromDp(inv.transientTaskbarIconSize[mTypeIndex], mMetrics);
375 int transientTaskbarBottomMargin =
376 res.getDimensionPixelSize(R.dimen.transient_taskbar_bottom_margin);
377 int transientTaskbarHeight =
378 Math.round((transientTaskbarIconSize * ICON_VISIBLE_AREA_FACTOR)
379 + (2 * res.getDimensionPixelSize(R.dimen.transient_taskbar_padding)));
380 mTransientTaskbarClaimedSpace = transientTaskbarHeight + 2 * transientTaskbarBottomMargin;
381
Uwais Ashraf3602d172023-09-15 11:36:32 +0000382 if (!isTaskbarPresent) {
383 taskbarIconSize = taskbarHeight = stashedTaskbarHeight = taskbarBottomMargin = 0;
384 startAlignTaskbar = false;
385 } else if (isTransientTaskbar) {
Uwais Ashrafaa7fa882023-10-10 21:36:06 +0000386 taskbarIconSize = transientTaskbarIconSize;
387 taskbarHeight = transientTaskbarHeight;
Jon Miranda9c478b62023-03-23 21:38:49 -0700388 stashedTaskbarHeight =
389 res.getDimensionPixelSize(R.dimen.transient_taskbar_stashed_height);
Uwais Ashrafaa7fa882023-10-10 21:36:06 +0000390 taskbarBottomMargin = transientTaskbarBottomMargin;
Jon Miranda04f05102023-04-04 12:16:31 -0700391 startAlignTaskbar = false;
Jon Miranda9c478b62023-03-23 21:38:49 -0700392 } else {
393 taskbarIconSize = pxFromDp(ResourcesCompat.getFloat(res, R.dimen.taskbar_icon_size),
394 mMetrics);
395 taskbarHeight = res.getDimensionPixelSize(R.dimen.taskbar_size);
396 stashedTaskbarHeight = res.getDimensionPixelSize(R.dimen.taskbar_stashed_size);
397 taskbarBottomMargin = 0;
Jon Miranda04f05102023-04-04 12:16:31 -0700398 startAlignTaskbar = inv.startAlignTaskbar[mTypeIndex];
Tony Wickham15883892021-02-12 11:24:40 -0800399 }
Tony Wickham15883892021-02-12 11:24:40 -0800400
Winson Chungb3800242013-10-24 11:01:54 -0700401 edgeMarginPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_edge_margin);
Alex Chau0c4e11b2022-07-08 18:41:36 +0100402 workspaceContentScale = res.getFloat(R.dimen.workspace_content_scale);
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700403
Alex Chau51da2192022-05-20 13:32:10 +0100404 gridVisualizationPaddingX = res.getDimensionPixelSize(
405 R.dimen.grid_visualization_horizontal_cell_spacing);
406 gridVisualizationPaddingY = res.getDimensionPixelSize(
407 R.dimen.grid_visualization_vertical_cell_spacing);
Samuel Fufaee9aff92021-04-05 13:30:40 -0500408
Alex Chaue0227552022-04-06 19:44:43 +0100409 bottomSheetTopPadding = mInsets.top // statusbar height
Andras Kloczl142b0542022-03-09 21:26:02 +0000410 + res.getDimensionPixelSize(R.dimen.bottom_sheet_extra_top_padding)
411 + (isTablet ? 0 : edgeMarginPx); // phones need edgeMarginPx additional padding
Alex Chau3d2c0622022-09-01 21:28:14 +0100412 bottomSheetOpenDuration = res.getInteger(R.integer.config_bottomSheetOpenDuration);
413 bottomSheetCloseDuration = res.getInteger(R.integer.config_bottomSheetCloseDuration);
414 if (isTablet) {
415 bottomSheetWorkspaceScale = workspaceContentScale;
Alex Chauab800f72022-12-13 17:46:06 +0000416 if (isMultiDisplay && !ENABLE_MULTI_DISPLAY_PARTIAL_DEPTH.get()) {
417 // TODO(b/259893832): Revert to use maxWallpaperScale to calculate bottomSheetDepth
418 // when screen recorder bug is fixed.
419 bottomSheetDepth = 1f;
420 } else {
421 // The goal is to set wallpaper to zoom at workspaceContentScale when in AllApps.
422 // When depth is 0, wallpaper zoom is set to maxWallpaperScale.
423 // When depth is 1, wallpaper zoom is set to 1.
424 // For depth to achieve zoom set to maxWallpaperScale * workspaceContentScale:
425 float maxWallpaperScale = res.getFloat(R.dimen.config_wallpaperMaxScale);
426 bottomSheetDepth = Utilities.mapToRange(maxWallpaperScale * workspaceContentScale,
427 maxWallpaperScale, 1f, 0f, 1f, LINEAR);
428 }
Alex Chau3d2c0622022-09-01 21:28:14 +0100429 } else {
430 bottomSheetWorkspaceScale = 1f;
431 bottomSheetDepth = 0f;
432 }
Andras Kloczl142b0542022-03-09 21:26:02 +0000433
Jon Mirandae126d722021-02-25 10:45:20 -0500434 folderLabelTextScale = res.getFloat(R.dimen.folder_label_text_scale);
Thales Limab35faed2022-09-05 16:30:01 -0300435
Thales Lima79456492023-05-23 11:32:22 +0100436 if (mIsScalableGrid && inv.folderStyle != INVALID_RESOURCE_HANDLE) {
Thales Limab35faed2022-09-05 16:30:01 -0300437 TypedArray folderStyle = context.obtainStyledAttributes(inv.folderStyle,
Thales Limad852d652023-01-17 14:01:13 +0000438 R.styleable.FolderStyle);
Thales Limab35faed2022-09-05 16:30:01 -0300439 // These are re-set in #updateFolderCellSize if the grid is not scalable
440 folderCellHeightPx = folderStyle.getDimensionPixelSize(
Thales Limad852d652023-01-17 14:01:13 +0000441 R.styleable.FolderStyle_folderCellHeight, 0);
Thales Limab35faed2022-09-05 16:30:01 -0300442 folderCellWidthPx = folderStyle.getDimensionPixelSize(
Thales Limad852d652023-01-17 14:01:13 +0000443 R.styleable.FolderStyle_folderCellWidth, 0);
Thales Limab35faed2022-09-05 16:30:01 -0300444
445 folderContentPaddingTop = folderStyle.getDimensionPixelSize(
Thales Limad852d652023-01-17 14:01:13 +0000446 R.styleable.FolderStyle_folderTopPadding, 0);
Jordan Silva637f4eb2023-06-13 11:21:53 +0100447
448 int gutter = folderStyle.getDimensionPixelSize(
Thales Limad852d652023-01-17 14:01:13 +0000449 R.styleable.FolderStyle_folderBorderSpace, 0);
Jordan Silva637f4eb2023-06-13 11:21:53 +0100450 folderCellLayoutBorderSpacePx = new Point(gutter, gutter);
Thales Limab35faed2022-09-05 16:30:01 -0300451 folderFooterHeightPx = folderStyle.getDimensionPixelSize(
Thales Limad852d652023-01-17 14:01:13 +0000452 R.styleable.FolderStyle_folderFooterHeight, 0);
Thales Limab35faed2022-09-05 16:30:01 -0300453 folderStyle.recycle();
Jordan Silva637f4eb2023-06-13 11:21:53 +0100454 } else if (!mIsResponsiveGrid) {
455 folderCellLayoutBorderSpacePx = new Point(0, 0);
Thales Lima7eee74b2023-03-16 16:00:55 -0300456 folderFooterHeightPx = res.getDimensionPixelSize(R.dimen.folder_footer_height_default);
Thales Limab35faed2022-09-05 16:30:01 -0300457 folderContentPaddingTop = res.getDimensionPixelSize(R.dimen.folder_top_padding_default);
458 }
Jon Mirandae126d722021-02-25 10:45:20 -0500459
Thales Lima85c942f2021-12-31 13:04:20 +0000460 allAppsBorderSpacePx = new Point(
Thales Limabb7d3882021-12-22 12:56:29 +0000461 pxFromDp(inv.allAppsBorderSpaces[mTypeIndex].x, mMetrics),
462 pxFromDp(inv.allAppsBorderSpaces[mTypeIndex].y, mMetrics));
Thales Limae9273ea2023-01-26 12:33:52 +0000463 setupAllAppsStyle(context);
Jon Mirandae126d722021-02-25 10:45:20 -0500464
Tony Wickham5edf9e22020-03-27 20:06:52 -0700465 workspacePageIndicatorHeight = res.getDimensionPixelSize(
466 R.dimen.workspace_page_indicator_height);
467 mWorkspacePageIndicatorOverlapWorkspace =
468 res.getDimensionPixelSize(R.dimen.workspace_page_indicator_overlap_workspace);
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700469
Thales Limad852d652023-01-17 14:01:13 +0000470 TypedArray cellStyle;
471 if (inv.cellStyle != INVALID_RESOURCE_HANDLE) {
472 cellStyle = context.obtainStyledAttributes(inv.cellStyle,
473 R.styleable.CellStyle);
474 } else {
475 cellStyle = context.obtainStyledAttributes(R.style.CellStyleDefault,
476 R.styleable.CellStyle);
477 }
Thales Lima93ee8fc2023-06-05 17:07:11 +0100478 mIconDrawablePaddingOriginalPx = cellStyle.getDimensionPixelSize(
Thales Limad852d652023-01-17 14:01:13 +0000479 R.styleable.CellStyle_iconDrawablePadding, 0);
480 cellStyle.recycle();
Alex Chaua02eddc2021-04-29 00:36:06 +0100481
Sunny Goyal47328fd2016-05-25 18:56:41 -0700482 dropTargetBarSizePx = res.getDimensionPixelSize(R.dimen.dynamic_grid_drop_target_size);
Pat Manningde25c0d2022-04-05 19:11:26 +0100483 dropTargetBarTopMarginPx = res.getDimensionPixelSize(R.dimen.drop_target_top_margin);
484 dropTargetBarBottomMarginPx = res.getDimensionPixelSize(R.dimen.drop_target_bottom_margin);
Alex Chaua02eddc2021-04-29 00:36:06 +0100485 dropTargetDragPaddingPx = res.getDimensionPixelSize(R.dimen.drop_target_drag_padding);
486 dropTargetTextSizePx = res.getDimensionPixelSize(R.dimen.drop_target_text_size);
Pat Manningde25c0d2022-04-05 19:11:26 +0100487 dropTargetHorizontalPaddingPx = res.getDimensionPixelSize(
488 R.dimen.drop_target_button_drawable_horizontal_padding);
489 dropTargetVerticalPaddingPx = res.getDimensionPixelSize(
490 R.dimen.drop_target_button_drawable_vertical_padding);
491 dropTargetGapPx = res.getDimensionPixelSize(R.dimen.drop_target_button_gap);
Alex Chau5b019302022-05-23 10:42:25 +0100492 dropTargetButtonWorkspaceEdgeGapPx = res.getDimensionPixelSize(
493 R.dimen.drop_target_button_workspace_edge_gap);
Alex Chaua02eddc2021-04-29 00:36:06 +0100494
Alex Chau906d8822022-05-23 10:42:25 +0100495 workspaceSpringLoadedMinNextPageVisiblePx = res.getDimensionPixelSize(
496 R.dimen.dynamic_grid_spring_loaded_min_next_space_visible);
Sunny Goyald5190522017-04-24 03:06:54 -0700497
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700498 workspaceCellPaddingXPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_cell_padding_x);
Jon Miranda09660722017-06-14 14:20:14 -0700499
Thales Limaa1012902022-01-13 17:58:42 +0000500 hotseatQsbHeight = res.getDimensionPixelSize(R.dimen.qsb_widget_height);
Thales Limab8c05952022-05-23 16:58:38 +0100501 hotseatQsbShadowHeight = res.getDimensionPixelSize(R.dimen.qsb_shadow_height);
502 hotseatQsbVisualHeight = hotseatQsbHeight - 2 * hotseatQsbShadowHeight;
503
Thales Lima12d0eff2022-03-25 17:06:11 +0000504 // Whether QSB might be inline in appropriate orientation (e.g. landscape).
505 boolean canQsbInline = (isTwoPanels ? inv.inlineQsb[INDEX_TWO_PANEL_PORTRAIT]
506 || inv.inlineQsb[INDEX_TWO_PANEL_LANDSCAPE]
507 : inv.inlineQsb[INDEX_DEFAULT] || inv.inlineQsb[INDEX_LANDSCAPE])
508 && hotseatQsbHeight > 0;
Thales Lima79456492023-05-23 11:32:22 +0100509 isQsbInline = mIsScalableGrid && inv.inlineQsb[mTypeIndex] && canQsbInline;
Alex Chau6ed408f2022-03-04 12:58:05 +0000510
Thales Lima425f6822022-05-10 13:44:58 -0300511 areNavButtonsInline = isTaskbarPresent && !isGestureMode;
Thales Lima9938c2f2022-07-25 14:38:16 +0100512 numShownHotseatIcons =
513 isTwoPanels ? inv.numDatabaseHotseatIcons : inv.numShownHotseatIcons;
Alex Chau6ed408f2022-03-04 12:58:05 +0000514
Sunny Goyal19ff7282021-04-22 10:12:54 -0700515 numShownAllAppsColumns =
516 isTwoPanels ? inv.numDatabaseAllAppsColumns : inv.numAllAppsColumns;
Thales Limab8c05952022-05-23 16:58:38 +0100517
Thales Lima8e11d532023-08-31 13:40:26 +0000518 int hotseatBarBottomSpace;
Thales Limab8c05952022-05-23 16:58:38 +0100519 int minQsbMargin = res.getDimensionPixelSize(R.dimen.min_qsb_margin);
Thales Limaf8bfb032023-07-24 15:08:05 +0100520
521 if (mIsResponsiveGrid) {
522 HotseatSpecs hotseatSpecs =
523 HotseatSpecs.create(new ResourceHelper(context,
524 isTwoPanels ? inv.hotseatSpecsTwoPanelId : inv.hotseatSpecsId));
Thales Lima8e11d532023-08-31 13:40:26 +0000525 mResponsiveHotseatSpec =
526 isVerticalBarLayout() ? hotseatSpecs.getCalculatedWidthSpec(widthPx)
527 : hotseatSpecs.getCalculatedHeightSpec(heightPx);
Thales Limaf8bfb032023-07-24 15:08:05 +0100528 hotseatQsbSpace = mResponsiveHotseatSpec.getHotseatQsbSpace();
Thales Lima8e11d532023-08-31 13:40:26 +0000529 hotseatBarBottomSpace =
530 isVerticalBarLayout() ? 0 : mResponsiveHotseatSpec.getEdgePadding();
531 mHotseatBarEdgePaddingPx =
532 isVerticalBarLayout() ? mResponsiveHotseatSpec.getEdgePadding() : 0;
533 mHotseatBarWorkspaceSpacePx = 0;
Thales Limaf8bfb032023-07-24 15:08:05 +0100534 } else {
535 hotseatQsbSpace = pxFromDp(inv.hotseatQsbSpace[mTypeIndex], mMetrics);
Thales Lima8e11d532023-08-31 13:40:26 +0000536 hotseatBarBottomSpace = pxFromDp(inv.hotseatBarBottomSpace[mTypeIndex], mMetrics);
537 mHotseatBarEdgePaddingPx =
538 isVerticalBarLayout() ? workspacePageIndicatorHeight : 0;
539 mHotseatBarWorkspaceSpacePx =
540 res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_side_padding);
Thales Limaf8bfb032023-07-24 15:08:05 +0100541 }
542
Thales Lima8e11d532023-08-31 13:40:26 +0000543 if (!isVerticalBarLayout()) {
544 // Have a little space between the inset and the QSB
545 if (mInsets.bottom + minQsbMargin > hotseatBarBottomSpace) {
546 int availableSpace = hotseatQsbSpace - (mInsets.bottom - hotseatBarBottomSpace);
Thales Limab8c05952022-05-23 16:58:38 +0100547
Thales Lima8e11d532023-08-31 13:40:26 +0000548 // Only change the spaces if there is space
549 if (availableSpace > 0) {
550 // Make sure there is enough space between hotseat/QSB and QSB/navBar
551 if (availableSpace < minQsbMargin * 2) {
552 minQsbMargin = availableSpace / 2;
553 hotseatQsbSpace = minQsbMargin;
554 } else {
555 hotseatQsbSpace -= minQsbMargin;
556 }
Thales Limab8c05952022-05-23 16:58:38 +0100557 }
Thales Lima8e11d532023-08-31 13:40:26 +0000558 hotseatBarBottomSpacePx = mInsets.bottom + minQsbMargin;
Thales Limab8c05952022-05-23 16:58:38 +0100559
Thales Lima8e11d532023-08-31 13:40:26 +0000560 } else {
561 hotseatBarBottomSpacePx = hotseatBarBottomSpace;
562 }
Thales Limaa1012902022-01-13 17:58:42 +0000563 }
Thales Lima425f6822022-05-10 13:44:58 -0300564
Pat Manningde25c0d2022-04-05 19:11:26 +0100565 springLoadedHotseatBarTopMarginPx = res.getDimensionPixelSize(
566 R.dimen.spring_loaded_hotseat_top_margin);
Thales Lima8e11d532023-08-31 13:40:26 +0000567 updateHotseatSizes(pxFromDp(inv.iconSize[mTypeIndex], mMetrics));
Vinit Nayak8a3d0552022-08-05 10:43:29 -0700568 if (areNavButtonsInline && !isPhone) {
Jon Mirandae17a9492023-03-08 16:42:20 -0800569 inlineNavButtonsEndSpacingPx =
Thales Limaffc68b02023-01-09 16:20:23 +0000570 res.getDimensionPixelSize(inv.inlineNavButtonsEndSpacing);
Pat Manning26f70f72022-07-07 13:50:39 +0100571 /*
572 * 3 nav buttons +
Vinit Nayakc7293172022-07-18 16:41:50 -0700573 * Spacing between nav buttons +
Thales Lima6a590062022-11-22 15:52:49 +0000574 * Space at the end for contextual buttons
Pat Manning26f70f72022-07-07 13:50:39 +0100575 */
576 hotseatBarEndOffset = 3 * res.getDimensionPixelSize(R.dimen.taskbar_nav_buttons_size)
Vinit Nayakc7293172022-07-18 16:41:50 -0700577 + 2 * res.getDimensionPixelSize(R.dimen.taskbar_button_space_inbetween)
Jon Mirandae17a9492023-03-08 16:42:20 -0800578 + inlineNavButtonsEndSpacingPx;
Pat Manning26f70f72022-07-07 13:50:39 +0100579 } else {
Jon Mirandae17a9492023-03-08 16:42:20 -0800580 inlineNavButtonsEndSpacingPx = 0;
Pat Manning26f70f72022-07-07 13:50:39 +0100581 hotseatBarEndOffset = 0;
582 }
Jon Miranda8bdb2222021-06-23 18:10:10 -0700583
Liran Binyamina833af32023-08-02 16:30:27 -0400584 mBubbleBarSpaceThresholdPx =
585 res.getDimensionPixelSize(R.dimen.bubblebar_hotseat_adjustment_threshold);
586
Thales Lima79456492023-05-23 11:32:22 +0100587 // Needs to be calculated after hotseatBarSizePx is correct,
588 // for the available height to be correct
589 if (mIsResponsiveGrid) {
Jordan Silva8bd7af22023-06-21 15:35:03 +0100590 WorkspaceSpecs workspaceSpecs = WorkspaceSpecs.create(
Jordan Silva575c3bd2023-07-21 12:00:43 +0100591 new ResourceHelper(context,
592 isTwoPanels ? inv.workspaceSpecsTwoPanelId : inv.workspaceSpecsId));
Thales Lima2759aa32023-06-05 16:25:45 +0100593 int availableResponsiveWidth =
594 availableWidthPx - (isVerticalBarLayout() ? hotseatBarSizePx : 0);
Jordan Silvac118fb52023-06-22 11:42:01 +0100595 int numColumns = getPanelCount() * inv.numColumns;
Thales Lima8e11d532023-08-31 13:40:26 +0000596 // don't use availableHeightPx because it subtracts mInsets.bottom
597 int availableResponsiveHeight = heightPx - mInsets.top
598 - (isVerticalBarLayout() ? 0 : hotseatBarSizePx);
Jordan Silvac118fb52023-06-22 11:42:01 +0100599 mResponsiveWidthSpec = workspaceSpecs.getCalculatedWidthSpec(numColumns,
Thales Lima2759aa32023-06-05 16:25:45 +0100600 availableResponsiveWidth);
Jordan Silva8bd7af22023-06-21 15:35:03 +0100601 mResponsiveHeightSpec = workspaceSpecs.getCalculatedHeightSpec(inv.numRows,
Thales Lima2759aa32023-06-05 16:25:45 +0100602 availableResponsiveHeight);
Thales Limaabfe3642023-05-24 18:08:53 +0100603
Jordan Silva8bd7af22023-06-21 15:35:03 +0100604 AllAppsSpecs allAppsSpecs = AllAppsSpecs.create(
Jordan Silva575c3bd2023-07-21 12:00:43 +0100605 new ResourceHelper(context,
606 isTwoPanels ? inv.allAppsSpecsTwoPanelId : inv.allAppsSpecsId));
Jordan Silvac118fb52023-06-22 11:42:01 +0100607 mAllAppsResponsiveWidthSpec = allAppsSpecs.getCalculatedWidthSpec(numColumns,
Thales Limaabfe3642023-05-24 18:08:53 +0100608 mResponsiveWidthSpec.getAvailableSpace(), mResponsiveWidthSpec);
Jordan Silva8bd7af22023-06-21 15:35:03 +0100609 mAllAppsResponsiveHeightSpec = allAppsSpecs.getCalculatedHeightSpec(inv.numRows,
610 mResponsiveHeightSpec.getAvailableSpace(), mResponsiveHeightSpec);
Jordan Silva637f4eb2023-06-13 11:21:53 +0100611
Jordan Silva8bd7af22023-06-21 15:35:03 +0100612 FolderSpecs folderSpecs = FolderSpecs.create(
Jordan Silva575c3bd2023-07-21 12:00:43 +0100613 new ResourceHelper(context,
614 isTwoPanels ? inv.folderSpecsTwoPanelId : inv.folderSpecsId));
Jordan Silva8bd7af22023-06-21 15:35:03 +0100615 mResponsiveFolderWidthSpec = folderSpecs.getCalculatedWidthSpec(inv.numFolderColumns,
Jordan Silva637f4eb2023-06-13 11:21:53 +0100616 mResponsiveWidthSpec.getAvailableSpace(), mResponsiveWidthSpec);
Jordan Silva8bd7af22023-06-21 15:35:03 +0100617 mResponsiveFolderHeightSpec = folderSpecs.getCalculatedHeightSpec(inv.numFolderRows,
Jordan Silva637f4eb2023-06-13 11:21:53 +0100618 mResponsiveHeightSpec.getAvailableSpace(), mResponsiveHeightSpec);
Thales Lima79456492023-05-23 11:32:22 +0100619 }
620
621 desiredWorkspaceHorizontalMarginPx = getHorizontalMarginPx(inv, res);
622 desiredWorkspaceHorizontalMarginOriginalPx = desiredWorkspaceHorizontalMarginPx;
623
Alex Chau635b3ab2022-01-26 16:49:10 +0000624 overviewTaskMarginPx = res.getDimensionPixelSize(R.dimen.overview_task_margin);
Pat Manning1695cc72023-07-05 11:45:13 +0100625 overviewTaskIconSizePx = enableOverviewIconMenu() ? res.getDimensionPixelSize(
626 R.dimen.task_thumbnail_icon_menu_drawable_touch_size) : res.getDimensionPixelSize(
627 R.dimen.task_thumbnail_icon_size);
Alex Chauac9df382021-08-02 19:08:41 +0100628 overviewTaskIconDrawableSizePx =
629 res.getDimensionPixelSize(R.dimen.task_thumbnail_icon_drawable_size);
630 overviewTaskIconDrawableSizeGridPx =
631 res.getDimensionPixelSize(R.dimen.task_thumbnail_icon_drawable_size_grid);
Pat Manning1695cc72023-07-05 11:45:13 +0100632 overviewTaskIconAppChipMenuDrawableSizePx = res.getDimensionPixelSize(
633 R.dimen.task_thumbnail_icon_menu_drawable_size);
634 overviewTaskThumbnailTopMarginPx =
635 enableOverviewIconMenu() ? 0 : overviewTaskIconSizePx + overviewTaskMarginPx;
Andy Wickhambc3bac42023-08-07 16:02:23 -0700636 // Don't add margin with floating search bar to minimize risk of overlapping.
637 overviewActionsTopMarginPx = FeatureFlags.ENABLE_FLOATING_SEARCH_BAR.get() ? 0
638 : res.getDimensionPixelSize(R.dimen.overview_actions_top_margin);
Alex Chau635b3ab2022-01-26 16:49:10 +0000639 overviewPageSpacing = res.getDimensionPixelSize(R.dimen.overview_page_spacing);
640 overviewActionsButtonSpacing = res.getDimensionPixelSize(
641 R.dimen.overview_actions_button_spacing);
Andy Wickhambc3bac42023-08-07 16:02:23 -0700642 overviewActionsHeight = res.getDimensionPixelSize(R.dimen.overview_actions_height);
Jeremy Sim1cfe6d42022-07-15 14:40:38 -0700643 overviewRowSpacing = res.getDimensionPixelSize(R.dimen.overview_grid_row_spacing);
Alex Chau635b3ab2022-01-26 16:49:10 +0000644 overviewGridSideMargin = res.getDimensionPixelSize(R.dimen.overview_grid_side_margin);
Zak Cohen334efeb2021-03-19 16:42:07 -0700645
Jeremy Sim0ac47082022-10-10 13:59:40 -0700646 splitPlaceholderInset = res.getDimensionPixelSize(R.dimen.split_placeholder_inset);
647
Jon Miranda2ed276e2017-06-29 11:36:34 -0700648 // Calculate all of the remaining variables.
Jon Miranda58561d42021-03-17 10:51:54 -0400649 extraSpace = updateAvailableDimensions(res);
Jon Miranda80cddbc2021-07-22 13:51:16 -0700650
Thales Lima79456492023-05-23 11:32:22 +0100651 calculateAndSetWorkspaceVerticalPadding(context, inv, extraSpace);
Pat Manning08610ca2022-04-05 21:03:16 +0100652
653 int cellLayoutPadding =
654 isTwoPanels ? cellLayoutBorderSpacePx.x / 2 : res.getDimensionPixelSize(
655 R.dimen.cell_layout_padding);
656 cellLayoutPaddingPx = new Rect(cellLayoutPadding, cellLayoutPadding, cellLayoutPadding,
657 cellLayoutPadding);
Sunny Goyal07b69292018-01-08 14:19:34 -0800658 updateWorkspacePadding();
Tony Wickham1237df02017-02-24 08:59:36 -0800659
Thales Lima7eee74b2023-03-16 16:00:55 -0300660 // Folder scaling requires correct workspace paddings
661 updateAvailableFolderCellDimensions(res);
662
Thales Limaffc68b02023-01-09 16:20:23 +0000663 mMinHotseatIconSpacePx = res.getDimensionPixelSize(R.dimen.min_hotseat_icon_space);
664 mMinHotseatQsbWidthPx = res.getDimensionPixelSize(R.dimen.min_hotseat_qsb_width);
665 mMaxHotseatIconSpacePx = areNavButtonsInline
Thales Lima6a590062022-11-22 15:52:49 +0000666 ? res.getDimensionPixelSize(R.dimen.max_hotseat_icon_space) : Integer.MAX_VALUE;
Thales Lima425f6822022-05-10 13:44:58 -0300667 // Hotseat and QSB width depends on updated cellSize and workspace padding
Thales Lima6a590062022-11-22 15:52:49 +0000668 recalculateHotseatWidthAndBorderSpace();
Alex Chau206ede92022-08-01 17:46:12 +0100669
Jordan Silva3646a1b2023-08-02 13:52:52 +0100670 if (mIsResponsiveGrid && isVerticalBarLayout()) {
671 hotseatBorderSpace = cellLayoutBorderSpacePx.y;
672 }
673
Alex Chau206ede92022-08-01 17:46:12 +0100674 // AllApps height calculation depends on updated cellSize
675 if (isTablet) {
676 int collapseHandleHeight =
677 res.getDimensionPixelOffset(R.dimen.bottom_sheet_handle_area_height);
678 int contentHeight = heightPx - collapseHandleHeight - hotseatQsbHeight;
679 int targetContentHeight = (int) (allAppsCellHeightPx * ALL_APPS_TABLET_MAX_ROWS);
Thales Limab433c9c2023-10-30 12:24:05 +0000680 allAppsPadding.top = Math.max(mInsets.top, contentHeight - targetContentHeight);
681 allAppsShiftRange = heightPx - allAppsPadding.top;
Alex Chau206ede92022-08-01 17:46:12 +0100682 } else {
Thales Limab433c9c2023-10-30 12:24:05 +0000683 allAppsPadding.top = 0;
Alex Chau206ede92022-08-01 17:46:12 +0100684 allAppsShiftRange =
685 res.getDimensionPixelSize(R.dimen.all_apps_starting_vertical_translate);
686 }
Alex Chau3d2c0622022-09-01 21:28:14 +0100687 allAppsOpenDuration = res.getInteger(R.integer.config_allAppsOpenDuration);
688 allAppsCloseDuration = res.getInteger(R.integer.config_allAppsCloseDuration);
Thales Lima425f6822022-05-10 13:44:58 -0300689
Alex Chaua02eddc2021-04-29 00:36:06 +0100690 flingToDeleteThresholdVelocity = res.getDimensionPixelSize(
691 R.dimen.drag_flingToDeleteMinVelocity);
692
Sihua Mae04aa202022-07-18 12:43:56 -0700693 mViewScaleProvider = viewScaleProvider;
694
Jon Miranda2b25ded2023-02-02 14:48:45 -0800695 dimensionOverrideProvider.accept(this);
696
Tony Wickham1237df02017-02-24 08:59:36 -0800697 // This is done last, after iconSizePx is calculated above.
Sunny Goyal799e1202023-02-09 10:54:28 -0800698 mDotRendererWorkSpace = createDotRenderer(context, iconSizePx, dotRendererCache);
699 mDotRendererAllApps = createDotRenderer(context, allAppsIconSizePx, dotRendererCache);
Sunny Goyal65190ae2022-08-02 14:16:26 -0700700 }
701
702 private static DotRenderer createDotRenderer(
Sunny Goyal799e1202023-02-09 10:54:28 -0800703 @NonNull Context context, int size, @NonNull SparseArray<DotRenderer> cache) {
Sunny Goyal65190ae2022-08-02 14:16:26 -0700704 DotRenderer renderer = cache.get(size);
705 if (renderer == null) {
Sunny Goyal799e1202023-02-09 10:54:28 -0800706 renderer = new DotRenderer(size, getShapePath(context, DEFAULT_DOT_SIZE),
707 DEFAULT_DOT_SIZE);
Sunny Goyal65190ae2022-08-02 14:16:26 -0700708 cache.put(size, renderer);
709 }
710 return renderer;
Adam Cohen63f1ec02014-08-12 09:23:13 -0700711 }
712
Thales Lima425f6822022-05-10 13:44:58 -0300713 /**
Fengjiang Li6c590822023-09-25 15:04:57 -0700714 * Return maximum of all apps row count displayed on screen. Note that 1) Partially displayed
715 * row is counted as 1 row, and 2) we don't exclude the space of floating search bar. This
716 * method is used for calculating number of {@link BubbleTextView} we need to pre-inflate. Thus
717 * reasonable over estimation is fine.
718 */
719 public int getMaxAllAppsRowCount() {
Thales Limab433c9c2023-10-30 12:24:05 +0000720 return (int) (Math.ceil((availableHeightPx - allAppsPadding.top)
Fengjiang Li6c590822023-09-25 15:04:57 -0700721 / (float) allAppsCellHeightPx));
722 }
723
724 /**
Thales Lima425f6822022-05-10 13:44:58 -0300725 * QSB width is always calculated because when in 3 button nav the width doesn't follow the
726 * width of the hotseat.
727 */
Thales Lima9938c2f2022-07-25 14:38:16 +0100728 private int calculateQsbWidth(int hotseatBorderSpace) {
Thales Lima425f6822022-05-10 13:44:58 -0300729 if (isQsbInline) {
Alex Chau906d8822022-05-23 10:42:25 +0100730 int columns = getPanelCount() * inv.numColumns;
Thales Lima425f6822022-05-10 13:44:58 -0300731 return getIconToIconWidthForColumns(columns)
732 - iconSizePx * numShownHotseatIcons
733 - hotseatBorderSpace * numShownHotseatIcons;
734 } else {
735 int columns = inv.hotseatColumnSpan[mTypeIndex];
736 return getIconToIconWidthForColumns(columns);
737 }
738 }
Thales Lima2903a622022-03-17 13:52:19 +0000739
Thales Lima425f6822022-05-10 13:44:58 -0300740 private int getIconToIconWidthForColumns(int columns) {
741 return columns * getCellSize().x
742 + (columns - 1) * cellLayoutBorderSpacePx.x
Thales Lima1e8b45f2022-08-25 11:50:59 -0400743 - getCellHorizontalSpace();
Thales Limaa1012902022-01-13 17:58:42 +0000744 }
745
Thales Limad90faab2021-09-21 17:18:47 +0100746 private int getHorizontalMarginPx(InvariantDeviceProfile idp, Resources res) {
Thales Lima79456492023-05-23 11:32:22 +0100747 if (mIsResponsiveGrid) {
748 return mResponsiveWidthSpec.getStartPaddingPx();
749 }
750
Thales Limad90faab2021-09-21 17:18:47 +0100751 if (isVerticalBarLayout()) {
752 return 0;
753 }
754
Thales Lima79456492023-05-23 11:32:22 +0100755 return mIsScalableGrid
Thales Lima83bedbf2021-10-05 17:47:39 +0100756 ? pxFromDp(idp.horizontalMargin[mTypeIndex], mMetrics)
757 : res.getDimensionPixelSize(R.dimen.dynamic_grid_left_right_margin);
Thales Limad90faab2021-09-21 17:18:47 +0100758 }
759
Thales Lima79456492023-05-23 11:32:22 +0100760 private void calculateAndSetWorkspaceVerticalPadding(Context context,
761 InvariantDeviceProfile inv,
762 int extraSpace) {
763 if (mIsResponsiveGrid) {
764 workspaceTopPadding = mResponsiveHeightSpec.getStartPaddingPx();
765 workspaceBottomPadding = mResponsiveHeightSpec.getEndPaddingPx();
766 } else if (mIsScalableGrid && inv.devicePaddingId != INVALID_RESOURCE_HANDLE) {
767 // Paddings were created assuming no scaling, so we first unscale the extra space.
768 int unscaledExtraSpace = (int) (extraSpace / cellScaleToFit);
769 DevicePaddings devicePaddings = new DevicePaddings(context, inv.devicePaddingId);
770 DevicePadding padding = devicePaddings.getDevicePadding(unscaledExtraSpace);
771 maxEmptySpace = padding.getMaxEmptySpacePx();
772
773 int paddingWorkspaceTop = padding.getWorkspaceTopPadding(unscaledExtraSpace);
774 int paddingWorkspaceBottom = padding.getWorkspaceBottomPadding(unscaledExtraSpace);
775
776 workspaceTopPadding = Math.round(paddingWorkspaceTop * cellScaleToFit);
777 workspaceBottomPadding = Math.round(paddingWorkspaceBottom * cellScaleToFit);
778 }
779 }
780
Thales Limab8c05952022-05-23 16:58:38 +0100781 /** Updates hotseatCellHeightPx and hotseatBarSizePx */
782 private void updateHotseatSizes(int hotseatIconSizePx) {
Jon Miranda92c1b5d2021-07-20 13:57:16 -0700783 // Ensure there is enough space for folder icons, which have a slightly larger radius.
Jordan Silva3646a1b2023-08-02 13:52:52 +0100784 hotseatCellHeightPx = getIconSizeWithOverlap(hotseatIconSizePx);
Thales Limab8c05952022-05-23 16:58:38 +0100785
Jon Miranda0d284852021-06-22 14:50:55 -0700786 if (isVerticalBarLayout()) {
Thales Lima8e11d532023-08-31 13:40:26 +0000787 hotseatBarSizePx = hotseatIconSizePx + mHotseatBarEdgePaddingPx
788 + mHotseatBarWorkspaceSpacePx;
Thales Limab8c05952022-05-23 16:58:38 +0100789 } else if (isQsbInline) {
790 hotseatBarSizePx = Math.max(hotseatIconSizePx, hotseatQsbVisualHeight)
791 + hotseatBarBottomSpacePx;
Jon Miranda0d284852021-06-22 14:50:55 -0700792 } else {
Thales Limab8c05952022-05-23 16:58:38 +0100793 hotseatBarSizePx = hotseatIconSizePx
794 + hotseatQsbSpace
795 + hotseatQsbVisualHeight
796 + hotseatBarBottomSpacePx;
Jon Miranda0d284852021-06-22 14:50:55 -0700797 }
798 }
799
Thales Lima6a590062022-11-22 15:52:49 +0000800 /**
801 * Calculates the width of the hotseat, changing spaces between the icons and removing icons if
802 * necessary.
803 */
804 public void recalculateHotseatWidthAndBorderSpace() {
Thales Lima79456492023-05-23 11:32:22 +0100805 if (!mIsScalableGrid) return;
Thales Lima6a590062022-11-22 15:52:49 +0000806
807 int columns = inv.hotseatColumnSpan[mTypeIndex];
808 float hotseatWidthPx = getIconToIconWidthForColumns(columns);
809 hotseatBorderSpace = calculateHotseatBorderSpace(hotseatWidthPx, /* numExtraBorder= */ 0);
Thales Lima9938c2f2022-07-25 14:38:16 +0100810 hotseatQsbWidth = calculateQsbWidth(hotseatBorderSpace);
Thales Lima6a590062022-11-22 15:52:49 +0000811 // Spaces should be correct when the nav buttons are not inline
Thales Lima9938c2f2022-07-25 14:38:16 +0100812 if (!areNavButtonsInline) {
813 return;
814 }
815
Thales Lima6a590062022-11-22 15:52:49 +0000816 // The side space with inline buttons should be what is defined in InvariantDeviceProfile
Jon Mirandae17a9492023-03-08 16:42:20 -0800817 int sideSpacePx = inlineNavButtonsEndSpacingPx;
Thales Limaffc68b02023-01-09 16:20:23 +0000818 int maxHotseatWidthPx = availableWidthPx - sideSpacePx - hotseatBarEndOffset;
819 int maxHotseatIconsWidthPx = maxHotseatWidthPx - (isQsbInline ? hotseatQsbWidth : 0);
820 hotseatBorderSpace = calculateHotseatBorderSpace(maxHotseatIconsWidthPx,
Thales Lima6a590062022-11-22 15:52:49 +0000821 (isQsbInline ? 1 : 0) + /* border between nav buttons and first icon */ 1);
Thales Lima9938c2f2022-07-25 14:38:16 +0100822
Thales Limaffc68b02023-01-09 16:20:23 +0000823 if (hotseatBorderSpace >= mMinHotseatIconSpacePx) {
Thales Lima9938c2f2022-07-25 14:38:16 +0100824 return;
825 }
826
827 // Border space can't be less than the minimum
Thales Limaffc68b02023-01-09 16:20:23 +0000828 hotseatBorderSpace = mMinHotseatIconSpacePx;
Thales Lima6a590062022-11-22 15:52:49 +0000829 int requiredWidth = getHotseatRequiredWidth();
Thales Lima9938c2f2022-07-25 14:38:16 +0100830
831 // If there is an inline qsb, change its size
832 if (isQsbInline) {
Thales Limaffc68b02023-01-09 16:20:23 +0000833 hotseatQsbWidth -= requiredWidth - maxHotseatWidthPx;
834 if (hotseatQsbWidth >= mMinHotseatQsbWidthPx) {
Thales Lima9938c2f2022-07-25 14:38:16 +0100835 return;
836 }
837
838 // QSB can't be less than the minimum
Thales Limaffc68b02023-01-09 16:20:23 +0000839 hotseatQsbWidth = mMinHotseatQsbWidthPx;
Thales Lima9938c2f2022-07-25 14:38:16 +0100840 }
841
Thales Limaffc68b02023-01-09 16:20:23 +0000842 maxHotseatIconsWidthPx = maxHotseatWidthPx - (isQsbInline ? hotseatQsbWidth : 0);
Thales Lima6a590062022-11-22 15:52:49 +0000843
Thales Lima9938c2f2022-07-25 14:38:16 +0100844 // If it still doesn't fit, start removing icons
845 do {
846 numShownHotseatIcons--;
Thales Limaffc68b02023-01-09 16:20:23 +0000847 hotseatBorderSpace = calculateHotseatBorderSpace(maxHotseatIconsWidthPx,
Thales Lima6a590062022-11-22 15:52:49 +0000848 (isQsbInline ? 1 : 0) + /* border between nav buttons and first icon */ 1);
Thales Limaffc68b02023-01-09 16:20:23 +0000849 } while (hotseatBorderSpace < mMinHotseatIconSpacePx && numShownHotseatIcons > 1);
Thales Lima9938c2f2022-07-25 14:38:16 +0100850 }
851
Thales Lima78d00ad2021-09-30 11:29:06 +0100852 private Point getCellLayoutBorderSpace(InvariantDeviceProfile idp) {
Thales Lima080d8902022-03-28 15:30:29 +0100853 return getCellLayoutBorderSpace(idp, 1f);
Thales Lima080d8902022-03-28 15:30:29 +0100854 }
855
856 private Point getCellLayoutBorderSpace(InvariantDeviceProfile idp, float scale) {
Thales Lima79456492023-05-23 11:32:22 +0100857 int horizontalSpacePx = 0;
858 int verticalSpacePx = 0;
Thales Lima78d00ad2021-09-30 11:29:06 +0100859
Thales Lima79456492023-05-23 11:32:22 +0100860 if (mIsResponsiveGrid) {
861 horizontalSpacePx = mResponsiveWidthSpec.getGutterPx();
862 verticalSpacePx = mResponsiveHeightSpec.getGutterPx();
863 } else if (mIsScalableGrid) {
864 horizontalSpacePx = pxFromDp(idp.borderSpaces[mTypeIndex].x, mMetrics, scale);
865 verticalSpacePx = pxFromDp(idp.borderSpaces[mTypeIndex].y, mMetrics, scale);
866 }
Thales Lima78d00ad2021-09-30 11:29:06 +0100867
868 return new Point(horizontalSpacePx, verticalSpacePx);
869 }
870
Sunny Goyal69a8eec2021-07-22 10:02:50 -0700871 public Info getDisplayInfo() {
872 return mInfo;
873 }
874
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700875 public Builder toBuilder(Context context) {
Sunny Goyal187b16c2022-03-01 16:53:23 -0800876 WindowBounds bounds = new WindowBounds(
877 widthPx, heightPx, availableWidthPx, availableHeightPx, rotationHint);
Sunny Goyal19ff7282021-04-22 10:12:54 -0700878 bounds.bounds.offsetTo(windowX, windowY);
Alex Chaue0227552022-04-06 19:44:43 +0100879 bounds.insets.set(mInsets);
Sunny Goyal65190ae2022-08-02 14:16:26 -0700880
881 SparseArray<DotRenderer> dotRendererCache = new SparseArray<>();
882 dotRendererCache.put(iconSizePx, mDotRendererWorkSpace);
883 dotRendererCache.put(allAppsIconSizePx, mDotRendererAllApps);
884
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700885 return new Builder(context, inv, mInfo)
Sunny Goyal19ff7282021-04-22 10:12:54 -0700886 .setWindowBounds(bounds)
Alex Chauab800f72022-12-13 17:46:06 +0000887 .setIsMultiDisplay(isMultiDisplay)
Alex Chau6ed408f2022-03-04 12:58:05 +0000888 .setMultiWindowMode(isMultiWindowMode)
Sunny Goyal65190ae2022-08-02 14:16:26 -0700889 .setDotRendererCache(dotRendererCache)
Alex Chau6ed408f2022-03-04 12:58:05 +0000890 .setGestureMode(isGestureMode);
Sunny Goyal1a52ef52018-01-11 10:15:03 -0800891 }
892
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700893 public DeviceProfile copy(Context context) {
894 return toBuilder(context).build();
895 }
896
897 /**
898 * TODO: Move this to the builder as part of setMultiWindowMode
899 */
Sunny Goyalb46703d2020-05-27 17:52:03 -0700900 public DeviceProfile getMultiWindowProfile(Context context, WindowBounds windowBounds) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700901 DeviceProfile profile = toBuilder(context)
Sunny Goyal19ff7282021-04-22 10:12:54 -0700902 .setWindowBounds(windowBounds)
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700903 .setMultiWindowMode(true)
904 .build();
Jon Miranda93e1f042016-11-11 14:13:04 -0800905
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800906 // We use these scales to measure and layout the widgets using their full invariant profile
907 // sizes and then draw them scaled and centered to fit in their multi-window mode cellspans.
908 float appWidgetScaleX = (float) profile.getCellSize().x / getCellSize().x;
909 float appWidgetScaleY = (float) profile.getCellSize().y / getCellSize().y;
Sihua Mae04aa202022-07-18 12:43:56 -0700910 if (appWidgetScaleX != 1 || appWidgetScaleY != 1) {
911 final PointF p = new PointF(appWidgetScaleX, appWidgetScaleY);
912 profile = profile.toBuilder(context)
913 .setViewScaleProvider(i -> p)
914 .build();
915 }
916
917 profile.hideWorkspaceLabelsIfNotEnoughSpace();
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800918
Jon Miranda93e1f042016-11-11 14:13:04 -0800919 return profile;
Jon Mirandacc42c5b2016-10-27 17:15:27 -0700920 }
921
Adam Cohen63f1ec02014-08-12 09:23:13 -0700922 /**
Jon Miranda941375e2021-03-31 13:10:45 -0400923 * Checks if there is enough space for labels on the workspace.
924 * If there is not, labels on the Workspace are hidden.
Jon Miranda1091e532017-07-21 13:31:50 -0700925 * It is important to call this method after the All Apps variables have been set.
926 */
Jon Miranda941375e2021-03-31 13:10:45 -0400927 private void hideWorkspaceLabelsIfNotEnoughSpace() {
928 float iconTextHeight = Utilities.calculateTextHeight(iconTextSizePx);
929 float workspaceCellPaddingY = getCellSize().y - iconSizePx - iconDrawablePaddingPx
930 - iconTextHeight;
931
Jordan Silva3646a1b2023-08-02 13:52:52 +0100932 if (mIsResponsiveGrid) {
Thales Limabba07722023-10-11 18:16:29 +0000933 iconTextSizePx = 0;
934 iconDrawablePaddingPx = 0;
935 int iconSizeWithOverlap = getIconSizeWithOverlap(iconSizePx);
936 cellYPaddingPx = Math.max(0, getCellSize().y - iconSizeWithOverlap) / 2;
937 autoResizeAllAppsCells();
Jordan Silva3646a1b2023-08-02 13:52:52 +0100938
939 return;
940 }
941
Jon Miranda941375e2021-03-31 13:10:45 -0400942 // We want enough space so that the text is closer to its corresponding icon.
943 if (workspaceCellPaddingY < iconTextHeight) {
944 iconTextSizePx = 0;
945 iconDrawablePaddingPx = 0;
Jordan Silva3646a1b2023-08-02 13:52:52 +0100946 cellHeightPx = getIconSizeWithOverlap(iconSizePx);
Jon Miranda941375e2021-03-31 13:10:45 -0400947 autoResizeAllAppsCells();
948 }
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700949 }
Jon Miranda1091e532017-07-21 13:31:50 -0700950
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700951 /**
Jon Miranda228877d2021-02-09 11:05:00 -0500952 * Returns the amount of extra (or unused) vertical space.
953 */
954 private int updateAvailableDimensions(Resources res) {
Alex Chaua68164d2022-12-15 16:16:03 +0000955 float invIconSizeDp = inv.iconSize[mTypeIndex];
956 float invIconTextSizeSp = inv.iconTextSize[mTypeIndex];
957 iconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mMetrics));
958 iconTextSizePx = pxFromSp(invIconTextSizeSp, mMetrics);
Thales Lima79456492023-05-23 11:32:22 +0100959 iconCenterVertically = mIsScalableGrid || mIsResponsiveGrid;
Alex Chaua68164d2022-12-15 16:16:03 +0000960
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700961 updateIconSize(1f, res);
Pat Manning08610ca2022-04-05 21:03:16 +0100962 updateWorkspacePadding();
Jon Mirandae126d722021-02-25 10:45:20 -0500963
Alex Chau5225e832023-08-01 16:32:15 +0100964 if (mIsResponsiveGrid) {
965 return 0;
966 }
967
Jon Mirandae126d722021-02-25 10:45:20 -0500968 // Check to see if the icons fit within the available height.
Pat Manninga2e14992022-04-22 11:29:17 +0100969 float usedHeight = getCellLayoutHeightSpecification();
Pat Manning25d53342022-05-10 09:58:49 +0000970 final int maxHeight = getCellLayoutHeight();
Jon Miranda228877d2021-02-09 11:05:00 -0500971 float extraHeight = Math.max(0, maxHeight - usedHeight);
Jon Mirandae126d722021-02-25 10:45:20 -0500972 float scaleY = maxHeight / usedHeight;
973 boolean shouldScale = scaleY < 1f;
974
975 float scaleX = 1f;
Thales Lima79456492023-05-23 11:32:22 +0100976 if (mIsScalableGrid) {
Jon Mirandae126d722021-02-25 10:45:20 -0500977 // We scale to fit the cellWidth and cellHeight in the available space.
978 // The benefit of scalable grids is that we can get consistent aspect ratios between
979 // devices.
Pat Manninga2e14992022-04-22 11:29:17 +0100980 float usedWidth =
981 getCellLayoutWidthSpecification() + (desiredWorkspaceHorizontalMarginPx * 2);
Jon Mirandae126d722021-02-25 10:45:20 -0500982 // We do not subtract padding here, as we also scale the workspace padding if needed.
983 scaleX = availableWidthPx / usedWidth;
984 shouldScale = true;
Winson Chungb3800242013-10-24 11:01:54 -0700985 }
Jon Mirandae126d722021-02-25 10:45:20 -0500986
987 if (shouldScale) {
988 float scale = Math.min(scaleX, scaleY);
989 updateIconSize(scale, res);
Pat Manninga2e14992022-04-22 11:29:17 +0100990 extraHeight = Math.max(0, maxHeight - getCellLayoutHeightSpecification());
Jon Mirandae126d722021-02-25 10:45:20 -0500991 }
992
Jon Miranda228877d2021-02-09 11:05:00 -0500993 return Math.round(extraHeight);
Winson Chungb3800242013-10-24 11:01:54 -0700994 }
995
Pat Manninga2e14992022-04-22 11:29:17 +0100996 private int getCellLayoutHeightSpecification() {
Pat Manning08610ca2022-04-05 21:03:16 +0100997 return (cellHeightPx * inv.numRows) + (cellLayoutBorderSpacePx.y * (inv.numRows - 1))
998 + cellLayoutPaddingPx.top + cellLayoutPaddingPx.bottom;
999 }
1000
Pat Manninga2e14992022-04-22 11:29:17 +01001001 private int getCellLayoutWidthSpecification() {
Pat Manning25d53342022-05-10 09:58:49 +00001002 int numColumns = getPanelCount() * inv.numColumns;
Pat Manning08610ca2022-04-05 21:03:16 +01001003 return (cellWidthPx * numColumns) + (cellLayoutBorderSpacePx.x * (numColumns - 1))
1004 + cellLayoutPaddingPx.left + cellLayoutPaddingPx.right;
Jon Mirandae126d722021-02-25 10:45:20 -05001005 }
1006
Thales Lima93ee8fc2023-06-05 17:07:11 +01001007 private int getNormalizedIconDrawablePadding() {
1008 // TODO(b/235886078): workaround needed because of this bug
1009 // Icons are 10% larger on XML than their visual size,
1010 // so remove that extra space to get labels closer to the correct padding
1011 int iconVisibleSizePx = (int) Math.round(ICON_VISIBLE_AREA_FACTOR * iconSizePx);
1012 return Math.max(0, mIconDrawablePaddingOriginalPx - ((iconSizePx - iconVisibleSizePx) / 2));
1013 }
1014
1015 private int getNormalizedFolderChildDrawablePaddingPx(int textHeight) {
1016 // TODO(b/235886078): workaround needed because of this bug
1017 // Icons are 10% larger on XML than their visual size,
1018 // so remove that extra space to get labels closer to the correct padding
1019 int drawablePadding = (folderCellHeightPx - folderChildIconSizePx - textHeight) / 3;
1020
1021 int iconVisibleSizePx = Math.round(ICON_VISIBLE_AREA_FACTOR * folderChildIconSizePx);
1022 int iconSizeDiff = folderChildIconSizePx - iconVisibleSizePx;
1023 return Math.max(0, drawablePadding - iconSizeDiff / 2);
1024 }
1025
Jordan Silva3646a1b2023-08-02 13:52:52 +01001026 private int getIconSizeWithOverlap(int iconSize) {
1027 return (int) Math.ceil(iconSize * ICON_OVERLAP_FACTOR);
1028 }
1029
Jon Miranda6f7e9702019-09-16 14:44:14 -07001030 /**
1031 * Updating the iconSize affects many aspects of the launcher layout, such as: iconSizePx,
1032 * iconTextSizePx, iconDrawablePaddingPx, cellWidth/Height, allApps* variants,
1033 * hotseat sizes, workspaceSpringLoadedShrinkFactor, folderIconSizePx, and folderIconOffsetYPx.
1034 */
Tony Wickham7ba547c2021-02-02 17:12:08 -08001035 public void updateIconSize(float scale, Resources res) {
Jon Mirandaab3c6812021-06-28 15:42:28 -07001036 // Icon scale should never exceed 1, otherwise pixellation may occur.
1037 iconScale = Math.min(1f, scale);
1038 cellScaleToFit = scale;
1039
Jon Miranda18751b62017-07-31 17:25:27 -07001040 // Workspace
Sunny Goyal07b69292018-01-08 14:19:34 -08001041 final boolean isVerticalLayout = isVerticalBarLayout();
Thales Lima080d8902022-03-28 15:30:29 +01001042 cellLayoutBorderSpacePx = getCellLayoutBorderSpace(inv, scale);
Jon Mirandae126d722021-02-25 10:45:20 -05001043
Thales Lima79456492023-05-23 11:32:22 +01001044 if (mIsResponsiveGrid) {
Thales Lima79456492023-05-23 11:32:22 +01001045 cellWidthPx = mResponsiveWidthSpec.getCellSizePx();
1046 cellHeightPx = mResponsiveHeightSpec.getCellSizePx();
Thales Lima79456492023-05-23 11:32:22 +01001047
Thales Lima2759aa32023-06-05 16:25:45 +01001048 if (cellWidthPx < iconSizePx) {
1049 // get a smaller icon size
1050 iconSizePx = mIconSizeSteps.getIconSmallerThan(cellWidthPx);
Thales Lima2759aa32023-06-05 16:25:45 +01001051 }
1052
Thales Lima93ee8fc2023-06-05 17:07:11 +01001053 iconDrawablePaddingPx = getNormalizedIconDrawablePadding();
Thales Lima93ee8fc2023-06-05 17:07:11 +01001054
Thales Lima24ceca62023-09-25 16:21:17 -07001055 CellContentDimensions cellContentDimensions = new CellContentDimensions(iconSizePx,
1056 iconDrawablePaddingPx,
1057 iconTextSizePx);
Thales Limabba07722023-10-11 18:16:29 +00001058 if (isVerticalLayout) {
1059 if (cellHeightPx < iconSizePx) {
1060 cellContentDimensions.setIconSizePx(
1061 mIconSizeSteps.getIconSmallerThan(cellHeightPx));
1062 }
Thales Lima24ceca62023-09-25 16:21:17 -07001063 } else {
1064 cellContentDimensions.resizeToFitCellHeight(cellHeightPx, mIconSizeSteps);
Thales Lima2759aa32023-06-05 16:25:45 +01001065 }
Thales Lima24ceca62023-09-25 16:21:17 -07001066 iconSizePx = cellContentDimensions.getIconSizePx();
1067 iconDrawablePaddingPx = cellContentDimensions.getIconDrawablePaddingPx();
1068 iconTextSizePx = cellContentDimensions.getIconTextSizePx();
1069 int cellContentHeight = cellContentDimensions.getCellContentHeight();
Thales Lima2759aa32023-06-05 16:25:45 +01001070
1071 cellYPaddingPx = Math.max(0, cellHeightPx - cellContentHeight) / 2;
Thales Lima79456492023-05-23 11:32:22 +01001072 } else if (mIsScalableGrid) {
Thales Lima93ee8fc2023-06-05 17:07:11 +01001073 iconDrawablePaddingPx = (int) (getNormalizedIconDrawablePadding() * iconScale);
Thales Lima83bedbf2021-10-05 17:47:39 +01001074 cellWidthPx = pxFromDp(inv.minCellSize[mTypeIndex].x, mMetrics, scale);
1075 cellHeightPx = pxFromDp(inv.minCellSize[mTypeIndex].y, mMetrics, scale);
Alex Chaube753132022-12-09 16:46:54 +00001076
1077 if (cellWidthPx < iconSizePx) {
1078 // If cellWidth no longer fit iconSize, reduce borderSpace to make cellWidth bigger.
1079 int numColumns = getPanelCount() * inv.numColumns;
1080 int numBorders = numColumns - 1;
1081 int extraWidthRequired = (iconSizePx - cellWidthPx) * numColumns;
1082 if (cellLayoutBorderSpacePx.x * numBorders >= extraWidthRequired) {
1083 cellWidthPx = iconSizePx;
1084 cellLayoutBorderSpacePx.x -= extraWidthRequired / numBorders;
1085 } else {
1086 // If it still doesn't fit, set borderSpace to 0 and distribute the space for
1087 // cellWidth, and reduce iconSize.
1088 cellWidthPx = (cellWidthPx * numColumns
1089 + cellLayoutBorderSpacePx.x * numBorders) / numColumns;
1090 iconSizePx = Math.min(iconSizePx, cellWidthPx);
1091 cellLayoutBorderSpacePx.x = 0;
1092 }
1093 }
1094
Thales Lima93ee8fc2023-06-05 17:07:11 +01001095 int cellTextAndPaddingHeight =
1096 iconDrawablePaddingPx + Utilities.calculateTextHeight(iconTextSizePx);
Alex Chaube753132022-12-09 16:46:54 +00001097 int cellContentHeight = iconSizePx + cellTextAndPaddingHeight;
1098 if (cellHeightPx < cellContentHeight) {
1099 // If cellHeight no longer fit iconSize, reduce borderSpace to make cellHeight
1100 // bigger.
1101 int numBorders = inv.numRows - 1;
1102 int extraHeightRequired = (cellContentHeight - cellHeightPx) * inv.numRows;
1103 if (cellLayoutBorderSpacePx.y * numBorders >= extraHeightRequired) {
1104 cellHeightPx = cellContentHeight;
1105 cellLayoutBorderSpacePx.y -= extraHeightRequired / numBorders;
1106 } else {
Alex Chau06f36e82023-01-06 10:50:54 +00001107 // If it still doesn't fit, set borderSpace to 0 to recover space.
Alex Chaube753132022-12-09 16:46:54 +00001108 cellHeightPx = (cellHeightPx * inv.numRows
1109 + cellLayoutBorderSpacePx.y * numBorders) / inv.numRows;
Alex Chaube753132022-12-09 16:46:54 +00001110 cellLayoutBorderSpacePx.y = 0;
Alex Chau06f36e82023-01-06 10:50:54 +00001111 // Reduce iconDrawablePaddingPx to make cellContentHeight smaller.
1112 int cellContentWithoutPadding = cellContentHeight - iconDrawablePaddingPx;
1113 if (cellContentWithoutPadding <= cellHeightPx) {
1114 iconDrawablePaddingPx = cellContentHeight - cellHeightPx;
1115 } else {
1116 // If it still doesn't fit, set iconDrawablePaddingPx to 0 to recover space,
1117 // then proportional reduce iconSizePx and iconTextSizePx to fit.
1118 iconDrawablePaddingPx = 0;
1119 float ratio = cellHeightPx / (float) cellContentWithoutPadding;
1120 iconSizePx = (int) (iconSizePx * ratio);
1121 iconTextSizePx = (int) (iconTextSizePx * ratio);
1122 }
1123 cellTextAndPaddingHeight =
1124 iconDrawablePaddingPx + Utilities.calculateTextHeight(iconTextSizePx);
Alex Chaube753132022-12-09 16:46:54 +00001125 }
1126 cellContentHeight = iconSizePx + cellTextAndPaddingHeight;
1127 }
Jon Mirandae126d722021-02-25 10:45:20 -05001128 cellYPaddingPx = Math.max(0, cellHeightPx - cellContentHeight) / 2;
Thales Limad90faab2021-09-21 17:18:47 +01001129 desiredWorkspaceHorizontalMarginPx =
1130 (int) (desiredWorkspaceHorizontalMarginOriginalPx * scale);
Jon Miranda228877d2021-02-09 11:05:00 -05001131 } else {
Thales Lima93ee8fc2023-06-05 17:07:11 +01001132 iconDrawablePaddingPx = (int) (getNormalizedIconDrawablePadding() * iconScale);
Jon Mirandae126d722021-02-25 10:45:20 -05001133 cellWidthPx = iconSizePx + iconDrawablePaddingPx;
Jordan Silva3646a1b2023-08-02 13:52:52 +01001134 cellHeightPx = getIconSizeWithOverlap(iconSizePx)
Jon Miranda92c1b5d2021-07-20 13:57:16 -07001135 + iconDrawablePaddingPx
Jon Miranda228877d2021-02-09 11:05:00 -05001136 + Utilities.calculateTextHeight(iconTextSizePx);
1137 int cellPaddingY = (getCellSize().y - cellHeightPx) / 2;
1138 if (iconDrawablePaddingPx > cellPaddingY && !isVerticalLayout
1139 && !isMultiWindowMode) {
1140 // Ensures that the label is closer to its corresponding icon. This is not an issue
1141 // with vertical bar layout or multi-window mode since the issue is handled
1142 // separately with their calls to {@link #adjustToHideWorkspaceLabels}.
1143 cellHeightPx -= (iconDrawablePaddingPx - cellPaddingY);
1144 iconDrawablePaddingPx = cellPaddingY;
1145 }
Jon Miranda846455e2017-10-02 14:58:52 -07001146 }
Jon Miranda18751b62017-07-31 17:25:27 -07001147
Sunny Goyalae190ff2020-04-14 00:19:01 +00001148 // All apps
Thales Limaabfe3642023-05-24 18:08:53 +01001149 if (mIsResponsiveGrid) {
1150 updateAllAppsWithResponsiveMeasures();
1151 } else {
1152 updateAllAppsIconSize(scale, res);
1153 }
1154 updateAllAppsContainerWidth();
1155 if (isVerticalBarLayout()) {
1156 hideWorkspaceLabelsIfNotEnoughSpace();
1157 }
Brandon Dayauon3cdb32c2023-08-22 21:26:37 -07001158 if (FeatureFlags.enableTwolineAllapps()) {
1159 // Add extra textHeight to the existing allAppsCellHeight.
1160 allAppsCellHeightPx += Utilities.calculateTextHeight(allAppsIconTextSizePx);
1161 }
Winson Chungb3800242013-10-24 11:01:54 -07001162
Thales Limab8c05952022-05-23 16:58:38 +01001163 updateHotseatSizes(iconSizePx);
Winson Chungb3800242013-10-24 11:01:54 -07001164
Sunny Goyalbaec6ff2016-09-14 11:26:21 -07001165 // Folder icon
Jon Miranda591e3602018-03-28 11:37:00 -07001166 folderIconSizePx = IconNormalizer.getNormalizedCircleSize(iconSizePx);
1167 folderIconOffsetYPx = (iconSizePx - folderIconSizePx) / 2;
Sunny Goyal6c304b12023-04-10 12:03:04 -07001168
1169 // Update widget padding:
1170 float minSpacing = pxFromDp(MIN_WIDGET_PADDING_DP, mMetrics);
1171 if (cellLayoutBorderSpacePx.x < minSpacing
1172 || cellLayoutBorderSpacePx.y < minSpacing) {
1173 widgetPadding.left = widgetPadding.right =
1174 Math.round(Math.max(0, minSpacing - cellLayoutBorderSpacePx.x));
1175 widgetPadding.top = widgetPadding.bottom =
1176 Math.round(Math.max(0, minSpacing - cellLayoutBorderSpacePx.y));
1177 } else {
1178 widgetPadding.setEmpty();
1179 }
Winson Chung0f785722015-04-08 10:27:49 -07001180 }
1181
Thales Lima425f6822022-05-10 13:44:58 -03001182 /**
Thales Lima6a590062022-11-22 15:52:49 +00001183 * This method calculates the space between the icons to achieve a certain width.
Thales Lima425f6822022-05-10 13:44:58 -03001184 */
Thales Lima6a590062022-11-22 15:52:49 +00001185 private int calculateHotseatBorderSpace(float hotseatWidthPx, int numExtraBorder) {
Jordan Silvad9227182023-08-17 15:53:59 +01001186 int numBorders = (numShownHotseatIcons - 1 + numExtraBorder);
1187 if (numBorders <= 0) return 0;
1188
Thales Lima9938c2f2022-07-25 14:38:16 +01001189 float hotseatIconsTotalPx = iconSizePx * numShownHotseatIcons;
Jordan Silvad9227182023-08-17 15:53:59 +01001190 int hotseatBorderSpacePx = (int) (hotseatWidthPx - hotseatIconsTotalPx) / numBorders;
Thales Limaffc68b02023-01-09 16:20:23 +00001191 return Math.min(hotseatBorderSpacePx, mMaxHotseatIconSpacePx);
Thales Lima425f6822022-05-10 13:44:58 -03001192 }
1193
Brian Isganitis25b2ac82022-01-28 16:25:13 -05001194 /**
1195 * Updates the iconSize for allApps* variants.
1196 */
Brian Isganitisa9a78112022-05-23 18:11:47 -07001197 private void updateAllAppsIconSize(float scale, Resources res) {
Thales Lima080d8902022-03-28 15:30:29 +01001198 allAppsBorderSpacePx = new Point(
1199 pxFromDp(inv.allAppsBorderSpaces[mTypeIndex].x, mMetrics, scale),
1200 pxFromDp(inv.allAppsBorderSpaces[mTypeIndex].y, mMetrics, scale));
Brandon Dayauon07ca8842022-04-27 10:52:28 -07001201 // AllApps cells don't have real space between cells,
1202 // so we add the border space to the cell height
Alex Chaube753132022-12-09 16:46:54 +00001203 allAppsCellHeightPx = pxFromDp(inv.allAppsCellSize[mTypeIndex].y, mMetrics)
Brandon Dayauon07ca8842022-04-27 10:52:28 -07001204 + allAppsBorderSpacePx.y;
1205 // but width is just the cell,
1206 // the border is added in #updateAllAppsContainerWidth
Thales Lima79456492023-05-23 11:32:22 +01001207 if (mIsScalableGrid) {
Alex Chaube753132022-12-09 16:46:54 +00001208 allAppsIconSizePx = pxFromDp(inv.allAppsIconSize[mTypeIndex], mMetrics);
1209 allAppsIconTextSizePx = pxFromSp(inv.allAppsIconTextSize[mTypeIndex], mMetrics);
Thales Lima93ee8fc2023-06-05 17:07:11 +01001210 allAppsIconDrawablePaddingPx = getNormalizedIconDrawablePadding();
Brandon Dayauon7a8a9ed2022-06-06 14:32:22 -07001211 allAppsCellWidthPx = pxFromDp(inv.allAppsCellSize[mTypeIndex].x, mMetrics, scale);
Alex Chaube753132022-12-09 16:46:54 +00001212
1213 if (allAppsCellWidthPx < allAppsIconSizePx) {
1214 // If allAppsCellWidth no longer fit allAppsIconSize, reduce allAppsBorderSpace to
1215 // make allAppsCellWidth bigger.
1216 int numBorders = inv.numAllAppsColumns - 1;
1217 int extraWidthRequired =
1218 (allAppsIconSizePx - allAppsCellWidthPx) * inv.numAllAppsColumns;
1219 if (allAppsBorderSpacePx.x * numBorders >= extraWidthRequired) {
1220 allAppsCellWidthPx = allAppsIconSizePx;
1221 allAppsBorderSpacePx.x -= extraWidthRequired / numBorders;
1222 } else {
1223 // If it still doesn't fit, set allAppsBorderSpace to 0 and distribute the space
1224 // for allAppsCellWidth, and reduce allAppsIconSize.
1225 allAppsCellWidthPx = (allAppsCellWidthPx * inv.numAllAppsColumns
1226 + allAppsBorderSpacePx.x * numBorders) / inv.numAllAppsColumns;
1227 allAppsIconSizePx = Math.min(allAppsIconSizePx, allAppsCellWidthPx);
1228 allAppsBorderSpacePx.x = 0;
1229 }
1230 }
1231
1232 int cellContentHeight = allAppsIconSizePx
1233 + Utilities.calculateTextHeight(allAppsIconTextSizePx) + allAppsBorderSpacePx.y;
1234 if (allAppsCellHeightPx < cellContentHeight) {
1235 // Increase allAppsCellHeight to fit its content.
1236 allAppsCellHeightPx = cellContentHeight;
1237 }
Brian Isganitis25b2ac82022-01-28 16:25:13 -05001238 } else {
Brandon Dayauon07ca8842022-04-27 10:52:28 -07001239 float invIconSizeDp = inv.allAppsIconSize[mTypeIndex];
1240 float invIconTextSizeSp = inv.allAppsIconTextSize[mTypeIndex];
Brian Isganitis25b2ac82022-01-28 16:25:13 -05001241 allAppsIconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mMetrics, scale));
1242 allAppsIconTextSizePx = (int) (pxFromSp(invIconTextSizeSp, mMetrics) * scale);
Brandon Dayauon07ca8842022-04-27 10:52:28 -07001243 allAppsIconDrawablePaddingPx =
1244 res.getDimensionPixelSize(R.dimen.all_apps_icon_drawable_padding);
Brandon Dayauon7a8a9ed2022-06-06 14:32:22 -07001245 allAppsCellWidthPx = allAppsIconSizePx + (2 * allAppsIconDrawablePaddingPx);
Brian Isganitis25b2ac82022-01-28 16:25:13 -05001246 }
Thales Limaabfe3642023-05-24 18:08:53 +01001247 }
Brian Isganitis25b2ac82022-01-28 16:25:13 -05001248
Thales Limaabfe3642023-05-24 18:08:53 +01001249 private void updateAllAppsWithResponsiveMeasures() {
1250 allAppsIconSizePx = iconSizePx;
1251 allAppsIconTextSizePx = iconTextSizePx;
Thales Lima93ee8fc2023-06-05 17:07:11 +01001252 allAppsIconDrawablePaddingPx = iconDrawablePaddingPx;
Thales Limaabfe3642023-05-24 18:08:53 +01001253
1254 allAppsBorderSpacePx = new Point(
1255 mAllAppsResponsiveWidthSpec.getGutterPx(),
1256 mAllAppsResponsiveHeightSpec.getGutterPx()
1257 );
1258 allAppsCellHeightPx = mAllAppsResponsiveHeightSpec.getCellSizePx()
1259 + mAllAppsResponsiveHeightSpec.getGutterPx();
1260 allAppsCellWidthPx = mAllAppsResponsiveWidthSpec.getCellSizePx();
Thales Limab433c9c2023-10-30 12:24:05 +00001261 allAppsPadding.left = mAllAppsResponsiveWidthSpec.getStartPaddingPx();
1262 allAppsPadding.right = mAllAppsResponsiveWidthSpec.getEndPaddingPx();
Thales Limaabfe3642023-05-24 18:08:53 +01001263 }
1264
1265 /**
1266 * Re-computes the all-apps cell size to be independent of workspace
1267 */
1268 public void autoResizeAllAppsCells() {
1269 int textHeight = Utilities.calculateTextHeight(allAppsIconTextSizePx);
1270 int topBottomPadding = textHeight;
1271 allAppsCellHeightPx = allAppsIconSizePx + allAppsIconDrawablePaddingPx
1272 + textHeight + (topBottomPadding * 2);
1273 }
1274
1275 private void updateAllAppsContainerWidth() {
1276 int cellLayoutHorizontalPadding =
1277 (cellLayoutPaddingPx.left + cellLayoutPaddingPx.right) / 2;
1278 if (isTablet) {
1279 int usedWidth = (allAppsCellWidthPx * numShownAllAppsColumns)
1280 + (allAppsBorderSpacePx.x * (numShownAllAppsColumns - 1))
Thales Limab433c9c2023-10-30 12:24:05 +00001281 + allAppsPadding.left + allAppsPadding.right;
Thales Limaabfe3642023-05-24 18:08:53 +01001282 allAppsLeftRightMargin = Math.max(1, (availableWidthPx - usedWidth) / 2);
1283 } else {
Thales Limab433c9c2023-10-30 12:24:05 +00001284 allAppsPadding.left = allAppsPadding.right =
Thales Limaabfe3642023-05-24 18:08:53 +01001285 Math.max(0, desiredWorkspaceHorizontalMarginPx + cellLayoutHorizontalPadding
1286 - (allAppsBorderSpacePx.x / 2));
Brian Isganitis25b2ac82022-01-28 16:25:13 -05001287 }
1288 }
1289
Thales Limaabfe3642023-05-24 18:08:53 +01001290 private void setupAllAppsStyle(Context context) {
1291 TypedArray allAppsStyle = context.obtainStyledAttributes(
1292 inv.allAppsStyle != INVALID_RESOURCE_HANDLE ? inv.allAppsStyle
1293 : R.style.AllAppsStyleDefault, R.styleable.AllAppsStyle);
1294
Thales Limab433c9c2023-10-30 12:24:05 +00001295 allAppsPadding.left = allAppsPadding.right = allAppsStyle.getDimensionPixelSize(
Thales Limaabfe3642023-05-24 18:08:53 +01001296 R.styleable.AllAppsStyle_horizontalPadding, 0);
1297 allAppsStyle.recycle();
1298 }
1299
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001300 private void updateAvailableFolderCellDimensions(Resources res) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001301 updateFolderCellSize(1f, res);
Jon Mirandabf7d8122016-11-03 15:29:29 -07001302
Jordan Silva637f4eb2023-06-13 11:21:53 +01001303 // Responsive grid doesn't need to scale the folder
1304 if (mIsResponsiveGrid) return;
1305
Thales Lima7eee74b2023-03-16 16:00:55 -03001306 // For usability we can't have the folder use the whole width of the screen
Sunny Goyal07b69292018-01-08 14:19:34 -08001307 Point totalWorkspacePadding = getTotalWorkspacePadding();
Jon Mirandac1b23992016-12-13 08:57:36 -08001308
Thales Lima7eee74b2023-03-16 16:00:55 -03001309 // Check if the folder fit within the available height.
Jon Miranda228877d2021-02-09 11:05:00 -05001310 float contentUsedHeight = folderCellHeightPx * inv.numFolderRows
Jordan Silva637f4eb2023-06-13 11:21:53 +01001311 + ((inv.numFolderRows - 1) * folderCellLayoutBorderSpacePx.y)
Thales Lima7eee74b2023-03-16 16:00:55 -03001312 + folderFooterHeightPx
1313 + folderContentPaddingTop;
1314 int contentMaxHeight = availableHeightPx - totalWorkspacePadding.y;
Samuel Fufa1c8d90a2019-11-12 17:54:58 -08001315 float scaleY = contentMaxHeight / contentUsedHeight;
Jon Mirandac1b23992016-12-13 08:57:36 -08001316
Thales Lima7eee74b2023-03-16 16:00:55 -03001317 // Check if the folder fit within the available width.
Jon Miranda228877d2021-02-09 11:05:00 -05001318 float contentUsedWidth = folderCellWidthPx * inv.numFolderColumns
Jordan Silva637f4eb2023-06-13 11:21:53 +01001319 + ((inv.numFolderColumns - 1) * folderCellLayoutBorderSpacePx.x)
Thales Lima7eee74b2023-03-16 16:00:55 -03001320 + folderContentPaddingLeftRight * 2;
1321 int contentMaxWidth = availableWidthPx - totalWorkspacePadding.x;
Samuel Fufa1c8d90a2019-11-12 17:54:58 -08001322 float scaleX = contentMaxWidth / contentUsedWidth;
Jon Mirandac1b23992016-12-13 08:57:36 -08001323
1324 float scale = Math.min(scaleX, scaleY);
1325 if (scale < 1f) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001326 updateFolderCellSize(scale, res);
Jon Mirandabf7d8122016-11-03 15:29:29 -07001327 }
1328 }
1329
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001330 private void updateFolderCellSize(float scale, Resources res) {
Alex Chau0d4f1ac2022-12-20 12:31:14 +00001331 float invIconSizeDp = inv.iconSize[mTypeIndex];
Sunny Goyal35c7b192021-04-20 16:51:10 -07001332 folderChildIconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mMetrics, scale));
Alex Chau0d4f1ac2022-12-20 12:31:14 +00001333 folderChildTextSizePx = pxFromSp(inv.iconTextSize[mTypeIndex], mMetrics, scale);
Thales Lima7eee74b2023-03-16 16:00:55 -03001334 folderLabelTextSizePx = Math.max(pxFromSp(MIN_FOLDER_TEXT_SIZE_SP, mMetrics, scale),
Thales Limab35faed2022-09-05 16:30:01 -03001335 (int) (folderChildTextSizePx * folderLabelTextScale));
Jon Mirandabf7d8122016-11-03 15:29:29 -07001336
1337 int textHeight = Utilities.calculateTextHeight(folderChildTextSizePx);
Jon Mirandabf7d8122016-11-03 15:29:29 -07001338
Jordan Silva637f4eb2023-06-13 11:21:53 +01001339 if (mIsResponsiveGrid) {
1340 folderCellWidthPx = mResponsiveFolderWidthSpec.getCellSizePx();
Jordan Silva637f4eb2023-06-13 11:21:53 +01001341 folderCellHeightPx = mResponsiveFolderHeightSpec.getCellSizePx();
1342 folderContentPaddingTop = mResponsiveFolderHeightSpec.getStartPaddingPx();
1343 folderFooterHeightPx = mResponsiveFolderHeightSpec.getEndPaddingPx();
1344
1345 folderCellLayoutBorderSpacePx = new Point(mResponsiveFolderWidthSpec.getGutterPx(),
Thales Lima4cfd9502023-07-10 14:01:28 +01001346 mResponsiveFolderHeightSpec.getGutterPx());
Jordan Silva637f4eb2023-06-13 11:21:53 +01001347
1348 folderContentPaddingLeftRight = mResponsiveFolderWidthSpec.getStartPaddingPx();
Jordan Silva12fae112023-06-26 12:51:01 +01001349
1350 // Reduce icon width if it's wider than the expected folder cell width
1351 if (folderCellWidthPx < folderChildIconSizePx) {
1352 folderChildIconSizePx = mIconSizeSteps.getIconSmallerThan(folderCellWidthPx);
1353 }
1354
1355 // Recalculating padding and cell height
1356 folderChildDrawablePaddingPx = getNormalizedFolderChildDrawablePaddingPx(textHeight);
Jordan Silva12fae112023-06-26 12:51:01 +01001357
Thales Limae9b5e142023-11-04 17:10:13 +00001358 CellContentDimensions cellContentDimensions = new CellContentDimensions(
1359 folderChildIconSizePx,
1360 folderChildDrawablePaddingPx,
1361 folderChildTextSizePx);
1362 cellContentDimensions.resizeToFitCellHeight(folderCellHeightPx, mIconSizeSteps);
1363 folderChildIconSizePx = cellContentDimensions.getIconSizePx();
1364 folderChildDrawablePaddingPx = cellContentDimensions.getIconDrawablePaddingPx();
1365 folderChildTextSizePx = cellContentDimensions.getIconTextSizePx();
Jordan Silva637f4eb2023-06-13 11:21:53 +01001366 } else if (mIsScalableGrid) {
Thales Limab35faed2022-09-05 16:30:01 -03001367 if (inv.folderStyle == INVALID_RESOURCE_HANDLE) {
Thales Lima7eee74b2023-03-16 16:00:55 -03001368 folderCellWidthPx = roundPxValueFromFloat(getCellSize().x * scale);
1369 folderCellHeightPx = roundPxValueFromFloat(getCellSize().y * scale);
1370 } else {
1371 folderCellWidthPx = roundPxValueFromFloat(folderCellWidthPx * scale);
1372 folderCellHeightPx = roundPxValueFromFloat(folderCellHeightPx * scale);
Thales Limab35faed2022-09-05 16:30:01 -03001373 }
Jon Mirandaf33f5b32021-07-22 17:15:31 -07001374
Thales Lima7eee74b2023-03-16 16:00:55 -03001375 folderContentPaddingTop = roundPxValueFromFloat(folderContentPaddingTop * scale);
Jordan Silva637f4eb2023-06-13 11:21:53 +01001376 folderCellLayoutBorderSpacePx = new Point(
1377 roundPxValueFromFloat(folderCellLayoutBorderSpacePx.x * scale),
1378 roundPxValueFromFloat(folderCellLayoutBorderSpacePx.y * scale)
1379 );
Thales Lima7eee74b2023-03-16 16:00:55 -03001380 folderFooterHeightPx = roundPxValueFromFloat(folderFooterHeightPx * scale);
1381
Jordan Silva637f4eb2023-06-13 11:21:53 +01001382 folderContentPaddingLeftRight = folderCellLayoutBorderSpacePx.x;
Jordan Silva12fae112023-06-26 12:51:01 +01001383
1384 folderChildDrawablePaddingPx = getNormalizedFolderChildDrawablePaddingPx(textHeight);
Jon Miranda823da222021-03-23 08:08:45 -04001385 } else {
1386 int cellPaddingX = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_x_padding)
1387 * scale);
1388 int cellPaddingY = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_y_padding)
1389 * scale);
1390
1391 folderCellWidthPx = folderChildIconSizePx + 2 * cellPaddingX;
1392 folderCellHeightPx = folderChildIconSizePx + 2 * cellPaddingY + textHeight;
Thales Lima7eee74b2023-03-16 16:00:55 -03001393 folderContentPaddingTop = roundPxValueFromFloat(folderContentPaddingTop * scale);
Thales Limab35faed2022-09-05 16:30:01 -03001394 folderContentPaddingLeftRight =
1395 res.getDimensionPixelSize(R.dimen.folder_content_padding_left_right);
1396 folderFooterHeightPx =
Thales Lima7eee74b2023-03-16 16:00:55 -03001397 roundPxValueFromFloat(
1398 res.getDimensionPixelSize(R.dimen.folder_footer_height_default)
1399 * scale);
1400
Jordan Silva12fae112023-06-26 12:51:01 +01001401 folderChildDrawablePaddingPx = getNormalizedFolderChildDrawablePaddingPx(textHeight);
Jon Miranda823da222021-03-23 08:08:45 -04001402 }
Jon Mirandabf7d8122016-11-03 15:29:29 -07001403 }
1404
Winson1f064272016-07-18 17:18:02 -07001405 public void updateInsets(Rect insets) {
1406 mInsets.set(insets);
1407 }
1408
Sunny Goyalae6e3182019-04-30 12:04:37 -07001409 /**
1410 * The current device insets. This is generally same as the insets being dispatched to
1411 * {@link Insettable} elements, but can differ if the element is using a different profile.
1412 */
Sunny Goyal1a52ef52018-01-11 10:15:03 -08001413 public Rect getInsets() {
1414 return mInsets;
1415 }
1416
Sunny Goyal756cd262015-08-20 12:33:21 -07001417 public Point getCellSize() {
Sunny Goyal19ff7282021-04-22 10:12:54 -07001418 return getCellSize(null);
Jon Miranda6f7e9702019-09-16 14:44:14 -07001419 }
1420
Sunny Goyal19ff7282021-04-22 10:12:54 -07001421 public Point getCellSize(Point result) {
1422 if (result == null) {
1423 result = new Point();
1424 }
Thales Limad1df5fc2021-09-03 18:37:19 +01001425
Pat Manning25d53342022-05-10 09:58:49 +00001426 int shortcutAndWidgetContainerWidth =
1427 getCellLayoutWidth() - (cellLayoutPaddingPx.left + cellLayoutPaddingPx.right);
1428 result.x = calculateCellWidth(shortcutAndWidgetContainerWidth, cellLayoutBorderSpacePx.x,
1429 inv.numColumns);
1430 int shortcutAndWidgetContainerHeight =
1431 getCellLayoutHeight() - (cellLayoutPaddingPx.top + cellLayoutPaddingPx.bottom);
1432 result.y = calculateCellHeight(shortcutAndWidgetContainerHeight, cellLayoutBorderSpacePx.y,
1433 inv.numRows);
Sunny Goyal3e8a04b2022-05-09 19:31:45 +00001434 return result;
Pat Manningb45d6c42022-05-03 14:32:06 +01001435 }
1436
1437 /**
Thales Lima1e8b45f2022-08-25 11:50:59 -04001438 * Returns the left and right space on the cell, which is the cell width - icon size
1439 */
1440 public int getCellHorizontalSpace() {
1441 return getCellSize().x - iconSizePx;
1442 }
1443
1444 /**
Pat Manning25d53342022-05-10 09:58:49 +00001445 * Gets the number of panels within the workspace.
1446 */
1447 public int getPanelCount() {
1448 return isTwoPanels ? 2 : 1;
1449 }
1450
1451 /**
Pat Manningde25c0d2022-04-05 19:11:26 +01001452 * Gets the space in px from the bottom of last item in the vertical-bar hotseat to the
1453 * bottom of the screen.
1454 */
Pat Manning5f74bfd2022-07-20 12:08:54 +01001455 private int getVerticalHotseatLastItemBottomOffset(Context context) {
1456 Rect hotseatBarPadding = getHotseatLayoutPadding(context);
Pat Manningde25c0d2022-04-05 19:11:26 +01001457 int cellHeight = calculateCellHeight(
Pat Manning5f74bfd2022-07-20 12:08:54 +01001458 heightPx - hotseatBarPadding.top - hotseatBarPadding.bottom, hotseatBorderSpace,
Pat Manningde25c0d2022-04-05 19:11:26 +01001459 numShownHotseatIcons);
Pat Manningde25c0d2022-04-05 19:11:26 +01001460 int extraIconEndSpacing = (cellHeight - iconSizePx) / 2;
Pat Manning5f74bfd2022-07-20 12:08:54 +01001461 return extraIconEndSpacing + hotseatBarPadding.bottom;
Pat Manningde25c0d2022-04-05 19:11:26 +01001462 }
1463
1464 /**
1465 * Gets the scaled top of the workspace in px for the spring-loaded edit state.
1466 */
Pat Manning25d53342022-05-10 09:58:49 +00001467 public float getCellLayoutSpringLoadShrunkTop() {
Pat Manning5f74bfd2022-07-20 12:08:54 +01001468 return mInsets.top + dropTargetBarTopMarginPx + dropTargetBarSizePx
Pat Manningde25c0d2022-04-05 19:11:26 +01001469 + dropTargetBarBottomMarginPx;
Pat Manningde25c0d2022-04-05 19:11:26 +01001470 }
1471
1472 /**
1473 * Gets the scaled bottom of the workspace in px for the spring-loaded edit state.
1474 */
Pat Manning5f74bfd2022-07-20 12:08:54 +01001475 public float getCellLayoutSpringLoadShrunkBottom(Context context) {
Pat Manningde25c0d2022-04-05 19:11:26 +01001476 int topOfHotseat = hotseatBarSizePx + springLoadedHotseatBarTopMarginPx;
Pat Manning5f74bfd2022-07-20 12:08:54 +01001477 return heightPx - (isVerticalBarLayout()
1478 ? getVerticalHotseatLastItemBottomOffset(context) : topOfHotseat);
Pat Manningde25c0d2022-04-05 19:11:26 +01001479 }
1480
Pat Manningea5c1d22022-04-14 10:58:16 +01001481 /**
Pat Manninga2e14992022-04-22 11:29:17 +01001482 * Gets the scale of the workspace for the spring-loaded edit state.
1483 */
Pat Manning5f74bfd2022-07-20 12:08:54 +01001484 public float getWorkspaceSpringLoadScale(Context context) {
1485 float scale =
1486 (getCellLayoutSpringLoadShrunkBottom(context) - getCellLayoutSpringLoadShrunkTop())
1487 / getCellLayoutHeight();
Pat Manninga2e14992022-04-22 11:29:17 +01001488 scale = Math.min(scale, 1f);
1489
Pat Manninge63dd252022-08-02 16:15:29 +01001490 // Reduce scale if next pages would not be visible after scaling the workspace.
Pat Manning25d53342022-05-10 09:58:49 +00001491 int workspaceWidth = availableWidthPx;
Pat Manninga2e14992022-04-22 11:29:17 +01001492 float scaledWorkspaceWidth = workspaceWidth * scale;
Alex Chau906d8822022-05-23 10:42:25 +01001493 float maxAvailableWidth = workspaceWidth - (2 * workspaceSpringLoadedMinNextPageVisiblePx);
Pat Manninga2e14992022-04-22 11:29:17 +01001494 if (scaledWorkspaceWidth > maxAvailableWidth) {
1495 scale *= maxAvailableWidth / scaledWorkspaceWidth;
1496 }
1497 return scale;
1498 }
1499
Pat Manning25d53342022-05-10 09:58:49 +00001500 /**
1501 * Gets the width of a single Cell Layout, aka a single panel within a Workspace.
1502 *
1503 * <p>This is the width of a Workspace, less its horizontal padding. Note that two-panel
1504 * layouts have two Cell Layouts per workspace.
1505 */
1506 public int getCellLayoutWidth() {
1507 return (availableWidthPx - getTotalWorkspacePadding().x) / getPanelCount();
Alex Chau60953332021-11-24 12:41:07 +00001508 }
1509
Pat Manning25d53342022-05-10 09:58:49 +00001510 /**
1511 * Gets the height of a single Cell Layout, aka a single panel within a Workspace.
1512 *
1513 * <p>This is the height of a Workspace, less its vertical padding.
1514 */
1515 public int getCellLayoutHeight() {
1516 return availableHeightPx - getTotalWorkspacePadding().y;
Pat Manning08610ca2022-04-05 21:03:16 +01001517 }
1518
Sunny Goyal6c2975e2016-07-06 09:47:56 -07001519 public Point getTotalWorkspacePadding() {
Sunny Goyal07b69292018-01-08 14:19:34 -08001520 return new Point(workspacePadding.left + workspacePadding.right,
1521 workspacePadding.top + workspacePadding.bottom);
Sunny Goyal6c2975e2016-07-06 09:47:56 -07001522 }
1523
1524 /**
Sunny Goyal07b69292018-01-08 14:19:34 -08001525 * Updates {@link #workspacePadding} as a result of any internal value change to reflect the
1526 * new workspace padding
Sunny Goyal6c2975e2016-07-06 09:47:56 -07001527 */
Sunny Goyal07b69292018-01-08 14:19:34 -08001528 private void updateWorkspacePadding() {
1529 Rect padding = workspacePadding;
Tony Wickham3a3517f2015-10-06 11:27:04 -07001530 if (isVerticalBarLayout()) {
Jordan Silva3646a1b2023-08-02 13:52:52 +01001531 if (mIsResponsiveGrid) {
1532 padding.top = mResponsiveHeightSpec.getStartPaddingPx();
Thales Lima8e11d532023-08-31 13:40:26 +00001533 padding.bottom = Math.max(0,
1534 mResponsiveHeightSpec.getEndPaddingPx() - mInsets.bottom);
Jordan Silva3646a1b2023-08-02 13:52:52 +01001535 if (isSeascape()) {
1536 padding.left = hotseatBarSizePx + mResponsiveWidthSpec.getEndPaddingPx();
1537 padding.right = mResponsiveWidthSpec.getStartPaddingPx();
1538 } else {
1539 padding.left = mResponsiveWidthSpec.getStartPaddingPx();
1540 padding.right = hotseatBarSizePx + mResponsiveWidthSpec.getEndPaddingPx();
1541 }
Winson1f064272016-07-18 17:18:02 -07001542 } else {
Jordan Silva3646a1b2023-08-02 13:52:52 +01001543 padding.top = 0;
1544 padding.bottom = edgeMarginPx;
1545 if (isSeascape()) {
1546 padding.left = hotseatBarSizePx;
Thales Lima8e11d532023-08-31 13:40:26 +00001547 padding.right = mHotseatBarEdgePaddingPx;
Jordan Silva3646a1b2023-08-02 13:52:52 +01001548 } else {
Thales Lima8e11d532023-08-31 13:40:26 +00001549 padding.left = mHotseatBarEdgePaddingPx;
Jordan Silva3646a1b2023-08-02 13:52:52 +01001550 padding.right = hotseatBarSizePx;
1551 }
Winson1f064272016-07-18 17:18:02 -07001552 }
Winson Chungb3800242013-10-24 11:01:54 -07001553 } else {
Thales Limab8c05952022-05-23 16:58:38 +01001554 // Pad the bottom of the workspace with hotseat bar
1555 // and leave a bit of space in case a widget go all the way down
Thales Lima79456492023-05-23 11:32:22 +01001556 int paddingBottom = hotseatBarSizePx + workspaceBottomPadding - mInsets.bottom;
1557 if (!mIsResponsiveGrid) {
1558 paddingBottom +=
1559 workspacePageIndicatorHeight - mWorkspacePageIndicatorOverlapWorkspace;
1560 }
1561 int paddingTop = workspaceTopPadding + (mIsScalableGrid ? 0 : edgeMarginPx);
Pat Manning08610ca2022-04-05 21:03:16 +01001562 int paddingSide = desiredWorkspaceHorizontalMarginPx;
Andras Kloczl8e57cce2021-02-11 23:51:19 +01001563
Pat Manning08610ca2022-04-05 21:03:16 +01001564 padding.set(paddingSide, paddingTop, paddingSide, paddingBottom);
Winson Chungb3800242013-10-24 11:01:54 -07001565 }
Pat Manning08610ca2022-04-05 21:03:16 +01001566 insetPadding(workspacePadding, cellLayoutPaddingPx);
1567 }
1568
1569 private void insetPadding(Rect paddings, Rect insets) {
1570 insets.left = Math.min(insets.left, paddings.left);
1571 paddings.left -= insets.left;
1572
1573 insets.top = Math.min(insets.top, paddings.top);
1574 paddings.top -= insets.top;
1575
1576 insets.right = Math.min(insets.right, paddings.right);
1577 paddings.right -= insets.right;
1578
1579 insets.bottom = Math.min(insets.bottom, paddings.bottom);
1580 paddings.bottom -= insets.bottom;
Winson Chungb3800242013-10-24 11:01:54 -07001581 }
1582
Liran Binyamina833af32023-08-02 16:30:27 -04001583
1584 /**
1585 * Returns the new border space that should be used between hotseat icons after adjusting it to
1586 * the bubble bar.
1587 *
1588 * <p>If there's no adjustment needed, this method returns {@code 0}.
1589 */
1590 public float getHotseatAdjustedBorderSpaceForBubbleBar(Context context) {
1591 // only need to adjust when QSB is on top of the hotseat.
1592 if (isQsbInline) {
1593 return 0;
1594 }
1595
1596 // no need to adjust if there's enough space for the bubble bar to the right of the hotseat.
1597 if (getHotseatLayoutPadding(context).right > mBubbleBarSpaceThresholdPx) {
1598 return 0;
1599 }
1600
1601 // The adjustment is shrinking the hotseat's width by 1 icon on either side.
1602 int iconsWidth =
1603 iconSizePx * numShownHotseatIcons + hotseatBorderSpace * (numShownHotseatIcons - 1);
1604 int newWidth = iconsWidth - 2 * iconSizePx;
1605 // Evenly space the icons within the boundaries of the new width.
1606 return (float) (newWidth - iconSizePx * numShownHotseatIcons) / (numShownHotseatIcons - 1);
1607 }
1608
Sunny Goyal57b22792021-05-25 14:35:01 -07001609 /**
1610 * Returns the padding for hotseat view
1611 */
1612 public Rect getHotseatLayoutPadding(Context context) {
Pat Manning5f74bfd2022-07-20 12:08:54 +01001613 Rect hotseatBarPadding = new Rect();
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001614 if (isVerticalBarLayout()) {
Sihua Ma38bb3b02022-03-21 22:20:14 -07001615 // The hotseat icons will be placed in the middle of the hotseat cells.
1616 // Changing the hotseatCellHeightPx is not affecting hotseat icon positions
1617 // in vertical bar layout.
1618 // Workspace icons are moved up by a small factor. The variable diffOverlapFactor
1619 // is set to account for that difference.
Jordan Silva3646a1b2023-08-02 13:52:52 +01001620 float diffOverlapFactor = mIsResponsiveGrid ? 0
1621 : iconSizePx * (ICON_OVERLAP_FACTOR - 1) / 2;
1622
Pat Manning08610ca2022-04-05 21:03:16 +01001623 int paddingTop = Math.max((int) (mInsets.top + cellLayoutPaddingPx.top
1624 - diffOverlapFactor), 0);
1625 int paddingBottom = Math.max((int) (mInsets.bottom + cellLayoutPaddingPx.bottom
Sihua Ma38bb3b02022-03-21 22:20:14 -07001626 + diffOverlapFactor), 0);
1627
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001628 if (isSeascape()) {
Thales Lima8e11d532023-08-31 13:40:26 +00001629 hotseatBarPadding.set(mInsets.left + mHotseatBarEdgePaddingPx, paddingTop,
1630 mHotseatBarWorkspaceSpacePx, paddingBottom);
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001631 } else {
Thales Lima8e11d532023-08-31 13:40:26 +00001632 hotseatBarPadding.set(mHotseatBarWorkspaceSpacePx, paddingTop,
1633 mInsets.right + mHotseatBarEdgePaddingPx, paddingBottom);
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001634 }
Sunny Goyal57b22792021-05-25 14:35:01 -07001635 } else if (isTaskbarPresent) {
Alex Chau51da2192022-05-20 13:32:10 +01001636 // Center the QSB vertically with hotseat
Thales Limab8c05952022-05-23 16:58:38 +01001637 int hotseatBarBottomPadding = getHotseatBarBottomPadding();
1638 int hotseatBarTopPadding =
1639 hotseatBarSizePx - hotseatBarBottomPadding - hotseatCellHeightPx;
Alex Chau51da2192022-05-20 13:32:10 +01001640
Thales Lima6a590062022-11-22 15:52:49 +00001641 int hotseatWidth = getHotseatRequiredWidth();
Helen Cheuke76291f2023-02-14 17:11:05 +00001642 int startSpacing;
1643 int endSpacing;
Thales Lima6a590062022-11-22 15:52:49 +00001644 // Hotseat aligns to the left with nav buttons
1645 if (hotseatBarEndOffset > 0) {
Jon Mirandae17a9492023-03-08 16:42:20 -08001646 startSpacing = inlineNavButtonsEndSpacingPx;
Helen Cheuke76291f2023-02-14 17:11:05 +00001647 endSpacing = availableWidthPx - hotseatWidth - startSpacing + hotseatBorderSpace;
1648 } else {
1649 startSpacing = (availableWidthPx - hotseatWidth) / 2;
1650 endSpacing = startSpacing;
Thales Lima6a590062022-11-22 15:52:49 +00001651 }
Helen Cheuke76291f2023-02-14 17:11:05 +00001652 startSpacing += getAdditionalQsbSpace();
Thales Lima612230d2022-03-31 18:04:37 +01001653
Helen Cheuke76291f2023-02-14 17:11:05 +00001654 hotseatBarPadding.top = hotseatBarTopPadding;
1655 hotseatBarPadding.bottom = hotseatBarBottomPadding;
Alex Chau51da2192022-05-20 13:32:10 +01001656 boolean isRtl = Utilities.isRtl(context.getResources());
Thales Lima612230d2022-03-31 18:04:37 +01001657 if (isRtl) {
Helen Cheuke76291f2023-02-14 17:11:05 +00001658 hotseatBarPadding.left = endSpacing;
1659 hotseatBarPadding.right = startSpacing;
Thales Lima612230d2022-03-31 18:04:37 +01001660 } else {
Helen Cheuke76291f2023-02-14 17:11:05 +00001661 hotseatBarPadding.left = startSpacing;
1662 hotseatBarPadding.right = endSpacing;
Thales Lima612230d2022-03-31 18:04:37 +01001663 }
Helen Cheuke76291f2023-02-14 17:11:05 +00001664
Thales Lima79456492023-05-23 11:32:22 +01001665 } else if (mIsScalableGrid) {
Alex Chau206ede92022-08-01 17:46:12 +01001666 int sideSpacing = (availableWidthPx - hotseatQsbWidth) / 2;
Pat Manning5f74bfd2022-07-20 12:08:54 +01001667 hotseatBarPadding.set(sideSpacing,
Thales Limab8c05952022-05-23 16:58:38 +01001668 0,
Thales Lima425f6822022-05-10 13:44:58 -03001669 sideSpacing,
Thales Limab8c05952022-05-23 16:58:38 +01001670 getHotseatBarBottomPadding());
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001671 } else {
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001672 // We want the edges of the hotseat to line up with the edges of the workspace, but the
1673 // icons in the hotseat are a different size, and so don't line up perfectly. To account
1674 // for this, we pad the left and right of the hotseat with half of the difference of a
1675 // workspace cell vs a hotseat cell.
1676 float workspaceCellWidth = (float) widthPx / inv.numColumns;
Sunny Goyal19ff7282021-04-22 10:12:54 -07001677 float hotseatCellWidth = (float) widthPx / numShownHotseatIcons;
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001678 int hotseatAdjustment = Math.round((workspaceCellWidth - hotseatCellWidth) / 2);
Pat Manning5f74bfd2022-07-20 12:08:54 +01001679 hotseatBarPadding.set(
Thales Limab8c05952022-05-23 16:58:38 +01001680 hotseatAdjustment + workspacePadding.left + cellLayoutPaddingPx.left
1681 + mInsets.left,
1682 0,
Pat Manning08610ca2022-04-05 21:03:16 +01001683 hotseatAdjustment + workspacePadding.right + cellLayoutPaddingPx.right
Sunny Goyal786940a2020-06-02 02:31:31 -07001684 + mInsets.right,
Thales Limab8c05952022-05-23 16:58:38 +01001685 getHotseatBarBottomPadding());
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001686 }
Pat Manning5f74bfd2022-07-20 12:08:54 +01001687 return hotseatBarPadding;
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001688 }
1689
Andy Wickhambd9a1802023-06-08 16:33:15 -07001690 /** The margin between the edge of all apps and the edge of the first icon. */
Thales Limab433c9c2023-10-30 12:24:05 +00001691 public int getAllAppsIconStartMargin(Context context) {
Andy Wickhambd9a1802023-06-08 16:33:15 -07001692 int allAppsSpacing;
1693 if (isVerticalBarLayout()) {
1694 // On phones, the landscape layout uses a different setup.
1695 allAppsSpacing = workspacePadding.left + workspacePadding.right;
1696 } else {
Thales Limab433c9c2023-10-30 12:24:05 +00001697 allAppsSpacing =
1698 allAppsPadding.left + allAppsPadding.right + allAppsLeftRightMargin * 2;
Andy Wickhambd9a1802023-06-08 16:33:15 -07001699 }
1700
1701 int cellWidth = DeviceProfile.calculateCellWidth(
1702 availableWidthPx - allAppsSpacing,
1703 0 /* borderSpace */,
1704 numShownAllAppsColumns);
1705 int iconVisibleSize = Math.round(ICON_VISIBLE_AREA_FACTOR * allAppsIconSizePx);
1706 int iconAlignmentMargin = (cellWidth - iconVisibleSize) / 2;
Thales Limab433c9c2023-10-30 12:24:05 +00001707
1708 return (Utilities.isRtl(context.getResources()) ? allAppsPadding.right
1709 : allAppsPadding.left) + iconAlignmentMargin;
Andy Wickhambd9a1802023-06-08 16:33:15 -07001710 }
1711
Thales Lima9938c2f2022-07-25 14:38:16 +01001712 private int getAdditionalQsbSpace() {
1713 return isQsbInline ? hotseatQsbWidth + hotseatBorderSpace : 0;
1714 }
1715
1716 /**
1717 * Calculate how much space the hotseat needs to be shown completely
1718 */
1719 private int getHotseatRequiredWidth() {
1720 int additionalQsbSpace = getAdditionalQsbSpace();
1721 return iconSizePx * numShownHotseatIcons
Thales Lima6a590062022-11-22 15:52:49 +00001722 + hotseatBorderSpace * (numShownHotseatIcons - (areNavButtonsInline ? 0 : 1))
Thales Lima9938c2f2022-07-25 14:38:16 +01001723 + additionalQsbSpace;
1724 }
1725
Winsonfadbe8f2016-07-22 16:35:37 -07001726 /**
Sunny Goyal57b22792021-05-25 14:35:01 -07001727 * Returns the number of pixels the QSB is translated from the bottom of the screen.
1728 */
1729 public int getQsbOffsetY() {
Thales Limaa1012902022-01-13 17:58:42 +00001730 if (isQsbInline) {
Thales Limab8c05952022-05-23 16:58:38 +01001731 return getHotseatBarBottomPadding() - ((hotseatQsbHeight - hotseatCellHeightPx) / 2);
1732 } else if (isTaskbarPresent) { // QSB on top
1733 return hotseatBarSizePx - hotseatQsbHeight + hotseatQsbShadowHeight;
Jonathan Miranda8f16a772021-07-23 23:10:37 +00001734 } else {
Thales Limab8c05952022-05-23 16:58:38 +01001735 return hotseatBarBottomSpacePx - hotseatQsbShadowHeight;
Jonathan Miranda7a273e22021-06-24 21:29:10 +00001736 }
Sunny Goyal57b22792021-05-25 14:35:01 -07001737 }
1738
Thales Limab8c05952022-05-23 16:58:38 +01001739 /**
1740 * Returns the number of pixels the hotseat is translated from the bottom of the screen.
1741 */
1742 private int getHotseatBarBottomPadding() {
1743 if (isTaskbarPresent) { // QSB on top or inline
1744 return hotseatBarBottomSpacePx - (Math.abs(hotseatCellHeightPx - iconSizePx) / 2);
Thales Limaa1012902022-01-13 17:58:42 +00001745 } else {
Thales Limab8c05952022-05-23 16:58:38 +01001746 return hotseatBarSizePx - hotseatCellHeightPx;
Thales Limaa1012902022-01-13 17:58:42 +00001747 }
Sunny Goyal57b22792021-05-25 14:35:01 -07001748 }
1749
1750 /**
Alex Chau51da2192022-05-20 13:32:10 +01001751 * Returns the number of pixels the taskbar is translated from the bottom of the screen.
1752 */
1753 public int getTaskbarOffsetY() {
Jon Miranda9c478b62023-03-23 21:38:49 -07001754 int taskbarIconBottomSpace = (taskbarHeight - iconSizePx) / 2;
Alex Chau51da2192022-05-20 13:32:10 +01001755 int launcherIconBottomSpace =
1756 Math.min((hotseatCellHeightPx - iconSizePx) / 2, gridVisualizationPaddingY);
Thales Limab8c05952022-05-23 16:58:38 +01001757 return getHotseatBarBottomPadding() + launcherIconBottomSpace - taskbarIconBottomSpace;
Alex Chau51da2192022-05-20 13:32:10 +01001758 }
1759
Uwais Ashrafaa7fa882023-10-10 21:36:06 +00001760 /** Returns the number of pixels required below OverviewActions. */
Alex Chaua2fc7642022-04-21 14:20:23 +01001761 public int getOverviewActionsClaimedSpaceBelow() {
Uwais Ashrafaa7fa882023-10-10 21:36:06 +00001762 return isTaskbarPresent ? mTransientTaskbarClaimedSpace : mInsets.bottom;
Alex Chaua2fc7642022-04-21 14:20:23 +01001763 }
1764
1765 /** Gets the space that the overview actions will take, including bottom margin. */
1766 public int getOverviewActionsClaimedSpace() {
Alex Chau4989f4f2023-10-11 14:08:22 +00001767 int overviewActionsSpace = isTablet && Flags.enableGridOnlyOverview()
Pat Manning7b8f7662023-01-18 14:48:30 +00001768 ? 0
1769 : (overviewActionsTopMarginPx + overviewActionsHeight);
1770 return overviewActionsSpace + getOverviewActionsClaimedSpaceBelow();
Alex Chaua2fc7642022-04-21 14:20:23 +01001771 }
1772
1773 /**
Sihua Mae04aa202022-07-18 12:43:56 -07001774 * Takes the View and return the scales of width and height depending on the DeviceProfile
1775 * specifications
1776 *
1777 * @param itemInfo The tag of the widget view
1778 * @return A PointF instance with the x set to be the scale of width, and y being the scale of
1779 * height
1780 */
1781 @NonNull
1782 public PointF getAppWidgetScale(@Nullable final ItemInfo itemInfo) {
1783 return mViewScaleProvider.getScaleFromItemInfo(itemInfo);
1784 }
1785
1786 /**
Winsonfadbe8f2016-07-22 16:35:37 -07001787 * @return the bounds for which the open folders should be contained within
1788 */
1789 public Rect getAbsoluteOpenFolderBounds() {
1790 if (isVerticalBarLayout()) {
1791 // Folders should only appear right of the drop target bar and left of the hotseat
1792 return new Rect(mInsets.left + dropTargetBarSizePx + edgeMarginPx,
1793 mInsets.top,
Jon Miranda18751b62017-07-31 17:25:27 -07001794 mInsets.left + availableWidthPx - hotseatBarSizePx - edgeMarginPx,
Winsonfadbe8f2016-07-22 16:35:37 -07001795 mInsets.top + availableHeightPx);
1796 } else {
1797 // Folders should only appear below the drop target bar and above the hotseat
Jon Miranda9c478b62023-03-23 21:38:49 -07001798 int hotseatTop = isTaskbarPresent ? taskbarHeight : hotseatBarSizePx;
Tony Wickhamb4b7e202018-01-12 17:39:24 -08001799 return new Rect(mInsets.left + edgeMarginPx,
Winsonfadbe8f2016-07-22 16:35:37 -07001800 mInsets.top + dropTargetBarSizePx + edgeMarginPx,
Tony Wickhamb4b7e202018-01-12 17:39:24 -08001801 mInsets.left + availableWidthPx - edgeMarginPx,
Tony Wickhamae72b462021-03-10 16:18:40 -08001802 mInsets.top + availableHeightPx - hotseatTop
Tony Wickham5edf9e22020-03-27 20:06:52 -07001803 - workspacePageIndicatorHeight - edgeMarginPx);
Winsonfadbe8f2016-07-22 16:35:37 -07001804 }
1805 }
1806
Jon Miranda228877d2021-02-09 11:05:00 -05001807 public static int calculateCellWidth(int width, int borderSpacing, int countX) {
1808 return (width - ((countX - 1) * borderSpacing)) / countX;
Winson Chungb3800242013-10-24 11:01:54 -07001809 }
Pierre Barbier de Reuille578deba2021-09-24 13:47:44 +01001810
Jon Miranda228877d2021-02-09 11:05:00 -05001811 public static int calculateCellHeight(int height, int borderSpacing, int countY) {
1812 return (height - ((countY - 1) * borderSpacing)) / countY;
Winson Chungb3800242013-10-24 11:01:54 -07001813 }
1814
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -07001815 /**
Tony Wickham55616cd2015-09-23 14:55:17 -07001816 * When {@code true}, the device is in landscape mode and the hotseat is on the right column.
1817 * When {@code false}, either device is in portrait mode or the device is in landscape mode and
1818 * the hotseat is on the bottom row.
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -07001819 */
Tony Wickhamab946a12015-09-16 15:38:16 -07001820 public boolean isVerticalBarLayout() {
Winson Chungb3800242013-10-24 11:01:54 -07001821 return isLandscape && transposeLayoutWithOrientation;
1822 }
1823
Sunny Goyal59d086c2018-05-07 17:31:40 -07001824 /**
1825 * Updates orientation information and returns true if it has changed from the previous value.
1826 */
Winson Chung13c1c2c2019-09-06 11:46:19 -07001827 public boolean updateIsSeascape(Context context) {
Sunny Goyal59d086c2018-05-07 17:31:40 -07001828 if (isVerticalBarLayout()) {
Sunny Goyal35c7b192021-04-20 16:51:10 -07001829 boolean isSeascape = DisplayController.INSTANCE.get(context)
1830 .getInfo().rotation == Surface.ROTATION_270;
Sunny Goyal59d086c2018-05-07 17:31:40 -07001831 if (mIsSeascape != isSeascape) {
1832 mIsSeascape = isSeascape;
Pat Manning08610ca2022-04-05 21:03:16 +01001833 // Hotseat changing sides requires updating workspace left/right paddings
1834 updateWorkspacePadding();
Sunny Goyal59d086c2018-05-07 17:31:40 -07001835 return true;
1836 }
1837 }
1838 return false;
1839 }
1840
Sunny Goyal7e2e67f2018-01-26 13:40:08 -08001841 public boolean isSeascape() {
Sunny Goyal59d086c2018-05-07 17:31:40 -07001842 return isVerticalBarLayout() && mIsSeascape;
Sunny Goyal7e2e67f2018-01-26 13:40:08 -08001843 }
1844
Sunny Goyal07b69292018-01-08 14:19:34 -08001845 public boolean shouldFadeAdjacentWorkspaceScreens() {
Sunny Goyal19ff7282021-04-22 10:12:54 -07001846 return isVerticalBarLayout();
Winson Chungb3800242013-10-24 11:01:54 -07001847 }
1848
Jon Miranda92c1b5d2021-07-20 13:57:16 -07001849 public int getCellContentHeight(@ContainerType int containerType) {
Sunny Goyalc13403c2016-11-18 23:44:48 -08001850 switch (containerType) {
1851 case CellLayout.WORKSPACE:
1852 return cellHeightPx;
1853 case CellLayout.FOLDER:
1854 return folderCellHeightPx;
1855 case CellLayout.HOTSEAT:
Jon Miranda92c1b5d2021-07-20 13:57:16 -07001856 // The hotseat is the only container where the cell height is going to be
1857 // different from the content within that cell.
1858 return iconSizePx;
Sunny Goyalc13403c2016-11-18 23:44:48 -08001859 default:
1860 // ??
1861 return 0;
1862 }
1863 }
Sunny Goyal13178ac2016-04-04 16:35:22 -07001864
Jon Miranda58561d42021-03-17 10:51:54 -04001865 private String pxToDpStr(String name, float value) {
Sunny Goyal35c7b192021-04-20 16:51:10 -07001866 return "\t" + name + ": " + value + "px (" + dpiFromPx(value, mMetrics.densityDpi) + "dp)";
Jon Miranda58561d42021-03-17 10:51:54 -04001867 }
1868
Alex Chaue818bcb2022-09-02 17:27:11 +01001869 private String dpPointFToString(String name, PointF value) {
1870 return String.format(Locale.ENGLISH, "\t%s: PointF(%.1f, %.1f)dp", name, value.x, value.y);
1871 }
1872
Pat Manning5f74bfd2022-07-20 12:08:54 +01001873 /** Dumps various DeviceProfile variables to the specified writer. */
1874 public void dump(Context context, String prefix, PrintWriter writer) {
Jon Miranda58561d42021-03-17 10:51:54 -04001875 writer.println(prefix + "DeviceProfile:");
Sunny Goyal35c7b192021-04-20 16:51:10 -07001876 writer.println(prefix + "\t1 dp = " + mMetrics.density + " px");
Jon Miranda58561d42021-03-17 10:51:54 -04001877
1878 writer.println(prefix + "\tisTablet:" + isTablet);
Jon Miranda58561d42021-03-17 10:51:54 -04001879 writer.println(prefix + "\tisPhone:" + isPhone);
1880 writer.println(prefix + "\ttransposeLayoutWithOrientation:"
1881 + transposeLayoutWithOrientation);
Alex Chau6ed408f2022-03-04 12:58:05 +00001882 writer.println(prefix + "\tisGestureMode:" + isGestureMode);
Jon Miranda58561d42021-03-17 10:51:54 -04001883
1884 writer.println(prefix + "\tisLandscape:" + isLandscape);
1885 writer.println(prefix + "\tisMultiWindowMode:" + isMultiWindowMode);
Sunny Goyal19ff7282021-04-22 10:12:54 -07001886 writer.println(prefix + "\tisTwoPanels:" + isTwoPanels);
Jon Miranda58561d42021-03-17 10:51:54 -04001887
1888 writer.println(prefix + pxToDpStr("windowX", windowX));
1889 writer.println(prefix + pxToDpStr("windowY", windowY));
1890 writer.println(prefix + pxToDpStr("widthPx", widthPx));
1891 writer.println(prefix + pxToDpStr("heightPx", heightPx));
Jon Miranda58561d42021-03-17 10:51:54 -04001892 writer.println(prefix + pxToDpStr("availableWidthPx", availableWidthPx));
1893 writer.println(prefix + pxToDpStr("availableHeightPx", availableHeightPx));
Alex Chaue0227552022-04-06 19:44:43 +01001894 writer.println(prefix + pxToDpStr("mInsets.left", mInsets.left));
1895 writer.println(prefix + pxToDpStr("mInsets.top", mInsets.top));
1896 writer.println(prefix + pxToDpStr("mInsets.right", mInsets.right));
1897 writer.println(prefix + pxToDpStr("mInsets.bottom", mInsets.bottom));
Jon Miranda58561d42021-03-17 10:51:54 -04001898
1899 writer.println(prefix + "\taspectRatio:" + aspectRatio);
1900
Thales Limac98b7812023-04-14 15:04:23 +01001901 writer.println(prefix + "\tisResponsiveGrid:" + mIsResponsiveGrid);
Thales Lima79456492023-05-23 11:32:22 +01001902 writer.println(prefix + "\tisScalableGrid:" + mIsScalableGrid);
Jon Miranda58561d42021-03-17 10:51:54 -04001903
Thales Lima83bedbf2021-10-05 17:47:39 +01001904 writer.println(prefix + "\tinv.numRows: " + inv.numRows);
Alex Chau9fee3fd2021-12-01 18:43:10 +00001905 writer.println(prefix + "\tinv.numColumns: " + inv.numColumns);
1906 writer.println(prefix + "\tinv.numSearchContainerColumns: "
1907 + inv.numSearchContainerColumns);
Jon Miranda58561d42021-03-17 10:51:54 -04001908
Alex Chaue818bcb2022-09-02 17:27:11 +01001909 writer.println(prefix + dpPointFToString("minCellSize", inv.minCellSize[mTypeIndex]));
Jon Mirandaab3c6812021-06-28 15:42:28 -07001910
Jon Miranda58561d42021-03-17 10:51:54 -04001911 writer.println(prefix + pxToDpStr("cellWidthPx", cellWidthPx));
1912 writer.println(prefix + pxToDpStr("cellHeightPx", cellHeightPx));
1913
1914 writer.println(prefix + pxToDpStr("getCellSize().x", getCellSize().x));
1915 writer.println(prefix + pxToDpStr("getCellSize().y", getCellSize().y));
1916
Thales Lima83bedbf2021-10-05 17:47:39 +01001917 writer.println(prefix + pxToDpStr("cellLayoutBorderSpacePx Horizontal",
1918 cellLayoutBorderSpacePx.x));
1919 writer.println(prefix + pxToDpStr("cellLayoutBorderSpacePx Vertical",
1920 cellLayoutBorderSpacePx.y));
Pat Manning5f74bfd2022-07-20 12:08:54 +01001921 writer.println(
1922 prefix + pxToDpStr("cellLayoutPaddingPx.left", cellLayoutPaddingPx.left));
1923 writer.println(
1924 prefix + pxToDpStr("cellLayoutPaddingPx.top", cellLayoutPaddingPx.top));
1925 writer.println(
1926 prefix + pxToDpStr("cellLayoutPaddingPx.right", cellLayoutPaddingPx.right));
Pat Manning08610ca2022-04-05 21:03:16 +01001927 writer.println(
1928 prefix + pxToDpStr("cellLayoutPaddingPx.bottom", cellLayoutPaddingPx.bottom));
Thales Lima83bedbf2021-10-05 17:47:39 +01001929
Jon Miranda58561d42021-03-17 10:51:54 -04001930 writer.println(prefix + pxToDpStr("iconSizePx", iconSizePx));
1931 writer.println(prefix + pxToDpStr("iconTextSizePx", iconTextSizePx));
1932 writer.println(prefix + pxToDpStr("iconDrawablePaddingPx", iconDrawablePaddingPx));
1933
Helen Cheuk599109b2023-02-23 17:15:39 +00001934 writer.println(prefix + "\tinv.numFolderRows: " + inv.numFolderRows);
1935 writer.println(prefix + "\tinv.numFolderColumns: " + inv.numFolderColumns);
Jon Miranda58561d42021-03-17 10:51:54 -04001936 writer.println(prefix + pxToDpStr("folderCellWidthPx", folderCellWidthPx));
1937 writer.println(prefix + pxToDpStr("folderCellHeightPx", folderCellHeightPx));
1938 writer.println(prefix + pxToDpStr("folderChildIconSizePx", folderChildIconSizePx));
1939 writer.println(prefix + pxToDpStr("folderChildTextSizePx", folderChildTextSizePx));
1940 writer.println(prefix + pxToDpStr("folderChildDrawablePaddingPx",
1941 folderChildDrawablePaddingPx));
Jordan Silva637f4eb2023-06-13 11:21:53 +01001942 writer.println(prefix + pxToDpStr("folderCellLayoutBorderSpacePx.x",
1943 folderCellLayoutBorderSpacePx.x));
1944 writer.println(prefix + pxToDpStr("folderCellLayoutBorderSpacePx.y",
1945 folderCellLayoutBorderSpacePx.y));
Thales Limaa08a4432022-08-09 09:55:17 +01001946 writer.println(prefix + pxToDpStr("folderContentPaddingLeftRight",
1947 folderContentPaddingLeftRight));
1948 writer.println(prefix + pxToDpStr("folderTopPadding", folderContentPaddingTop));
Thales Limab35faed2022-09-05 16:30:01 -03001949 writer.println(prefix + pxToDpStr("folderFooterHeight", folderFooterHeightPx));
Jon Miranda58561d42021-03-17 10:51:54 -04001950
Alex Chaue0227552022-04-06 19:44:43 +01001951 writer.println(prefix + pxToDpStr("bottomSheetTopPadding", bottomSheetTopPadding));
Alex Chau3d2c0622022-09-01 21:28:14 +01001952 writer.println(prefix + "\tbottomSheetOpenDuration: " + bottomSheetOpenDuration);
1953 writer.println(prefix + "\tbottomSheetCloseDuration: " + bottomSheetCloseDuration);
1954 writer.println(prefix + "\tbottomSheetWorkspaceScale: " + bottomSheetWorkspaceScale);
1955 writer.println(prefix + "\tbottomSheetDepth: " + bottomSheetDepth);
Alex Chaue0227552022-04-06 19:44:43 +01001956
1957 writer.println(prefix + pxToDpStr("allAppsShiftRange", allAppsShiftRange));
Alex Chau3d2c0622022-09-01 21:28:14 +01001958 writer.println(prefix + "\tallAppsOpenDuration: " + allAppsOpenDuration);
1959 writer.println(prefix + "\tallAppsCloseDuration: " + allAppsCloseDuration);
Jon Miranda58561d42021-03-17 10:51:54 -04001960 writer.println(prefix + pxToDpStr("allAppsIconSizePx", allAppsIconSizePx));
1961 writer.println(prefix + pxToDpStr("allAppsIconTextSizePx", allAppsIconTextSizePx));
1962 writer.println(prefix + pxToDpStr("allAppsIconDrawablePaddingPx",
1963 allAppsIconDrawablePaddingPx));
1964 writer.println(prefix + pxToDpStr("allAppsCellHeightPx", allAppsCellHeightPx));
Alex Chau27b39b92022-01-14 18:02:18 +00001965 writer.println(prefix + pxToDpStr("allAppsCellWidthPx", allAppsCellWidthPx));
Pat Manning26f70f72022-07-07 13:50:39 +01001966 writer.println(prefix + pxToDpStr("allAppsBorderSpacePxX", allAppsBorderSpacePx.x));
1967 writer.println(prefix + pxToDpStr("allAppsBorderSpacePxY", allAppsBorderSpacePx.y));
Sunny Goyal19ff7282021-04-22 10:12:54 -07001968 writer.println(prefix + "\tnumShownAllAppsColumns: " + numShownAllAppsColumns);
Thales Limab433c9c2023-10-30 12:24:05 +00001969 writer.println(prefix + pxToDpStr("allAppsPadding.top", allAppsPadding.top));
1970 writer.println(prefix + pxToDpStr("allAppsPadding.left", allAppsPadding.left));
1971 writer.println(prefix + pxToDpStr("allAppsPadding.right", allAppsPadding.right));
Alex Chau27b39b92022-01-14 18:02:18 +00001972 writer.println(prefix + pxToDpStr("allAppsLeftRightMargin", allAppsLeftRightMargin));
Jon Miranda58561d42021-03-17 10:51:54 -04001973
1974 writer.println(prefix + pxToDpStr("hotseatBarSizePx", hotseatBarSizePx));
Thales Lima425f6822022-05-10 13:44:58 -03001975 writer.println(prefix + "\tinv.hotseatColumnSpan: " + inv.hotseatColumnSpan[mTypeIndex]);
Jon Miranda58561d42021-03-17 10:51:54 -04001976 writer.println(prefix + pxToDpStr("hotseatCellHeightPx", hotseatCellHeightPx));
Alex Chau62572c02022-07-25 18:36:37 +00001977 writer.println(prefix + pxToDpStr("hotseatBarBottomSpacePx", hotseatBarBottomSpacePx));
Thales Lima8e11d532023-08-31 13:40:26 +00001978 writer.println(prefix + pxToDpStr("mHotseatBarEdgePaddingPx",
1979 mHotseatBarEdgePaddingPx));
1980 writer.println(prefix + pxToDpStr("mHotseatBarWorkspaceSpacePx",
1981 mHotseatBarWorkspaceSpacePx));
Pat Manning26f70f72022-07-07 13:50:39 +01001982 writer.println(prefix + pxToDpStr("hotseatBarEndOffset", hotseatBarEndOffset));
Thales Limab8c05952022-05-23 16:58:38 +01001983 writer.println(prefix + pxToDpStr("hotseatQsbSpace", hotseatQsbSpace));
1984 writer.println(prefix + pxToDpStr("hotseatQsbHeight", hotseatQsbHeight));
Pat Manningde25c0d2022-04-05 19:11:26 +01001985 writer.println(prefix + pxToDpStr("springLoadedHotseatBarTopMarginPx",
1986 springLoadedHotseatBarTopMarginPx));
Pat Manning5f74bfd2022-07-20 12:08:54 +01001987 Rect hotseatLayoutPadding = getHotseatLayoutPadding(context);
1988 writer.println(prefix + pxToDpStr("getHotseatLayoutPadding(context).top",
1989 hotseatLayoutPadding.top));
1990 writer.println(prefix + pxToDpStr("getHotseatLayoutPadding(context).bottom",
1991 hotseatLayoutPadding.bottom));
1992 writer.println(prefix + pxToDpStr("getHotseatLayoutPadding(context).left",
1993 hotseatLayoutPadding.left));
1994 writer.println(prefix + pxToDpStr("getHotseatLayoutPadding(context).right",
1995 hotseatLayoutPadding.right));
Sunny Goyal19ff7282021-04-22 10:12:54 -07001996 writer.println(prefix + "\tnumShownHotseatIcons: " + numShownHotseatIcons);
Thales Lima116b51a2022-02-03 16:19:47 +00001997 writer.println(prefix + pxToDpStr("hotseatBorderSpace", hotseatBorderSpace));
Thales Limaa1012902022-01-13 17:58:42 +00001998 writer.println(prefix + "\tisQsbInline: " + isQsbInline);
Alex Chau206ede92022-08-01 17:46:12 +01001999 writer.println(prefix + pxToDpStr("hotseatQsbWidth", hotseatQsbWidth));
Jon Miranda58561d42021-03-17 10:51:54 -04002000
2001 writer.println(prefix + "\tisTaskbarPresent:" + isTaskbarPresent);
Tony Wickham635e1802021-07-22 14:28:04 -10002002 writer.println(prefix + "\tisTaskbarPresentInApps:" + isTaskbarPresentInApps);
Jon Miranda9c478b62023-03-23 21:38:49 -07002003 writer.println(prefix + pxToDpStr("taskbarHeight", taskbarHeight));
2004 writer.println(prefix + pxToDpStr("stashedTaskbarHeight", stashedTaskbarHeight));
2005 writer.println(prefix + pxToDpStr("taskbarBottomMargin", taskbarBottomMargin));
2006 writer.println(prefix + pxToDpStr("taskbarIconSize", taskbarIconSize));
Jon Miranda58561d42021-03-17 10:51:54 -04002007
Thales Lima83bedbf2021-10-05 17:47:39 +01002008 writer.println(prefix + pxToDpStr("desiredWorkspaceHorizontalMarginPx",
2009 desiredWorkspaceHorizontalMarginPx));
Jon Miranda58561d42021-03-17 10:51:54 -04002010 writer.println(prefix + pxToDpStr("workspacePadding.left", workspacePadding.left));
2011 writer.println(prefix + pxToDpStr("workspacePadding.top", workspacePadding.top));
2012 writer.println(prefix + pxToDpStr("workspacePadding.right", workspacePadding.right));
Alex Chau62572c02022-07-25 18:36:37 +00002013 writer.println(prefix + pxToDpStr("workspacePadding.bottom", workspacePadding.bottom));
Jon Miranda58561d42021-03-17 10:51:54 -04002014
Jon Mirandaab3c6812021-06-28 15:42:28 -07002015 writer.println(prefix + pxToDpStr("iconScale", iconScale));
2016 writer.println(prefix + pxToDpStr("cellScaleToFit ", cellScaleToFit));
Jon Miranda58561d42021-03-17 10:51:54 -04002017 writer.println(prefix + pxToDpStr("extraSpace", extraSpace));
Alex Chau62572c02022-07-25 18:36:37 +00002018 writer.println(prefix + pxToDpStr("unscaled extraSpace", extraSpace / iconScale));
Jon Mirandac9e69fa2021-03-22 17:13:34 -04002019
Thales Lima171ee662022-11-22 15:52:49 +00002020 writer.println(prefix + pxToDpStr("maxEmptySpace", maxEmptySpace));
Jon Miranda58561d42021-03-17 10:51:54 -04002021 writer.println(prefix + pxToDpStr("workspaceTopPadding", workspaceTopPadding));
2022 writer.println(prefix + pxToDpStr("workspaceBottomPadding", workspaceBottomPadding));
Alex Chau635b3ab2022-01-26 16:49:10 +00002023
2024 writer.println(prefix + pxToDpStr("overviewTaskMarginPx", overviewTaskMarginPx));
Alex Chau635b3ab2022-01-26 16:49:10 +00002025 writer.println(prefix + pxToDpStr("overviewTaskIconSizePx", overviewTaskIconSizePx));
2026 writer.println(prefix + pxToDpStr("overviewTaskIconDrawableSizePx",
2027 overviewTaskIconDrawableSizePx));
2028 writer.println(prefix + pxToDpStr("overviewTaskIconDrawableSizeGridPx",
2029 overviewTaskIconDrawableSizeGridPx));
Pat Manning1695cc72023-07-05 11:45:13 +01002030 writer.println(prefix + pxToDpStr("overviewTaskIconAppChipMenuDrawableSizePx",
2031 overviewTaskIconAppChipMenuDrawableSizePx));
Alex Chau635b3ab2022-01-26 16:49:10 +00002032 writer.println(prefix + pxToDpStr("overviewTaskThumbnailTopMarginPx",
2033 overviewTaskThumbnailTopMarginPx));
Alex Chaua2fc7642022-04-21 14:20:23 +01002034 writer.println(prefix + pxToDpStr("overviewActionsTopMarginPx",
2035 overviewActionsTopMarginPx));
2036 writer.println(prefix + pxToDpStr("overviewActionsHeight",
2037 overviewActionsHeight));
Alex Chau1b276a12022-12-19 14:01:36 +00002038 writer.println(prefix + pxToDpStr("overviewActionsClaimedSpaceBelow",
2039 getOverviewActionsClaimedSpaceBelow()));
Alex Chau635b3ab2022-01-26 16:49:10 +00002040 writer.println(prefix + pxToDpStr("overviewActionsButtonSpacing",
2041 overviewActionsButtonSpacing));
2042 writer.println(prefix + pxToDpStr("overviewPageSpacing", overviewPageSpacing));
2043 writer.println(prefix + pxToDpStr("overviewRowSpacing", overviewRowSpacing));
2044 writer.println(prefix + pxToDpStr("overviewGridSideMargin", overviewGridSideMargin));
Pat Manningde25c0d2022-04-05 19:11:26 +01002045
Alex Chau62572c02022-07-25 18:36:37 +00002046 writer.println(prefix + pxToDpStr("dropTargetBarTopMarginPx", dropTargetBarTopMarginPx));
Pat Manningde25c0d2022-04-05 19:11:26 +01002047 writer.println(prefix + pxToDpStr("dropTargetBarSizePx", dropTargetBarSizePx));
Alex Chau62572c02022-07-25 18:36:37 +00002048 writer.println(
2049 prefix + pxToDpStr("dropTargetBarBottomMarginPx", dropTargetBarBottomMarginPx));
Pat Manningde25c0d2022-04-05 19:11:26 +01002050
Pat Manning5f74bfd2022-07-20 12:08:54 +01002051 writer.println(prefix + pxToDpStr("getCellLayoutSpringLoadShrunkTop()",
2052 getCellLayoutSpringLoadShrunkTop()));
2053 writer.println(prefix + pxToDpStr("getCellLayoutSpringLoadShrunkBottom()",
2054 getCellLayoutSpringLoadShrunkBottom(context)));
Alex Chau906d8822022-05-23 10:42:25 +01002055 writer.println(prefix + pxToDpStr("workspaceSpringLoadedMinNextPageVisiblePx",
2056 workspaceSpringLoadedMinNextPageVisiblePx));
Pat Manning5f74bfd2022-07-20 12:08:54 +01002057 writer.println(prefix + pxToDpStr("getWorkspaceSpringLoadScale()",
2058 getWorkspaceSpringLoadScale(context)));
Thales Limab8c05952022-05-23 16:58:38 +01002059 writer.println(prefix + pxToDpStr("getCellLayoutHeight()", getCellLayoutHeight()));
2060 writer.println(prefix + pxToDpStr("getCellLayoutWidth()", getCellLayoutWidth()));
Thales Lima79456492023-05-23 11:32:22 +01002061 if (mIsResponsiveGrid) {
2062 writer.println(prefix + "\tmResponsiveHeightSpec:" + mResponsiveHeightSpec.toString());
2063 writer.println(prefix + "\tmResponsiveWidthSpec:" + mResponsiveWidthSpec.toString());
Thales Limaabfe3642023-05-24 18:08:53 +01002064 writer.println(prefix + "\tmAllAppsResponsiveHeightSpec:"
2065 + mAllAppsResponsiveHeightSpec.toString());
2066 writer.println(prefix + "\tmAllAppsResponsiveWidthSpec:"
2067 + mAllAppsResponsiveWidthSpec.toString());
Jordan Silva637f4eb2023-06-13 11:21:53 +01002068 writer.println(prefix + "\tmResponsiveFolderHeightSpec:" + mResponsiveFolderHeightSpec);
2069 writer.println(prefix + "\tmResponsiveFolderWidthSpec:" + mResponsiveFolderWidthSpec);
Thales Limaf8bfb032023-07-24 15:08:05 +01002070 writer.println(prefix + "\tmResponsiveHotseatSpec:" + mResponsiveHotseatSpec);
Thales Lima79456492023-05-23 11:32:22 +01002071 }
Jon Miranda58561d42021-03-17 10:51:54 -04002072 }
2073
Nicolo' Mazzucatocb7bd502023-01-16 19:46:30 +00002074 /** Returns a reduced representation of this DeviceProfile. */
2075 public String toSmallString() {
2076 return "isTablet:" + isTablet + ", "
2077 + "isMultiDisplay:" + isMultiDisplay + ", "
2078 + "widthPx:" + widthPx + ", "
2079 + "heightPx:" + heightPx + ", "
2080 + "insets:" + mInsets + ", "
2081 + "rotationHint:" + rotationHint;
2082 }
2083
Alex Chaua6907dc2022-03-18 15:24:07 +00002084 private static Context getContext(Context c, Info info, int orientation, WindowBounds bounds) {
Sunny Goyal1890f672020-04-30 12:28:00 -07002085 Configuration config = new Configuration(c.getResources().getConfiguration());
2086 config.orientation = orientation;
Thales Lima425f6822022-05-10 13:44:58 -03002087 config.densityDpi = info.getDensityDpi();
Alex Chaua6907dc2022-03-18 15:24:07 +00002088 config.smallestScreenWidthDp = (int) info.smallestSizeDp(bounds);
Sunny Goyal1890f672020-04-30 12:28:00 -07002089 return c.createConfigurationContext(config);
Jon Mirandab28c4fc2017-06-20 10:58:36 -07002090 }
Sunny Goyalfde55052018-02-01 14:46:13 -08002091
2092 /**
2093 * Callback when a component changes the DeviceProfile associated with it, as a result of
2094 * configuration change
2095 */
2096 public interface OnDeviceProfileChangeListener {
2097
2098 /**
2099 * Called when the device profile is reassigned. Note that for layout and measurements, it
2100 * is sufficient to listen for inset changes. Use this callback when you need to perform
2101 * a one time operation.
2102 */
2103 void onDeviceProfileChanged(DeviceProfile dp);
2104 }
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002105
Sihua Mae04aa202022-07-18 12:43:56 -07002106 /**
2107 * Handler that deals with ItemInfo of the views for the DeviceProfile
2108 */
2109 @FunctionalInterface
2110 public interface ViewScaleProvider {
2111 /**
2112 * Get the scales from the view
2113 *
2114 * @param itemInfo The tag of the widget view
2115 * @return PointF instance containing the scale information, or null if using the default
2116 * app widget scale of this device profile.
2117 */
2118 @NonNull
2119 PointF getScaleFromItemInfo(@Nullable ItemInfo itemInfo);
2120 }
2121
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002122 public static class Builder {
2123 private Context mContext;
2124 private InvariantDeviceProfile mInv;
Sunny Goyalfd58da62020-08-11 12:06:49 -07002125 private Info mInfo;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002126
Sunny Goyal19ff7282021-04-22 10:12:54 -07002127 private WindowBounds mWindowBounds;
Alex Chauab800f72022-12-13 17:46:06 +00002128 private boolean mIsMultiDisplay;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002129
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002130 private boolean mIsMultiWindowMode = false;
Sunny Goyal19ff7282021-04-22 10:12:54 -07002131 private Boolean mTransposeLayoutWithOrientation;
Alex Chau6ed408f2022-03-04 12:58:05 +00002132 private Boolean mIsGestureMode;
Sihua Mae04aa202022-07-18 12:43:56 -07002133 private ViewScaleProvider mViewScaleProvider = null;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002134
Sunny Goyal65190ae2022-08-02 14:16:26 -07002135 private SparseArray<DotRenderer> mDotRendererCache;
2136
Jon Miranda2b25ded2023-02-02 14:48:45 -08002137 private Consumer<DeviceProfile> mOverrideProvider;
2138
Jagrut Desai3a7d1392023-09-06 15:56:19 -07002139 private boolean mIsTransientTaskbar;
2140
Sunny Goyalfd58da62020-08-11 12:06:49 -07002141 public Builder(Context context, InvariantDeviceProfile inv, Info info) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002142 mContext = context;
2143 mInv = inv;
2144 mInfo = info;
Jagrut Desai3a7d1392023-09-06 15:56:19 -07002145 mIsTransientTaskbar = info.isTransientTaskbar();
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002146 }
2147
2148 public Builder setMultiWindowMode(boolean isMultiWindowMode) {
2149 mIsMultiWindowMode = isMultiWindowMode;
2150 return this;
2151 }
2152
Alex Chauab800f72022-12-13 17:46:06 +00002153 public Builder setIsMultiDisplay(boolean isMultiDisplay) {
2154 mIsMultiDisplay = isMultiDisplay;
Sunny Goyal19ff7282021-04-22 10:12:54 -07002155 return this;
2156 }
2157
Sunny Goyal65190ae2022-08-02 14:16:26 -07002158 public Builder setDotRendererCache(SparseArray<DotRenderer> dotRendererCache) {
2159 mDotRendererCache = dotRendererCache;
2160 return this;
2161 }
Sunny Goyal19ff7282021-04-22 10:12:54 -07002162
2163 public Builder setWindowBounds(WindowBounds bounds) {
2164 mWindowBounds = bounds;
Sunny Goyal0addbf02020-04-28 14:17:35 -07002165 return this;
2166 }
2167
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002168 public Builder setTransposeLayoutWithOrientation(boolean transposeLayoutWithOrientation) {
2169 mTransposeLayoutWithOrientation = transposeLayoutWithOrientation;
2170 return this;
2171 }
2172
Alex Chau6ed408f2022-03-04 12:58:05 +00002173 public Builder setGestureMode(boolean isGestureMode) {
2174 mIsGestureMode = isGestureMode;
2175 return this;
2176 }
2177
Jon Miranda2b25ded2023-02-02 14:48:45 -08002178 public Builder withDimensionsOverride(Consumer<DeviceProfile> overrideProvider) {
2179 mOverrideProvider = overrideProvider;
2180 return this;
2181 }
2182
Sihua Mae04aa202022-07-18 12:43:56 -07002183 /**
2184 * Set the viewScaleProvider for the builder
2185 *
2186 * @param viewScaleProvider The viewScaleProvider to be set for the
Thales Limae9273ea2023-01-26 12:33:52 +00002187 * DeviceProfile
Sihua Mae04aa202022-07-18 12:43:56 -07002188 * @return This builder
2189 */
2190 @NonNull
2191 public Builder setViewScaleProvider(@Nullable ViewScaleProvider viewScaleProvider) {
2192 mViewScaleProvider = viewScaleProvider;
2193 return this;
2194 }
2195
Jagrut Desai3a7d1392023-09-06 15:56:19 -07002196 /**
2197 * Set the isTransientTaskbar for the builder
2198 * @return This Builder
2199 */
2200 public Builder setIsTransientTaskbar(boolean isTransientTaskbar) {
2201 mIsTransientTaskbar = isTransientTaskbar;
2202 return this;
2203 }
2204
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002205 public DeviceProfile build() {
Sunny Goyal19ff7282021-04-22 10:12:54 -07002206 if (mWindowBounds == null) {
2207 throw new IllegalArgumentException("Window bounds not set");
2208 }
2209 if (mTransposeLayoutWithOrientation == null) {
2210 mTransposeLayoutWithOrientation = !mInfo.isTablet(mWindowBounds);
2211 }
Alex Chau6ed408f2022-03-04 12:58:05 +00002212 if (mIsGestureMode == null) {
Alex Chaue818bcb2022-09-02 17:27:11 +01002213 mIsGestureMode = mInfo.navigationMode.hasGestures;
Alex Chau6ed408f2022-03-04 12:58:05 +00002214 }
Sunny Goyal65190ae2022-08-02 14:16:26 -07002215 if (mDotRendererCache == null) {
2216 mDotRendererCache = new SparseArray<>();
2217 }
Sihua Mae04aa202022-07-18 12:43:56 -07002218 if (mViewScaleProvider == null) {
2219 mViewScaleProvider = DEFAULT_PROVIDER;
2220 }
Jon Miranda2b25ded2023-02-02 14:48:45 -08002221 if (mOverrideProvider == null) {
2222 mOverrideProvider = DEFAULT_DIMENSION_PROVIDER;
2223 }
Sunny Goyal65190ae2022-08-02 14:16:26 -07002224 return new DeviceProfile(mContext, mInv, mInfo, mWindowBounds, mDotRendererCache,
Alex Chauab800f72022-12-13 17:46:06 +00002225 mIsMultiWindowMode, mTransposeLayoutWithOrientation, mIsMultiDisplay,
Jagrut Desai3a7d1392023-09-06 15:56:19 -07002226 mIsGestureMode, mViewScaleProvider, mOverrideProvider, mIsTransientTaskbar);
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002227 }
2228 }
Winson Chungb3800242013-10-24 11:01:54 -07002229}