blob: be43e6ca4f30b918d5265d25f71a6a6a89c25f54 [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;
Jon Miranda92c1b5d2021-07-20 13:57:16 -070027import static com.android.launcher3.folder.ClippedFolderIconLayoutRule.ICON_OVERLAP_FACTOR;
Sunny Goyal65190ae2022-08-02 14:16:26 -070028import static com.android.launcher3.icons.GraphicsUtils.getShapePath;
Jon Miranda95f44722023-06-06 19:48:19 -070029import static com.android.launcher3.icons.IconNormalizer.ICON_VISIBLE_AREA_FACTOR;
Thales Limab35faed2022-09-05 16:30:01 -030030import static com.android.launcher3.testing.shared.ResourceUtils.INVALID_RESOURCE_HANDLE;
Pat Manning5f74bfd2022-07-20 12:08:54 +010031import static com.android.launcher3.testing.shared.ResourceUtils.pxFromDp;
Thales Lima7eee74b2023-03-16 16:00:55 -030032import static com.android.launcher3.testing.shared.ResourceUtils.roundPxValueFromFloat;
Jon Miranda228877d2021-02-09 11:05:00 -050033
Sunny Goyal35c7b192021-04-20 16:51:10 -070034import android.annotation.SuppressLint;
Winson Chungb3800242013-10-24 11:01:54 -070035import android.content.Context;
Jon Mirandab28c4fc2017-06-20 10:58:36 -070036import android.content.res.Configuration;
Winson Chungb3800242013-10-24 11:01:54 -070037import android.content.res.Resources;
Thales Limab35faed2022-09-05 16:30:01 -030038import android.content.res.TypedArray;
Winson Chungb3800242013-10-24 11:01:54 -070039import android.graphics.Point;
Jon Miranda7ae64ff2016-11-21 16:18:46 -080040import android.graphics.PointF;
Winson Chungb3800242013-10-24 11:01:54 -070041import android.graphics.Rect;
Sunny Goyal35c7b192021-04-20 16:51:10 -070042import android.util.DisplayMetrics;
Sunny Goyal65190ae2022-08-02 14:16:26 -070043import android.util.SparseArray;
Sunny Goyal59d086c2018-05-07 17:31:40 -070044import android.view.Surface;
Winson Chungb3800242013-10-24 11:01:54 -070045
Sunny Goyal65190ae2022-08-02 14:16:26 -070046import androidx.annotation.NonNull;
Sihua Mae04aa202022-07-18 12:43:56 -070047import androidx.annotation.Nullable;
Jon Miranda9c478b62023-03-23 21:38:49 -070048import androidx.core.content.res.ResourcesCompat;
Sunny Goyal65190ae2022-08-02 14:16:26 -070049
Sunny Goyalc13403c2016-11-18 23:44:48 -080050import com.android.launcher3.CellLayout.ContainerType;
Jon Miranda228877d2021-02-09 11:05:00 -050051import com.android.launcher3.DevicePaddings.DevicePadding;
Alex Chaud67ddc42022-09-30 18:15:56 +010052import com.android.launcher3.config.FeatureFlags;
Tony Wickham8912b042018-11-29 15:28:53 -080053import com.android.launcher3.icons.DotRenderer;
Hyunyoung Song48cb7bc2018-09-25 17:03:34 -070054import com.android.launcher3.icons.IconNormalizer;
Sihua Mae04aa202022-07-18 12:43:56 -070055import com.android.launcher3.model.data.ItemInfo;
Thales Limaabfe3642023-05-24 18:08:53 +010056import com.android.launcher3.responsive.AllAppsSpecs;
57import com.android.launcher3.responsive.CalculatedAllAppsSpec;
Jordan Silva637f4eb2023-06-13 11:21:53 +010058import com.android.launcher3.responsive.CalculatedFolderSpec;
Thales Limaf8bfb032023-07-24 15:08:05 +010059import com.android.launcher3.responsive.CalculatedHotseatSpec;
Jordan Silva8bd7af22023-06-21 15:35:03 +010060import com.android.launcher3.responsive.CalculatedWorkspaceSpec;
Jordan Silva637f4eb2023-06-13 11:21:53 +010061import com.android.launcher3.responsive.FolderSpecs;
Thales Limaf8bfb032023-07-24 15:08:05 +010062import com.android.launcher3.responsive.HotseatSpecs;
Jordan Silva8bd7af22023-06-21 15:35:03 +010063import com.android.launcher3.responsive.WorkspaceSpecs;
Sunny Goyal57b22792021-05-25 14:35:01 -070064import com.android.launcher3.uioverrides.ApiWrapper;
Sunny Goyalfd58da62020-08-11 12:06:49 -070065import com.android.launcher3.util.DisplayController;
66import com.android.launcher3.util.DisplayController.Info;
Thales Lima2759aa32023-06-05 16:25:45 +010067import com.android.launcher3.util.IconSizeSteps;
Thales Limac98b7812023-04-14 15:04:23 +010068import com.android.launcher3.util.ResourceHelper;
Sunny Goyalb46703d2020-05-27 17:52:03 -070069import com.android.launcher3.util.WindowBounds;
Winson1f064272016-07-18 17:18:02 -070070
Jon Miranda58561d42021-03-17 10:51:54 -040071import java.io.PrintWriter;
Alex Chaue818bcb2022-09-02 17:27:11 +010072import java.util.Locale;
Jon Miranda2b25ded2023-02-02 14:48:45 -080073import java.util.function.Consumer;
Jon Miranda58561d42021-03-17 10:51:54 -040074
Sunny Goyal35c7b192021-04-20 16:51:10 -070075@SuppressLint("NewApi")
Winson Chungb3800242013-10-24 11:01:54 -070076public class DeviceProfile {
Adam Cohen2e6da152015-05-06 11:42:25 -070077
Sunny Goyal8b9919d2021-04-07 14:45:17 -070078 private static final int DEFAULT_DOT_SIZE = 100;
Alex Chau206ede92022-08-01 17:46:12 +010079 private static final float ALL_APPS_TABLET_MAX_ROWS = 5.5f;
Thales Limab35faed2022-09-05 16:30:01 -030080 private static final float MIN_FOLDER_TEXT_SIZE_SP = 16f;
Sunny Goyal6c304b12023-04-10 12:03:04 -070081 private static final float MIN_WIDGET_PADDING_DP = 6f;
Alex Chau206ede92022-08-01 17:46:12 +010082
Sihua Mae04aa202022-07-18 12:43:56 -070083 public static final PointF DEFAULT_SCALE = new PointF(1.0f, 1.0f);
84 public static final ViewScaleProvider DEFAULT_PROVIDER = itemInfo -> DEFAULT_SCALE;
Jordan Silva637f4eb2023-06-13 11:21:53 +010085 public static final Consumer<DeviceProfile> DEFAULT_DIMENSION_PROVIDER = dp -> {};
Sihua Mae04aa202022-07-18 12:43:56 -070086
Adam Cohen2e6da152015-05-06 11:42:25 -070087 public final InvariantDeviceProfile inv;
Sunny Goyalfd58da62020-08-11 12:06:49 -070088 private final Info mInfo;
Sunny Goyal35c7b192021-04-20 16:51:10 -070089 private final DisplayMetrics mMetrics;
Thales Lima2759aa32023-06-05 16:25:45 +010090 private final IconSizeSteps mIconSizeSteps;
Winson Chungbe876472014-05-14 14:15:20 -070091
Sunny Goyalc6205602015-05-21 20:46:33 -070092 // Device properties
93 public final boolean isTablet;
Sunny Goyalc6205602015-05-21 20:46:33 -070094 public final boolean isPhone;
95 public final boolean transposeLayoutWithOrientation;
Alex Chauab800f72022-12-13 17:46:06 +000096 public final boolean isMultiDisplay;
Sunny Goyal19ff7282021-04-22 10:12:54 -070097 public final boolean isTwoPanels;
Thales Limaa1012902022-01-13 17:58:42 +000098 public final boolean isQsbInline;
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -070099
Sunny Goyalc6205602015-05-21 20:46:33 -0700100 // Device properties in current orientation
Sunny Goyald792a772018-04-05 13:37:46 -0700101 public final boolean isLandscape;
Sunny Goyald70e75a2018-02-22 10:07:32 -0800102 public final boolean isMultiWindowMode;
Alex Chau6ed408f2022-03-04 12:58:05 +0000103 public final boolean isGestureMode;
Sunny Goyald70e75a2018-02-22 10:07:32 -0800104
Sunny Goyal0addbf02020-04-28 14:17:35 -0700105 public final int windowX;
106 public final int windowY;
Sunny Goyalc6205602015-05-21 20:46:33 -0700107 public final int widthPx;
108 public final int heightPx;
109 public final int availableWidthPx;
110 public final int availableHeightPx;
Sunny Goyal187b16c2022-03-01 16:53:23 -0800111 public final int rotationHint;
Jon Mirandabba64512019-03-27 10:54:17 -0700112
113 public final float aspectRatio;
114
Thales Lima79456492023-05-23 11:32:22 +0100115 private final boolean mIsScalableGrid;
Thales Lima83bedbf2021-10-05 17:47:39 +0100116 private final int mTypeIndex;
Jon Mirandae126d722021-02-25 10:45:20 -0500117
Thales Limac98b7812023-04-14 15:04:23 +0100118 // Responsive grid
119 private final boolean mIsResponsiveGrid;
Thales Limac98b7812023-04-14 15:04:23 +0100120 private CalculatedWorkspaceSpec mResponsiveWidthSpec;
121 private CalculatedWorkspaceSpec mResponsiveHeightSpec;
Thales Limaabfe3642023-05-24 18:08:53 +0100122 private CalculatedAllAppsSpec mAllAppsResponsiveWidthSpec;
123 private CalculatedAllAppsSpec mAllAppsResponsiveHeightSpec;
Jordan Silva637f4eb2023-06-13 11:21:53 +0100124 private CalculatedFolderSpec mResponsiveFolderWidthSpec;
125 private CalculatedFolderSpec mResponsiveFolderHeightSpec;
Thales Limaf8bfb032023-07-24 15:08:05 +0100126 private CalculatedHotseatSpec mResponsiveHotseatSpec;
Thales Limac98b7812023-04-14 15:04:23 +0100127
Tony Wickhamd6b40372015-09-23 18:37:57 -0700128 /**
129 * The maximum amount of left/right workspace padding as a percentage of the screen width.
130 * To be clear, this means that up to 7% of the screen width can be used as left padding, and
131 * 7% of the screen width can be used as right padding.
132 */
133 private static final float MAX_HORIZONTAL_PADDING_PERCENT = 0.14f;
Winson Chungb3800242013-10-24 11:01:54 -0700134
Jon Miranda3f9bab22017-07-28 14:50:17 -0700135 private static final float TALL_DEVICE_ASPECT_RATIO_THRESHOLD = 2.0f;
Jon Miranda80cddbc2021-07-22 13:51:16 -0700136 private static final float TALLER_DEVICE_ASPECT_RATIO_THRESHOLD = 2.15f;
Jon Miranda80dda302021-07-28 14:14:59 -0700137 private static final float TALL_DEVICE_EXTRA_SPACE_THRESHOLD_DP = 252;
138 private static final float TALL_DEVICE_MORE_EXTRA_SPACE_THRESHOLD_DP = 268;
Jon Miranda30d0aa22017-07-25 15:55:29 -0700139
Sunny Goyalc6205602015-05-21 20:46:33 -0700140 // Workspace
Thales Limad90faab2021-09-21 17:18:47 +0100141 public final int desiredWorkspaceHorizontalMarginOriginalPx;
142 public int desiredWorkspaceHorizontalMarginPx;
Alex Chau51da2192022-05-20 13:32:10 +0100143 public int gridVisualizationPaddingX;
144 public int gridVisualizationPaddingY;
Thales Lima78d00ad2021-09-30 11:29:06 +0100145 public Point cellLayoutBorderSpaceOriginalPx;
146 public Point cellLayoutBorderSpacePx;
Pat Manning08610ca2022-04-05 21:03:16 +0100147 public Rect cellLayoutPaddingPx = new Rect();
148
Sunny Goyalc6205602015-05-21 20:46:33 -0700149 public final int edgeMarginPx;
Alex Chau0c4e11b2022-07-08 18:41:36 +0100150 public final float workspaceContentScale;
Alex Chau906d8822022-05-23 10:42:25 +0100151 public final int workspaceSpringLoadedMinNextPageVisiblePx;
Sunny Goyalc6205602015-05-21 20:46:33 -0700152
Jon Miranda58561d42021-03-17 10:51:54 -0400153 private final int extraSpace;
Thales Lima171ee662022-11-22 15:52:49 +0000154 private int maxEmptySpace;
Jon Miranda228877d2021-02-09 11:05:00 -0500155 public int workspaceTopPadding;
156 public int workspaceBottomPadding;
157
Tony Wickham5edf9e22020-03-27 20:06:52 -0700158 // Workspace page indicator
159 public final int workspacePageIndicatorHeight;
160 private final int mWorkspacePageIndicatorOverlapWorkspace;
Winson1f064272016-07-18 17:18:02 -0700161
Sunny Goyalc6205602015-05-21 20:46:33 -0700162 // Workspace icons
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400163 public float iconScale;
Sunny Goyalc6205602015-05-21 20:46:33 -0700164 public int iconSizePx;
165 public int iconTextSizePx;
166 public int iconDrawablePaddingPx;
Thales Lima93ee8fc2023-06-05 17:07:11 +0100167 private final int mIconDrawablePaddingOriginalPx;
Thales Lima79456492023-05-23 11:32:22 +0100168 public boolean iconCenterVertically;
Winson Chungb3800242013-10-24 11:01:54 -0700169
Jon Mirandaab3c6812021-06-28 15:42:28 -0700170 public float cellScaleToFit;
Adam Cohen59400422014-03-05 18:07:04 -0800171 public int cellWidthPx;
172 public int cellHeightPx;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700173 public int workspaceCellPaddingXPx;
Adam Cohen59400422014-03-05 18:07:04 -0800174
Thales Lima79456492023-05-23 11:32:22 +0100175 public int cellYPaddingPx = -1;
Jon Mirandae126d722021-02-25 10:45:20 -0500176
Sunny Goyalc6205602015-05-21 20:46:33 -0700177 // Folder
Jon Mirandae126d722021-02-25 10:45:20 -0500178 public float folderLabelTextScale;
179 public int folderLabelTextSizePx;
Thales Limab35faed2022-09-05 16:30:01 -0300180 public int folderFooterHeightPx;
Sunny Goyalc6205602015-05-21 20:46:33 -0700181 public int folderIconSizePx;
Jon Miranda591e3602018-03-28 11:37:00 -0700182 public int folderIconOffsetYPx;
Jon Mirandabf7d8122016-11-03 15:29:29 -0700183
Jon Mirandae126d722021-02-25 10:45:20 -0500184 // Folder content
Jordan Silva637f4eb2023-06-13 11:21:53 +0100185 public Point folderCellLayoutBorderSpacePx;
Jon Mirandae126d722021-02-25 10:45:20 -0500186 public int folderContentPaddingLeftRight;
187 public int folderContentPaddingTop;
188
Jon Mirandabf7d8122016-11-03 15:29:29 -0700189 // Folder cell
Sunny Goyalc6205602015-05-21 20:46:33 -0700190 public int folderCellWidthPx;
191 public int folderCellHeightPx;
Jon Mirandabf7d8122016-11-03 15:29:29 -0700192
193 // Folder child
194 public int folderChildIconSizePx;
195 public int folderChildTextSizePx;
Sunny Goyalbaec6ff2016-09-14 11:26:21 -0700196 public int folderChildDrawablePaddingPx;
Winson Chungb3800242013-10-24 11:01:54 -0700197
Sunny Goyalc6205602015-05-21 20:46:33 -0700198 // Hotseat
Thales Lima9938c2f2022-07-25 14:38:16 +0100199 public int numShownHotseatIcons;
Sunny Goyalc6205602015-05-21 20:46:33 -0700200 public int hotseatCellHeightPx;
Pat Manning26f70f72022-07-07 13:50:39 +0100201 public final boolean areNavButtonsInline;
Jon Miranda18751b62017-07-31 17:25:27 -0700202 // In portrait: size = height, in landscape: size = width
203 public int hotseatBarSizePx;
Thales Limab8c05952022-05-23 16:58:38 +0100204 public int hotseatBarBottomSpacePx;
Pat Manning26f70f72022-07-07 13:50:39 +0100205 public int hotseatBarEndOffset;
Thales Limab8c05952022-05-23 16:58:38 +0100206 public int hotseatQsbSpace;
Pat Manningde25c0d2022-04-05 19:11:26 +0100207 public int springLoadedHotseatBarTopMarginPx;
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700208 // Start is the side next to the nav bar, end is the side next to the workspace
209 public final int hotseatBarSidePaddingStartPx;
210 public final int hotseatBarSidePaddingEndPx;
Alex Chau206ede92022-08-01 17:46:12 +0100211 public int hotseatQsbWidth; // only used when isQsbInline
Sunny Goyal57b22792021-05-25 14:35:01 -0700212 public final int hotseatQsbHeight;
Thales Limab8c05952022-05-23 16:58:38 +0100213 public final int hotseatQsbVisualHeight;
214 private final int hotseatQsbShadowHeight;
Thales Limadd027342022-01-07 12:54:37 +0000215 public int hotseatBorderSpace;
Thales Limaffc68b02023-01-09 16:20:23 +0000216 private final int mMinHotseatIconSpacePx;
217 private final int mMinHotseatQsbWidthPx;
218 private final int mMaxHotseatIconSpacePx;
Jon Mirandae17a9492023-03-08 16:42:20 -0800219 public final int inlineNavButtonsEndSpacingPx;
Adam Cohen2e6da152015-05-06 11:42:25 -0700220
Alex Chau3d2c0622022-09-01 21:28:14 +0100221 // Bottom sheets
222 public int bottomSheetTopPadding;
223 public int bottomSheetOpenDuration;
224 public int bottomSheetCloseDuration;
225 public float bottomSheetWorkspaceScale;
226 public float bottomSheetDepth;
227
Sunny Goyalc6205602015-05-21 20:46:33 -0700228 // All apps
Thales Lima85c942f2021-12-31 13:04:20 +0000229 public Point allAppsBorderSpacePx;
Alex Chaub8c22e12022-02-14 18:35:58 +0000230 public int allAppsShiftRange;
231 public int allAppsTopPadding;
Alex Chau3d2c0622022-09-01 21:28:14 +0100232 public int allAppsOpenDuration;
233 public int allAppsCloseDuration;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700234 public int allAppsCellHeightPx;
Samuel Fufaf1424a32019-10-04 15:15:19 -0700235 public int allAppsCellWidthPx;
Winson1f064272016-07-18 17:18:02 -0700236 public int allAppsIconSizePx;
237 public int allAppsIconDrawablePaddingPx;
sfufa@google.comde013292021-09-21 18:22:44 -0700238 public int allAppsLeftRightPadding;
Alex Chau27b39b92022-01-14 18:02:18 +0000239 public int allAppsLeftRightMargin;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700240 public final int numShownAllAppsColumns;
Winson1f064272016-07-18 17:18:02 -0700241 public float allAppsIconTextSizePx;
242
Zak Cohen334efeb2021-03-19 16:42:07 -0700243 // Overview
Zak Cohen334efeb2021-03-19 16:42:07 -0700244 public int overviewTaskMarginPx;
Alex Chaudedbc8a2021-03-17 16:53:26 +0000245 public int overviewTaskIconSizePx;
Alex Chauac9df382021-08-02 19:08:41 +0100246 public int overviewTaskIconDrawableSizePx;
247 public int overviewTaskIconDrawableSizeGridPx;
Alex Chaudedbc8a2021-03-17 16:53:26 +0000248 public int overviewTaskThumbnailTopMarginPx;
Alex Chau19c6eca2022-03-10 20:12:56 +0000249 public final int overviewActionsHeight;
Alex Chaua2fc7642022-04-21 14:20:23 +0100250 public final int overviewActionsTopMarginPx;
Alex Chau1bf0fe12021-11-30 15:32:45 +0000251 public final int overviewActionsButtonSpacing;
Alex Chau5fd9d492021-07-22 17:27:11 +0100252 public int overviewPageSpacing;
253 public int overviewRowSpacing;
Alex Chau56bd2572021-11-03 18:48:18 +0000254 public int overviewGridSideMargin;
Zak Cohen334efeb2021-03-19 16:42:07 -0700255
Jeremy Sim0ac47082022-10-10 13:59:40 -0700256 // Split staging
257 public int splitPlaceholderInset;
258
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800259 // Widgets
Sihua Mae04aa202022-07-18 12:43:56 -0700260 private final ViewScaleProvider mViewScaleProvider;
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800261
Sunny Goyal47328fd2016-05-25 18:56:41 -0700262 // Drop Target
263 public int dropTargetBarSizePx;
Pat Manningde25c0d2022-04-05 19:11:26 +0100264 public int dropTargetBarTopMarginPx;
265 public int dropTargetBarBottomMarginPx;
Alex Chaua02eddc2021-04-29 00:36:06 +0100266 public int dropTargetDragPaddingPx;
267 public int dropTargetTextSizePx;
Pat Manningde25c0d2022-04-05 19:11:26 +0100268 public int dropTargetHorizontalPaddingPx;
269 public int dropTargetVerticalPaddingPx;
270 public int dropTargetGapPx;
Alex Chau5b019302022-05-23 10:42:25 +0100271 public int dropTargetButtonWorkspaceEdgeGapPx;
Adam Cohen4ae96ce2014-08-29 15:05:48 -0700272
Winson1f064272016-07-18 17:18:02 -0700273 // Insets
Sunny Goyal07b69292018-01-08 14:19:34 -0800274 private final Rect mInsets = new Rect();
275 public final Rect workspacePadding = new Rect();
Sunny Goyal6c304b12023-04-10 12:03:04 -0700276 // Additional padding added to the widget inside its cellSpace. It is applied outside
277 // the widgetView, such that the actual view size is same as the widget size.
278 public final Rect widgetPadding = new Rect();
279
Jon Miranda0bd63d12019-03-06 17:29:29 -0800280 // When true, nav bar is on the left side of the screen.
Sunny Goyal59d086c2018-05-07 17:31:40 -0700281 private boolean mIsSeascape;
Winson1f064272016-07-18 17:18:02 -0700282
Tony Wickhamf34bee82018-12-03 18:11:39 -0800283 // Notification dots
Sunny Goyal65190ae2022-08-02 14:16:26 -0700284 public final DotRenderer mDotRendererWorkSpace;
285 public final DotRenderer mDotRendererAllApps;
Tony Wickham9a8d11f2017-01-11 09:53:12 -0800286
Pierre Barbier de Reuille578deba2021-09-24 13:47:44 +0100287 // Taskbar
Tony Wickham15883892021-02-12 11:24:40 -0800288 public boolean isTaskbarPresent;
Tony Wickham635e1802021-07-22 14:28:04 -1000289 // Whether Taskbar will inset the bottom of apps by taskbarSize.
290 public boolean isTaskbarPresentInApps;
Jon Miranda9c478b62023-03-23 21:38:49 -0700291 public final int taskbarHeight;
292 public final int stashedTaskbarHeight;
293 public final int taskbarBottomMargin;
294 public final int taskbarIconSize;
Jon Miranda04f05102023-04-04 12:16:31 -0700295 // If true, used to layout taskbar in 3 button navigation mode.
296 public final boolean startAlignTaskbar;
Thales Limae9566402023-08-30 16:35:12 +0100297 public final boolean isTransientTaskbar;
Tony Wickham15883892021-02-12 11:24:40 -0800298
Alex Chaua02eddc2021-04-29 00:36:06 +0100299 // DragController
300 public int flingToDeleteThresholdVelocity;
301
Vinit Nayak17c4b332021-08-05 12:54:58 -0700302 /** TODO: Once we fully migrate to staged split, remove "isMultiWindowMode" */
Sunny Goyal19ff7282021-04-22 10:12:54 -0700303 DeviceProfile(Context context, InvariantDeviceProfile inv, Info info, WindowBounds windowBounds,
Sunny Goyal65190ae2022-08-02 14:16:26 -0700304 SparseArray<DotRenderer> dotRendererCache, boolean isMultiWindowMode,
Alex Chauab800f72022-12-13 17:46:06 +0000305 boolean transposeLayoutWithOrientation, boolean isMultiDisplay, boolean isGestureMode,
Jon Miranda2b25ded2023-02-02 14:48:45 -0800306 @NonNull final ViewScaleProvider viewScaleProvider,
307 @NonNull final Consumer<DeviceProfile> dimensionOverrideProvider) {
Sunny Goyalfee35bb2015-05-11 11:38:19 -0700308
Adam Cohen2e6da152015-05-06 11:42:25 -0700309 this.inv = inv;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700310 this.isLandscape = windowBounds.isLandscape();
Sunny Goyald70e75a2018-02-22 10:07:32 -0800311 this.isMultiWindowMode = isMultiWindowMode;
Jon Mirandae126d722021-02-25 10:45:20 -0500312 this.transposeLayoutWithOrientation = transposeLayoutWithOrientation;
Alex Chauab800f72022-12-13 17:46:06 +0000313 this.isMultiDisplay = isMultiDisplay;
Alex Chau6ed408f2022-03-04 12:58:05 +0000314 this.isGestureMode = isGestureMode;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700315 windowX = windowBounds.bounds.left;
316 windowY = windowBounds.bounds.top;
Sunny Goyal187b16c2022-03-01 16:53:23 -0800317 this.rotationHint = windowBounds.rotationHint;
Alex Chaue0227552022-04-06 19:44:43 +0100318 mInsets.set(windowBounds.insets);
Winson Chungb3800242013-10-24 11:01:54 -0700319
Thales Limac98b7812023-04-14 15:04:23 +0100320 // TODO(b/241386436): shouldn't change any launcher behaviour
Thales Limaabfe3642023-05-24 18:08:53 +0100321 mIsResponsiveGrid = inv.workspaceSpecsId != INVALID_RESOURCE_HANDLE
Jordan Silva637f4eb2023-06-13 11:21:53 +0100322 && inv.allAppsSpecsId != INVALID_RESOURCE_HANDLE
Thales Limaf8bfb032023-07-24 15:08:05 +0100323 && inv.folderSpecsId != INVALID_RESOURCE_HANDLE
324 && inv.hotseatSpecsId != INVALID_RESOURCE_HANDLE;
Thales Limaec5abba2023-04-05 16:33:50 +0100325
Thales Lima79456492023-05-23 11:32:22 +0100326 mIsScalableGrid = inv.isScalable && !isVerticalBarLayout() && !isMultiWindowMode;
Alex Chaudfc8ddf2022-01-25 11:26:25 +0000327 // Determine device posture.
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700328 mInfo = info;
Alex Chau29983072021-11-19 15:14:20 +0000329 isTablet = info.isTablet(windowBounds);
Sunny Goyal19ff7282021-04-22 10:12:54 -0700330 isPhone = !isTablet;
Alex Chauab800f72022-12-13 17:46:06 +0000331 isTwoPanels = isTablet && isMultiDisplay;
Vinit Nayak58c27cc2022-02-16 17:42:21 -0800332 isTaskbarPresent = isTablet && ApiWrapper.TASKBAR_DRAWN_IN_PROCESS;
Adam Cohen2e6da152015-05-06 11:42:25 -0700333
Alex Chaudfc8ddf2022-01-25 11:26:25 +0000334 // Some more constants.
Alex Chau635b3ab2022-01-26 16:49:10 +0000335 context = getContext(context, info, isVerticalBarLayout() || (isTablet && isLandscape)
Brandon Dayauon07ca8842022-04-27 10:52:28 -0700336 ? Configuration.ORIENTATION_LANDSCAPE
337 : Configuration.ORIENTATION_PORTRAIT,
Alex Chaua6907dc2022-03-18 15:24:07 +0000338 windowBounds);
Sunny Goyal1890f672020-04-30 12:28:00 -0700339 final Resources res = context.getResources();
Alex Chaudfc8ddf2022-01-25 11:26:25 +0000340 mMetrics = res.getDisplayMetrics();
341
Thales Lima2759aa32023-06-05 16:25:45 +0100342 mIconSizeSteps = mIsResponsiveGrid ? new IconSizeSteps(res) : null;
343
Alex Chaudfc8ddf2022-01-25 11:26:25 +0000344 // Determine sizes.
345 widthPx = windowBounds.bounds.width();
346 heightPx = windowBounds.bounds.height();
347 availableWidthPx = windowBounds.availableSize.x;
Thales Limab8c05952022-05-23 16:58:38 +0100348 availableHeightPx = windowBounds.availableSize.y;
Alex Chaudfc8ddf2022-01-25 11:26:25 +0000349
350 aspectRatio = ((float) Math.max(widthPx, heightPx)) / Math.min(widthPx, heightPx);
Thales Lima83bedbf2021-10-05 17:47:39 +0100351 if (isTwoPanels) {
352 if (isLandscape) {
Thales Lima12d0eff2022-03-25 17:06:11 +0000353 mTypeIndex = INDEX_TWO_PANEL_LANDSCAPE;
Thales Lima83bedbf2021-10-05 17:47:39 +0100354 } else {
Thales Lima12d0eff2022-03-25 17:06:11 +0000355 mTypeIndex = INDEX_TWO_PANEL_PORTRAIT;
Thales Lima83bedbf2021-10-05 17:47:39 +0100356 }
357 } else {
358 if (isLandscape) {
Thales Lima12d0eff2022-03-25 17:06:11 +0000359 mTypeIndex = INDEX_LANDSCAPE;
Thales Lima83bedbf2021-10-05 17:47:39 +0100360 } else {
Thales Lima12d0eff2022-03-25 17:06:11 +0000361 mTypeIndex = INDEX_DEFAULT;
Thales Lima83bedbf2021-10-05 17:47:39 +0100362 }
363 }
364
Thales Limae9566402023-08-30 16:35:12 +0100365 isTransientTaskbar = DisplayController.isTransientTaskbar(context);
366 if (isTransientTaskbar) {
Jon Miranda9c478b62023-03-23 21:38:49 -0700367 float invTransientIconSizeDp = inv.transientTaskbarIconSize[mTypeIndex];
368 taskbarIconSize = pxFromDp(invTransientIconSizeDp, mMetrics);
Jon Miranda95f44722023-06-06 19:48:19 -0700369 taskbarHeight = Math.round((taskbarIconSize * ICON_VISIBLE_AREA_FACTOR)
370 + (2 * res.getDimensionPixelSize(R.dimen.transient_taskbar_padding)));
Jon Miranda9c478b62023-03-23 21:38:49 -0700371 stashedTaskbarHeight =
372 res.getDimensionPixelSize(R.dimen.transient_taskbar_stashed_height);
373 taskbarBottomMargin =
374 res.getDimensionPixelSize(R.dimen.transient_taskbar_bottom_margin);
Jon Miranda04f05102023-04-04 12:16:31 -0700375 startAlignTaskbar = false;
Jon Miranda9c478b62023-03-23 21:38:49 -0700376 } else {
377 taskbarIconSize = pxFromDp(ResourcesCompat.getFloat(res, R.dimen.taskbar_icon_size),
378 mMetrics);
379 taskbarHeight = res.getDimensionPixelSize(R.dimen.taskbar_size);
380 stashedTaskbarHeight = res.getDimensionPixelSize(R.dimen.taskbar_stashed_size);
381 taskbarBottomMargin = 0;
Jon Miranda04f05102023-04-04 12:16:31 -0700382 startAlignTaskbar = inv.startAlignTaskbar[mTypeIndex];
Tony Wickham15883892021-02-12 11:24:40 -0800383 }
Tony Wickham15883892021-02-12 11:24:40 -0800384
Winson Chungb3800242013-10-24 11:01:54 -0700385 edgeMarginPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_edge_margin);
Alex Chau0c4e11b2022-07-08 18:41:36 +0100386 workspaceContentScale = res.getFloat(R.dimen.workspace_content_scale);
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700387
Alex Chau51da2192022-05-20 13:32:10 +0100388 gridVisualizationPaddingX = res.getDimensionPixelSize(
389 R.dimen.grid_visualization_horizontal_cell_spacing);
390 gridVisualizationPaddingY = res.getDimensionPixelSize(
391 R.dimen.grid_visualization_vertical_cell_spacing);
Samuel Fufaee9aff92021-04-05 13:30:40 -0500392
Alex Chaue0227552022-04-06 19:44:43 +0100393 bottomSheetTopPadding = mInsets.top // statusbar height
Andras Kloczl142b0542022-03-09 21:26:02 +0000394 + res.getDimensionPixelSize(R.dimen.bottom_sheet_extra_top_padding)
395 + (isTablet ? 0 : edgeMarginPx); // phones need edgeMarginPx additional padding
Alex Chau3d2c0622022-09-01 21:28:14 +0100396 bottomSheetOpenDuration = res.getInteger(R.integer.config_bottomSheetOpenDuration);
397 bottomSheetCloseDuration = res.getInteger(R.integer.config_bottomSheetCloseDuration);
398 if (isTablet) {
399 bottomSheetWorkspaceScale = workspaceContentScale;
Alex Chauab800f72022-12-13 17:46:06 +0000400 if (isMultiDisplay && !ENABLE_MULTI_DISPLAY_PARTIAL_DEPTH.get()) {
401 // TODO(b/259893832): Revert to use maxWallpaperScale to calculate bottomSheetDepth
402 // when screen recorder bug is fixed.
403 bottomSheetDepth = 1f;
404 } else {
405 // The goal is to set wallpaper to zoom at workspaceContentScale when in AllApps.
406 // When depth is 0, wallpaper zoom is set to maxWallpaperScale.
407 // When depth is 1, wallpaper zoom is set to 1.
408 // For depth to achieve zoom set to maxWallpaperScale * workspaceContentScale:
409 float maxWallpaperScale = res.getFloat(R.dimen.config_wallpaperMaxScale);
410 bottomSheetDepth = Utilities.mapToRange(maxWallpaperScale * workspaceContentScale,
411 maxWallpaperScale, 1f, 0f, 1f, LINEAR);
412 }
Alex Chau3d2c0622022-09-01 21:28:14 +0100413 } else {
414 bottomSheetWorkspaceScale = 1f;
415 bottomSheetDepth = 0f;
416 }
Andras Kloczl142b0542022-03-09 21:26:02 +0000417
Jon Mirandae126d722021-02-25 10:45:20 -0500418 folderLabelTextScale = res.getFloat(R.dimen.folder_label_text_scale);
Thales Limab35faed2022-09-05 16:30:01 -0300419
Thales Lima79456492023-05-23 11:32:22 +0100420 if (mIsScalableGrid && inv.folderStyle != INVALID_RESOURCE_HANDLE) {
Thales Limab35faed2022-09-05 16:30:01 -0300421 TypedArray folderStyle = context.obtainStyledAttributes(inv.folderStyle,
Thales Limad852d652023-01-17 14:01:13 +0000422 R.styleable.FolderStyle);
Thales Limab35faed2022-09-05 16:30:01 -0300423 // These are re-set in #updateFolderCellSize if the grid is not scalable
424 folderCellHeightPx = folderStyle.getDimensionPixelSize(
Thales Limad852d652023-01-17 14:01:13 +0000425 R.styleable.FolderStyle_folderCellHeight, 0);
Thales Limab35faed2022-09-05 16:30:01 -0300426 folderCellWidthPx = folderStyle.getDimensionPixelSize(
Thales Limad852d652023-01-17 14:01:13 +0000427 R.styleable.FolderStyle_folderCellWidth, 0);
Thales Limab35faed2022-09-05 16:30:01 -0300428
429 folderContentPaddingTop = folderStyle.getDimensionPixelSize(
Thales Limad852d652023-01-17 14:01:13 +0000430 R.styleable.FolderStyle_folderTopPadding, 0);
Jordan Silva637f4eb2023-06-13 11:21:53 +0100431
432 int gutter = folderStyle.getDimensionPixelSize(
Thales Limad852d652023-01-17 14:01:13 +0000433 R.styleable.FolderStyle_folderBorderSpace, 0);
Jordan Silva637f4eb2023-06-13 11:21:53 +0100434 folderCellLayoutBorderSpacePx = new Point(gutter, gutter);
Thales Limab35faed2022-09-05 16:30:01 -0300435 folderFooterHeightPx = folderStyle.getDimensionPixelSize(
Thales Limad852d652023-01-17 14:01:13 +0000436 R.styleable.FolderStyle_folderFooterHeight, 0);
Thales Limab35faed2022-09-05 16:30:01 -0300437 folderStyle.recycle();
Jordan Silva637f4eb2023-06-13 11:21:53 +0100438 } else if (!mIsResponsiveGrid) {
439 folderCellLayoutBorderSpacePx = new Point(0, 0);
Thales Lima7eee74b2023-03-16 16:00:55 -0300440 folderFooterHeightPx = res.getDimensionPixelSize(R.dimen.folder_footer_height_default);
Thales Limab35faed2022-09-05 16:30:01 -0300441 folderContentPaddingTop = res.getDimensionPixelSize(R.dimen.folder_top_padding_default);
442 }
Jon Mirandae126d722021-02-25 10:45:20 -0500443
Thales Lima85c942f2021-12-31 13:04:20 +0000444 allAppsBorderSpacePx = new Point(
Thales Limabb7d3882021-12-22 12:56:29 +0000445 pxFromDp(inv.allAppsBorderSpaces[mTypeIndex].x, mMetrics),
446 pxFromDp(inv.allAppsBorderSpaces[mTypeIndex].y, mMetrics));
Thales Limae9273ea2023-01-26 12:33:52 +0000447 setupAllAppsStyle(context);
Jon Mirandae126d722021-02-25 10:45:20 -0500448
Tony Wickham5edf9e22020-03-27 20:06:52 -0700449 workspacePageIndicatorHeight = res.getDimensionPixelSize(
450 R.dimen.workspace_page_indicator_height);
451 mWorkspacePageIndicatorOverlapWorkspace =
452 res.getDimensionPixelSize(R.dimen.workspace_page_indicator_overlap_workspace);
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700453
Thales Limad852d652023-01-17 14:01:13 +0000454 TypedArray cellStyle;
455 if (inv.cellStyle != INVALID_RESOURCE_HANDLE) {
456 cellStyle = context.obtainStyledAttributes(inv.cellStyle,
457 R.styleable.CellStyle);
458 } else {
459 cellStyle = context.obtainStyledAttributes(R.style.CellStyleDefault,
460 R.styleable.CellStyle);
461 }
Thales Lima93ee8fc2023-06-05 17:07:11 +0100462 mIconDrawablePaddingOriginalPx = cellStyle.getDimensionPixelSize(
Thales Limad852d652023-01-17 14:01:13 +0000463 R.styleable.CellStyle_iconDrawablePadding, 0);
464 cellStyle.recycle();
Alex Chaua02eddc2021-04-29 00:36:06 +0100465
Sunny Goyal47328fd2016-05-25 18:56:41 -0700466 dropTargetBarSizePx = res.getDimensionPixelSize(R.dimen.dynamic_grid_drop_target_size);
Pat Manningde25c0d2022-04-05 19:11:26 +0100467 dropTargetBarTopMarginPx = res.getDimensionPixelSize(R.dimen.drop_target_top_margin);
468 dropTargetBarBottomMarginPx = res.getDimensionPixelSize(R.dimen.drop_target_bottom_margin);
Alex Chaua02eddc2021-04-29 00:36:06 +0100469 dropTargetDragPaddingPx = res.getDimensionPixelSize(R.dimen.drop_target_drag_padding);
470 dropTargetTextSizePx = res.getDimensionPixelSize(R.dimen.drop_target_text_size);
Pat Manningde25c0d2022-04-05 19:11:26 +0100471 dropTargetHorizontalPaddingPx = res.getDimensionPixelSize(
472 R.dimen.drop_target_button_drawable_horizontal_padding);
473 dropTargetVerticalPaddingPx = res.getDimensionPixelSize(
474 R.dimen.drop_target_button_drawable_vertical_padding);
475 dropTargetGapPx = res.getDimensionPixelSize(R.dimen.drop_target_button_gap);
Alex Chau5b019302022-05-23 10:42:25 +0100476 dropTargetButtonWorkspaceEdgeGapPx = res.getDimensionPixelSize(
477 R.dimen.drop_target_button_workspace_edge_gap);
Alex Chaua02eddc2021-04-29 00:36:06 +0100478
Alex Chau906d8822022-05-23 10:42:25 +0100479 workspaceSpringLoadedMinNextPageVisiblePx = res.getDimensionPixelSize(
480 R.dimen.dynamic_grid_spring_loaded_min_next_space_visible);
Sunny Goyald5190522017-04-24 03:06:54 -0700481
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700482 workspaceCellPaddingXPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_cell_padding_x);
Jon Miranda09660722017-06-14 14:20:14 -0700483
Thales Limaa1012902022-01-13 17:58:42 +0000484 hotseatQsbHeight = res.getDimensionPixelSize(R.dimen.qsb_widget_height);
Thales Limab8c05952022-05-23 16:58:38 +0100485 hotseatQsbShadowHeight = res.getDimensionPixelSize(R.dimen.qsb_shadow_height);
486 hotseatQsbVisualHeight = hotseatQsbHeight - 2 * hotseatQsbShadowHeight;
487
Thales Lima12d0eff2022-03-25 17:06:11 +0000488 // Whether QSB might be inline in appropriate orientation (e.g. landscape).
489 boolean canQsbInline = (isTwoPanels ? inv.inlineQsb[INDEX_TWO_PANEL_PORTRAIT]
490 || inv.inlineQsb[INDEX_TWO_PANEL_LANDSCAPE]
491 : inv.inlineQsb[INDEX_DEFAULT] || inv.inlineQsb[INDEX_LANDSCAPE])
492 && hotseatQsbHeight > 0;
Thales Lima79456492023-05-23 11:32:22 +0100493 isQsbInline = mIsScalableGrid && inv.inlineQsb[mTypeIndex] && canQsbInline;
Alex Chau6ed408f2022-03-04 12:58:05 +0000494
Thales Lima425f6822022-05-10 13:44:58 -0300495 areNavButtonsInline = isTaskbarPresent && !isGestureMode;
Thales Lima9938c2f2022-07-25 14:38:16 +0100496 numShownHotseatIcons =
497 isTwoPanels ? inv.numDatabaseHotseatIcons : inv.numShownHotseatIcons;
Alex Chau6ed408f2022-03-04 12:58:05 +0000498
Sunny Goyal19ff7282021-04-22 10:12:54 -0700499 numShownAllAppsColumns =
500 isTwoPanels ? inv.numDatabaseAllAppsColumns : inv.numAllAppsColumns;
Thales Limab8c05952022-05-23 16:58:38 +0100501
502 int hotseatBarBottomSpace = pxFromDp(inv.hotseatBarBottomSpace[mTypeIndex], mMetrics);
503 int minQsbMargin = res.getDimensionPixelSize(R.dimen.min_qsb_margin);
Thales Limaf8bfb032023-07-24 15:08:05 +0100504
505 if (mIsResponsiveGrid) {
506 HotseatSpecs hotseatSpecs =
507 HotseatSpecs.create(new ResourceHelper(context,
508 isTwoPanels ? inv.hotseatSpecsTwoPanelId : inv.hotseatSpecsId));
509 mResponsiveHotseatSpec = hotseatSpecs.getCalculatedHeightSpec(heightPx);
510 hotseatQsbSpace = mResponsiveHotseatSpec.getHotseatQsbSpace();
511 } else {
512 hotseatQsbSpace = pxFromDp(inv.hotseatQsbSpace[mTypeIndex], mMetrics);
513 }
514
Thales Limab8c05952022-05-23 16:58:38 +0100515 // Have a little space between the inset and the QSB
516 if (mInsets.bottom + minQsbMargin > hotseatBarBottomSpace) {
517 int availableSpace = hotseatQsbSpace - (mInsets.bottom - hotseatBarBottomSpace);
518
519 // Only change the spaces if there is space
520 if (availableSpace > 0) {
521 // Make sure there is enough space between hotseat/QSB and QSB/navBar
522 if (availableSpace < minQsbMargin * 2) {
523 minQsbMargin = availableSpace / 2;
524 hotseatQsbSpace = minQsbMargin;
525 } else {
526 hotseatQsbSpace -= minQsbMargin;
527 }
528 }
529 hotseatBarBottomSpacePx = mInsets.bottom + minQsbMargin;
530
Thales Limaa1012902022-01-13 17:58:42 +0000531 } else {
Thales Limab8c05952022-05-23 16:58:38 +0100532 hotseatBarBottomSpacePx = hotseatBarBottomSpace;
Thales Limaa1012902022-01-13 17:58:42 +0000533 }
Thales Lima425f6822022-05-10 13:44:58 -0300534
Pat Manningde25c0d2022-04-05 19:11:26 +0100535 springLoadedHotseatBarTopMarginPx = res.getDimensionPixelSize(
536 R.dimen.spring_loaded_hotseat_top_margin);
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700537 hotseatBarSidePaddingEndPx =
Sunny Goyal228153d2018-01-04 15:35:22 -0800538 res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_side_padding);
Jon Miranda3f411e72019-05-16 17:15:16 -0700539 // Add a bit of space between nav bar and hotseat in vertical bar layout.
Tony Wickham5edf9e22020-03-27 20:06:52 -0700540 hotseatBarSidePaddingStartPx = isVerticalBarLayout() ? workspacePageIndicatorHeight : 0;
Thales Limab8c05952022-05-23 16:58:38 +0100541 updateHotseatSizes(pxFromDp(inv.iconSize[INDEX_DEFAULT], mMetrics));
Vinit Nayak8a3d0552022-08-05 10:43:29 -0700542 if (areNavButtonsInline && !isPhone) {
Jon Mirandae17a9492023-03-08 16:42:20 -0800543 inlineNavButtonsEndSpacingPx =
Thales Limaffc68b02023-01-09 16:20:23 +0000544 res.getDimensionPixelSize(inv.inlineNavButtonsEndSpacing);
Pat Manning26f70f72022-07-07 13:50:39 +0100545 /*
546 * 3 nav buttons +
Vinit Nayakc7293172022-07-18 16:41:50 -0700547 * Spacing between nav buttons +
Thales Lima6a590062022-11-22 15:52:49 +0000548 * Space at the end for contextual buttons
Pat Manning26f70f72022-07-07 13:50:39 +0100549 */
550 hotseatBarEndOffset = 3 * res.getDimensionPixelSize(R.dimen.taskbar_nav_buttons_size)
Vinit Nayakc7293172022-07-18 16:41:50 -0700551 + 2 * res.getDimensionPixelSize(R.dimen.taskbar_button_space_inbetween)
Jon Mirandae17a9492023-03-08 16:42:20 -0800552 + inlineNavButtonsEndSpacingPx;
Pat Manning26f70f72022-07-07 13:50:39 +0100553 } else {
Jon Mirandae17a9492023-03-08 16:42:20 -0800554 inlineNavButtonsEndSpacingPx = 0;
Pat Manning26f70f72022-07-07 13:50:39 +0100555 hotseatBarEndOffset = 0;
556 }
Jon Miranda8bdb2222021-06-23 18:10:10 -0700557
Thales Lima79456492023-05-23 11:32:22 +0100558 // Needs to be calculated after hotseatBarSizePx is correct,
559 // for the available height to be correct
560 if (mIsResponsiveGrid) {
Jordan Silva8bd7af22023-06-21 15:35:03 +0100561 WorkspaceSpecs workspaceSpecs = WorkspaceSpecs.create(
Jordan Silva575c3bd2023-07-21 12:00:43 +0100562 new ResourceHelper(context,
563 isTwoPanels ? inv.workspaceSpecsTwoPanelId : inv.workspaceSpecsId));
Thales Lima2759aa32023-06-05 16:25:45 +0100564 int availableResponsiveWidth =
565 availableWidthPx - (isVerticalBarLayout() ? hotseatBarSizePx : 0);
Jordan Silvac118fb52023-06-22 11:42:01 +0100566 int numColumns = getPanelCount() * inv.numColumns;
Thales Lima2759aa32023-06-05 16:25:45 +0100567 // don't use availableHeightPx because it subtracts bottom padding,
568 // but the workspace go behind it
569 int availableResponsiveHeight =
570 heightPx - mInsets.top - (isVerticalBarLayout() ? 0 : hotseatBarSizePx);
Jordan Silvac118fb52023-06-22 11:42:01 +0100571 mResponsiveWidthSpec = workspaceSpecs.getCalculatedWidthSpec(numColumns,
Thales Lima2759aa32023-06-05 16:25:45 +0100572 availableResponsiveWidth);
Jordan Silva8bd7af22023-06-21 15:35:03 +0100573 mResponsiveHeightSpec = workspaceSpecs.getCalculatedHeightSpec(inv.numRows,
Thales Lima2759aa32023-06-05 16:25:45 +0100574 availableResponsiveHeight);
Thales Limaabfe3642023-05-24 18:08:53 +0100575
Jordan Silva8bd7af22023-06-21 15:35:03 +0100576 AllAppsSpecs allAppsSpecs = AllAppsSpecs.create(
Jordan Silva575c3bd2023-07-21 12:00:43 +0100577 new ResourceHelper(context,
578 isTwoPanels ? inv.allAppsSpecsTwoPanelId : inv.allAppsSpecsId));
Jordan Silvac118fb52023-06-22 11:42:01 +0100579 mAllAppsResponsiveWidthSpec = allAppsSpecs.getCalculatedWidthSpec(numColumns,
Thales Limaabfe3642023-05-24 18:08:53 +0100580 mResponsiveWidthSpec.getAvailableSpace(), mResponsiveWidthSpec);
Jordan Silva8bd7af22023-06-21 15:35:03 +0100581 mAllAppsResponsiveHeightSpec = allAppsSpecs.getCalculatedHeightSpec(inv.numRows,
582 mResponsiveHeightSpec.getAvailableSpace(), mResponsiveHeightSpec);
Jordan Silva637f4eb2023-06-13 11:21:53 +0100583
Jordan Silva8bd7af22023-06-21 15:35:03 +0100584 FolderSpecs folderSpecs = FolderSpecs.create(
Jordan Silva575c3bd2023-07-21 12:00:43 +0100585 new ResourceHelper(context,
586 isTwoPanels ? inv.folderSpecsTwoPanelId : inv.folderSpecsId));
Jordan Silva8bd7af22023-06-21 15:35:03 +0100587 mResponsiveFolderWidthSpec = folderSpecs.getCalculatedWidthSpec(inv.numFolderColumns,
Jordan Silva637f4eb2023-06-13 11:21:53 +0100588 mResponsiveWidthSpec.getAvailableSpace(), mResponsiveWidthSpec);
Jordan Silva8bd7af22023-06-21 15:35:03 +0100589 mResponsiveFolderHeightSpec = folderSpecs.getCalculatedHeightSpec(inv.numFolderRows,
Jordan Silva637f4eb2023-06-13 11:21:53 +0100590 mResponsiveHeightSpec.getAvailableSpace(), mResponsiveHeightSpec);
Thales Lima79456492023-05-23 11:32:22 +0100591 }
592
593 desiredWorkspaceHorizontalMarginPx = getHorizontalMarginPx(inv, res);
594 desiredWorkspaceHorizontalMarginOriginalPx = desiredWorkspaceHorizontalMarginPx;
595
Alex Chau635b3ab2022-01-26 16:49:10 +0000596 overviewTaskMarginPx = res.getDimensionPixelSize(R.dimen.overview_task_margin);
Alex Chau5fd9d492021-07-22 17:27:11 +0100597 overviewTaskIconSizePx = res.getDimensionPixelSize(R.dimen.task_thumbnail_icon_size);
Alex Chauac9df382021-08-02 19:08:41 +0100598 overviewTaskIconDrawableSizePx =
599 res.getDimensionPixelSize(R.dimen.task_thumbnail_icon_drawable_size);
600 overviewTaskIconDrawableSizeGridPx =
601 res.getDimensionPixelSize(R.dimen.task_thumbnail_icon_drawable_size_grid);
Jeremy Sim1cfe6d42022-07-15 14:40:38 -0700602 overviewTaskThumbnailTopMarginPx = overviewTaskIconSizePx + overviewTaskMarginPx;
Andy Wickhambc3bac42023-08-07 16:02:23 -0700603 // Don't add margin with floating search bar to minimize risk of overlapping.
604 overviewActionsTopMarginPx = FeatureFlags.ENABLE_FLOATING_SEARCH_BAR.get() ? 0
605 : res.getDimensionPixelSize(R.dimen.overview_actions_top_margin);
Alex Chau635b3ab2022-01-26 16:49:10 +0000606 overviewPageSpacing = res.getDimensionPixelSize(R.dimen.overview_page_spacing);
607 overviewActionsButtonSpacing = res.getDimensionPixelSize(
608 R.dimen.overview_actions_button_spacing);
Andy Wickhambc3bac42023-08-07 16:02:23 -0700609 overviewActionsHeight = res.getDimensionPixelSize(R.dimen.overview_actions_height);
Jeremy Sim1cfe6d42022-07-15 14:40:38 -0700610 overviewRowSpacing = res.getDimensionPixelSize(R.dimen.overview_grid_row_spacing);
Alex Chau635b3ab2022-01-26 16:49:10 +0000611 overviewGridSideMargin = res.getDimensionPixelSize(R.dimen.overview_grid_side_margin);
Zak Cohen334efeb2021-03-19 16:42:07 -0700612
Jeremy Sim0ac47082022-10-10 13:59:40 -0700613 splitPlaceholderInset = res.getDimensionPixelSize(R.dimen.split_placeholder_inset);
614
Jon Miranda2ed276e2017-06-29 11:36:34 -0700615 // Calculate all of the remaining variables.
Jon Miranda58561d42021-03-17 10:51:54 -0400616 extraSpace = updateAvailableDimensions(res);
Jon Miranda80cddbc2021-07-22 13:51:16 -0700617
Thales Lima79456492023-05-23 11:32:22 +0100618 calculateAndSetWorkspaceVerticalPadding(context, inv, extraSpace);
Pat Manning08610ca2022-04-05 21:03:16 +0100619
620 int cellLayoutPadding =
621 isTwoPanels ? cellLayoutBorderSpacePx.x / 2 : res.getDimensionPixelSize(
622 R.dimen.cell_layout_padding);
623 cellLayoutPaddingPx = new Rect(cellLayoutPadding, cellLayoutPadding, cellLayoutPadding,
624 cellLayoutPadding);
Sunny Goyal07b69292018-01-08 14:19:34 -0800625 updateWorkspacePadding();
Tony Wickham1237df02017-02-24 08:59:36 -0800626
Thales Lima7eee74b2023-03-16 16:00:55 -0300627 // Folder scaling requires correct workspace paddings
628 updateAvailableFolderCellDimensions(res);
629
Thales Limaffc68b02023-01-09 16:20:23 +0000630 mMinHotseatIconSpacePx = res.getDimensionPixelSize(R.dimen.min_hotseat_icon_space);
631 mMinHotseatQsbWidthPx = res.getDimensionPixelSize(R.dimen.min_hotseat_qsb_width);
632 mMaxHotseatIconSpacePx = areNavButtonsInline
Thales Lima6a590062022-11-22 15:52:49 +0000633 ? res.getDimensionPixelSize(R.dimen.max_hotseat_icon_space) : Integer.MAX_VALUE;
Thales Lima425f6822022-05-10 13:44:58 -0300634 // Hotseat and QSB width depends on updated cellSize and workspace padding
Thales Lima6a590062022-11-22 15:52:49 +0000635 recalculateHotseatWidthAndBorderSpace();
Alex Chau206ede92022-08-01 17:46:12 +0100636
Jordan Silva3646a1b2023-08-02 13:52:52 +0100637 if (mIsResponsiveGrid && isVerticalBarLayout()) {
638 hotseatBorderSpace = cellLayoutBorderSpacePx.y;
639 }
640
Alex Chau206ede92022-08-01 17:46:12 +0100641 // AllApps height calculation depends on updated cellSize
642 if (isTablet) {
643 int collapseHandleHeight =
644 res.getDimensionPixelOffset(R.dimen.bottom_sheet_handle_area_height);
645 int contentHeight = heightPx - collapseHandleHeight - hotseatQsbHeight;
646 int targetContentHeight = (int) (allAppsCellHeightPx * ALL_APPS_TABLET_MAX_ROWS);
647 allAppsTopPadding = Math.max(mInsets.top, contentHeight - targetContentHeight);
648 allAppsShiftRange = heightPx - allAppsTopPadding;
649 } else {
650 allAppsTopPadding = 0;
651 allAppsShiftRange =
652 res.getDimensionPixelSize(R.dimen.all_apps_starting_vertical_translate);
653 }
Alex Chau3d2c0622022-09-01 21:28:14 +0100654 allAppsOpenDuration = res.getInteger(R.integer.config_allAppsOpenDuration);
655 allAppsCloseDuration = res.getInteger(R.integer.config_allAppsCloseDuration);
Thales Lima425f6822022-05-10 13:44:58 -0300656
Alex Chaua02eddc2021-04-29 00:36:06 +0100657 flingToDeleteThresholdVelocity = res.getDimensionPixelSize(
658 R.dimen.drag_flingToDeleteMinVelocity);
659
Sihua Mae04aa202022-07-18 12:43:56 -0700660 mViewScaleProvider = viewScaleProvider;
661
Jon Miranda2b25ded2023-02-02 14:48:45 -0800662 dimensionOverrideProvider.accept(this);
663
Tony Wickham1237df02017-02-24 08:59:36 -0800664 // This is done last, after iconSizePx is calculated above.
Sunny Goyal799e1202023-02-09 10:54:28 -0800665 mDotRendererWorkSpace = createDotRenderer(context, iconSizePx, dotRendererCache);
666 mDotRendererAllApps = createDotRenderer(context, allAppsIconSizePx, dotRendererCache);
Sunny Goyal65190ae2022-08-02 14:16:26 -0700667 }
668
669 private static DotRenderer createDotRenderer(
Sunny Goyal799e1202023-02-09 10:54:28 -0800670 @NonNull Context context, int size, @NonNull SparseArray<DotRenderer> cache) {
Sunny Goyal65190ae2022-08-02 14:16:26 -0700671 DotRenderer renderer = cache.get(size);
672 if (renderer == null) {
Sunny Goyal799e1202023-02-09 10:54:28 -0800673 renderer = new DotRenderer(size, getShapePath(context, DEFAULT_DOT_SIZE),
674 DEFAULT_DOT_SIZE);
Sunny Goyal65190ae2022-08-02 14:16:26 -0700675 cache.put(size, renderer);
676 }
677 return renderer;
Adam Cohen63f1ec02014-08-12 09:23:13 -0700678 }
679
Thales Lima425f6822022-05-10 13:44:58 -0300680 /**
681 * QSB width is always calculated because when in 3 button nav the width doesn't follow the
682 * width of the hotseat.
683 */
Thales Lima9938c2f2022-07-25 14:38:16 +0100684 private int calculateQsbWidth(int hotseatBorderSpace) {
Thales Lima425f6822022-05-10 13:44:58 -0300685 if (isQsbInline) {
Alex Chau906d8822022-05-23 10:42:25 +0100686 int columns = getPanelCount() * inv.numColumns;
Thales Lima425f6822022-05-10 13:44:58 -0300687 return getIconToIconWidthForColumns(columns)
688 - iconSizePx * numShownHotseatIcons
689 - hotseatBorderSpace * numShownHotseatIcons;
690 } else {
691 int columns = inv.hotseatColumnSpan[mTypeIndex];
692 return getIconToIconWidthForColumns(columns);
693 }
694 }
Thales Lima2903a622022-03-17 13:52:19 +0000695
Thales Lima425f6822022-05-10 13:44:58 -0300696 private int getIconToIconWidthForColumns(int columns) {
697 return columns * getCellSize().x
698 + (columns - 1) * cellLayoutBorderSpacePx.x
Thales Lima1e8b45f2022-08-25 11:50:59 -0400699 - getCellHorizontalSpace();
Thales Limaa1012902022-01-13 17:58:42 +0000700 }
701
Thales Limad90faab2021-09-21 17:18:47 +0100702 private int getHorizontalMarginPx(InvariantDeviceProfile idp, Resources res) {
Thales Lima79456492023-05-23 11:32:22 +0100703 if (mIsResponsiveGrid) {
704 return mResponsiveWidthSpec.getStartPaddingPx();
705 }
706
Thales Limad90faab2021-09-21 17:18:47 +0100707 if (isVerticalBarLayout()) {
708 return 0;
709 }
710
Thales Lima79456492023-05-23 11:32:22 +0100711 return mIsScalableGrid
Thales Lima83bedbf2021-10-05 17:47:39 +0100712 ? pxFromDp(idp.horizontalMargin[mTypeIndex], mMetrics)
713 : res.getDimensionPixelSize(R.dimen.dynamic_grid_left_right_margin);
Thales Limad90faab2021-09-21 17:18:47 +0100714 }
715
Thales Lima79456492023-05-23 11:32:22 +0100716 private void calculateAndSetWorkspaceVerticalPadding(Context context,
717 InvariantDeviceProfile inv,
718 int extraSpace) {
719 if (mIsResponsiveGrid) {
720 workspaceTopPadding = mResponsiveHeightSpec.getStartPaddingPx();
721 workspaceBottomPadding = mResponsiveHeightSpec.getEndPaddingPx();
722 } else if (mIsScalableGrid && inv.devicePaddingId != INVALID_RESOURCE_HANDLE) {
723 // Paddings were created assuming no scaling, so we first unscale the extra space.
724 int unscaledExtraSpace = (int) (extraSpace / cellScaleToFit);
725 DevicePaddings devicePaddings = new DevicePaddings(context, inv.devicePaddingId);
726 DevicePadding padding = devicePaddings.getDevicePadding(unscaledExtraSpace);
727 maxEmptySpace = padding.getMaxEmptySpacePx();
728
729 int paddingWorkspaceTop = padding.getWorkspaceTopPadding(unscaledExtraSpace);
730 int paddingWorkspaceBottom = padding.getWorkspaceBottomPadding(unscaledExtraSpace);
731
732 workspaceTopPadding = Math.round(paddingWorkspaceTop * cellScaleToFit);
733 workspaceBottomPadding = Math.round(paddingWorkspaceBottom * cellScaleToFit);
734 }
735 }
736
Thales Limab8c05952022-05-23 16:58:38 +0100737 /** Updates hotseatCellHeightPx and hotseatBarSizePx */
738 private void updateHotseatSizes(int hotseatIconSizePx) {
Jon Miranda92c1b5d2021-07-20 13:57:16 -0700739 // Ensure there is enough space for folder icons, which have a slightly larger radius.
Jordan Silva3646a1b2023-08-02 13:52:52 +0100740 hotseatCellHeightPx = getIconSizeWithOverlap(hotseatIconSizePx);
Thales Limab8c05952022-05-23 16:58:38 +0100741
Jon Miranda0d284852021-06-22 14:50:55 -0700742 if (isVerticalBarLayout()) {
743 hotseatBarSizePx = hotseatIconSizePx + hotseatBarSidePaddingStartPx
744 + hotseatBarSidePaddingEndPx;
Thales Limab8c05952022-05-23 16:58:38 +0100745 } else if (isQsbInline) {
746 hotseatBarSizePx = Math.max(hotseatIconSizePx, hotseatQsbVisualHeight)
747 + hotseatBarBottomSpacePx;
Jon Miranda0d284852021-06-22 14:50:55 -0700748 } else {
Thales Limab8c05952022-05-23 16:58:38 +0100749 hotseatBarSizePx = hotseatIconSizePx
750 + hotseatQsbSpace
751 + hotseatQsbVisualHeight
752 + hotseatBarBottomSpacePx;
Jon Miranda0d284852021-06-22 14:50:55 -0700753 }
754 }
755
Thales Lima6a590062022-11-22 15:52:49 +0000756 /**
757 * Calculates the width of the hotseat, changing spaces between the icons and removing icons if
758 * necessary.
759 */
760 public void recalculateHotseatWidthAndBorderSpace() {
Thales Lima79456492023-05-23 11:32:22 +0100761 if (!mIsScalableGrid) return;
Thales Lima6a590062022-11-22 15:52:49 +0000762
763 int columns = inv.hotseatColumnSpan[mTypeIndex];
764 float hotseatWidthPx = getIconToIconWidthForColumns(columns);
765 hotseatBorderSpace = calculateHotseatBorderSpace(hotseatWidthPx, /* numExtraBorder= */ 0);
Thales Lima9938c2f2022-07-25 14:38:16 +0100766 hotseatQsbWidth = calculateQsbWidth(hotseatBorderSpace);
Thales Lima6a590062022-11-22 15:52:49 +0000767 // Spaces should be correct when the nav buttons are not inline
Thales Lima9938c2f2022-07-25 14:38:16 +0100768 if (!areNavButtonsInline) {
769 return;
770 }
771
Thales Lima6a590062022-11-22 15:52:49 +0000772 // The side space with inline buttons should be what is defined in InvariantDeviceProfile
Jon Mirandae17a9492023-03-08 16:42:20 -0800773 int sideSpacePx = inlineNavButtonsEndSpacingPx;
Thales Limaffc68b02023-01-09 16:20:23 +0000774 int maxHotseatWidthPx = availableWidthPx - sideSpacePx - hotseatBarEndOffset;
775 int maxHotseatIconsWidthPx = maxHotseatWidthPx - (isQsbInline ? hotseatQsbWidth : 0);
776 hotseatBorderSpace = calculateHotseatBorderSpace(maxHotseatIconsWidthPx,
Thales Lima6a590062022-11-22 15:52:49 +0000777 (isQsbInline ? 1 : 0) + /* border between nav buttons and first icon */ 1);
Thales Lima9938c2f2022-07-25 14:38:16 +0100778
Thales Limaffc68b02023-01-09 16:20:23 +0000779 if (hotseatBorderSpace >= mMinHotseatIconSpacePx) {
Thales Lima9938c2f2022-07-25 14:38:16 +0100780 return;
781 }
782
783 // Border space can't be less than the minimum
Thales Limaffc68b02023-01-09 16:20:23 +0000784 hotseatBorderSpace = mMinHotseatIconSpacePx;
Thales Lima6a590062022-11-22 15:52:49 +0000785 int requiredWidth = getHotseatRequiredWidth();
Thales Lima9938c2f2022-07-25 14:38:16 +0100786
787 // If there is an inline qsb, change its size
788 if (isQsbInline) {
Thales Limaffc68b02023-01-09 16:20:23 +0000789 hotseatQsbWidth -= requiredWidth - maxHotseatWidthPx;
790 if (hotseatQsbWidth >= mMinHotseatQsbWidthPx) {
Thales Lima9938c2f2022-07-25 14:38:16 +0100791 return;
792 }
793
794 // QSB can't be less than the minimum
Thales Limaffc68b02023-01-09 16:20:23 +0000795 hotseatQsbWidth = mMinHotseatQsbWidthPx;
Thales Lima9938c2f2022-07-25 14:38:16 +0100796 }
797
Thales Limaffc68b02023-01-09 16:20:23 +0000798 maxHotseatIconsWidthPx = maxHotseatWidthPx - (isQsbInline ? hotseatQsbWidth : 0);
Thales Lima6a590062022-11-22 15:52:49 +0000799
Thales Lima9938c2f2022-07-25 14:38:16 +0100800 // If it still doesn't fit, start removing icons
801 do {
802 numShownHotseatIcons--;
Thales Limaffc68b02023-01-09 16:20:23 +0000803 hotseatBorderSpace = calculateHotseatBorderSpace(maxHotseatIconsWidthPx,
Thales Lima6a590062022-11-22 15:52:49 +0000804 (isQsbInline ? 1 : 0) + /* border between nav buttons and first icon */ 1);
Thales Limaffc68b02023-01-09 16:20:23 +0000805 } while (hotseatBorderSpace < mMinHotseatIconSpacePx && numShownHotseatIcons > 1);
Thales Lima9938c2f2022-07-25 14:38:16 +0100806 }
807
Thales Lima78d00ad2021-09-30 11:29:06 +0100808 private Point getCellLayoutBorderSpace(InvariantDeviceProfile idp) {
Thales Lima080d8902022-03-28 15:30:29 +0100809 return getCellLayoutBorderSpace(idp, 1f);
Thales Lima080d8902022-03-28 15:30:29 +0100810 }
811
812 private Point getCellLayoutBorderSpace(InvariantDeviceProfile idp, float scale) {
Thales Lima79456492023-05-23 11:32:22 +0100813 int horizontalSpacePx = 0;
814 int verticalSpacePx = 0;
Thales Lima78d00ad2021-09-30 11:29:06 +0100815
Thales Lima79456492023-05-23 11:32:22 +0100816 if (mIsResponsiveGrid) {
817 horizontalSpacePx = mResponsiveWidthSpec.getGutterPx();
818 verticalSpacePx = mResponsiveHeightSpec.getGutterPx();
819 } else if (mIsScalableGrid) {
820 horizontalSpacePx = pxFromDp(idp.borderSpaces[mTypeIndex].x, mMetrics, scale);
821 verticalSpacePx = pxFromDp(idp.borderSpaces[mTypeIndex].y, mMetrics, scale);
822 }
Thales Lima78d00ad2021-09-30 11:29:06 +0100823
824 return new Point(horizontalSpacePx, verticalSpacePx);
825 }
826
Sunny Goyal69a8eec2021-07-22 10:02:50 -0700827 public Info getDisplayInfo() {
828 return mInfo;
829 }
830
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700831 public Builder toBuilder(Context context) {
Sunny Goyal187b16c2022-03-01 16:53:23 -0800832 WindowBounds bounds = new WindowBounds(
833 widthPx, heightPx, availableWidthPx, availableHeightPx, rotationHint);
Sunny Goyal19ff7282021-04-22 10:12:54 -0700834 bounds.bounds.offsetTo(windowX, windowY);
Alex Chaue0227552022-04-06 19:44:43 +0100835 bounds.insets.set(mInsets);
Sunny Goyal65190ae2022-08-02 14:16:26 -0700836
837 SparseArray<DotRenderer> dotRendererCache = new SparseArray<>();
838 dotRendererCache.put(iconSizePx, mDotRendererWorkSpace);
839 dotRendererCache.put(allAppsIconSizePx, mDotRendererAllApps);
840
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700841 return new Builder(context, inv, mInfo)
Sunny Goyal19ff7282021-04-22 10:12:54 -0700842 .setWindowBounds(bounds)
Alex Chauab800f72022-12-13 17:46:06 +0000843 .setIsMultiDisplay(isMultiDisplay)
Alex Chau6ed408f2022-03-04 12:58:05 +0000844 .setMultiWindowMode(isMultiWindowMode)
Sunny Goyal65190ae2022-08-02 14:16:26 -0700845 .setDotRendererCache(dotRendererCache)
Alex Chau6ed408f2022-03-04 12:58:05 +0000846 .setGestureMode(isGestureMode);
Sunny Goyal1a52ef52018-01-11 10:15:03 -0800847 }
848
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700849 public DeviceProfile copy(Context context) {
850 return toBuilder(context).build();
851 }
852
853 /**
854 * TODO: Move this to the builder as part of setMultiWindowMode
855 */
Sunny Goyalb46703d2020-05-27 17:52:03 -0700856 public DeviceProfile getMultiWindowProfile(Context context, WindowBounds windowBounds) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700857 DeviceProfile profile = toBuilder(context)
Sunny Goyal19ff7282021-04-22 10:12:54 -0700858 .setWindowBounds(windowBounds)
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700859 .setMultiWindowMode(true)
860 .build();
Jon Miranda93e1f042016-11-11 14:13:04 -0800861
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800862 // We use these scales to measure and layout the widgets using their full invariant profile
863 // sizes and then draw them scaled and centered to fit in their multi-window mode cellspans.
864 float appWidgetScaleX = (float) profile.getCellSize().x / getCellSize().x;
865 float appWidgetScaleY = (float) profile.getCellSize().y / getCellSize().y;
Sihua Mae04aa202022-07-18 12:43:56 -0700866 if (appWidgetScaleX != 1 || appWidgetScaleY != 1) {
867 final PointF p = new PointF(appWidgetScaleX, appWidgetScaleY);
868 profile = profile.toBuilder(context)
869 .setViewScaleProvider(i -> p)
870 .build();
871 }
872
873 profile.hideWorkspaceLabelsIfNotEnoughSpace();
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800874
Jon Miranda93e1f042016-11-11 14:13:04 -0800875 return profile;
Jon Mirandacc42c5b2016-10-27 17:15:27 -0700876 }
877
Adam Cohen63f1ec02014-08-12 09:23:13 -0700878 /**
Jon Miranda941375e2021-03-31 13:10:45 -0400879 * Checks if there is enough space for labels on the workspace.
880 * If there is not, labels on the Workspace are hidden.
Jon Miranda1091e532017-07-21 13:31:50 -0700881 * It is important to call this method after the All Apps variables have been set.
882 */
Jon Miranda941375e2021-03-31 13:10:45 -0400883 private void hideWorkspaceLabelsIfNotEnoughSpace() {
884 float iconTextHeight = Utilities.calculateTextHeight(iconTextSizePx);
885 float workspaceCellPaddingY = getCellSize().y - iconSizePx - iconDrawablePaddingPx
886 - iconTextHeight;
887
Jordan Silva3646a1b2023-08-02 13:52:52 +0100888 if (mIsResponsiveGrid) {
889 // Hide text only if doesn't fit inside the cell for responsive grid
890 if (workspaceCellPaddingY < 0) {
891 iconTextSizePx = 0;
892 iconDrawablePaddingPx = 0;
893 int iconSizeWithOverlap = getIconSizeWithOverlap(iconSizePx);
894 cellYPaddingPx = Math.max(0, getCellSize().y - iconSizeWithOverlap) / 2;
895 autoResizeAllAppsCells();
896 }
897
898 return;
899 }
900
Jon Miranda941375e2021-03-31 13:10:45 -0400901 // We want enough space so that the text is closer to its corresponding icon.
902 if (workspaceCellPaddingY < iconTextHeight) {
903 iconTextSizePx = 0;
904 iconDrawablePaddingPx = 0;
Jordan Silva3646a1b2023-08-02 13:52:52 +0100905 cellHeightPx = getIconSizeWithOverlap(iconSizePx);
Jon Miranda941375e2021-03-31 13:10:45 -0400906 autoResizeAllAppsCells();
907 }
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700908 }
Jon Miranda1091e532017-07-21 13:31:50 -0700909
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700910 /**
Jon Miranda228877d2021-02-09 11:05:00 -0500911 * Returns the amount of extra (or unused) vertical space.
912 */
913 private int updateAvailableDimensions(Resources res) {
Alex Chaua68164d2022-12-15 16:16:03 +0000914 float invIconSizeDp = inv.iconSize[mTypeIndex];
915 float invIconTextSizeSp = inv.iconTextSize[mTypeIndex];
916 iconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mMetrics));
917 iconTextSizePx = pxFromSp(invIconTextSizeSp, mMetrics);
Thales Lima79456492023-05-23 11:32:22 +0100918 iconCenterVertically = mIsScalableGrid || mIsResponsiveGrid;
Alex Chaua68164d2022-12-15 16:16:03 +0000919
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700920 updateIconSize(1f, res);
Pat Manning08610ca2022-04-05 21:03:16 +0100921 updateWorkspacePadding();
Jon Mirandae126d722021-02-25 10:45:20 -0500922
Alex Chau5225e832023-08-01 16:32:15 +0100923 if (mIsResponsiveGrid) {
924 return 0;
925 }
926
Jon Mirandae126d722021-02-25 10:45:20 -0500927 // Check to see if the icons fit within the available height.
Pat Manninga2e14992022-04-22 11:29:17 +0100928 float usedHeight = getCellLayoutHeightSpecification();
Pat Manning25d53342022-05-10 09:58:49 +0000929 final int maxHeight = getCellLayoutHeight();
Jon Miranda228877d2021-02-09 11:05:00 -0500930 float extraHeight = Math.max(0, maxHeight - usedHeight);
Jon Mirandae126d722021-02-25 10:45:20 -0500931 float scaleY = maxHeight / usedHeight;
932 boolean shouldScale = scaleY < 1f;
933
934 float scaleX = 1f;
Thales Lima79456492023-05-23 11:32:22 +0100935 if (mIsScalableGrid) {
Jon Mirandae126d722021-02-25 10:45:20 -0500936 // We scale to fit the cellWidth and cellHeight in the available space.
937 // The benefit of scalable grids is that we can get consistent aspect ratios between
938 // devices.
Pat Manninga2e14992022-04-22 11:29:17 +0100939 float usedWidth =
940 getCellLayoutWidthSpecification() + (desiredWorkspaceHorizontalMarginPx * 2);
Jon Mirandae126d722021-02-25 10:45:20 -0500941 // We do not subtract padding here, as we also scale the workspace padding if needed.
942 scaleX = availableWidthPx / usedWidth;
943 shouldScale = true;
Winson Chungb3800242013-10-24 11:01:54 -0700944 }
Jon Mirandae126d722021-02-25 10:45:20 -0500945
946 if (shouldScale) {
947 float scale = Math.min(scaleX, scaleY);
948 updateIconSize(scale, res);
Pat Manninga2e14992022-04-22 11:29:17 +0100949 extraHeight = Math.max(0, maxHeight - getCellLayoutHeightSpecification());
Jon Mirandae126d722021-02-25 10:45:20 -0500950 }
951
Jon Miranda228877d2021-02-09 11:05:00 -0500952 return Math.round(extraHeight);
Winson Chungb3800242013-10-24 11:01:54 -0700953 }
954
Pat Manninga2e14992022-04-22 11:29:17 +0100955 private int getCellLayoutHeightSpecification() {
Pat Manning08610ca2022-04-05 21:03:16 +0100956 return (cellHeightPx * inv.numRows) + (cellLayoutBorderSpacePx.y * (inv.numRows - 1))
957 + cellLayoutPaddingPx.top + cellLayoutPaddingPx.bottom;
958 }
959
Pat Manninga2e14992022-04-22 11:29:17 +0100960 private int getCellLayoutWidthSpecification() {
Pat Manning25d53342022-05-10 09:58:49 +0000961 int numColumns = getPanelCount() * inv.numColumns;
Pat Manning08610ca2022-04-05 21:03:16 +0100962 return (cellWidthPx * numColumns) + (cellLayoutBorderSpacePx.x * (numColumns - 1))
963 + cellLayoutPaddingPx.left + cellLayoutPaddingPx.right;
Jon Mirandae126d722021-02-25 10:45:20 -0500964 }
965
Thales Lima93ee8fc2023-06-05 17:07:11 +0100966 private int getNormalizedIconDrawablePadding() {
967 // TODO(b/235886078): workaround needed because of this bug
968 // Icons are 10% larger on XML than their visual size,
969 // so remove that extra space to get labels closer to the correct padding
970 int iconVisibleSizePx = (int) Math.round(ICON_VISIBLE_AREA_FACTOR * iconSizePx);
971 return Math.max(0, mIconDrawablePaddingOriginalPx - ((iconSizePx - iconVisibleSizePx) / 2));
972 }
973
974 private int getNormalizedFolderChildDrawablePaddingPx(int textHeight) {
975 // TODO(b/235886078): workaround needed because of this bug
976 // Icons are 10% larger on XML than their visual size,
977 // so remove that extra space to get labels closer to the correct padding
978 int drawablePadding = (folderCellHeightPx - folderChildIconSizePx - textHeight) / 3;
979
980 int iconVisibleSizePx = Math.round(ICON_VISIBLE_AREA_FACTOR * folderChildIconSizePx);
981 int iconSizeDiff = folderChildIconSizePx - iconVisibleSizePx;
982 return Math.max(0, drawablePadding - iconSizeDiff / 2);
983 }
984
Jordan Silva3646a1b2023-08-02 13:52:52 +0100985 private int getIconSizeWithOverlap(int iconSize) {
986 return (int) Math.ceil(iconSize * ICON_OVERLAP_FACTOR);
987 }
988
Jon Miranda6f7e9702019-09-16 14:44:14 -0700989 /**
990 * Updating the iconSize affects many aspects of the launcher layout, such as: iconSizePx,
991 * iconTextSizePx, iconDrawablePaddingPx, cellWidth/Height, allApps* variants,
992 * hotseat sizes, workspaceSpringLoadedShrinkFactor, folderIconSizePx, and folderIconOffsetYPx.
993 */
Tony Wickham7ba547c2021-02-02 17:12:08 -0800994 public void updateIconSize(float scale, Resources res) {
Jon Mirandaab3c6812021-06-28 15:42:28 -0700995 // Icon scale should never exceed 1, otherwise pixellation may occur.
996 iconScale = Math.min(1f, scale);
997 cellScaleToFit = scale;
998
Jon Miranda18751b62017-07-31 17:25:27 -0700999 // Workspace
Sunny Goyal07b69292018-01-08 14:19:34 -08001000 final boolean isVerticalLayout = isVerticalBarLayout();
Thales Lima080d8902022-03-28 15:30:29 +01001001 cellLayoutBorderSpacePx = getCellLayoutBorderSpace(inv, scale);
Jon Mirandae126d722021-02-25 10:45:20 -05001002
Thales Lima79456492023-05-23 11:32:22 +01001003 if (mIsResponsiveGrid) {
Thales Lima79456492023-05-23 11:32:22 +01001004 cellWidthPx = mResponsiveWidthSpec.getCellSizePx();
1005 cellHeightPx = mResponsiveHeightSpec.getCellSizePx();
Thales Lima79456492023-05-23 11:32:22 +01001006
Thales Lima2759aa32023-06-05 16:25:45 +01001007 if (cellWidthPx < iconSizePx) {
1008 // get a smaller icon size
1009 iconSizePx = mIconSizeSteps.getIconSmallerThan(cellWidthPx);
Thales Lima2759aa32023-06-05 16:25:45 +01001010 }
1011
Thales Lima93ee8fc2023-06-05 17:07:11 +01001012 iconDrawablePaddingPx = getNormalizedIconDrawablePadding();
1013 int iconTextHeight = Utilities.calculateTextHeight(iconTextSizePx);
1014 int cellContentHeight = iconSizePx + iconDrawablePaddingPx + iconTextHeight;
1015
Thales Lima2759aa32023-06-05 16:25:45 +01001016 while (iconSizePx > mIconSizeSteps.minimumIconSize()
1017 && cellContentHeight > cellHeightPx) {
Thales Lima93ee8fc2023-06-05 17:07:11 +01001018 iconDrawablePaddingPx -= cellContentHeight - cellHeightPx;
1019 if (iconDrawablePaddingPx < 0) {
Thales Lima2759aa32023-06-05 16:25:45 +01001020 // get a smaller icon size
1021 iconSizePx = mIconSizeSteps.getNextLowerIconSize(iconSizePx);
Thales Lima93ee8fc2023-06-05 17:07:11 +01001022 iconDrawablePaddingPx = getNormalizedIconDrawablePadding();
Thales Lima2759aa32023-06-05 16:25:45 +01001023 }
1024 // calculate new cellContentHeight
Thales Lima93ee8fc2023-06-05 17:07:11 +01001025 cellContentHeight = iconSizePx + iconDrawablePaddingPx + iconTextHeight;
Thales Lima2759aa32023-06-05 16:25:45 +01001026 }
1027
1028 cellYPaddingPx = Math.max(0, cellHeightPx - cellContentHeight) / 2;
Thales Lima79456492023-05-23 11:32:22 +01001029 } else if (mIsScalableGrid) {
Thales Lima93ee8fc2023-06-05 17:07:11 +01001030 iconDrawablePaddingPx = (int) (getNormalizedIconDrawablePadding() * iconScale);
Thales Lima83bedbf2021-10-05 17:47:39 +01001031 cellWidthPx = pxFromDp(inv.minCellSize[mTypeIndex].x, mMetrics, scale);
1032 cellHeightPx = pxFromDp(inv.minCellSize[mTypeIndex].y, mMetrics, scale);
Alex Chaube753132022-12-09 16:46:54 +00001033
1034 if (cellWidthPx < iconSizePx) {
1035 // If cellWidth no longer fit iconSize, reduce borderSpace to make cellWidth bigger.
1036 int numColumns = getPanelCount() * inv.numColumns;
1037 int numBorders = numColumns - 1;
1038 int extraWidthRequired = (iconSizePx - cellWidthPx) * numColumns;
1039 if (cellLayoutBorderSpacePx.x * numBorders >= extraWidthRequired) {
1040 cellWidthPx = iconSizePx;
1041 cellLayoutBorderSpacePx.x -= extraWidthRequired / numBorders;
1042 } else {
1043 // If it still doesn't fit, set borderSpace to 0 and distribute the space for
1044 // cellWidth, and reduce iconSize.
1045 cellWidthPx = (cellWidthPx * numColumns
1046 + cellLayoutBorderSpacePx.x * numBorders) / numColumns;
1047 iconSizePx = Math.min(iconSizePx, cellWidthPx);
1048 cellLayoutBorderSpacePx.x = 0;
1049 }
1050 }
1051
Thales Lima93ee8fc2023-06-05 17:07:11 +01001052 int cellTextAndPaddingHeight =
1053 iconDrawablePaddingPx + Utilities.calculateTextHeight(iconTextSizePx);
Alex Chaube753132022-12-09 16:46:54 +00001054 int cellContentHeight = iconSizePx + cellTextAndPaddingHeight;
1055 if (cellHeightPx < cellContentHeight) {
1056 // If cellHeight no longer fit iconSize, reduce borderSpace to make cellHeight
1057 // bigger.
1058 int numBorders = inv.numRows - 1;
1059 int extraHeightRequired = (cellContentHeight - cellHeightPx) * inv.numRows;
1060 if (cellLayoutBorderSpacePx.y * numBorders >= extraHeightRequired) {
1061 cellHeightPx = cellContentHeight;
1062 cellLayoutBorderSpacePx.y -= extraHeightRequired / numBorders;
1063 } else {
Alex Chau06f36e82023-01-06 10:50:54 +00001064 // If it still doesn't fit, set borderSpace to 0 to recover space.
Alex Chaube753132022-12-09 16:46:54 +00001065 cellHeightPx = (cellHeightPx * inv.numRows
1066 + cellLayoutBorderSpacePx.y * numBorders) / inv.numRows;
Alex Chaube753132022-12-09 16:46:54 +00001067 cellLayoutBorderSpacePx.y = 0;
Alex Chau06f36e82023-01-06 10:50:54 +00001068 // Reduce iconDrawablePaddingPx to make cellContentHeight smaller.
1069 int cellContentWithoutPadding = cellContentHeight - iconDrawablePaddingPx;
1070 if (cellContentWithoutPadding <= cellHeightPx) {
1071 iconDrawablePaddingPx = cellContentHeight - cellHeightPx;
1072 } else {
1073 // If it still doesn't fit, set iconDrawablePaddingPx to 0 to recover space,
1074 // then proportional reduce iconSizePx and iconTextSizePx to fit.
1075 iconDrawablePaddingPx = 0;
1076 float ratio = cellHeightPx / (float) cellContentWithoutPadding;
1077 iconSizePx = (int) (iconSizePx * ratio);
1078 iconTextSizePx = (int) (iconTextSizePx * ratio);
1079 }
1080 cellTextAndPaddingHeight =
1081 iconDrawablePaddingPx + Utilities.calculateTextHeight(iconTextSizePx);
Alex Chaube753132022-12-09 16:46:54 +00001082 }
1083 cellContentHeight = iconSizePx + cellTextAndPaddingHeight;
1084 }
Jon Mirandae126d722021-02-25 10:45:20 -05001085 cellYPaddingPx = Math.max(0, cellHeightPx - cellContentHeight) / 2;
Thales Limad90faab2021-09-21 17:18:47 +01001086 desiredWorkspaceHorizontalMarginPx =
1087 (int) (desiredWorkspaceHorizontalMarginOriginalPx * scale);
Jon Miranda228877d2021-02-09 11:05:00 -05001088 } else {
Thales Lima93ee8fc2023-06-05 17:07:11 +01001089 iconDrawablePaddingPx = (int) (getNormalizedIconDrawablePadding() * iconScale);
Jon Mirandae126d722021-02-25 10:45:20 -05001090 cellWidthPx = iconSizePx + iconDrawablePaddingPx;
Jordan Silva3646a1b2023-08-02 13:52:52 +01001091 cellHeightPx = getIconSizeWithOverlap(iconSizePx)
Jon Miranda92c1b5d2021-07-20 13:57:16 -07001092 + iconDrawablePaddingPx
Jon Miranda228877d2021-02-09 11:05:00 -05001093 + Utilities.calculateTextHeight(iconTextSizePx);
1094 int cellPaddingY = (getCellSize().y - cellHeightPx) / 2;
1095 if (iconDrawablePaddingPx > cellPaddingY && !isVerticalLayout
1096 && !isMultiWindowMode) {
1097 // Ensures that the label is closer to its corresponding icon. This is not an issue
1098 // with vertical bar layout or multi-window mode since the issue is handled
1099 // separately with their calls to {@link #adjustToHideWorkspaceLabels}.
1100 cellHeightPx -= (iconDrawablePaddingPx - cellPaddingY);
1101 iconDrawablePaddingPx = cellPaddingY;
1102 }
Jon Miranda846455e2017-10-02 14:58:52 -07001103 }
Jon Miranda18751b62017-07-31 17:25:27 -07001104
Sunny Goyalae190ff2020-04-14 00:19:01 +00001105 // All apps
Thales Limaabfe3642023-05-24 18:08:53 +01001106 if (mIsResponsiveGrid) {
1107 updateAllAppsWithResponsiveMeasures();
1108 } else {
1109 updateAllAppsIconSize(scale, res);
1110 }
1111 updateAllAppsContainerWidth();
1112 if (isVerticalBarLayout()) {
1113 hideWorkspaceLabelsIfNotEnoughSpace();
1114 }
Winson Chungb3800242013-10-24 11:01:54 -07001115
Thales Limab8c05952022-05-23 16:58:38 +01001116 updateHotseatSizes(iconSizePx);
Winson Chungb3800242013-10-24 11:01:54 -07001117
Sunny Goyalbaec6ff2016-09-14 11:26:21 -07001118 // Folder icon
Jon Miranda591e3602018-03-28 11:37:00 -07001119 folderIconSizePx = IconNormalizer.getNormalizedCircleSize(iconSizePx);
1120 folderIconOffsetYPx = (iconSizePx - folderIconSizePx) / 2;
Sunny Goyal6c304b12023-04-10 12:03:04 -07001121
1122 // Update widget padding:
1123 float minSpacing = pxFromDp(MIN_WIDGET_PADDING_DP, mMetrics);
1124 if (cellLayoutBorderSpacePx.x < minSpacing
1125 || cellLayoutBorderSpacePx.y < minSpacing) {
1126 widgetPadding.left = widgetPadding.right =
1127 Math.round(Math.max(0, minSpacing - cellLayoutBorderSpacePx.x));
1128 widgetPadding.top = widgetPadding.bottom =
1129 Math.round(Math.max(0, minSpacing - cellLayoutBorderSpacePx.y));
1130 } else {
1131 widgetPadding.setEmpty();
1132 }
Winson Chung0f785722015-04-08 10:27:49 -07001133 }
1134
Thales Lima425f6822022-05-10 13:44:58 -03001135 /**
Thales Lima6a590062022-11-22 15:52:49 +00001136 * This method calculates the space between the icons to achieve a certain width.
Thales Lima425f6822022-05-10 13:44:58 -03001137 */
Thales Lima6a590062022-11-22 15:52:49 +00001138 private int calculateHotseatBorderSpace(float hotseatWidthPx, int numExtraBorder) {
Jordan Silvad9227182023-08-17 15:53:59 +01001139 int numBorders = (numShownHotseatIcons - 1 + numExtraBorder);
1140 if (numBorders <= 0) return 0;
1141
Thales Lima9938c2f2022-07-25 14:38:16 +01001142 float hotseatIconsTotalPx = iconSizePx * numShownHotseatIcons;
Jordan Silvad9227182023-08-17 15:53:59 +01001143 int hotseatBorderSpacePx = (int) (hotseatWidthPx - hotseatIconsTotalPx) / numBorders;
Thales Limaffc68b02023-01-09 16:20:23 +00001144 return Math.min(hotseatBorderSpacePx, mMaxHotseatIconSpacePx);
Thales Lima425f6822022-05-10 13:44:58 -03001145 }
1146
Brian Isganitis25b2ac82022-01-28 16:25:13 -05001147 /**
1148 * Updates the iconSize for allApps* variants.
1149 */
Brian Isganitisa9a78112022-05-23 18:11:47 -07001150 private void updateAllAppsIconSize(float scale, Resources res) {
Thales Lima080d8902022-03-28 15:30:29 +01001151 allAppsBorderSpacePx = new Point(
1152 pxFromDp(inv.allAppsBorderSpaces[mTypeIndex].x, mMetrics, scale),
1153 pxFromDp(inv.allAppsBorderSpaces[mTypeIndex].y, mMetrics, scale));
Brandon Dayauon07ca8842022-04-27 10:52:28 -07001154 // AllApps cells don't have real space between cells,
1155 // so we add the border space to the cell height
Alex Chaube753132022-12-09 16:46:54 +00001156 allAppsCellHeightPx = pxFromDp(inv.allAppsCellSize[mTypeIndex].y, mMetrics)
Brandon Dayauon07ca8842022-04-27 10:52:28 -07001157 + allAppsBorderSpacePx.y;
1158 // but width is just the cell,
1159 // the border is added in #updateAllAppsContainerWidth
Thales Lima79456492023-05-23 11:32:22 +01001160 if (mIsScalableGrid) {
Alex Chaube753132022-12-09 16:46:54 +00001161 allAppsIconSizePx = pxFromDp(inv.allAppsIconSize[mTypeIndex], mMetrics);
1162 allAppsIconTextSizePx = pxFromSp(inv.allAppsIconTextSize[mTypeIndex], mMetrics);
Thales Lima93ee8fc2023-06-05 17:07:11 +01001163 allAppsIconDrawablePaddingPx = getNormalizedIconDrawablePadding();
Brandon Dayauon7a8a9ed2022-06-06 14:32:22 -07001164 allAppsCellWidthPx = pxFromDp(inv.allAppsCellSize[mTypeIndex].x, mMetrics, scale);
Alex Chaube753132022-12-09 16:46:54 +00001165
1166 if (allAppsCellWidthPx < allAppsIconSizePx) {
1167 // If allAppsCellWidth no longer fit allAppsIconSize, reduce allAppsBorderSpace to
1168 // make allAppsCellWidth bigger.
1169 int numBorders = inv.numAllAppsColumns - 1;
1170 int extraWidthRequired =
1171 (allAppsIconSizePx - allAppsCellWidthPx) * inv.numAllAppsColumns;
1172 if (allAppsBorderSpacePx.x * numBorders >= extraWidthRequired) {
1173 allAppsCellWidthPx = allAppsIconSizePx;
1174 allAppsBorderSpacePx.x -= extraWidthRequired / numBorders;
1175 } else {
1176 // If it still doesn't fit, set allAppsBorderSpace to 0 and distribute the space
1177 // for allAppsCellWidth, and reduce allAppsIconSize.
1178 allAppsCellWidthPx = (allAppsCellWidthPx * inv.numAllAppsColumns
1179 + allAppsBorderSpacePx.x * numBorders) / inv.numAllAppsColumns;
1180 allAppsIconSizePx = Math.min(allAppsIconSizePx, allAppsCellWidthPx);
1181 allAppsBorderSpacePx.x = 0;
1182 }
1183 }
1184
1185 int cellContentHeight = allAppsIconSizePx
1186 + Utilities.calculateTextHeight(allAppsIconTextSizePx) + allAppsBorderSpacePx.y;
1187 if (allAppsCellHeightPx < cellContentHeight) {
1188 // Increase allAppsCellHeight to fit its content.
1189 allAppsCellHeightPx = cellContentHeight;
1190 }
Brian Isganitis25b2ac82022-01-28 16:25:13 -05001191 } else {
Brandon Dayauon07ca8842022-04-27 10:52:28 -07001192 float invIconSizeDp = inv.allAppsIconSize[mTypeIndex];
1193 float invIconTextSizeSp = inv.allAppsIconTextSize[mTypeIndex];
Brian Isganitis25b2ac82022-01-28 16:25:13 -05001194 allAppsIconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mMetrics, scale));
1195 allAppsIconTextSizePx = (int) (pxFromSp(invIconTextSizeSp, mMetrics) * scale);
Brandon Dayauon07ca8842022-04-27 10:52:28 -07001196 allAppsIconDrawablePaddingPx =
1197 res.getDimensionPixelSize(R.dimen.all_apps_icon_drawable_padding);
Brandon Dayauon7a8a9ed2022-06-06 14:32:22 -07001198 allAppsCellWidthPx = allAppsIconSizePx + (2 * allAppsIconDrawablePaddingPx);
Brian Isganitis25b2ac82022-01-28 16:25:13 -05001199 }
Thales Limaabfe3642023-05-24 18:08:53 +01001200 }
Brian Isganitis25b2ac82022-01-28 16:25:13 -05001201
Thales Limaabfe3642023-05-24 18:08:53 +01001202 private void updateAllAppsWithResponsiveMeasures() {
1203 allAppsIconSizePx = iconSizePx;
1204 allAppsIconTextSizePx = iconTextSizePx;
Thales Lima93ee8fc2023-06-05 17:07:11 +01001205 allAppsIconDrawablePaddingPx = iconDrawablePaddingPx;
Thales Limaabfe3642023-05-24 18:08:53 +01001206
1207 allAppsBorderSpacePx = new Point(
1208 mAllAppsResponsiveWidthSpec.getGutterPx(),
1209 mAllAppsResponsiveHeightSpec.getGutterPx()
1210 );
1211 allAppsCellHeightPx = mAllAppsResponsiveHeightSpec.getCellSizePx()
1212 + mAllAppsResponsiveHeightSpec.getGutterPx();
1213 allAppsCellWidthPx = mAllAppsResponsiveWidthSpec.getCellSizePx();
1214 allAppsLeftRightPadding = mAllAppsResponsiveWidthSpec.getStartPaddingPx();
1215 }
1216
1217 /**
1218 * Re-computes the all-apps cell size to be independent of workspace
1219 */
1220 public void autoResizeAllAppsCells() {
1221 int textHeight = Utilities.calculateTextHeight(allAppsIconTextSizePx);
1222 int topBottomPadding = textHeight;
1223 allAppsCellHeightPx = allAppsIconSizePx + allAppsIconDrawablePaddingPx
1224 + textHeight + (topBottomPadding * 2);
1225 }
1226
1227 private void updateAllAppsContainerWidth() {
1228 int cellLayoutHorizontalPadding =
1229 (cellLayoutPaddingPx.left + cellLayoutPaddingPx.right) / 2;
1230 if (isTablet) {
1231 int usedWidth = (allAppsCellWidthPx * numShownAllAppsColumns)
1232 + (allAppsBorderSpacePx.x * (numShownAllAppsColumns - 1))
1233 + allAppsLeftRightPadding * 2;
1234 allAppsLeftRightMargin = Math.max(1, (availableWidthPx - usedWidth) / 2);
1235 } else {
1236 allAppsLeftRightPadding =
1237 Math.max(0, desiredWorkspaceHorizontalMarginPx + cellLayoutHorizontalPadding
1238 - (allAppsBorderSpacePx.x / 2));
Brian Isganitis25b2ac82022-01-28 16:25:13 -05001239 }
1240 }
1241
Thales Limaabfe3642023-05-24 18:08:53 +01001242 private void setupAllAppsStyle(Context context) {
1243 TypedArray allAppsStyle = context.obtainStyledAttributes(
1244 inv.allAppsStyle != INVALID_RESOURCE_HANDLE ? inv.allAppsStyle
1245 : R.style.AllAppsStyleDefault, R.styleable.AllAppsStyle);
1246
1247 allAppsLeftRightPadding = allAppsStyle.getDimensionPixelSize(
1248 R.styleable.AllAppsStyle_horizontalPadding, 0);
1249 allAppsStyle.recycle();
1250 }
1251
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001252 private void updateAvailableFolderCellDimensions(Resources res) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001253 updateFolderCellSize(1f, res);
Jon Mirandabf7d8122016-11-03 15:29:29 -07001254
Jordan Silva637f4eb2023-06-13 11:21:53 +01001255 // Responsive grid doesn't need to scale the folder
1256 if (mIsResponsiveGrid) return;
1257
Thales Lima7eee74b2023-03-16 16:00:55 -03001258 // For usability we can't have the folder use the whole width of the screen
Sunny Goyal07b69292018-01-08 14:19:34 -08001259 Point totalWorkspacePadding = getTotalWorkspacePadding();
Jon Mirandac1b23992016-12-13 08:57:36 -08001260
Thales Lima7eee74b2023-03-16 16:00:55 -03001261 // Check if the folder fit within the available height.
Jon Miranda228877d2021-02-09 11:05:00 -05001262 float contentUsedHeight = folderCellHeightPx * inv.numFolderRows
Jordan Silva637f4eb2023-06-13 11:21:53 +01001263 + ((inv.numFolderRows - 1) * folderCellLayoutBorderSpacePx.y)
Thales Lima7eee74b2023-03-16 16:00:55 -03001264 + folderFooterHeightPx
1265 + folderContentPaddingTop;
1266 int contentMaxHeight = availableHeightPx - totalWorkspacePadding.y;
Samuel Fufa1c8d90a2019-11-12 17:54:58 -08001267 float scaleY = contentMaxHeight / contentUsedHeight;
Jon Mirandac1b23992016-12-13 08:57:36 -08001268
Thales Lima7eee74b2023-03-16 16:00:55 -03001269 // Check if the folder fit within the available width.
Jon Miranda228877d2021-02-09 11:05:00 -05001270 float contentUsedWidth = folderCellWidthPx * inv.numFolderColumns
Jordan Silva637f4eb2023-06-13 11:21:53 +01001271 + ((inv.numFolderColumns - 1) * folderCellLayoutBorderSpacePx.x)
Thales Lima7eee74b2023-03-16 16:00:55 -03001272 + folderContentPaddingLeftRight * 2;
1273 int contentMaxWidth = availableWidthPx - totalWorkspacePadding.x;
Samuel Fufa1c8d90a2019-11-12 17:54:58 -08001274 float scaleX = contentMaxWidth / contentUsedWidth;
Jon Mirandac1b23992016-12-13 08:57:36 -08001275
1276 float scale = Math.min(scaleX, scaleY);
1277 if (scale < 1f) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001278 updateFolderCellSize(scale, res);
Jon Mirandabf7d8122016-11-03 15:29:29 -07001279 }
1280 }
1281
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001282 private void updateFolderCellSize(float scale, Resources res) {
Alex Chau0d4f1ac2022-12-20 12:31:14 +00001283 float invIconSizeDp = inv.iconSize[mTypeIndex];
Sunny Goyal35c7b192021-04-20 16:51:10 -07001284 folderChildIconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mMetrics, scale));
Alex Chau0d4f1ac2022-12-20 12:31:14 +00001285 folderChildTextSizePx = pxFromSp(inv.iconTextSize[mTypeIndex], mMetrics, scale);
Thales Lima7eee74b2023-03-16 16:00:55 -03001286 folderLabelTextSizePx = Math.max(pxFromSp(MIN_FOLDER_TEXT_SIZE_SP, mMetrics, scale),
Thales Limab35faed2022-09-05 16:30:01 -03001287 (int) (folderChildTextSizePx * folderLabelTextScale));
Jon Mirandabf7d8122016-11-03 15:29:29 -07001288
1289 int textHeight = Utilities.calculateTextHeight(folderChildTextSizePx);
Jon Mirandabf7d8122016-11-03 15:29:29 -07001290
Jordan Silva637f4eb2023-06-13 11:21:53 +01001291 if (mIsResponsiveGrid) {
1292 folderCellWidthPx = mResponsiveFolderWidthSpec.getCellSizePx();
1293
1294 // Height
1295 folderCellHeightPx = mResponsiveFolderHeightSpec.getCellSizePx();
1296 folderContentPaddingTop = mResponsiveFolderHeightSpec.getStartPaddingPx();
1297 folderFooterHeightPx = mResponsiveFolderHeightSpec.getEndPaddingPx();
1298
1299 folderCellLayoutBorderSpacePx = new Point(mResponsiveFolderWidthSpec.getGutterPx(),
Thales Lima4cfd9502023-07-10 14:01:28 +01001300 mResponsiveFolderHeightSpec.getGutterPx());
Jordan Silva637f4eb2023-06-13 11:21:53 +01001301
1302 folderContentPaddingLeftRight = mResponsiveFolderWidthSpec.getStartPaddingPx();
Jordan Silva12fae112023-06-26 12:51:01 +01001303
1304 // Reduce icon width if it's wider than the expected folder cell width
1305 if (folderCellWidthPx < folderChildIconSizePx) {
1306 folderChildIconSizePx = mIconSizeSteps.getIconSmallerThan(folderCellWidthPx);
1307 }
1308
1309 // Recalculating padding and cell height
1310 folderChildDrawablePaddingPx = getNormalizedFolderChildDrawablePaddingPx(textHeight);
1311 int folderCellContentHeight = folderChildIconSizePx + folderChildDrawablePaddingPx
1312 + textHeight;
1313
1314 // Reduce the icon in height when it's taller than the expected cell height
1315 while (folderChildIconSizePx > mIconSizeSteps.minimumIconSize()
1316 && folderCellContentHeight > folderCellHeightPx) {
1317 folderChildDrawablePaddingPx -= folderCellContentHeight - folderCellHeightPx;
1318 if (folderChildDrawablePaddingPx < 0) {
1319 // get a smaller icon size
1320 folderChildIconSizePx = mIconSizeSteps.getNextLowerIconSize(
1321 folderChildIconSizePx);
1322 folderChildDrawablePaddingPx =
1323 getNormalizedFolderChildDrawablePaddingPx(textHeight);
1324 }
1325 // calculate new cellContentHeight
1326 folderCellContentHeight = folderChildIconSizePx + folderChildDrawablePaddingPx
1327 + textHeight;
1328 }
Jordan Silva637f4eb2023-06-13 11:21:53 +01001329 } else if (mIsScalableGrid) {
Thales Limab35faed2022-09-05 16:30:01 -03001330 if (inv.folderStyle == INVALID_RESOURCE_HANDLE) {
Thales Lima7eee74b2023-03-16 16:00:55 -03001331 folderCellWidthPx = roundPxValueFromFloat(getCellSize().x * scale);
1332 folderCellHeightPx = roundPxValueFromFloat(getCellSize().y * scale);
1333 } else {
1334 folderCellWidthPx = roundPxValueFromFloat(folderCellWidthPx * scale);
1335 folderCellHeightPx = roundPxValueFromFloat(folderCellHeightPx * scale);
Thales Limab35faed2022-09-05 16:30:01 -03001336 }
Jon Mirandaf33f5b32021-07-22 17:15:31 -07001337
Thales Lima7eee74b2023-03-16 16:00:55 -03001338 folderContentPaddingTop = roundPxValueFromFloat(folderContentPaddingTop * scale);
Jordan Silva637f4eb2023-06-13 11:21:53 +01001339 folderCellLayoutBorderSpacePx = new Point(
1340 roundPxValueFromFloat(folderCellLayoutBorderSpacePx.x * scale),
1341 roundPxValueFromFloat(folderCellLayoutBorderSpacePx.y * scale)
1342 );
Thales Lima7eee74b2023-03-16 16:00:55 -03001343 folderFooterHeightPx = roundPxValueFromFloat(folderFooterHeightPx * scale);
1344
Jordan Silva637f4eb2023-06-13 11:21:53 +01001345 folderContentPaddingLeftRight = folderCellLayoutBorderSpacePx.x;
Jordan Silva12fae112023-06-26 12:51:01 +01001346
1347 folderChildDrawablePaddingPx = getNormalizedFolderChildDrawablePaddingPx(textHeight);
Jon Miranda823da222021-03-23 08:08:45 -04001348 } else {
1349 int cellPaddingX = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_x_padding)
1350 * scale);
1351 int cellPaddingY = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_y_padding)
1352 * scale);
1353
1354 folderCellWidthPx = folderChildIconSizePx + 2 * cellPaddingX;
1355 folderCellHeightPx = folderChildIconSizePx + 2 * cellPaddingY + textHeight;
Thales Lima7eee74b2023-03-16 16:00:55 -03001356 folderContentPaddingTop = roundPxValueFromFloat(folderContentPaddingTop * scale);
Thales Limab35faed2022-09-05 16:30:01 -03001357 folderContentPaddingLeftRight =
1358 res.getDimensionPixelSize(R.dimen.folder_content_padding_left_right);
1359 folderFooterHeightPx =
Thales Lima7eee74b2023-03-16 16:00:55 -03001360 roundPxValueFromFloat(
1361 res.getDimensionPixelSize(R.dimen.folder_footer_height_default)
1362 * scale);
1363
Jordan Silva12fae112023-06-26 12:51:01 +01001364 folderChildDrawablePaddingPx = getNormalizedFolderChildDrawablePaddingPx(textHeight);
Jon Miranda823da222021-03-23 08:08:45 -04001365 }
Jon Mirandabf7d8122016-11-03 15:29:29 -07001366 }
1367
Winson1f064272016-07-18 17:18:02 -07001368 public void updateInsets(Rect insets) {
1369 mInsets.set(insets);
1370 }
1371
Sunny Goyalae6e3182019-04-30 12:04:37 -07001372 /**
1373 * The current device insets. This is generally same as the insets being dispatched to
1374 * {@link Insettable} elements, but can differ if the element is using a different profile.
1375 */
Sunny Goyal1a52ef52018-01-11 10:15:03 -08001376 public Rect getInsets() {
1377 return mInsets;
1378 }
1379
Sunny Goyal756cd262015-08-20 12:33:21 -07001380 public Point getCellSize() {
Sunny Goyal19ff7282021-04-22 10:12:54 -07001381 return getCellSize(null);
Jon Miranda6f7e9702019-09-16 14:44:14 -07001382 }
1383
Sunny Goyal19ff7282021-04-22 10:12:54 -07001384 public Point getCellSize(Point result) {
1385 if (result == null) {
1386 result = new Point();
1387 }
Thales Limad1df5fc2021-09-03 18:37:19 +01001388
Pat Manning25d53342022-05-10 09:58:49 +00001389 int shortcutAndWidgetContainerWidth =
1390 getCellLayoutWidth() - (cellLayoutPaddingPx.left + cellLayoutPaddingPx.right);
1391 result.x = calculateCellWidth(shortcutAndWidgetContainerWidth, cellLayoutBorderSpacePx.x,
1392 inv.numColumns);
1393 int shortcutAndWidgetContainerHeight =
1394 getCellLayoutHeight() - (cellLayoutPaddingPx.top + cellLayoutPaddingPx.bottom);
1395 result.y = calculateCellHeight(shortcutAndWidgetContainerHeight, cellLayoutBorderSpacePx.y,
1396 inv.numRows);
Sunny Goyal3e8a04b2022-05-09 19:31:45 +00001397 return result;
Pat Manningb45d6c42022-05-03 14:32:06 +01001398 }
1399
1400 /**
Thales Lima1e8b45f2022-08-25 11:50:59 -04001401 * Returns the left and right space on the cell, which is the cell width - icon size
1402 */
1403 public int getCellHorizontalSpace() {
1404 return getCellSize().x - iconSizePx;
1405 }
1406
1407 /**
Pat Manning25d53342022-05-10 09:58:49 +00001408 * Gets the number of panels within the workspace.
1409 */
1410 public int getPanelCount() {
1411 return isTwoPanels ? 2 : 1;
1412 }
1413
1414 /**
Pat Manningde25c0d2022-04-05 19:11:26 +01001415 * Gets the space in px from the bottom of last item in the vertical-bar hotseat to the
1416 * bottom of the screen.
1417 */
Pat Manning5f74bfd2022-07-20 12:08:54 +01001418 private int getVerticalHotseatLastItemBottomOffset(Context context) {
1419 Rect hotseatBarPadding = getHotseatLayoutPadding(context);
Pat Manningde25c0d2022-04-05 19:11:26 +01001420 int cellHeight = calculateCellHeight(
Pat Manning5f74bfd2022-07-20 12:08:54 +01001421 heightPx - hotseatBarPadding.top - hotseatBarPadding.bottom, hotseatBorderSpace,
Pat Manningde25c0d2022-04-05 19:11:26 +01001422 numShownHotseatIcons);
Pat Manningde25c0d2022-04-05 19:11:26 +01001423 int extraIconEndSpacing = (cellHeight - iconSizePx) / 2;
Pat Manning5f74bfd2022-07-20 12:08:54 +01001424 return extraIconEndSpacing + hotseatBarPadding.bottom;
Pat Manningde25c0d2022-04-05 19:11:26 +01001425 }
1426
1427 /**
1428 * Gets the scaled top of the workspace in px for the spring-loaded edit state.
1429 */
Pat Manning25d53342022-05-10 09:58:49 +00001430 public float getCellLayoutSpringLoadShrunkTop() {
Pat Manning5f74bfd2022-07-20 12:08:54 +01001431 return mInsets.top + dropTargetBarTopMarginPx + dropTargetBarSizePx
Pat Manningde25c0d2022-04-05 19:11:26 +01001432 + dropTargetBarBottomMarginPx;
Pat Manningde25c0d2022-04-05 19:11:26 +01001433 }
1434
1435 /**
1436 * Gets the scaled bottom of the workspace in px for the spring-loaded edit state.
1437 */
Pat Manning5f74bfd2022-07-20 12:08:54 +01001438 public float getCellLayoutSpringLoadShrunkBottom(Context context) {
Pat Manningde25c0d2022-04-05 19:11:26 +01001439 int topOfHotseat = hotseatBarSizePx + springLoadedHotseatBarTopMarginPx;
Pat Manning5f74bfd2022-07-20 12:08:54 +01001440 return heightPx - (isVerticalBarLayout()
1441 ? getVerticalHotseatLastItemBottomOffset(context) : topOfHotseat);
Pat Manningde25c0d2022-04-05 19:11:26 +01001442 }
1443
Pat Manningea5c1d22022-04-14 10:58:16 +01001444 /**
Pat Manninga2e14992022-04-22 11:29:17 +01001445 * Gets the scale of the workspace for the spring-loaded edit state.
1446 */
Pat Manning5f74bfd2022-07-20 12:08:54 +01001447 public float getWorkspaceSpringLoadScale(Context context) {
1448 float scale =
1449 (getCellLayoutSpringLoadShrunkBottom(context) - getCellLayoutSpringLoadShrunkTop())
1450 / getCellLayoutHeight();
Pat Manninga2e14992022-04-22 11:29:17 +01001451 scale = Math.min(scale, 1f);
1452
Pat Manninge63dd252022-08-02 16:15:29 +01001453 // Reduce scale if next pages would not be visible after scaling the workspace.
Pat Manning25d53342022-05-10 09:58:49 +00001454 int workspaceWidth = availableWidthPx;
Pat Manninga2e14992022-04-22 11:29:17 +01001455 float scaledWorkspaceWidth = workspaceWidth * scale;
Alex Chau906d8822022-05-23 10:42:25 +01001456 float maxAvailableWidth = workspaceWidth - (2 * workspaceSpringLoadedMinNextPageVisiblePx);
Pat Manninga2e14992022-04-22 11:29:17 +01001457 if (scaledWorkspaceWidth > maxAvailableWidth) {
1458 scale *= maxAvailableWidth / scaledWorkspaceWidth;
1459 }
1460 return scale;
1461 }
1462
Pat Manning25d53342022-05-10 09:58:49 +00001463 /**
1464 * Gets the width of a single Cell Layout, aka a single panel within a Workspace.
1465 *
1466 * <p>This is the width of a Workspace, less its horizontal padding. Note that two-panel
1467 * layouts have two Cell Layouts per workspace.
1468 */
1469 public int getCellLayoutWidth() {
1470 return (availableWidthPx - getTotalWorkspacePadding().x) / getPanelCount();
Alex Chau60953332021-11-24 12:41:07 +00001471 }
1472
Pat Manning25d53342022-05-10 09:58:49 +00001473 /**
1474 * Gets the height of a single Cell Layout, aka a single panel within a Workspace.
1475 *
1476 * <p>This is the height of a Workspace, less its vertical padding.
1477 */
1478 public int getCellLayoutHeight() {
1479 return availableHeightPx - getTotalWorkspacePadding().y;
Pat Manning08610ca2022-04-05 21:03:16 +01001480 }
1481
Sunny Goyal6c2975e2016-07-06 09:47:56 -07001482 public Point getTotalWorkspacePadding() {
Sunny Goyal07b69292018-01-08 14:19:34 -08001483 return new Point(workspacePadding.left + workspacePadding.right,
1484 workspacePadding.top + workspacePadding.bottom);
Sunny Goyal6c2975e2016-07-06 09:47:56 -07001485 }
1486
1487 /**
Sunny Goyal07b69292018-01-08 14:19:34 -08001488 * Updates {@link #workspacePadding} as a result of any internal value change to reflect the
1489 * new workspace padding
Sunny Goyal6c2975e2016-07-06 09:47:56 -07001490 */
Sunny Goyal07b69292018-01-08 14:19:34 -08001491 private void updateWorkspacePadding() {
1492 Rect padding = workspacePadding;
Tony Wickham3a3517f2015-10-06 11:27:04 -07001493 if (isVerticalBarLayout()) {
Jordan Silva3646a1b2023-08-02 13:52:52 +01001494 if (mIsResponsiveGrid) {
1495 padding.top = mResponsiveHeightSpec.getStartPaddingPx();
1496 padding.bottom = mResponsiveHeightSpec.getEndPaddingPx();
1497 if (isSeascape()) {
1498 padding.left = hotseatBarSizePx + mResponsiveWidthSpec.getEndPaddingPx();
1499 padding.right = mResponsiveWidthSpec.getStartPaddingPx();
1500 } else {
1501 padding.left = mResponsiveWidthSpec.getStartPaddingPx();
1502 padding.right = hotseatBarSizePx + mResponsiveWidthSpec.getEndPaddingPx();
1503 }
Winson1f064272016-07-18 17:18:02 -07001504 } else {
Jordan Silva3646a1b2023-08-02 13:52:52 +01001505 padding.top = 0;
1506 padding.bottom = edgeMarginPx;
1507 if (isSeascape()) {
1508 padding.left = hotseatBarSizePx;
1509 padding.right = hotseatBarSidePaddingStartPx;
1510 } else {
1511 padding.left = hotseatBarSidePaddingStartPx;
1512 padding.right = hotseatBarSizePx;
1513 }
Winson1f064272016-07-18 17:18:02 -07001514 }
Winson Chungb3800242013-10-24 11:01:54 -07001515 } else {
Thales Limab8c05952022-05-23 16:58:38 +01001516 // Pad the bottom of the workspace with hotseat bar
1517 // and leave a bit of space in case a widget go all the way down
Thales Lima79456492023-05-23 11:32:22 +01001518 int paddingBottom = hotseatBarSizePx + workspaceBottomPadding - mInsets.bottom;
1519 if (!mIsResponsiveGrid) {
1520 paddingBottom +=
1521 workspacePageIndicatorHeight - mWorkspacePageIndicatorOverlapWorkspace;
1522 }
1523 int paddingTop = workspaceTopPadding + (mIsScalableGrid ? 0 : edgeMarginPx);
Pat Manning08610ca2022-04-05 21:03:16 +01001524 int paddingSide = desiredWorkspaceHorizontalMarginPx;
Andras Kloczl8e57cce2021-02-11 23:51:19 +01001525
Pat Manning08610ca2022-04-05 21:03:16 +01001526 padding.set(paddingSide, paddingTop, paddingSide, paddingBottom);
Winson Chungb3800242013-10-24 11:01:54 -07001527 }
Pat Manning08610ca2022-04-05 21:03:16 +01001528 insetPadding(workspacePadding, cellLayoutPaddingPx);
1529 }
1530
1531 private void insetPadding(Rect paddings, Rect insets) {
1532 insets.left = Math.min(insets.left, paddings.left);
1533 paddings.left -= insets.left;
1534
1535 insets.top = Math.min(insets.top, paddings.top);
1536 paddings.top -= insets.top;
1537
1538 insets.right = Math.min(insets.right, paddings.right);
1539 paddings.right -= insets.right;
1540
1541 insets.bottom = Math.min(insets.bottom, paddings.bottom);
1542 paddings.bottom -= insets.bottom;
Winson Chungb3800242013-10-24 11:01:54 -07001543 }
1544
Sunny Goyal57b22792021-05-25 14:35:01 -07001545 /**
1546 * Returns the padding for hotseat view
1547 */
1548 public Rect getHotseatLayoutPadding(Context context) {
Pat Manning5f74bfd2022-07-20 12:08:54 +01001549 Rect hotseatBarPadding = new Rect();
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001550 if (isVerticalBarLayout()) {
Sihua Ma38bb3b02022-03-21 22:20:14 -07001551 // The hotseat icons will be placed in the middle of the hotseat cells.
1552 // Changing the hotseatCellHeightPx is not affecting hotseat icon positions
1553 // in vertical bar layout.
1554 // Workspace icons are moved up by a small factor. The variable diffOverlapFactor
1555 // is set to account for that difference.
Jordan Silva3646a1b2023-08-02 13:52:52 +01001556 float diffOverlapFactor = mIsResponsiveGrid ? 0
1557 : iconSizePx * (ICON_OVERLAP_FACTOR - 1) / 2;
1558
Pat Manning08610ca2022-04-05 21:03:16 +01001559 int paddingTop = Math.max((int) (mInsets.top + cellLayoutPaddingPx.top
1560 - diffOverlapFactor), 0);
1561 int paddingBottom = Math.max((int) (mInsets.bottom + cellLayoutPaddingPx.bottom
Sihua Ma38bb3b02022-03-21 22:20:14 -07001562 + diffOverlapFactor), 0);
1563
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001564 if (isSeascape()) {
Pat Manning5f74bfd2022-07-20 12:08:54 +01001565 hotseatBarPadding.set(mInsets.left + hotseatBarSidePaddingStartPx, paddingTop,
Pat Manning08610ca2022-04-05 21:03:16 +01001566 hotseatBarSidePaddingEndPx, paddingBottom);
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001567 } else {
Pat Manning5f74bfd2022-07-20 12:08:54 +01001568 hotseatBarPadding.set(hotseatBarSidePaddingEndPx, paddingTop,
Pat Manning08610ca2022-04-05 21:03:16 +01001569 mInsets.right + hotseatBarSidePaddingStartPx, paddingBottom);
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001570 }
Sunny Goyal57b22792021-05-25 14:35:01 -07001571 } else if (isTaskbarPresent) {
Alex Chau51da2192022-05-20 13:32:10 +01001572 // Center the QSB vertically with hotseat
Thales Limab8c05952022-05-23 16:58:38 +01001573 int hotseatBarBottomPadding = getHotseatBarBottomPadding();
1574 int hotseatBarTopPadding =
1575 hotseatBarSizePx - hotseatBarBottomPadding - hotseatCellHeightPx;
Alex Chau51da2192022-05-20 13:32:10 +01001576
Thales Lima6a590062022-11-22 15:52:49 +00001577 int hotseatWidth = getHotseatRequiredWidth();
Helen Cheuke76291f2023-02-14 17:11:05 +00001578 int startSpacing;
1579 int endSpacing;
Thales Lima6a590062022-11-22 15:52:49 +00001580 // Hotseat aligns to the left with nav buttons
1581 if (hotseatBarEndOffset > 0) {
Jon Mirandae17a9492023-03-08 16:42:20 -08001582 startSpacing = inlineNavButtonsEndSpacingPx;
Helen Cheuke76291f2023-02-14 17:11:05 +00001583 endSpacing = availableWidthPx - hotseatWidth - startSpacing + hotseatBorderSpace;
1584 } else {
1585 startSpacing = (availableWidthPx - hotseatWidth) / 2;
1586 endSpacing = startSpacing;
Thales Lima6a590062022-11-22 15:52:49 +00001587 }
Helen Cheuke76291f2023-02-14 17:11:05 +00001588 startSpacing += getAdditionalQsbSpace();
Thales Lima612230d2022-03-31 18:04:37 +01001589
Helen Cheuke76291f2023-02-14 17:11:05 +00001590 hotseatBarPadding.top = hotseatBarTopPadding;
1591 hotseatBarPadding.bottom = hotseatBarBottomPadding;
Alex Chau51da2192022-05-20 13:32:10 +01001592 boolean isRtl = Utilities.isRtl(context.getResources());
Thales Lima612230d2022-03-31 18:04:37 +01001593 if (isRtl) {
Helen Cheuke76291f2023-02-14 17:11:05 +00001594 hotseatBarPadding.left = endSpacing;
1595 hotseatBarPadding.right = startSpacing;
Thales Lima612230d2022-03-31 18:04:37 +01001596 } else {
Helen Cheuke76291f2023-02-14 17:11:05 +00001597 hotseatBarPadding.left = startSpacing;
1598 hotseatBarPadding.right = endSpacing;
Thales Lima612230d2022-03-31 18:04:37 +01001599 }
Helen Cheuke76291f2023-02-14 17:11:05 +00001600
Thales Lima79456492023-05-23 11:32:22 +01001601 } else if (mIsScalableGrid) {
Alex Chau206ede92022-08-01 17:46:12 +01001602 int sideSpacing = (availableWidthPx - hotseatQsbWidth) / 2;
Pat Manning5f74bfd2022-07-20 12:08:54 +01001603 hotseatBarPadding.set(sideSpacing,
Thales Limab8c05952022-05-23 16:58:38 +01001604 0,
Thales Lima425f6822022-05-10 13:44:58 -03001605 sideSpacing,
Thales Limab8c05952022-05-23 16:58:38 +01001606 getHotseatBarBottomPadding());
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001607 } else {
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001608 // We want the edges of the hotseat to line up with the edges of the workspace, but the
1609 // icons in the hotseat are a different size, and so don't line up perfectly. To account
1610 // for this, we pad the left and right of the hotseat with half of the difference of a
1611 // workspace cell vs a hotseat cell.
1612 float workspaceCellWidth = (float) widthPx / inv.numColumns;
Sunny Goyal19ff7282021-04-22 10:12:54 -07001613 float hotseatCellWidth = (float) widthPx / numShownHotseatIcons;
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001614 int hotseatAdjustment = Math.round((workspaceCellWidth - hotseatCellWidth) / 2);
Pat Manning5f74bfd2022-07-20 12:08:54 +01001615 hotseatBarPadding.set(
Thales Limab8c05952022-05-23 16:58:38 +01001616 hotseatAdjustment + workspacePadding.left + cellLayoutPaddingPx.left
1617 + mInsets.left,
1618 0,
Pat Manning08610ca2022-04-05 21:03:16 +01001619 hotseatAdjustment + workspacePadding.right + cellLayoutPaddingPx.right
Sunny Goyal786940a2020-06-02 02:31:31 -07001620 + mInsets.right,
Thales Limab8c05952022-05-23 16:58:38 +01001621 getHotseatBarBottomPadding());
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001622 }
Pat Manning5f74bfd2022-07-20 12:08:54 +01001623 return hotseatBarPadding;
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001624 }
1625
Andy Wickhambd9a1802023-06-08 16:33:15 -07001626 /** The margin between the edge of all apps and the edge of the first icon. */
1627 public int getAllAppsIconStartMargin() {
1628 int allAppsSpacing;
1629 if (isVerticalBarLayout()) {
1630 // On phones, the landscape layout uses a different setup.
1631 allAppsSpacing = workspacePadding.left + workspacePadding.right;
1632 } else {
1633 allAppsSpacing = allAppsLeftRightPadding * 2 + allAppsLeftRightMargin * 2;
1634 }
1635
1636 int cellWidth = DeviceProfile.calculateCellWidth(
1637 availableWidthPx - allAppsSpacing,
1638 0 /* borderSpace */,
1639 numShownAllAppsColumns);
1640 int iconVisibleSize = Math.round(ICON_VISIBLE_AREA_FACTOR * allAppsIconSizePx);
1641 int iconAlignmentMargin = (cellWidth - iconVisibleSize) / 2;
1642 return allAppsLeftRightPadding + iconAlignmentMargin;
1643 }
1644
Thales Lima9938c2f2022-07-25 14:38:16 +01001645 private int getAdditionalQsbSpace() {
1646 return isQsbInline ? hotseatQsbWidth + hotseatBorderSpace : 0;
1647 }
1648
1649 /**
1650 * Calculate how much space the hotseat needs to be shown completely
1651 */
1652 private int getHotseatRequiredWidth() {
1653 int additionalQsbSpace = getAdditionalQsbSpace();
1654 return iconSizePx * numShownHotseatIcons
Thales Lima6a590062022-11-22 15:52:49 +00001655 + hotseatBorderSpace * (numShownHotseatIcons - (areNavButtonsInline ? 0 : 1))
Thales Lima9938c2f2022-07-25 14:38:16 +01001656 + additionalQsbSpace;
1657 }
1658
Winsonfadbe8f2016-07-22 16:35:37 -07001659 /**
Sunny Goyal57b22792021-05-25 14:35:01 -07001660 * Returns the number of pixels the QSB is translated from the bottom of the screen.
1661 */
1662 public int getQsbOffsetY() {
Thales Limaa1012902022-01-13 17:58:42 +00001663 if (isQsbInline) {
Thales Limab8c05952022-05-23 16:58:38 +01001664 return getHotseatBarBottomPadding() - ((hotseatQsbHeight - hotseatCellHeightPx) / 2);
1665 } else if (isTaskbarPresent) { // QSB on top
1666 return hotseatBarSizePx - hotseatQsbHeight + hotseatQsbShadowHeight;
Jonathan Miranda8f16a772021-07-23 23:10:37 +00001667 } else {
Thales Limab8c05952022-05-23 16:58:38 +01001668 return hotseatBarBottomSpacePx - hotseatQsbShadowHeight;
Jonathan Miranda7a273e22021-06-24 21:29:10 +00001669 }
Sunny Goyal57b22792021-05-25 14:35:01 -07001670 }
1671
Thales Limab8c05952022-05-23 16:58:38 +01001672 /**
1673 * Returns the number of pixels the hotseat is translated from the bottom of the screen.
1674 */
1675 private int getHotseatBarBottomPadding() {
1676 if (isTaskbarPresent) { // QSB on top or inline
1677 return hotseatBarBottomSpacePx - (Math.abs(hotseatCellHeightPx - iconSizePx) / 2);
Thales Limaa1012902022-01-13 17:58:42 +00001678 } else {
Thales Limab8c05952022-05-23 16:58:38 +01001679 return hotseatBarSizePx - hotseatCellHeightPx;
Thales Limaa1012902022-01-13 17:58:42 +00001680 }
Sunny Goyal57b22792021-05-25 14:35:01 -07001681 }
1682
1683 /**
Alex Chau51da2192022-05-20 13:32:10 +01001684 * Returns the number of pixels the taskbar is translated from the bottom of the screen.
1685 */
1686 public int getTaskbarOffsetY() {
Jon Miranda9c478b62023-03-23 21:38:49 -07001687 int taskbarIconBottomSpace = (taskbarHeight - iconSizePx) / 2;
Alex Chau51da2192022-05-20 13:32:10 +01001688 int launcherIconBottomSpace =
1689 Math.min((hotseatCellHeightPx - iconSizePx) / 2, gridVisualizationPaddingY);
Thales Limab8c05952022-05-23 16:58:38 +01001690 return getHotseatBarBottomPadding() + launcherIconBottomSpace - taskbarIconBottomSpace;
Alex Chau51da2192022-05-20 13:32:10 +01001691 }
1692
1693 /**
Alex Chaua2fc7642022-04-21 14:20:23 +01001694 * Returns the number of pixels required below OverviewActions excluding insets.
1695 */
1696 public int getOverviewActionsClaimedSpaceBelow() {
Alex Chaud67ddc42022-09-30 18:15:56 +01001697 if (isTaskbarPresent) {
Jon Miranda9c478b62023-03-23 21:38:49 -07001698 return taskbarHeight + taskbarBottomMargin * 2;
Alex Chaud67ddc42022-09-30 18:15:56 +01001699 }
1700 return mInsets.bottom;
Alex Chaua2fc7642022-04-21 14:20:23 +01001701 }
1702
1703 /** Gets the space that the overview actions will take, including bottom margin. */
1704 public int getOverviewActionsClaimedSpace() {
Pat Manning7b8f7662023-01-18 14:48:30 +00001705 int overviewActionsSpace = isTablet && FeatureFlags.ENABLE_GRID_ONLY_OVERVIEW.get()
1706 ? 0
1707 : (overviewActionsTopMarginPx + overviewActionsHeight);
1708 return overviewActionsSpace + getOverviewActionsClaimedSpaceBelow();
Alex Chaua2fc7642022-04-21 14:20:23 +01001709 }
1710
1711 /**
Sihua Mae04aa202022-07-18 12:43:56 -07001712 * Takes the View and return the scales of width and height depending on the DeviceProfile
1713 * specifications
1714 *
1715 * @param itemInfo The tag of the widget view
1716 * @return A PointF instance with the x set to be the scale of width, and y being the scale of
1717 * height
1718 */
1719 @NonNull
1720 public PointF getAppWidgetScale(@Nullable final ItemInfo itemInfo) {
1721 return mViewScaleProvider.getScaleFromItemInfo(itemInfo);
1722 }
1723
1724 /**
Winsonfadbe8f2016-07-22 16:35:37 -07001725 * @return the bounds for which the open folders should be contained within
1726 */
1727 public Rect getAbsoluteOpenFolderBounds() {
1728 if (isVerticalBarLayout()) {
1729 // Folders should only appear right of the drop target bar and left of the hotseat
1730 return new Rect(mInsets.left + dropTargetBarSizePx + edgeMarginPx,
1731 mInsets.top,
Jon Miranda18751b62017-07-31 17:25:27 -07001732 mInsets.left + availableWidthPx - hotseatBarSizePx - edgeMarginPx,
Winsonfadbe8f2016-07-22 16:35:37 -07001733 mInsets.top + availableHeightPx);
1734 } else {
1735 // Folders should only appear below the drop target bar and above the hotseat
Jon Miranda9c478b62023-03-23 21:38:49 -07001736 int hotseatTop = isTaskbarPresent ? taskbarHeight : hotseatBarSizePx;
Tony Wickhamb4b7e202018-01-12 17:39:24 -08001737 return new Rect(mInsets.left + edgeMarginPx,
Winsonfadbe8f2016-07-22 16:35:37 -07001738 mInsets.top + dropTargetBarSizePx + edgeMarginPx,
Tony Wickhamb4b7e202018-01-12 17:39:24 -08001739 mInsets.left + availableWidthPx - edgeMarginPx,
Tony Wickhamae72b462021-03-10 16:18:40 -08001740 mInsets.top + availableHeightPx - hotseatTop
Tony Wickham5edf9e22020-03-27 20:06:52 -07001741 - workspacePageIndicatorHeight - edgeMarginPx);
Winsonfadbe8f2016-07-22 16:35:37 -07001742 }
1743 }
1744
Jon Miranda228877d2021-02-09 11:05:00 -05001745 public static int calculateCellWidth(int width, int borderSpacing, int countX) {
1746 return (width - ((countX - 1) * borderSpacing)) / countX;
Winson Chungb3800242013-10-24 11:01:54 -07001747 }
Pierre Barbier de Reuille578deba2021-09-24 13:47:44 +01001748
Jon Miranda228877d2021-02-09 11:05:00 -05001749 public static int calculateCellHeight(int height, int borderSpacing, int countY) {
1750 return (height - ((countY - 1) * borderSpacing)) / countY;
Winson Chungb3800242013-10-24 11:01:54 -07001751 }
1752
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -07001753 /**
Tony Wickham55616cd2015-09-23 14:55:17 -07001754 * When {@code true}, the device is in landscape mode and the hotseat is on the right column.
1755 * When {@code false}, either device is in portrait mode or the device is in landscape mode and
1756 * the hotseat is on the bottom row.
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -07001757 */
Tony Wickhamab946a12015-09-16 15:38:16 -07001758 public boolean isVerticalBarLayout() {
Winson Chungb3800242013-10-24 11:01:54 -07001759 return isLandscape && transposeLayoutWithOrientation;
1760 }
1761
Sunny Goyal59d086c2018-05-07 17:31:40 -07001762 /**
1763 * Updates orientation information and returns true if it has changed from the previous value.
1764 */
Winson Chung13c1c2c2019-09-06 11:46:19 -07001765 public boolean updateIsSeascape(Context context) {
Sunny Goyal59d086c2018-05-07 17:31:40 -07001766 if (isVerticalBarLayout()) {
Sunny Goyal35c7b192021-04-20 16:51:10 -07001767 boolean isSeascape = DisplayController.INSTANCE.get(context)
1768 .getInfo().rotation == Surface.ROTATION_270;
Sunny Goyal59d086c2018-05-07 17:31:40 -07001769 if (mIsSeascape != isSeascape) {
1770 mIsSeascape = isSeascape;
Pat Manning08610ca2022-04-05 21:03:16 +01001771 // Hotseat changing sides requires updating workspace left/right paddings
1772 updateWorkspacePadding();
Sunny Goyal59d086c2018-05-07 17:31:40 -07001773 return true;
1774 }
1775 }
1776 return false;
1777 }
1778
Sunny Goyal7e2e67f2018-01-26 13:40:08 -08001779 public boolean isSeascape() {
Sunny Goyal59d086c2018-05-07 17:31:40 -07001780 return isVerticalBarLayout() && mIsSeascape;
Sunny Goyal7e2e67f2018-01-26 13:40:08 -08001781 }
1782
Sunny Goyal07b69292018-01-08 14:19:34 -08001783 public boolean shouldFadeAdjacentWorkspaceScreens() {
Sunny Goyal19ff7282021-04-22 10:12:54 -07001784 return isVerticalBarLayout();
Winson Chungb3800242013-10-24 11:01:54 -07001785 }
1786
Jon Miranda92c1b5d2021-07-20 13:57:16 -07001787 public int getCellContentHeight(@ContainerType int containerType) {
Sunny Goyalc13403c2016-11-18 23:44:48 -08001788 switch (containerType) {
1789 case CellLayout.WORKSPACE:
1790 return cellHeightPx;
1791 case CellLayout.FOLDER:
1792 return folderCellHeightPx;
1793 case CellLayout.HOTSEAT:
Jon Miranda92c1b5d2021-07-20 13:57:16 -07001794 // The hotseat is the only container where the cell height is going to be
1795 // different from the content within that cell.
1796 return iconSizePx;
Sunny Goyalc13403c2016-11-18 23:44:48 -08001797 default:
1798 // ??
1799 return 0;
1800 }
1801 }
Sunny Goyal13178ac2016-04-04 16:35:22 -07001802
Jon Miranda58561d42021-03-17 10:51:54 -04001803 private String pxToDpStr(String name, float value) {
Sunny Goyal35c7b192021-04-20 16:51:10 -07001804 return "\t" + name + ": " + value + "px (" + dpiFromPx(value, mMetrics.densityDpi) + "dp)";
Jon Miranda58561d42021-03-17 10:51:54 -04001805 }
1806
Alex Chaue818bcb2022-09-02 17:27:11 +01001807 private String dpPointFToString(String name, PointF value) {
1808 return String.format(Locale.ENGLISH, "\t%s: PointF(%.1f, %.1f)dp", name, value.x, value.y);
1809 }
1810
Pat Manning5f74bfd2022-07-20 12:08:54 +01001811 /** Dumps various DeviceProfile variables to the specified writer. */
1812 public void dump(Context context, String prefix, PrintWriter writer) {
Jon Miranda58561d42021-03-17 10:51:54 -04001813 writer.println(prefix + "DeviceProfile:");
Sunny Goyal35c7b192021-04-20 16:51:10 -07001814 writer.println(prefix + "\t1 dp = " + mMetrics.density + " px");
Jon Miranda58561d42021-03-17 10:51:54 -04001815
1816 writer.println(prefix + "\tisTablet:" + isTablet);
Jon Miranda58561d42021-03-17 10:51:54 -04001817 writer.println(prefix + "\tisPhone:" + isPhone);
1818 writer.println(prefix + "\ttransposeLayoutWithOrientation:"
1819 + transposeLayoutWithOrientation);
Alex Chau6ed408f2022-03-04 12:58:05 +00001820 writer.println(prefix + "\tisGestureMode:" + isGestureMode);
Jon Miranda58561d42021-03-17 10:51:54 -04001821
1822 writer.println(prefix + "\tisLandscape:" + isLandscape);
1823 writer.println(prefix + "\tisMultiWindowMode:" + isMultiWindowMode);
Sunny Goyal19ff7282021-04-22 10:12:54 -07001824 writer.println(prefix + "\tisTwoPanels:" + isTwoPanels);
Jon Miranda58561d42021-03-17 10:51:54 -04001825
1826 writer.println(prefix + pxToDpStr("windowX", windowX));
1827 writer.println(prefix + pxToDpStr("windowY", windowY));
1828 writer.println(prefix + pxToDpStr("widthPx", widthPx));
1829 writer.println(prefix + pxToDpStr("heightPx", heightPx));
Jon Miranda58561d42021-03-17 10:51:54 -04001830 writer.println(prefix + pxToDpStr("availableWidthPx", availableWidthPx));
1831 writer.println(prefix + pxToDpStr("availableHeightPx", availableHeightPx));
Alex Chaue0227552022-04-06 19:44:43 +01001832 writer.println(prefix + pxToDpStr("mInsets.left", mInsets.left));
1833 writer.println(prefix + pxToDpStr("mInsets.top", mInsets.top));
1834 writer.println(prefix + pxToDpStr("mInsets.right", mInsets.right));
1835 writer.println(prefix + pxToDpStr("mInsets.bottom", mInsets.bottom));
Jon Miranda58561d42021-03-17 10:51:54 -04001836
1837 writer.println(prefix + "\taspectRatio:" + aspectRatio);
1838
Thales Limac98b7812023-04-14 15:04:23 +01001839 writer.println(prefix + "\tisResponsiveGrid:" + mIsResponsiveGrid);
Thales Lima79456492023-05-23 11:32:22 +01001840 writer.println(prefix + "\tisScalableGrid:" + mIsScalableGrid);
Jon Miranda58561d42021-03-17 10:51:54 -04001841
Thales Lima83bedbf2021-10-05 17:47:39 +01001842 writer.println(prefix + "\tinv.numRows: " + inv.numRows);
Alex Chau9fee3fd2021-12-01 18:43:10 +00001843 writer.println(prefix + "\tinv.numColumns: " + inv.numColumns);
1844 writer.println(prefix + "\tinv.numSearchContainerColumns: "
1845 + inv.numSearchContainerColumns);
Jon Miranda58561d42021-03-17 10:51:54 -04001846
Alex Chaue818bcb2022-09-02 17:27:11 +01001847 writer.println(prefix + dpPointFToString("minCellSize", inv.minCellSize[mTypeIndex]));
Jon Mirandaab3c6812021-06-28 15:42:28 -07001848
Jon Miranda58561d42021-03-17 10:51:54 -04001849 writer.println(prefix + pxToDpStr("cellWidthPx", cellWidthPx));
1850 writer.println(prefix + pxToDpStr("cellHeightPx", cellHeightPx));
1851
1852 writer.println(prefix + pxToDpStr("getCellSize().x", getCellSize().x));
1853 writer.println(prefix + pxToDpStr("getCellSize().y", getCellSize().y));
1854
Thales Lima83bedbf2021-10-05 17:47:39 +01001855 writer.println(prefix + pxToDpStr("cellLayoutBorderSpacePx Horizontal",
1856 cellLayoutBorderSpacePx.x));
1857 writer.println(prefix + pxToDpStr("cellLayoutBorderSpacePx Vertical",
1858 cellLayoutBorderSpacePx.y));
Pat Manning5f74bfd2022-07-20 12:08:54 +01001859 writer.println(
1860 prefix + pxToDpStr("cellLayoutPaddingPx.left", cellLayoutPaddingPx.left));
1861 writer.println(
1862 prefix + pxToDpStr("cellLayoutPaddingPx.top", cellLayoutPaddingPx.top));
1863 writer.println(
1864 prefix + pxToDpStr("cellLayoutPaddingPx.right", cellLayoutPaddingPx.right));
Pat Manning08610ca2022-04-05 21:03:16 +01001865 writer.println(
1866 prefix + pxToDpStr("cellLayoutPaddingPx.bottom", cellLayoutPaddingPx.bottom));
Thales Lima83bedbf2021-10-05 17:47:39 +01001867
Jon Miranda58561d42021-03-17 10:51:54 -04001868 writer.println(prefix + pxToDpStr("iconSizePx", iconSizePx));
1869 writer.println(prefix + pxToDpStr("iconTextSizePx", iconTextSizePx));
1870 writer.println(prefix + pxToDpStr("iconDrawablePaddingPx", iconDrawablePaddingPx));
1871
Helen Cheuk599109b2023-02-23 17:15:39 +00001872 writer.println(prefix + "\tinv.numFolderRows: " + inv.numFolderRows);
1873 writer.println(prefix + "\tinv.numFolderColumns: " + inv.numFolderColumns);
Jon Miranda58561d42021-03-17 10:51:54 -04001874 writer.println(prefix + pxToDpStr("folderCellWidthPx", folderCellWidthPx));
1875 writer.println(prefix + pxToDpStr("folderCellHeightPx", folderCellHeightPx));
1876 writer.println(prefix + pxToDpStr("folderChildIconSizePx", folderChildIconSizePx));
1877 writer.println(prefix + pxToDpStr("folderChildTextSizePx", folderChildTextSizePx));
1878 writer.println(prefix + pxToDpStr("folderChildDrawablePaddingPx",
1879 folderChildDrawablePaddingPx));
Jordan Silva637f4eb2023-06-13 11:21:53 +01001880 writer.println(prefix + pxToDpStr("folderCellLayoutBorderSpacePx.x",
1881 folderCellLayoutBorderSpacePx.x));
1882 writer.println(prefix + pxToDpStr("folderCellLayoutBorderSpacePx.y",
1883 folderCellLayoutBorderSpacePx.y));
Thales Limaa08a4432022-08-09 09:55:17 +01001884 writer.println(prefix + pxToDpStr("folderContentPaddingLeftRight",
1885 folderContentPaddingLeftRight));
1886 writer.println(prefix + pxToDpStr("folderTopPadding", folderContentPaddingTop));
Thales Limab35faed2022-09-05 16:30:01 -03001887 writer.println(prefix + pxToDpStr("folderFooterHeight", folderFooterHeightPx));
Jon Miranda58561d42021-03-17 10:51:54 -04001888
Alex Chaue0227552022-04-06 19:44:43 +01001889 writer.println(prefix + pxToDpStr("bottomSheetTopPadding", bottomSheetTopPadding));
Alex Chau3d2c0622022-09-01 21:28:14 +01001890 writer.println(prefix + "\tbottomSheetOpenDuration: " + bottomSheetOpenDuration);
1891 writer.println(prefix + "\tbottomSheetCloseDuration: " + bottomSheetCloseDuration);
1892 writer.println(prefix + "\tbottomSheetWorkspaceScale: " + bottomSheetWorkspaceScale);
1893 writer.println(prefix + "\tbottomSheetDepth: " + bottomSheetDepth);
Alex Chaue0227552022-04-06 19:44:43 +01001894
1895 writer.println(prefix + pxToDpStr("allAppsShiftRange", allAppsShiftRange));
1896 writer.println(prefix + pxToDpStr("allAppsTopPadding", allAppsTopPadding));
Alex Chau3d2c0622022-09-01 21:28:14 +01001897 writer.println(prefix + "\tallAppsOpenDuration: " + allAppsOpenDuration);
1898 writer.println(prefix + "\tallAppsCloseDuration: " + allAppsCloseDuration);
Jon Miranda58561d42021-03-17 10:51:54 -04001899 writer.println(prefix + pxToDpStr("allAppsIconSizePx", allAppsIconSizePx));
1900 writer.println(prefix + pxToDpStr("allAppsIconTextSizePx", allAppsIconTextSizePx));
1901 writer.println(prefix + pxToDpStr("allAppsIconDrawablePaddingPx",
1902 allAppsIconDrawablePaddingPx));
1903 writer.println(prefix + pxToDpStr("allAppsCellHeightPx", allAppsCellHeightPx));
Alex Chau27b39b92022-01-14 18:02:18 +00001904 writer.println(prefix + pxToDpStr("allAppsCellWidthPx", allAppsCellWidthPx));
Pat Manning26f70f72022-07-07 13:50:39 +01001905 writer.println(prefix + pxToDpStr("allAppsBorderSpacePxX", allAppsBorderSpacePx.x));
1906 writer.println(prefix + pxToDpStr("allAppsBorderSpacePxY", allAppsBorderSpacePx.y));
Sunny Goyal19ff7282021-04-22 10:12:54 -07001907 writer.println(prefix + "\tnumShownAllAppsColumns: " + numShownAllAppsColumns);
Alex Chau62572c02022-07-25 18:36:37 +00001908 writer.println(prefix + pxToDpStr("allAppsLeftRightPadding", allAppsLeftRightPadding));
Alex Chau27b39b92022-01-14 18:02:18 +00001909 writer.println(prefix + pxToDpStr("allAppsLeftRightMargin", allAppsLeftRightMargin));
Jon Miranda58561d42021-03-17 10:51:54 -04001910
1911 writer.println(prefix + pxToDpStr("hotseatBarSizePx", hotseatBarSizePx));
Thales Lima425f6822022-05-10 13:44:58 -03001912 writer.println(prefix + "\tinv.hotseatColumnSpan: " + inv.hotseatColumnSpan[mTypeIndex]);
Jon Miranda58561d42021-03-17 10:51:54 -04001913 writer.println(prefix + pxToDpStr("hotseatCellHeightPx", hotseatCellHeightPx));
Alex Chau62572c02022-07-25 18:36:37 +00001914 writer.println(prefix + pxToDpStr("hotseatBarBottomSpacePx", hotseatBarBottomSpacePx));
Jon Miranda58561d42021-03-17 10:51:54 -04001915 writer.println(prefix + pxToDpStr("hotseatBarSidePaddingStartPx",
1916 hotseatBarSidePaddingStartPx));
1917 writer.println(prefix + pxToDpStr("hotseatBarSidePaddingEndPx",
1918 hotseatBarSidePaddingEndPx));
Pat Manning26f70f72022-07-07 13:50:39 +01001919 writer.println(prefix + pxToDpStr("hotseatBarEndOffset", hotseatBarEndOffset));
Thales Limab8c05952022-05-23 16:58:38 +01001920 writer.println(prefix + pxToDpStr("hotseatQsbSpace", hotseatQsbSpace));
1921 writer.println(prefix + pxToDpStr("hotseatQsbHeight", hotseatQsbHeight));
Pat Manningde25c0d2022-04-05 19:11:26 +01001922 writer.println(prefix + pxToDpStr("springLoadedHotseatBarTopMarginPx",
1923 springLoadedHotseatBarTopMarginPx));
Pat Manning5f74bfd2022-07-20 12:08:54 +01001924 Rect hotseatLayoutPadding = getHotseatLayoutPadding(context);
1925 writer.println(prefix + pxToDpStr("getHotseatLayoutPadding(context).top",
1926 hotseatLayoutPadding.top));
1927 writer.println(prefix + pxToDpStr("getHotseatLayoutPadding(context).bottom",
1928 hotseatLayoutPadding.bottom));
1929 writer.println(prefix + pxToDpStr("getHotseatLayoutPadding(context).left",
1930 hotseatLayoutPadding.left));
1931 writer.println(prefix + pxToDpStr("getHotseatLayoutPadding(context).right",
1932 hotseatLayoutPadding.right));
Sunny Goyal19ff7282021-04-22 10:12:54 -07001933 writer.println(prefix + "\tnumShownHotseatIcons: " + numShownHotseatIcons);
Thales Lima116b51a2022-02-03 16:19:47 +00001934 writer.println(prefix + pxToDpStr("hotseatBorderSpace", hotseatBorderSpace));
Thales Limaa1012902022-01-13 17:58:42 +00001935 writer.println(prefix + "\tisQsbInline: " + isQsbInline);
Alex Chau206ede92022-08-01 17:46:12 +01001936 writer.println(prefix + pxToDpStr("hotseatQsbWidth", hotseatQsbWidth));
Jon Miranda58561d42021-03-17 10:51:54 -04001937
1938 writer.println(prefix + "\tisTaskbarPresent:" + isTaskbarPresent);
Tony Wickham635e1802021-07-22 14:28:04 -10001939 writer.println(prefix + "\tisTaskbarPresentInApps:" + isTaskbarPresentInApps);
Jon Miranda9c478b62023-03-23 21:38:49 -07001940 writer.println(prefix + pxToDpStr("taskbarHeight", taskbarHeight));
1941 writer.println(prefix + pxToDpStr("stashedTaskbarHeight", stashedTaskbarHeight));
1942 writer.println(prefix + pxToDpStr("taskbarBottomMargin", taskbarBottomMargin));
1943 writer.println(prefix + pxToDpStr("taskbarIconSize", taskbarIconSize));
Jon Miranda58561d42021-03-17 10:51:54 -04001944
Thales Lima83bedbf2021-10-05 17:47:39 +01001945 writer.println(prefix + pxToDpStr("desiredWorkspaceHorizontalMarginPx",
1946 desiredWorkspaceHorizontalMarginPx));
Jon Miranda58561d42021-03-17 10:51:54 -04001947 writer.println(prefix + pxToDpStr("workspacePadding.left", workspacePadding.left));
1948 writer.println(prefix + pxToDpStr("workspacePadding.top", workspacePadding.top));
1949 writer.println(prefix + pxToDpStr("workspacePadding.right", workspacePadding.right));
Alex Chau62572c02022-07-25 18:36:37 +00001950 writer.println(prefix + pxToDpStr("workspacePadding.bottom", workspacePadding.bottom));
Jon Miranda58561d42021-03-17 10:51:54 -04001951
Jon Mirandaab3c6812021-06-28 15:42:28 -07001952 writer.println(prefix + pxToDpStr("iconScale", iconScale));
1953 writer.println(prefix + pxToDpStr("cellScaleToFit ", cellScaleToFit));
Jon Miranda58561d42021-03-17 10:51:54 -04001954 writer.println(prefix + pxToDpStr("extraSpace", extraSpace));
Alex Chau62572c02022-07-25 18:36:37 +00001955 writer.println(prefix + pxToDpStr("unscaled extraSpace", extraSpace / iconScale));
Jon Mirandac9e69fa2021-03-22 17:13:34 -04001956
Thales Lima171ee662022-11-22 15:52:49 +00001957 writer.println(prefix + pxToDpStr("maxEmptySpace", maxEmptySpace));
Jon Miranda58561d42021-03-17 10:51:54 -04001958 writer.println(prefix + pxToDpStr("workspaceTopPadding", workspaceTopPadding));
1959 writer.println(prefix + pxToDpStr("workspaceBottomPadding", workspaceBottomPadding));
Alex Chau635b3ab2022-01-26 16:49:10 +00001960
1961 writer.println(prefix + pxToDpStr("overviewTaskMarginPx", overviewTaskMarginPx));
Alex Chau635b3ab2022-01-26 16:49:10 +00001962 writer.println(prefix + pxToDpStr("overviewTaskIconSizePx", overviewTaskIconSizePx));
1963 writer.println(prefix + pxToDpStr("overviewTaskIconDrawableSizePx",
1964 overviewTaskIconDrawableSizePx));
1965 writer.println(prefix + pxToDpStr("overviewTaskIconDrawableSizeGridPx",
1966 overviewTaskIconDrawableSizeGridPx));
1967 writer.println(prefix + pxToDpStr("overviewTaskThumbnailTopMarginPx",
1968 overviewTaskThumbnailTopMarginPx));
Alex Chaua2fc7642022-04-21 14:20:23 +01001969 writer.println(prefix + pxToDpStr("overviewActionsTopMarginPx",
1970 overviewActionsTopMarginPx));
1971 writer.println(prefix + pxToDpStr("overviewActionsHeight",
1972 overviewActionsHeight));
Alex Chau1b276a12022-12-19 14:01:36 +00001973 writer.println(prefix + pxToDpStr("overviewActionsClaimedSpaceBelow",
1974 getOverviewActionsClaimedSpaceBelow()));
Alex Chau635b3ab2022-01-26 16:49:10 +00001975 writer.println(prefix + pxToDpStr("overviewActionsButtonSpacing",
1976 overviewActionsButtonSpacing));
1977 writer.println(prefix + pxToDpStr("overviewPageSpacing", overviewPageSpacing));
1978 writer.println(prefix + pxToDpStr("overviewRowSpacing", overviewRowSpacing));
1979 writer.println(prefix + pxToDpStr("overviewGridSideMargin", overviewGridSideMargin));
Pat Manningde25c0d2022-04-05 19:11:26 +01001980
Alex Chau62572c02022-07-25 18:36:37 +00001981 writer.println(prefix + pxToDpStr("dropTargetBarTopMarginPx", dropTargetBarTopMarginPx));
Pat Manningde25c0d2022-04-05 19:11:26 +01001982 writer.println(prefix + pxToDpStr("dropTargetBarSizePx", dropTargetBarSizePx));
Alex Chau62572c02022-07-25 18:36:37 +00001983 writer.println(
1984 prefix + pxToDpStr("dropTargetBarBottomMarginPx", dropTargetBarBottomMarginPx));
Pat Manningde25c0d2022-04-05 19:11:26 +01001985
Pat Manning5f74bfd2022-07-20 12:08:54 +01001986 writer.println(prefix + pxToDpStr("getCellLayoutSpringLoadShrunkTop()",
1987 getCellLayoutSpringLoadShrunkTop()));
1988 writer.println(prefix + pxToDpStr("getCellLayoutSpringLoadShrunkBottom()",
1989 getCellLayoutSpringLoadShrunkBottom(context)));
Alex Chau906d8822022-05-23 10:42:25 +01001990 writer.println(prefix + pxToDpStr("workspaceSpringLoadedMinNextPageVisiblePx",
1991 workspaceSpringLoadedMinNextPageVisiblePx));
Pat Manning5f74bfd2022-07-20 12:08:54 +01001992 writer.println(prefix + pxToDpStr("getWorkspaceSpringLoadScale()",
1993 getWorkspaceSpringLoadScale(context)));
Thales Limab8c05952022-05-23 16:58:38 +01001994 writer.println(prefix + pxToDpStr("getCellLayoutHeight()", getCellLayoutHeight()));
1995 writer.println(prefix + pxToDpStr("getCellLayoutWidth()", getCellLayoutWidth()));
Thales Lima79456492023-05-23 11:32:22 +01001996 if (mIsResponsiveGrid) {
1997 writer.println(prefix + "\tmResponsiveHeightSpec:" + mResponsiveHeightSpec.toString());
1998 writer.println(prefix + "\tmResponsiveWidthSpec:" + mResponsiveWidthSpec.toString());
Thales Limaabfe3642023-05-24 18:08:53 +01001999 writer.println(prefix + "\tmAllAppsResponsiveHeightSpec:"
2000 + mAllAppsResponsiveHeightSpec.toString());
2001 writer.println(prefix + "\tmAllAppsResponsiveWidthSpec:"
2002 + mAllAppsResponsiveWidthSpec.toString());
Jordan Silva637f4eb2023-06-13 11:21:53 +01002003 writer.println(prefix + "\tmResponsiveFolderHeightSpec:" + mResponsiveFolderHeightSpec);
2004 writer.println(prefix + "\tmResponsiveFolderWidthSpec:" + mResponsiveFolderWidthSpec);
Thales Limaf8bfb032023-07-24 15:08:05 +01002005 writer.println(prefix + "\tmResponsiveHotseatSpec:" + mResponsiveHotseatSpec);
Thales Lima79456492023-05-23 11:32:22 +01002006 }
Jon Miranda58561d42021-03-17 10:51:54 -04002007 }
2008
Nicolo' Mazzucatocb7bd502023-01-16 19:46:30 +00002009 /** Returns a reduced representation of this DeviceProfile. */
2010 public String toSmallString() {
2011 return "isTablet:" + isTablet + ", "
2012 + "isMultiDisplay:" + isMultiDisplay + ", "
2013 + "widthPx:" + widthPx + ", "
2014 + "heightPx:" + heightPx + ", "
2015 + "insets:" + mInsets + ", "
2016 + "rotationHint:" + rotationHint;
2017 }
2018
Alex Chaua6907dc2022-03-18 15:24:07 +00002019 private static Context getContext(Context c, Info info, int orientation, WindowBounds bounds) {
Sunny Goyal1890f672020-04-30 12:28:00 -07002020 Configuration config = new Configuration(c.getResources().getConfiguration());
2021 config.orientation = orientation;
Thales Lima425f6822022-05-10 13:44:58 -03002022 config.densityDpi = info.getDensityDpi();
Alex Chaua6907dc2022-03-18 15:24:07 +00002023 config.smallestScreenWidthDp = (int) info.smallestSizeDp(bounds);
Sunny Goyal1890f672020-04-30 12:28:00 -07002024 return c.createConfigurationContext(config);
Jon Mirandab28c4fc2017-06-20 10:58:36 -07002025 }
Sunny Goyalfde55052018-02-01 14:46:13 -08002026
2027 /**
2028 * Callback when a component changes the DeviceProfile associated with it, as a result of
2029 * configuration change
2030 */
2031 public interface OnDeviceProfileChangeListener {
2032
2033 /**
2034 * Called when the device profile is reassigned. Note that for layout and measurements, it
2035 * is sufficient to listen for inset changes. Use this callback when you need to perform
2036 * a one time operation.
2037 */
2038 void onDeviceProfileChanged(DeviceProfile dp);
2039 }
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002040
Sihua Mae04aa202022-07-18 12:43:56 -07002041 /**
2042 * Handler that deals with ItemInfo of the views for the DeviceProfile
2043 */
2044 @FunctionalInterface
2045 public interface ViewScaleProvider {
2046 /**
2047 * Get the scales from the view
2048 *
2049 * @param itemInfo The tag of the widget view
2050 * @return PointF instance containing the scale information, or null if using the default
2051 * app widget scale of this device profile.
2052 */
2053 @NonNull
2054 PointF getScaleFromItemInfo(@Nullable ItemInfo itemInfo);
2055 }
2056
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002057 public static class Builder {
2058 private Context mContext;
2059 private InvariantDeviceProfile mInv;
Sunny Goyalfd58da62020-08-11 12:06:49 -07002060 private Info mInfo;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002061
Sunny Goyal19ff7282021-04-22 10:12:54 -07002062 private WindowBounds mWindowBounds;
Alex Chauab800f72022-12-13 17:46:06 +00002063 private boolean mIsMultiDisplay;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002064
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002065 private boolean mIsMultiWindowMode = false;
Sunny Goyal19ff7282021-04-22 10:12:54 -07002066 private Boolean mTransposeLayoutWithOrientation;
Alex Chau6ed408f2022-03-04 12:58:05 +00002067 private Boolean mIsGestureMode;
Sihua Mae04aa202022-07-18 12:43:56 -07002068 private ViewScaleProvider mViewScaleProvider = null;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002069
Sunny Goyal65190ae2022-08-02 14:16:26 -07002070 private SparseArray<DotRenderer> mDotRendererCache;
2071
Jon Miranda2b25ded2023-02-02 14:48:45 -08002072 private Consumer<DeviceProfile> mOverrideProvider;
2073
Sunny Goyalfd58da62020-08-11 12:06:49 -07002074 public Builder(Context context, InvariantDeviceProfile inv, Info info) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002075 mContext = context;
2076 mInv = inv;
2077 mInfo = info;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002078 }
2079
2080 public Builder setMultiWindowMode(boolean isMultiWindowMode) {
2081 mIsMultiWindowMode = isMultiWindowMode;
2082 return this;
2083 }
2084
Alex Chauab800f72022-12-13 17:46:06 +00002085 public Builder setIsMultiDisplay(boolean isMultiDisplay) {
2086 mIsMultiDisplay = isMultiDisplay;
Sunny Goyal19ff7282021-04-22 10:12:54 -07002087 return this;
2088 }
2089
Sunny Goyal65190ae2022-08-02 14:16:26 -07002090 public Builder setDotRendererCache(SparseArray<DotRenderer> dotRendererCache) {
2091 mDotRendererCache = dotRendererCache;
2092 return this;
2093 }
Sunny Goyal19ff7282021-04-22 10:12:54 -07002094
2095 public Builder setWindowBounds(WindowBounds bounds) {
2096 mWindowBounds = bounds;
Sunny Goyal0addbf02020-04-28 14:17:35 -07002097 return this;
2098 }
2099
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002100 public Builder setTransposeLayoutWithOrientation(boolean transposeLayoutWithOrientation) {
2101 mTransposeLayoutWithOrientation = transposeLayoutWithOrientation;
2102 return this;
2103 }
2104
Alex Chau6ed408f2022-03-04 12:58:05 +00002105 public Builder setGestureMode(boolean isGestureMode) {
2106 mIsGestureMode = isGestureMode;
2107 return this;
2108 }
2109
Jon Miranda2b25ded2023-02-02 14:48:45 -08002110 public Builder withDimensionsOverride(Consumer<DeviceProfile> overrideProvider) {
2111 mOverrideProvider = overrideProvider;
2112 return this;
2113 }
2114
Sihua Mae04aa202022-07-18 12:43:56 -07002115 /**
2116 * Set the viewScaleProvider for the builder
2117 *
2118 * @param viewScaleProvider The viewScaleProvider to be set for the
Thales Limae9273ea2023-01-26 12:33:52 +00002119 * DeviceProfile
Sihua Mae04aa202022-07-18 12:43:56 -07002120 * @return This builder
2121 */
2122 @NonNull
2123 public Builder setViewScaleProvider(@Nullable ViewScaleProvider viewScaleProvider) {
2124 mViewScaleProvider = viewScaleProvider;
2125 return this;
2126 }
2127
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002128 public DeviceProfile build() {
Sunny Goyal19ff7282021-04-22 10:12:54 -07002129 if (mWindowBounds == null) {
2130 throw new IllegalArgumentException("Window bounds not set");
2131 }
2132 if (mTransposeLayoutWithOrientation == null) {
2133 mTransposeLayoutWithOrientation = !mInfo.isTablet(mWindowBounds);
2134 }
Alex Chau6ed408f2022-03-04 12:58:05 +00002135 if (mIsGestureMode == null) {
Alex Chaue818bcb2022-09-02 17:27:11 +01002136 mIsGestureMode = mInfo.navigationMode.hasGestures;
Alex Chau6ed408f2022-03-04 12:58:05 +00002137 }
Sunny Goyal65190ae2022-08-02 14:16:26 -07002138 if (mDotRendererCache == null) {
2139 mDotRendererCache = new SparseArray<>();
2140 }
Sihua Mae04aa202022-07-18 12:43:56 -07002141 if (mViewScaleProvider == null) {
2142 mViewScaleProvider = DEFAULT_PROVIDER;
2143 }
Jon Miranda2b25ded2023-02-02 14:48:45 -08002144 if (mOverrideProvider == null) {
2145 mOverrideProvider = DEFAULT_DIMENSION_PROVIDER;
2146 }
Sunny Goyal65190ae2022-08-02 14:16:26 -07002147 return new DeviceProfile(mContext, mInv, mInfo, mWindowBounds, mDotRendererCache,
Alex Chauab800f72022-12-13 17:46:06 +00002148 mIsMultiWindowMode, mTransposeLayoutWithOrientation, mIsMultiDisplay,
Jon Miranda2b25ded2023-02-02 14:48:45 -08002149 mIsGestureMode, mViewScaleProvider, mOverrideProvider);
Sunny Goyal0e7a3382020-04-13 17:15:05 -07002150 }
2151 }
2152
Winson Chungb3800242013-10-24 11:01:54 -07002153}