blob: 4dd3acc315c4c9b9ed6bf3757b2dd51d706cdb4b [file] [log] [blame]
Winson Chungb3800242013-10-24 11:01:54 -07001/*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.launcher3;
18
Thales Lima12d0eff2022-03-25 17:06:11 +000019import static com.android.launcher3.InvariantDeviceProfile.INDEX_DEFAULT;
20import static com.android.launcher3.InvariantDeviceProfile.INDEX_LANDSCAPE;
21import static com.android.launcher3.InvariantDeviceProfile.INDEX_TWO_PANEL_LANDSCAPE;
22import static com.android.launcher3.InvariantDeviceProfile.INDEX_TWO_PANEL_PORTRAIT;
Jon Miranda58561d42021-03-17 10:51:54 -040023import static com.android.launcher3.Utilities.dpiFromPx;
Jon Mirandaaf3aed02021-05-06 18:28:45 -070024import static com.android.launcher3.Utilities.pxFromSp;
Alex Chau3d2c0622022-09-01 21:28:14 +010025import static com.android.launcher3.anim.Interpolators.LINEAR;
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;
Thales Limab35faed2022-09-05 16:30:01 -030029import static com.android.launcher3.testing.shared.ResourceUtils.INVALID_RESOURCE_HANDLE;
Pat Manning5f74bfd2022-07-20 12:08:54 +010030import static com.android.launcher3.testing.shared.ResourceUtils.pxFromDp;
Jon Miranda228877d2021-02-09 11:05:00 -050031
Sunny Goyal35c7b192021-04-20 16:51:10 -070032import android.annotation.SuppressLint;
Winson Chungb3800242013-10-24 11:01:54 -070033import android.content.Context;
Jon Mirandab28c4fc2017-06-20 10:58:36 -070034import android.content.res.Configuration;
Winson Chungb3800242013-10-24 11:01:54 -070035import android.content.res.Resources;
Thales Limab35faed2022-09-05 16:30:01 -030036import android.content.res.TypedArray;
Winson Chungb3800242013-10-24 11:01:54 -070037import android.graphics.Point;
Jon Miranda7ae64ff2016-11-21 16:18:46 -080038import android.graphics.PointF;
Winson Chungb3800242013-10-24 11:01:54 -070039import android.graphics.Rect;
Sunny Goyal35c7b192021-04-20 16:51:10 -070040import android.util.DisplayMetrics;
Sunny Goyal65190ae2022-08-02 14:16:26 -070041import android.util.SparseArray;
Sunny Goyal59d086c2018-05-07 17:31:40 -070042import android.view.Surface;
Winson Chungb3800242013-10-24 11:01:54 -070043
Sunny Goyal65190ae2022-08-02 14:16:26 -070044import androidx.annotation.NonNull;
Sihua Mae04aa202022-07-18 12:43:56 -070045import androidx.annotation.Nullable;
Sunny Goyal65190ae2022-08-02 14:16:26 -070046
Sunny Goyalc13403c2016-11-18 23:44:48 -080047import com.android.launcher3.CellLayout.ContainerType;
Jon Miranda228877d2021-02-09 11:05:00 -050048import com.android.launcher3.DevicePaddings.DevicePadding;
Alex Chaud67ddc42022-09-30 18:15:56 +010049import com.android.launcher3.config.FeatureFlags;
Tony Wickham8912b042018-11-29 15:28:53 -080050import com.android.launcher3.icons.DotRenderer;
Hyunyoung Song48cb7bc2018-09-25 17:03:34 -070051import com.android.launcher3.icons.IconNormalizer;
Sihua Mae04aa202022-07-18 12:43:56 -070052import com.android.launcher3.model.data.ItemInfo;
Sunny Goyal57b22792021-05-25 14:35:01 -070053import com.android.launcher3.uioverrides.ApiWrapper;
Sunny Goyalfd58da62020-08-11 12:06:49 -070054import com.android.launcher3.util.DisplayController;
55import com.android.launcher3.util.DisplayController.Info;
Sunny Goyalb46703d2020-05-27 17:52:03 -070056import com.android.launcher3.util.WindowBounds;
Winson1f064272016-07-18 17:18:02 -070057
Jon Miranda58561d42021-03-17 10:51:54 -040058import java.io.PrintWriter;
Alex Chaue818bcb2022-09-02 17:27:11 +010059import java.util.Locale;
Jon Miranda58561d42021-03-17 10:51:54 -040060
Sunny Goyal35c7b192021-04-20 16:51:10 -070061@SuppressLint("NewApi")
Winson Chungb3800242013-10-24 11:01:54 -070062public class DeviceProfile {
Adam Cohen2e6da152015-05-06 11:42:25 -070063
Sunny Goyal8b9919d2021-04-07 14:45:17 -070064 private static final int DEFAULT_DOT_SIZE = 100;
Alex Chau206ede92022-08-01 17:46:12 +010065 private static final float ALL_APPS_TABLET_MAX_ROWS = 5.5f;
Thales Limab35faed2022-09-05 16:30:01 -030066 private static final float MIN_FOLDER_TEXT_SIZE_SP = 16f;
Alex Chau206ede92022-08-01 17:46:12 +010067
Sihua Mae04aa202022-07-18 12:43:56 -070068 public static final PointF DEFAULT_SCALE = new PointF(1.0f, 1.0f);
69 public static final ViewScaleProvider DEFAULT_PROVIDER = itemInfo -> DEFAULT_SCALE;
70
Sunny Goyal57b22792021-05-25 14:35:01 -070071 // Ratio of empty space, qsb should take up to appear visually centered.
Pratyush9afe1ea2021-10-13 11:13:27 +000072 private final float mQsbCenterFactor;
Sunny Goyal1890f672020-04-30 12:28:00 -070073
Adam Cohen2e6da152015-05-06 11:42:25 -070074 public final InvariantDeviceProfile inv;
Sunny Goyalfd58da62020-08-11 12:06:49 -070075 private final Info mInfo;
Sunny Goyal35c7b192021-04-20 16:51:10 -070076 private final DisplayMetrics mMetrics;
Winson Chungbe876472014-05-14 14:15:20 -070077
Sunny Goyalc6205602015-05-21 20:46:33 -070078 // Device properties
79 public final boolean isTablet;
Sunny Goyalc6205602015-05-21 20:46:33 -070080 public final boolean isPhone;
81 public final boolean transposeLayoutWithOrientation;
Alex Chauab800f72022-12-13 17:46:06 +000082 public final boolean isMultiDisplay;
Sunny Goyal19ff7282021-04-22 10:12:54 -070083 public final boolean isTwoPanels;
Thales Limaa1012902022-01-13 17:58:42 +000084 public final boolean isQsbInline;
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -070085
Sunny Goyalc6205602015-05-21 20:46:33 -070086 // Device properties in current orientation
Sunny Goyald792a772018-04-05 13:37:46 -070087 public final boolean isLandscape;
Sunny Goyald70e75a2018-02-22 10:07:32 -080088 public final boolean isMultiWindowMode;
Alex Chau6ed408f2022-03-04 12:58:05 +000089 public final boolean isGestureMode;
Sunny Goyald70e75a2018-02-22 10:07:32 -080090
Sunny Goyal0addbf02020-04-28 14:17:35 -070091 public final int windowX;
92 public final int windowY;
Sunny Goyalc6205602015-05-21 20:46:33 -070093 public final int widthPx;
94 public final int heightPx;
95 public final int availableWidthPx;
96 public final int availableHeightPx;
Sunny Goyal187b16c2022-03-01 16:53:23 -080097 public final int rotationHint;
Jon Mirandabba64512019-03-27 10:54:17 -070098
99 public final float aspectRatio;
100
Jon Mirandae126d722021-02-25 10:45:20 -0500101 public final boolean isScalableGrid;
Thales Lima83bedbf2021-10-05 17:47:39 +0100102 private final int mTypeIndex;
Jon Mirandae126d722021-02-25 10:45:20 -0500103
Tony Wickhamd6b40372015-09-23 18:37:57 -0700104 /**
105 * The maximum amount of left/right workspace padding as a percentage of the screen width.
106 * To be clear, this means that up to 7% of the screen width can be used as left padding, and
107 * 7% of the screen width can be used as right padding.
108 */
109 private static final float MAX_HORIZONTAL_PADDING_PERCENT = 0.14f;
Winson Chungb3800242013-10-24 11:01:54 -0700110
Jon Miranda3f9bab22017-07-28 14:50:17 -0700111 private static final float TALL_DEVICE_ASPECT_RATIO_THRESHOLD = 2.0f;
Jon Miranda80cddbc2021-07-22 13:51:16 -0700112 private static final float TALLER_DEVICE_ASPECT_RATIO_THRESHOLD = 2.15f;
Jon Miranda80dda302021-07-28 14:14:59 -0700113 private static final float TALL_DEVICE_EXTRA_SPACE_THRESHOLD_DP = 252;
114 private static final float TALL_DEVICE_MORE_EXTRA_SPACE_THRESHOLD_DP = 268;
Jon Miranda30d0aa22017-07-25 15:55:29 -0700115
Sunny Goyalc6205602015-05-21 20:46:33 -0700116 // Workspace
Thales Limad90faab2021-09-21 17:18:47 +0100117 public final int desiredWorkspaceHorizontalMarginOriginalPx;
118 public int desiredWorkspaceHorizontalMarginPx;
Alex Chau51da2192022-05-20 13:32:10 +0100119 public int gridVisualizationPaddingX;
120 public int gridVisualizationPaddingY;
Thales Lima78d00ad2021-09-30 11:29:06 +0100121 public Point cellLayoutBorderSpaceOriginalPx;
122 public Point cellLayoutBorderSpacePx;
Pat Manning08610ca2022-04-05 21:03:16 +0100123 public Rect cellLayoutPaddingPx = new Rect();
124
Sunny Goyalc6205602015-05-21 20:46:33 -0700125 public final int edgeMarginPx;
Alex Chau0c4e11b2022-07-08 18:41:36 +0100126 public final float workspaceContentScale;
Alex Chau906d8822022-05-23 10:42:25 +0100127 public final int workspaceSpringLoadedMinNextPageVisiblePx;
Sunny Goyalc6205602015-05-21 20:46:33 -0700128
Jon Miranda58561d42021-03-17 10:51:54 -0400129 private final int extraSpace;
Thales Lima171ee662022-11-22 15:52:49 +0000130 private int maxEmptySpace;
Jon Miranda228877d2021-02-09 11:05:00 -0500131 public int workspaceTopPadding;
132 public int workspaceBottomPadding;
133
Tony Wickham5edf9e22020-03-27 20:06:52 -0700134 // Workspace page indicator
135 public final int workspacePageIndicatorHeight;
136 private final int mWorkspacePageIndicatorOverlapWorkspace;
Winson1f064272016-07-18 17:18:02 -0700137
Sunny Goyalc6205602015-05-21 20:46:33 -0700138 // Workspace icons
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400139 public float iconScale;
Sunny Goyalc6205602015-05-21 20:46:33 -0700140 public int iconSizePx;
141 public int iconTextSizePx;
142 public int iconDrawablePaddingPx;
Winson Chung5f4e0fd2015-05-22 11:12:27 -0700143 public int iconDrawablePaddingOriginalPx;
Winson Chungb3800242013-10-24 11:01:54 -0700144
Jon Mirandaab3c6812021-06-28 15:42:28 -0700145 public float cellScaleToFit;
Adam Cohen59400422014-03-05 18:07:04 -0800146 public int cellWidthPx;
147 public int cellHeightPx;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700148 public int workspaceCellPaddingXPx;
Adam Cohen59400422014-03-05 18:07:04 -0800149
Jon Mirandae126d722021-02-25 10:45:20 -0500150 public int cellYPaddingPx;
Jon Mirandae126d722021-02-25 10:45:20 -0500151
Sunny Goyalc6205602015-05-21 20:46:33 -0700152 // Folder
Jon Mirandae126d722021-02-25 10:45:20 -0500153 public float folderLabelTextScale;
154 public int folderLabelTextSizePx;
Thales Limab35faed2022-09-05 16:30:01 -0300155 public int folderFooterHeightPx;
Sunny Goyalc6205602015-05-21 20:46:33 -0700156 public int folderIconSizePx;
Jon Miranda591e3602018-03-28 11:37:00 -0700157 public int folderIconOffsetYPx;
Jon Mirandabf7d8122016-11-03 15:29:29 -0700158
Jon Mirandae126d722021-02-25 10:45:20 -0500159 // Folder content
Thales Limab35faed2022-09-05 16:30:01 -0300160 public int folderCellLayoutBorderSpacePx;
Jon Mirandae126d722021-02-25 10:45:20 -0500161 public int folderContentPaddingLeftRight;
162 public int folderContentPaddingTop;
163
Jon Mirandabf7d8122016-11-03 15:29:29 -0700164 // Folder cell
Sunny Goyalc6205602015-05-21 20:46:33 -0700165 public int folderCellWidthPx;
166 public int folderCellHeightPx;
Jon Mirandabf7d8122016-11-03 15:29:29 -0700167
168 // Folder child
169 public int folderChildIconSizePx;
170 public int folderChildTextSizePx;
Sunny Goyalbaec6ff2016-09-14 11:26:21 -0700171 public int folderChildDrawablePaddingPx;
Winson Chungb3800242013-10-24 11:01:54 -0700172
Sunny Goyalc6205602015-05-21 20:46:33 -0700173 // Hotseat
Thales Lima9938c2f2022-07-25 14:38:16 +0100174 public int numShownHotseatIcons;
Sunny Goyalc6205602015-05-21 20:46:33 -0700175 public int hotseatCellHeightPx;
Pat Manning26f70f72022-07-07 13:50:39 +0100176 public final boolean areNavButtonsInline;
Jon Miranda18751b62017-07-31 17:25:27 -0700177 // In portrait: size = height, in landscape: size = width
178 public int hotseatBarSizePx;
Thales Limab8c05952022-05-23 16:58:38 +0100179 public int hotseatBarBottomSpacePx;
Pat Manning26f70f72022-07-07 13:50:39 +0100180 public int hotseatBarEndOffset;
Thales Limab8c05952022-05-23 16:58:38 +0100181 public int hotseatQsbSpace;
Pat Manningde25c0d2022-04-05 19:11:26 +0100182 public int springLoadedHotseatBarTopMarginPx;
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700183 // Start is the side next to the nav bar, end is the side next to the workspace
184 public final int hotseatBarSidePaddingStartPx;
185 public final int hotseatBarSidePaddingEndPx;
Alex Chau206ede92022-08-01 17:46:12 +0100186 public int hotseatQsbWidth; // only used when isQsbInline
Sunny Goyal57b22792021-05-25 14:35:01 -0700187 public final int hotseatQsbHeight;
Thales Limab8c05952022-05-23 16:58:38 +0100188 public final int hotseatQsbVisualHeight;
189 private final int hotseatQsbShadowHeight;
Thales Limadd027342022-01-07 12:54:37 +0000190 public int hotseatBorderSpace;
Thales Lima6a590062022-11-22 15:52:49 +0000191 private int minHotseatIconSpacePx;
192 private int minHotseatQsbWidthPx;
193 private final int maxHotseatIconSpacePx;
194 private int inlineNavButtonsEndSpacing;
Adam Cohen2e6da152015-05-06 11:42:25 -0700195
Alex Chau3d2c0622022-09-01 21:28:14 +0100196 // Bottom sheets
197 public int bottomSheetTopPadding;
198 public int bottomSheetOpenDuration;
199 public int bottomSheetCloseDuration;
200 public float bottomSheetWorkspaceScale;
201 public float bottomSheetDepth;
202
Sunny Goyalc6205602015-05-21 20:46:33 -0700203 // All apps
Thales Lima85c942f2021-12-31 13:04:20 +0000204 public Point allAppsBorderSpacePx;
Alex Chaub8c22e12022-02-14 18:35:58 +0000205 public int allAppsShiftRange;
206 public int allAppsTopPadding;
Alex Chau3d2c0622022-09-01 21:28:14 +0100207 public int allAppsOpenDuration;
208 public int allAppsCloseDuration;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700209 public int allAppsCellHeightPx;
Samuel Fufaf1424a32019-10-04 15:15:19 -0700210 public int allAppsCellWidthPx;
Winson1f064272016-07-18 17:18:02 -0700211 public int allAppsIconSizePx;
212 public int allAppsIconDrawablePaddingPx;
sfufa@google.comde013292021-09-21 18:22:44 -0700213 public int allAppsLeftRightPadding;
Alex Chau27b39b92022-01-14 18:02:18 +0000214 public int allAppsLeftRightMargin;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700215 public final int numShownAllAppsColumns;
Winson1f064272016-07-18 17:18:02 -0700216 public float allAppsIconTextSizePx;
217
Zak Cohen334efeb2021-03-19 16:42:07 -0700218 // Overview
Zak Cohen334efeb2021-03-19 16:42:07 -0700219 public int overviewTaskMarginPx;
Alex Chaudedbc8a2021-03-17 16:53:26 +0000220 public int overviewTaskIconSizePx;
Alex Chauac9df382021-08-02 19:08:41 +0100221 public int overviewTaskIconDrawableSizePx;
222 public int overviewTaskIconDrawableSizeGridPx;
Alex Chaudedbc8a2021-03-17 16:53:26 +0000223 public int overviewTaskThumbnailTopMarginPx;
Alex Chau19c6eca2022-03-10 20:12:56 +0000224 public final int overviewActionsHeight;
Alex Chaua2fc7642022-04-21 14:20:23 +0100225 public final int overviewActionsTopMarginPx;
Alex Chau1bf0fe12021-11-30 15:32:45 +0000226 public final int overviewActionsButtonSpacing;
Alex Chau5fd9d492021-07-22 17:27:11 +0100227 public int overviewPageSpacing;
228 public int overviewRowSpacing;
Alex Chau56bd2572021-11-03 18:48:18 +0000229 public int overviewGridSideMargin;
Zak Cohen334efeb2021-03-19 16:42:07 -0700230
Jeremy Sim0ac47082022-10-10 13:59:40 -0700231 // Split staging
232 public int splitPlaceholderInset;
233
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800234 // Widgets
Sihua Mae04aa202022-07-18 12:43:56 -0700235 private final ViewScaleProvider mViewScaleProvider;
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800236
Sunny Goyal47328fd2016-05-25 18:56:41 -0700237 // Drop Target
238 public int dropTargetBarSizePx;
Pat Manningde25c0d2022-04-05 19:11:26 +0100239 public int dropTargetBarTopMarginPx;
240 public int dropTargetBarBottomMarginPx;
Alex Chaua02eddc2021-04-29 00:36:06 +0100241 public int dropTargetDragPaddingPx;
242 public int dropTargetTextSizePx;
Pat Manningde25c0d2022-04-05 19:11:26 +0100243 public int dropTargetHorizontalPaddingPx;
244 public int dropTargetVerticalPaddingPx;
245 public int dropTargetGapPx;
Alex Chau5b019302022-05-23 10:42:25 +0100246 public int dropTargetButtonWorkspaceEdgeGapPx;
Adam Cohen4ae96ce2014-08-29 15:05:48 -0700247
Winson1f064272016-07-18 17:18:02 -0700248 // Insets
Sunny Goyal07b69292018-01-08 14:19:34 -0800249 private final Rect mInsets = new Rect();
250 public final Rect workspacePadding = new Rect();
Jon Miranda0bd63d12019-03-06 17:29:29 -0800251 // When true, nav bar is on the left side of the screen.
Sunny Goyal59d086c2018-05-07 17:31:40 -0700252 private boolean mIsSeascape;
Winson1f064272016-07-18 17:18:02 -0700253
Tony Wickhamf34bee82018-12-03 18:11:39 -0800254 // Notification dots
Sunny Goyal65190ae2022-08-02 14:16:26 -0700255 public final DotRenderer mDotRendererWorkSpace;
256 public final DotRenderer mDotRendererAllApps;
Tony Wickham9a8d11f2017-01-11 09:53:12 -0800257
Pierre Barbier de Reuille578deba2021-09-24 13:47:44 +0100258 // Taskbar
Tony Wickham15883892021-02-12 11:24:40 -0800259 public boolean isTaskbarPresent;
Tony Wickham635e1802021-07-22 14:28:04 -1000260 // Whether Taskbar will inset the bottom of apps by taskbarSize.
261 public boolean isTaskbarPresentInApps;
Tony Wickham15883892021-02-12 11:24:40 -0800262 public int taskbarSize;
Alex Chau85d664e2023-01-16 16:31:59 +0000263 public int transientTaskbarSize;
Alex Chau6a7d1e22022-01-20 19:54:17 +0000264 public int stashedTaskbarSize;
Alex Chau905e0f12022-11-14 21:55:37 +0000265 public int transientTaskbarMargin;
Tony Wickham15883892021-02-12 11:24:40 -0800266
Alex Chaua02eddc2021-04-29 00:36:06 +0100267 // DragController
268 public int flingToDeleteThresholdVelocity;
269
Vinit Nayak17c4b332021-08-05 12:54:58 -0700270 /** TODO: Once we fully migrate to staged split, remove "isMultiWindowMode" */
Sunny Goyal19ff7282021-04-22 10:12:54 -0700271 DeviceProfile(Context context, InvariantDeviceProfile inv, Info info, WindowBounds windowBounds,
Sunny Goyal65190ae2022-08-02 14:16:26 -0700272 SparseArray<DotRenderer> dotRendererCache, boolean isMultiWindowMode,
Alex Chauab800f72022-12-13 17:46:06 +0000273 boolean transposeLayoutWithOrientation, boolean isMultiDisplay, boolean isGestureMode,
Sihua Mae04aa202022-07-18 12:43:56 -0700274 @NonNull final ViewScaleProvider viewScaleProvider) {
Sunny Goyalfee35bb2015-05-11 11:38:19 -0700275
Adam Cohen2e6da152015-05-06 11:42:25 -0700276 this.inv = inv;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700277 this.isLandscape = windowBounds.isLandscape();
Sunny Goyald70e75a2018-02-22 10:07:32 -0800278 this.isMultiWindowMode = isMultiWindowMode;
Jon Mirandae126d722021-02-25 10:45:20 -0500279 this.transposeLayoutWithOrientation = transposeLayoutWithOrientation;
Alex Chauab800f72022-12-13 17:46:06 +0000280 this.isMultiDisplay = isMultiDisplay;
Alex Chau6ed408f2022-03-04 12:58:05 +0000281 this.isGestureMode = isGestureMode;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700282 windowX = windowBounds.bounds.left;
283 windowY = windowBounds.bounds.top;
Sunny Goyal187b16c2022-03-01 16:53:23 -0800284 this.rotationHint = windowBounds.rotationHint;
Alex Chaue0227552022-04-06 19:44:43 +0100285 mInsets.set(windowBounds.insets);
Winson Chungb3800242013-10-24 11:01:54 -0700286
Jon Mirandae126d722021-02-25 10:45:20 -0500287 isScalableGrid = inv.isScalable && !isVerticalBarLayout() && !isMultiWindowMode;
Alex Chaudfc8ddf2022-01-25 11:26:25 +0000288 // Determine device posture.
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700289 mInfo = info;
Alex Chau29983072021-11-19 15:14:20 +0000290 isTablet = info.isTablet(windowBounds);
Sunny Goyal19ff7282021-04-22 10:12:54 -0700291 isPhone = !isTablet;
Alex Chauab800f72022-12-13 17:46:06 +0000292 isTwoPanels = isTablet && isMultiDisplay;
Vinit Nayak58c27cc2022-02-16 17:42:21 -0800293 isTaskbarPresent = isTablet && ApiWrapper.TASKBAR_DRAWN_IN_PROCESS;
Adam Cohen2e6da152015-05-06 11:42:25 -0700294
Alex Chaudfc8ddf2022-01-25 11:26:25 +0000295 // Some more constants.
Alex Chau635b3ab2022-01-26 16:49:10 +0000296 context = getContext(context, info, isVerticalBarLayout() || (isTablet && isLandscape)
Brandon Dayauon07ca8842022-04-27 10:52:28 -0700297 ? Configuration.ORIENTATION_LANDSCAPE
298 : Configuration.ORIENTATION_PORTRAIT,
Alex Chaua6907dc2022-03-18 15:24:07 +0000299 windowBounds);
Sunny Goyal1890f672020-04-30 12:28:00 -0700300 final Resources res = context.getResources();
Alex Chaudfc8ddf2022-01-25 11:26:25 +0000301 mMetrics = res.getDisplayMetrics();
302
303 // Determine sizes.
304 widthPx = windowBounds.bounds.width();
305 heightPx = windowBounds.bounds.height();
306 availableWidthPx = windowBounds.availableSize.x;
Thales Limab8c05952022-05-23 16:58:38 +0100307 availableHeightPx = windowBounds.availableSize.y;
Alex Chaudfc8ddf2022-01-25 11:26:25 +0000308
309 aspectRatio = ((float) Math.max(widthPx, heightPx)) / Math.min(widthPx, heightPx);
310 boolean isTallDevice = Float.compare(aspectRatio, TALL_DEVICE_ASPECT_RATIO_THRESHOLD) >= 0;
311 mQsbCenterFactor = res.getFloat(R.dimen.qsb_center_factor);
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700312
Thales Lima83bedbf2021-10-05 17:47:39 +0100313 if (isTwoPanels) {
314 if (isLandscape) {
Thales Lima12d0eff2022-03-25 17:06:11 +0000315 mTypeIndex = INDEX_TWO_PANEL_LANDSCAPE;
Thales Lima83bedbf2021-10-05 17:47:39 +0100316 } else {
Thales Lima12d0eff2022-03-25 17:06:11 +0000317 mTypeIndex = INDEX_TWO_PANEL_PORTRAIT;
Thales Lima83bedbf2021-10-05 17:47:39 +0100318 }
319 } else {
320 if (isLandscape) {
Thales Lima12d0eff2022-03-25 17:06:11 +0000321 mTypeIndex = INDEX_LANDSCAPE;
Thales Lima83bedbf2021-10-05 17:47:39 +0100322 } else {
Thales Lima12d0eff2022-03-25 17:06:11 +0000323 mTypeIndex = INDEX_DEFAULT;
Thales Lima83bedbf2021-10-05 17:47:39 +0100324 }
325 }
326
Tony Wickham15883892021-02-12 11:24:40 -0800327 if (isTaskbarPresent) {
Alex Chau85d664e2023-01-16 16:31:59 +0000328 transientTaskbarSize = res.getDimensionPixelSize(R.dimen.transient_taskbar_size);
329 transientTaskbarMargin = res.getDimensionPixelSize(R.dimen.transient_taskbar_margin);
Jon Miranda7e819502022-11-03 10:56:32 -0700330 if (DisplayController.isTransientTaskbar(context)) {
Alex Chau85d664e2023-01-16 16:31:59 +0000331 taskbarSize = transientTaskbarSize;
Jon Miranda7e819502022-11-03 10:56:32 -0700332 stashedTaskbarSize =
333 res.getDimensionPixelSize(R.dimen.transient_taskbar_stashed_size);
334 } else {
335 taskbarSize = res.getDimensionPixelSize(R.dimen.taskbar_size);
336 stashedTaskbarSize = res.getDimensionPixelSize(R.dimen.taskbar_stashed_size);
337 }
Tony Wickham15883892021-02-12 11:24:40 -0800338 }
Tony Wickham15883892021-02-12 11:24:40 -0800339
Winson Chungb3800242013-10-24 11:01:54 -0700340 edgeMarginPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_edge_margin);
Alex Chau0c4e11b2022-07-08 18:41:36 +0100341 workspaceContentScale = res.getFloat(R.dimen.workspace_content_scale);
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700342
Thales Limad90faab2021-09-21 17:18:47 +0100343 desiredWorkspaceHorizontalMarginPx = getHorizontalMarginPx(inv, res);
344 desiredWorkspaceHorizontalMarginOriginalPx = desiredWorkspaceHorizontalMarginPx;
Alex Chau51da2192022-05-20 13:32:10 +0100345 gridVisualizationPaddingX = res.getDimensionPixelSize(
346 R.dimen.grid_visualization_horizontal_cell_spacing);
347 gridVisualizationPaddingY = res.getDimensionPixelSize(
348 R.dimen.grid_visualization_vertical_cell_spacing);
Samuel Fufaee9aff92021-04-05 13:30:40 -0500349
Alex Chaue0227552022-04-06 19:44:43 +0100350 bottomSheetTopPadding = mInsets.top // statusbar height
Andras Kloczl142b0542022-03-09 21:26:02 +0000351 + res.getDimensionPixelSize(R.dimen.bottom_sheet_extra_top_padding)
352 + (isTablet ? 0 : edgeMarginPx); // phones need edgeMarginPx additional padding
Alex Chau3d2c0622022-09-01 21:28:14 +0100353 bottomSheetOpenDuration = res.getInteger(R.integer.config_bottomSheetOpenDuration);
354 bottomSheetCloseDuration = res.getInteger(R.integer.config_bottomSheetCloseDuration);
355 if (isTablet) {
356 bottomSheetWorkspaceScale = workspaceContentScale;
Alex Chauab800f72022-12-13 17:46:06 +0000357 if (isMultiDisplay && !ENABLE_MULTI_DISPLAY_PARTIAL_DEPTH.get()) {
358 // TODO(b/259893832): Revert to use maxWallpaperScale to calculate bottomSheetDepth
359 // when screen recorder bug is fixed.
360 bottomSheetDepth = 1f;
361 } else {
362 // The goal is to set wallpaper to zoom at workspaceContentScale when in AllApps.
363 // When depth is 0, wallpaper zoom is set to maxWallpaperScale.
364 // When depth is 1, wallpaper zoom is set to 1.
365 // For depth to achieve zoom set to maxWallpaperScale * workspaceContentScale:
366 float maxWallpaperScale = res.getFloat(R.dimen.config_wallpaperMaxScale);
367 bottomSheetDepth = Utilities.mapToRange(maxWallpaperScale * workspaceContentScale,
368 maxWallpaperScale, 1f, 0f, 1f, LINEAR);
369 }
Alex Chau3d2c0622022-09-01 21:28:14 +0100370 } else {
371 bottomSheetWorkspaceScale = 1f;
372 bottomSheetDepth = 0f;
373 }
Andras Kloczl142b0542022-03-09 21:26:02 +0000374
Jon Mirandae126d722021-02-25 10:45:20 -0500375 folderLabelTextScale = res.getFloat(R.dimen.folder_label_text_scale);
Thales Limab35faed2022-09-05 16:30:01 -0300376
377 if (inv.folderStyle != INVALID_RESOURCE_HANDLE) {
378 TypedArray folderStyle = context.obtainStyledAttributes(inv.folderStyle,
Thales Limad852d652023-01-17 14:01:13 +0000379 R.styleable.FolderStyle);
Thales Limab35faed2022-09-05 16:30:01 -0300380 // These are re-set in #updateFolderCellSize if the grid is not scalable
381 folderCellHeightPx = folderStyle.getDimensionPixelSize(
Thales Limad852d652023-01-17 14:01:13 +0000382 R.styleable.FolderStyle_folderCellHeight, 0);
Thales Limab35faed2022-09-05 16:30:01 -0300383 folderCellWidthPx = folderStyle.getDimensionPixelSize(
Thales Limad852d652023-01-17 14:01:13 +0000384 R.styleable.FolderStyle_folderCellWidth, 0);
Thales Limab35faed2022-09-05 16:30:01 -0300385
386 folderContentPaddingTop = folderStyle.getDimensionPixelSize(
Thales Limad852d652023-01-17 14:01:13 +0000387 R.styleable.FolderStyle_folderTopPadding, 0);
Thales Limab35faed2022-09-05 16:30:01 -0300388 folderCellLayoutBorderSpacePx = folderStyle.getDimensionPixelSize(
Thales Limad852d652023-01-17 14:01:13 +0000389 R.styleable.FolderStyle_folderBorderSpace, 0);
Thales Limab35faed2022-09-05 16:30:01 -0300390 folderFooterHeightPx = folderStyle.getDimensionPixelSize(
Thales Limad852d652023-01-17 14:01:13 +0000391 R.styleable.FolderStyle_folderFooterHeight, 0);
Thales Limab35faed2022-09-05 16:30:01 -0300392 folderStyle.recycle();
393 } else {
394 folderCellLayoutBorderSpacePx = 0;
395 folderFooterHeightPx = 0;
396 folderContentPaddingTop = res.getDimensionPixelSize(R.dimen.folder_top_padding_default);
397 }
Jon Mirandae126d722021-02-25 10:45:20 -0500398
Thales Lima78d00ad2021-09-30 11:29:06 +0100399 cellLayoutBorderSpacePx = getCellLayoutBorderSpace(inv);
Thales Limab35faed2022-09-05 16:30:01 -0300400 cellLayoutBorderSpaceOriginalPx = new Point(cellLayoutBorderSpacePx);
Thales Lima85c942f2021-12-31 13:04:20 +0000401 allAppsBorderSpacePx = new Point(
Thales Limabb7d3882021-12-22 12:56:29 +0000402 pxFromDp(inv.allAppsBorderSpaces[mTypeIndex].x, mMetrics),
403 pxFromDp(inv.allAppsBorderSpaces[mTypeIndex].y, mMetrics));
Thales Limae9273ea2023-01-26 12:33:52 +0000404 setupAllAppsStyle(context);
Jon Mirandae126d722021-02-25 10:45:20 -0500405
Tony Wickham5edf9e22020-03-27 20:06:52 -0700406 workspacePageIndicatorHeight = res.getDimensionPixelSize(
407 R.dimen.workspace_page_indicator_height);
408 mWorkspacePageIndicatorOverlapWorkspace =
409 res.getDimensionPixelSize(R.dimen.workspace_page_indicator_overlap_workspace);
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700410
Thales Limad852d652023-01-17 14:01:13 +0000411 TypedArray cellStyle;
412 if (inv.cellStyle != INVALID_RESOURCE_HANDLE) {
413 cellStyle = context.obtainStyledAttributes(inv.cellStyle,
414 R.styleable.CellStyle);
415 } else {
416 cellStyle = context.obtainStyledAttributes(R.style.CellStyleDefault,
417 R.styleable.CellStyle);
418 }
419 iconDrawablePaddingOriginalPx = cellStyle.getDimensionPixelSize(
420 R.styleable.CellStyle_iconDrawablePadding, 0);
421 cellStyle.recycle();
Alex Chaua02eddc2021-04-29 00:36:06 +0100422
Sunny Goyal47328fd2016-05-25 18:56:41 -0700423 dropTargetBarSizePx = res.getDimensionPixelSize(R.dimen.dynamic_grid_drop_target_size);
Pat Manningde25c0d2022-04-05 19:11:26 +0100424 dropTargetBarTopMarginPx = res.getDimensionPixelSize(R.dimen.drop_target_top_margin);
425 dropTargetBarBottomMarginPx = res.getDimensionPixelSize(R.dimen.drop_target_bottom_margin);
Alex Chaua02eddc2021-04-29 00:36:06 +0100426 dropTargetDragPaddingPx = res.getDimensionPixelSize(R.dimen.drop_target_drag_padding);
427 dropTargetTextSizePx = res.getDimensionPixelSize(R.dimen.drop_target_text_size);
Pat Manningde25c0d2022-04-05 19:11:26 +0100428 dropTargetHorizontalPaddingPx = res.getDimensionPixelSize(
429 R.dimen.drop_target_button_drawable_horizontal_padding);
430 dropTargetVerticalPaddingPx = res.getDimensionPixelSize(
431 R.dimen.drop_target_button_drawable_vertical_padding);
432 dropTargetGapPx = res.getDimensionPixelSize(R.dimen.drop_target_button_gap);
Alex Chau5b019302022-05-23 10:42:25 +0100433 dropTargetButtonWorkspaceEdgeGapPx = res.getDimensionPixelSize(
434 R.dimen.drop_target_button_workspace_edge_gap);
Alex Chaua02eddc2021-04-29 00:36:06 +0100435
Alex Chau906d8822022-05-23 10:42:25 +0100436 workspaceSpringLoadedMinNextPageVisiblePx = res.getDimensionPixelSize(
437 R.dimen.dynamic_grid_spring_loaded_min_next_space_visible);
Sunny Goyald5190522017-04-24 03:06:54 -0700438
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700439 workspaceCellPaddingXPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_cell_padding_x);
Jon Miranda09660722017-06-14 14:20:14 -0700440
Thales Limaa1012902022-01-13 17:58:42 +0000441 hotseatQsbHeight = res.getDimensionPixelSize(R.dimen.qsb_widget_height);
Thales Limab8c05952022-05-23 16:58:38 +0100442 hotseatQsbShadowHeight = res.getDimensionPixelSize(R.dimen.qsb_shadow_height);
443 hotseatQsbVisualHeight = hotseatQsbHeight - 2 * hotseatQsbShadowHeight;
444
Thales Lima12d0eff2022-03-25 17:06:11 +0000445 // Whether QSB might be inline in appropriate orientation (e.g. landscape).
446 boolean canQsbInline = (isTwoPanels ? inv.inlineQsb[INDEX_TWO_PANEL_PORTRAIT]
447 || inv.inlineQsb[INDEX_TWO_PANEL_LANDSCAPE]
448 : inv.inlineQsb[INDEX_DEFAULT] || inv.inlineQsb[INDEX_LANDSCAPE])
449 && hotseatQsbHeight > 0;
Thales Lima6a590062022-11-22 15:52:49 +0000450 isQsbInline = isScalableGrid && inv.inlineQsb[mTypeIndex] && canQsbInline;
Alex Chau6ed408f2022-03-04 12:58:05 +0000451
Thales Lima425f6822022-05-10 13:44:58 -0300452 areNavButtonsInline = isTaskbarPresent && !isGestureMode;
Thales Lima9938c2f2022-07-25 14:38:16 +0100453 numShownHotseatIcons =
454 isTwoPanels ? inv.numDatabaseHotseatIcons : inv.numShownHotseatIcons;
Alex Chau6ed408f2022-03-04 12:58:05 +0000455
Sunny Goyal19ff7282021-04-22 10:12:54 -0700456 numShownAllAppsColumns =
457 isTwoPanels ? inv.numDatabaseAllAppsColumns : inv.numAllAppsColumns;
Thales Limab8c05952022-05-23 16:58:38 +0100458
459 int hotseatBarBottomSpace = pxFromDp(inv.hotseatBarBottomSpace[mTypeIndex], mMetrics);
460 int minQsbMargin = res.getDimensionPixelSize(R.dimen.min_qsb_margin);
461 hotseatQsbSpace = pxFromDp(inv.hotseatQsbSpace[mTypeIndex], mMetrics);
462 // Have a little space between the inset and the QSB
463 if (mInsets.bottom + minQsbMargin > hotseatBarBottomSpace) {
464 int availableSpace = hotseatQsbSpace - (mInsets.bottom - hotseatBarBottomSpace);
465
466 // Only change the spaces if there is space
467 if (availableSpace > 0) {
468 // Make sure there is enough space between hotseat/QSB and QSB/navBar
469 if (availableSpace < minQsbMargin * 2) {
470 minQsbMargin = availableSpace / 2;
471 hotseatQsbSpace = minQsbMargin;
472 } else {
473 hotseatQsbSpace -= minQsbMargin;
474 }
475 }
476 hotseatBarBottomSpacePx = mInsets.bottom + minQsbMargin;
477
Thales Limaa1012902022-01-13 17:58:42 +0000478 } else {
Thales Limab8c05952022-05-23 16:58:38 +0100479 hotseatBarBottomSpacePx = hotseatBarBottomSpace;
Thales Limaa1012902022-01-13 17:58:42 +0000480 }
Thales Lima425f6822022-05-10 13:44:58 -0300481
Pat Manningde25c0d2022-04-05 19:11:26 +0100482 springLoadedHotseatBarTopMarginPx = res.getDimensionPixelSize(
483 R.dimen.spring_loaded_hotseat_top_margin);
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700484 hotseatBarSidePaddingEndPx =
Sunny Goyal228153d2018-01-04 15:35:22 -0800485 res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_side_padding);
Jon Miranda3f411e72019-05-16 17:15:16 -0700486 // Add a bit of space between nav bar and hotseat in vertical bar layout.
Tony Wickham5edf9e22020-03-27 20:06:52 -0700487 hotseatBarSidePaddingStartPx = isVerticalBarLayout() ? workspacePageIndicatorHeight : 0;
Thales Limab8c05952022-05-23 16:58:38 +0100488 updateHotseatSizes(pxFromDp(inv.iconSize[INDEX_DEFAULT], mMetrics));
Vinit Nayak8a3d0552022-08-05 10:43:29 -0700489 if (areNavButtonsInline && !isPhone) {
Thales Lima6a590062022-11-22 15:52:49 +0000490 inlineNavButtonsEndSpacing = res.getDimensionPixelSize(inv.inlineNavButtonsEndSpacing);
Pat Manning26f70f72022-07-07 13:50:39 +0100491 /*
492 * 3 nav buttons +
Vinit Nayakc7293172022-07-18 16:41:50 -0700493 * Spacing between nav buttons +
Thales Lima6a590062022-11-22 15:52:49 +0000494 * Space at the end for contextual buttons
Pat Manning26f70f72022-07-07 13:50:39 +0100495 */
496 hotseatBarEndOffset = 3 * res.getDimensionPixelSize(R.dimen.taskbar_nav_buttons_size)
Vinit Nayakc7293172022-07-18 16:41:50 -0700497 + 2 * res.getDimensionPixelSize(R.dimen.taskbar_button_space_inbetween)
Thales Lima6a590062022-11-22 15:52:49 +0000498 + inlineNavButtonsEndSpacing;
Pat Manning26f70f72022-07-07 13:50:39 +0100499 } else {
Thales Lima6a590062022-11-22 15:52:49 +0000500 inlineNavButtonsEndSpacing = 0;
Pat Manning26f70f72022-07-07 13:50:39 +0100501 hotseatBarEndOffset = 0;
502 }
Jon Miranda8bdb2222021-06-23 18:10:10 -0700503
Alex Chau635b3ab2022-01-26 16:49:10 +0000504 overviewTaskMarginPx = res.getDimensionPixelSize(R.dimen.overview_task_margin);
Alex Chau5fd9d492021-07-22 17:27:11 +0100505 overviewTaskIconSizePx = res.getDimensionPixelSize(R.dimen.task_thumbnail_icon_size);
Alex Chauac9df382021-08-02 19:08:41 +0100506 overviewTaskIconDrawableSizePx =
507 res.getDimensionPixelSize(R.dimen.task_thumbnail_icon_drawable_size);
508 overviewTaskIconDrawableSizeGridPx =
509 res.getDimensionPixelSize(R.dimen.task_thumbnail_icon_drawable_size_grid);
Jeremy Sim1cfe6d42022-07-15 14:40:38 -0700510 overviewTaskThumbnailTopMarginPx = overviewTaskIconSizePx + overviewTaskMarginPx;
Jeremy Sim3c2c3f12022-05-16 20:37:43 -0700511 overviewActionsTopMarginPx = res.getDimensionPixelSize(R.dimen.overview_actions_top_margin);
Alex Chau635b3ab2022-01-26 16:49:10 +0000512 overviewPageSpacing = res.getDimensionPixelSize(R.dimen.overview_page_spacing);
513 overviewActionsButtonSpacing = res.getDimensionPixelSize(
514 R.dimen.overview_actions_button_spacing);
Alex Chau19c6eca2022-03-10 20:12:56 +0000515 overviewActionsHeight = res.getDimensionPixelSize(R.dimen.overview_actions_height);
Jeremy Sim1cfe6d42022-07-15 14:40:38 -0700516 overviewRowSpacing = res.getDimensionPixelSize(R.dimen.overview_grid_row_spacing);
Alex Chau635b3ab2022-01-26 16:49:10 +0000517 overviewGridSideMargin = res.getDimensionPixelSize(R.dimen.overview_grid_side_margin);
Zak Cohen334efeb2021-03-19 16:42:07 -0700518
Jeremy Sim0ac47082022-10-10 13:59:40 -0700519 splitPlaceholderInset = res.getDimensionPixelSize(R.dimen.split_placeholder_inset);
520
Jon Miranda2ed276e2017-06-29 11:36:34 -0700521 // Calculate all of the remaining variables.
Jon Miranda58561d42021-03-17 10:51:54 -0400522 extraSpace = updateAvailableDimensions(res);
Jon Miranda80cddbc2021-07-22 13:51:16 -0700523
Jon Miranda2ed276e2017-06-29 11:36:34 -0700524 // Now that we have all of the variables calculated, we can tune certain sizes.
Thales Limaae0d7ef2022-11-16 15:53:43 +0000525 if (isScalableGrid && inv.devicePaddingId != INVALID_RESOURCE_HANDLE) {
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400526 // Paddings were created assuming no scaling, so we first unscale the extra space.
Jon Mirandaab3c6812021-06-28 15:42:28 -0700527 int unscaledExtraSpace = (int) (extraSpace / cellScaleToFit);
Thales Limaae0d7ef2022-11-16 15:53:43 +0000528 DevicePaddings devicePaddings = new DevicePaddings(context, inv.devicePaddingId);
529 DevicePadding padding = devicePaddings.getDevicePadding(unscaledExtraSpace);
Thales Lima171ee662022-11-22 15:52:49 +0000530 maxEmptySpace = padding.getMaxEmptySpacePx();
Jon Miranda228877d2021-02-09 11:05:00 -0500531
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400532 int paddingWorkspaceTop = padding.getWorkspaceTopPadding(unscaledExtraSpace);
533 int paddingWorkspaceBottom = padding.getWorkspaceBottomPadding(unscaledExtraSpace);
534 int paddingHotseatBottom = padding.getHotseatBottomPadding(unscaledExtraSpace);
535
Jon Mirandaab3c6812021-06-28 15:42:28 -0700536 workspaceTopPadding = Math.round(paddingWorkspaceTop * cellScaleToFit);
537 workspaceBottomPadding = Math.round(paddingWorkspaceBottom * cellScaleToFit);
Jon Miranda2ed276e2017-06-29 11:36:34 -0700538 }
Pat Manning08610ca2022-04-05 21:03:16 +0100539
540 int cellLayoutPadding =
541 isTwoPanels ? cellLayoutBorderSpacePx.x / 2 : res.getDimensionPixelSize(
542 R.dimen.cell_layout_padding);
543 cellLayoutPaddingPx = new Rect(cellLayoutPadding, cellLayoutPadding, cellLayoutPadding,
544 cellLayoutPadding);
Sunny Goyal07b69292018-01-08 14:19:34 -0800545 updateWorkspacePadding();
Tony Wickham1237df02017-02-24 08:59:36 -0800546
Thales Lima6a590062022-11-22 15:52:49 +0000547 minHotseatIconSpacePx = res.getDimensionPixelSize(R.dimen.min_hotseat_icon_space);
548 minHotseatQsbWidthPx = res.getDimensionPixelSize(R.dimen.min_hotseat_qsb_width);
549 maxHotseatIconSpacePx = areNavButtonsInline
550 ? res.getDimensionPixelSize(R.dimen.max_hotseat_icon_space) : Integer.MAX_VALUE;
Thales Lima425f6822022-05-10 13:44:58 -0300551 // Hotseat and QSB width depends on updated cellSize and workspace padding
Thales Lima6a590062022-11-22 15:52:49 +0000552 recalculateHotseatWidthAndBorderSpace();
Alex Chau206ede92022-08-01 17:46:12 +0100553
554 // AllApps height calculation depends on updated cellSize
555 if (isTablet) {
556 int collapseHandleHeight =
557 res.getDimensionPixelOffset(R.dimen.bottom_sheet_handle_area_height);
558 int contentHeight = heightPx - collapseHandleHeight - hotseatQsbHeight;
559 int targetContentHeight = (int) (allAppsCellHeightPx * ALL_APPS_TABLET_MAX_ROWS);
560 allAppsTopPadding = Math.max(mInsets.top, contentHeight - targetContentHeight);
561 allAppsShiftRange = heightPx - allAppsTopPadding;
562 } else {
563 allAppsTopPadding = 0;
564 allAppsShiftRange =
565 res.getDimensionPixelSize(R.dimen.all_apps_starting_vertical_translate);
566 }
Alex Chau3d2c0622022-09-01 21:28:14 +0100567 allAppsOpenDuration = res.getInteger(R.integer.config_allAppsOpenDuration);
568 allAppsCloseDuration = res.getInteger(R.integer.config_allAppsCloseDuration);
Thales Lima425f6822022-05-10 13:44:58 -0300569
Alex Chaua02eddc2021-04-29 00:36:06 +0100570 flingToDeleteThresholdVelocity = res.getDimensionPixelSize(
571 R.dimen.drag_flingToDeleteMinVelocity);
572
Sihua Mae04aa202022-07-18 12:43:56 -0700573 mViewScaleProvider = viewScaleProvider;
574
Tony Wickham1237df02017-02-24 08:59:36 -0800575 // This is done last, after iconSizePx is calculated above.
Sunny Goyal65190ae2022-08-02 14:16:26 -0700576 mDotRendererWorkSpace = createDotRenderer(iconSizePx, dotRendererCache);
577 mDotRendererAllApps = createDotRenderer(allAppsIconSizePx, dotRendererCache);
578 }
579
580 private static DotRenderer createDotRenderer(
581 int size, @NonNull SparseArray<DotRenderer> cache) {
582 DotRenderer renderer = cache.get(size);
583 if (renderer == null) {
584 renderer = new DotRenderer(size, getShapePath(DEFAULT_DOT_SIZE), DEFAULT_DOT_SIZE);
585 cache.put(size, renderer);
586 }
587 return renderer;
Adam Cohen63f1ec02014-08-12 09:23:13 -0700588 }
589
Thales Lima425f6822022-05-10 13:44:58 -0300590 /**
591 * QSB width is always calculated because when in 3 button nav the width doesn't follow the
592 * width of the hotseat.
593 */
Thales Lima9938c2f2022-07-25 14:38:16 +0100594 private int calculateQsbWidth(int hotseatBorderSpace) {
Thales Lima425f6822022-05-10 13:44:58 -0300595 if (isQsbInline) {
Alex Chau906d8822022-05-23 10:42:25 +0100596 int columns = getPanelCount() * inv.numColumns;
Thales Lima425f6822022-05-10 13:44:58 -0300597 return getIconToIconWidthForColumns(columns)
598 - iconSizePx * numShownHotseatIcons
599 - hotseatBorderSpace * numShownHotseatIcons;
600 } else {
601 int columns = inv.hotseatColumnSpan[mTypeIndex];
602 return getIconToIconWidthForColumns(columns);
603 }
604 }
Thales Lima2903a622022-03-17 13:52:19 +0000605
Thales Lima425f6822022-05-10 13:44:58 -0300606 private int getIconToIconWidthForColumns(int columns) {
607 return columns * getCellSize().x
608 + (columns - 1) * cellLayoutBorderSpacePx.x
Thales Lima1e8b45f2022-08-25 11:50:59 -0400609 - getCellHorizontalSpace();
Thales Limaa1012902022-01-13 17:58:42 +0000610 }
611
Thales Limad90faab2021-09-21 17:18:47 +0100612 private int getHorizontalMarginPx(InvariantDeviceProfile idp, Resources res) {
613 if (isVerticalBarLayout()) {
614 return 0;
615 }
616
Thales Lima83bedbf2021-10-05 17:47:39 +0100617 return isScalableGrid
618 ? pxFromDp(idp.horizontalMargin[mTypeIndex], mMetrics)
619 : res.getDimensionPixelSize(R.dimen.dynamic_grid_left_right_margin);
Thales Limad90faab2021-09-21 17:18:47 +0100620 }
621
Thales Limab8c05952022-05-23 16:58:38 +0100622 /** Updates hotseatCellHeightPx and hotseatBarSizePx */
623 private void updateHotseatSizes(int hotseatIconSizePx) {
Jon Miranda92c1b5d2021-07-20 13:57:16 -0700624 // Ensure there is enough space for folder icons, which have a slightly larger radius.
625 hotseatCellHeightPx = (int) Math.ceil(hotseatIconSizePx * ICON_OVERLAP_FACTOR);
Thales Limab8c05952022-05-23 16:58:38 +0100626
Jon Miranda0d284852021-06-22 14:50:55 -0700627 if (isVerticalBarLayout()) {
628 hotseatBarSizePx = hotseatIconSizePx + hotseatBarSidePaddingStartPx
629 + hotseatBarSidePaddingEndPx;
Thales Limab8c05952022-05-23 16:58:38 +0100630 } else if (isQsbInline) {
631 hotseatBarSizePx = Math.max(hotseatIconSizePx, hotseatQsbVisualHeight)
632 + hotseatBarBottomSpacePx;
Jon Miranda0d284852021-06-22 14:50:55 -0700633 } else {
Thales Limab8c05952022-05-23 16:58:38 +0100634 hotseatBarSizePx = hotseatIconSizePx
635 + hotseatQsbSpace
636 + hotseatQsbVisualHeight
637 + hotseatBarBottomSpacePx;
Jon Miranda0d284852021-06-22 14:50:55 -0700638 }
639 }
640
Thales Lima6a590062022-11-22 15:52:49 +0000641 /**
642 * Calculates the width of the hotseat, changing spaces between the icons and removing icons if
643 * necessary.
644 */
645 public void recalculateHotseatWidthAndBorderSpace() {
646 if (!isScalableGrid) return;
647
648 int columns = inv.hotseatColumnSpan[mTypeIndex];
649 float hotseatWidthPx = getIconToIconWidthForColumns(columns);
650 hotseatBorderSpace = calculateHotseatBorderSpace(hotseatWidthPx, /* numExtraBorder= */ 0);
Thales Lima9938c2f2022-07-25 14:38:16 +0100651 hotseatQsbWidth = calculateQsbWidth(hotseatBorderSpace);
Thales Lima6a590062022-11-22 15:52:49 +0000652 // Spaces should be correct when the nav buttons are not inline
Thales Lima9938c2f2022-07-25 14:38:16 +0100653 if (!areNavButtonsInline) {
654 return;
655 }
656
Thales Lima6a590062022-11-22 15:52:49 +0000657 // The side space with inline buttons should be what is defined in InvariantDeviceProfile
658 int sideSpace = inlineNavButtonsEndSpacing;
659 int maxHotseatWidth = availableWidthPx - sideSpace - hotseatBarEndOffset;
660 int maxHotseatIconsWidth = maxHotseatWidth - (isQsbInline ? hotseatQsbWidth : 0);
661 hotseatBorderSpace = calculateHotseatBorderSpace(maxHotseatIconsWidth,
662 (isQsbInline ? 1 : 0) + /* border between nav buttons and first icon */ 1);
Thales Lima9938c2f2022-07-25 14:38:16 +0100663
Thales Lima6a590062022-11-22 15:52:49 +0000664 if (hotseatBorderSpace >= minHotseatIconSpacePx) {
Thales Lima9938c2f2022-07-25 14:38:16 +0100665 return;
666 }
667
668 // Border space can't be less than the minimum
Thales Lima6a590062022-11-22 15:52:49 +0000669 hotseatBorderSpace = minHotseatIconSpacePx;
670 int requiredWidth = getHotseatRequiredWidth();
Thales Lima9938c2f2022-07-25 14:38:16 +0100671
672 // If there is an inline qsb, change its size
673 if (isQsbInline) {
674 hotseatQsbWidth -= requiredWidth - maxHotseatWidth;
Thales Lima6a590062022-11-22 15:52:49 +0000675 if (hotseatQsbWidth >= minHotseatQsbWidthPx) {
Thales Lima9938c2f2022-07-25 14:38:16 +0100676 return;
677 }
678
679 // QSB can't be less than the minimum
Thales Lima6a590062022-11-22 15:52:49 +0000680 hotseatQsbWidth = minHotseatQsbWidthPx;
Thales Lima9938c2f2022-07-25 14:38:16 +0100681 }
682
Thales Lima6a590062022-11-22 15:52:49 +0000683 maxHotseatIconsWidth = maxHotseatWidth - (isQsbInline ? hotseatQsbWidth : 0);
684
Thales Lima9938c2f2022-07-25 14:38:16 +0100685 // If it still doesn't fit, start removing icons
686 do {
687 numShownHotseatIcons--;
Thales Lima6a590062022-11-22 15:52:49 +0000688 hotseatBorderSpace = calculateHotseatBorderSpace(maxHotseatIconsWidth,
689 (isQsbInline ? 1 : 0) + /* border between nav buttons and first icon */ 1);
690 } while (hotseatBorderSpace < minHotseatIconSpacePx && numShownHotseatIcons > 1);
Thales Lima9938c2f2022-07-25 14:38:16 +0100691
Thales Lima9938c2f2022-07-25 14:38:16 +0100692 }
693
Thales Lima78d00ad2021-09-30 11:29:06 +0100694 private Point getCellLayoutBorderSpace(InvariantDeviceProfile idp) {
Thales Lima080d8902022-03-28 15:30:29 +0100695 return getCellLayoutBorderSpace(idp, 1f);
Thales Lima080d8902022-03-28 15:30:29 +0100696 }
697
698 private Point getCellLayoutBorderSpace(InvariantDeviceProfile idp, float scale) {
Thales Lima78d00ad2021-09-30 11:29:06 +0100699 if (!isScalableGrid) {
700 return new Point(0, 0);
701 }
702
Thales Lima080d8902022-03-28 15:30:29 +0100703 int horizontalSpacePx = pxFromDp(idp.borderSpaces[mTypeIndex].x, mMetrics, scale);
704 int verticalSpacePx = pxFromDp(idp.borderSpaces[mTypeIndex].y, mMetrics, scale);
Thales Lima78d00ad2021-09-30 11:29:06 +0100705
706 return new Point(horizontalSpacePx, verticalSpacePx);
707 }
708
Sunny Goyal69a8eec2021-07-22 10:02:50 -0700709 public Info getDisplayInfo() {
710 return mInfo;
711 }
712
Jon Miranda611dba42021-03-02 14:12:13 -0500713 /**
714 * We inset the widget padding added by the system and instead rely on the border spacing
715 * between cells to create reliable consistency between widgets
716 */
717 public boolean shouldInsetWidgets() {
718 Rect widgetPadding = inv.defaultWidgetPadding;
719
Jon Miranda49811182021-06-03 09:52:40 -0700720 // Check all sides to ensure that the widget won't overlap into another cell, or into
721 // status bar.
722 return workspaceTopPadding > widgetPadding.top
Thales Lima78d00ad2021-09-30 11:29:06 +0100723 && cellLayoutBorderSpacePx.x > widgetPadding.left
724 && cellLayoutBorderSpacePx.y > widgetPadding.top
725 && cellLayoutBorderSpacePx.x > widgetPadding.right
726 && cellLayoutBorderSpacePx.y > widgetPadding.bottom;
Jon Miranda611dba42021-03-02 14:12:13 -0500727 }
Jon Mirandae126d722021-02-25 10:45:20 -0500728
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700729 public Builder toBuilder(Context context) {
Sunny Goyal187b16c2022-03-01 16:53:23 -0800730 WindowBounds bounds = new WindowBounds(
731 widthPx, heightPx, availableWidthPx, availableHeightPx, rotationHint);
Sunny Goyal19ff7282021-04-22 10:12:54 -0700732 bounds.bounds.offsetTo(windowX, windowY);
Alex Chaue0227552022-04-06 19:44:43 +0100733 bounds.insets.set(mInsets);
Sunny Goyal65190ae2022-08-02 14:16:26 -0700734
735 SparseArray<DotRenderer> dotRendererCache = new SparseArray<>();
736 dotRendererCache.put(iconSizePx, mDotRendererWorkSpace);
737 dotRendererCache.put(allAppsIconSizePx, mDotRendererAllApps);
738
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700739 return new Builder(context, inv, mInfo)
Sunny Goyal19ff7282021-04-22 10:12:54 -0700740 .setWindowBounds(bounds)
Alex Chauab800f72022-12-13 17:46:06 +0000741 .setIsMultiDisplay(isMultiDisplay)
Alex Chau6ed408f2022-03-04 12:58:05 +0000742 .setMultiWindowMode(isMultiWindowMode)
Sunny Goyal65190ae2022-08-02 14:16:26 -0700743 .setDotRendererCache(dotRendererCache)
Alex Chau6ed408f2022-03-04 12:58:05 +0000744 .setGestureMode(isGestureMode);
Sunny Goyal1a52ef52018-01-11 10:15:03 -0800745 }
746
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700747 public DeviceProfile copy(Context context) {
748 return toBuilder(context).build();
749 }
750
751 /**
752 * TODO: Move this to the builder as part of setMultiWindowMode
753 */
Sunny Goyalb46703d2020-05-27 17:52:03 -0700754 public DeviceProfile getMultiWindowProfile(Context context, WindowBounds windowBounds) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700755 DeviceProfile profile = toBuilder(context)
Sunny Goyal19ff7282021-04-22 10:12:54 -0700756 .setWindowBounds(windowBounds)
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700757 .setMultiWindowMode(true)
758 .build();
Jon Miranda93e1f042016-11-11 14:13:04 -0800759
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800760 // We use these scales to measure and layout the widgets using their full invariant profile
761 // sizes and then draw them scaled and centered to fit in their multi-window mode cellspans.
762 float appWidgetScaleX = (float) profile.getCellSize().x / getCellSize().x;
763 float appWidgetScaleY = (float) profile.getCellSize().y / getCellSize().y;
Sihua Mae04aa202022-07-18 12:43:56 -0700764 if (appWidgetScaleX != 1 || appWidgetScaleY != 1) {
765 final PointF p = new PointF(appWidgetScaleX, appWidgetScaleY);
766 profile = profile.toBuilder(context)
767 .setViewScaleProvider(i -> p)
768 .build();
769 }
770
771 profile.hideWorkspaceLabelsIfNotEnoughSpace();
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800772
Jon Miranda93e1f042016-11-11 14:13:04 -0800773 return profile;
Jon Mirandacc42c5b2016-10-27 17:15:27 -0700774 }
775
Adam Cohen63f1ec02014-08-12 09:23:13 -0700776 /**
Jon Miranda941375e2021-03-31 13:10:45 -0400777 * Checks if there is enough space for labels on the workspace.
778 * If there is not, labels on the Workspace are hidden.
Jon Miranda1091e532017-07-21 13:31:50 -0700779 * It is important to call this method after the All Apps variables have been set.
780 */
Jon Miranda941375e2021-03-31 13:10:45 -0400781 private void hideWorkspaceLabelsIfNotEnoughSpace() {
782 float iconTextHeight = Utilities.calculateTextHeight(iconTextSizePx);
783 float workspaceCellPaddingY = getCellSize().y - iconSizePx - iconDrawablePaddingPx
784 - iconTextHeight;
785
786 // We want enough space so that the text is closer to its corresponding icon.
787 if (workspaceCellPaddingY < iconTextHeight) {
788 iconTextSizePx = 0;
789 iconDrawablePaddingPx = 0;
Jon Miranda92c1b5d2021-07-20 13:57:16 -0700790 cellHeightPx = (int) Math.ceil(iconSizePx * ICON_OVERLAP_FACTOR);
Jon Miranda941375e2021-03-31 13:10:45 -0400791 autoResizeAllAppsCells();
792 }
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700793 }
Jon Miranda1091e532017-07-21 13:31:50 -0700794
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700795 /**
796 * Re-computes the all-apps cell size to be independent of workspace
797 */
798 public void autoResizeAllAppsCells() {
Jon Miranda941375e2021-03-31 13:10:45 -0400799 int textHeight = Utilities.calculateTextHeight(allAppsIconTextSizePx);
800 int topBottomPadding = textHeight;
Jon Miranda1091e532017-07-21 13:31:50 -0700801 allAppsCellHeightPx = allAppsIconSizePx + allAppsIconDrawablePaddingPx
Jon Miranda941375e2021-03-31 13:10:45 -0400802 + textHeight + (topBottomPadding * 2);
Jon Miranda1091e532017-07-21 13:31:50 -0700803 }
804
Thales Limab7ef5692022-03-10 10:32:36 +0000805 private void updateAllAppsContainerWidth(Resources res) {
Pat Manning08610ca2022-04-05 21:03:16 +0100806 int cellLayoutHorizontalPadding =
807 (cellLayoutPaddingPx.left + cellLayoutPaddingPx.right) / 2;
Alex Chau27b39b92022-01-14 18:02:18 +0000808 if (isTablet) {
sfufa@google.comde013292021-09-21 18:22:44 -0700809 int usedWidth = (allAppsCellWidthPx * numShownAllAppsColumns)
Thales Limab7ef5692022-03-10 10:32:36 +0000810 + (allAppsBorderSpacePx.x * (numShownAllAppsColumns - 1))
Alex Chau27b39b92022-01-14 18:02:18 +0000811 + allAppsLeftRightPadding * 2;
812 allAppsLeftRightMargin = Math.max(1, (availableWidthPx - usedWidth) / 2);
sfufa@google.comde013292021-09-21 18:22:44 -0700813 } else {
814 allAppsLeftRightPadding =
Pat Manning08610ca2022-04-05 21:03:16 +0100815 desiredWorkspaceHorizontalMarginPx + cellLayoutHorizontalPadding;
sfufa@google.comde013292021-09-21 18:22:44 -0700816 }
817 }
818
Thales Limae9273ea2023-01-26 12:33:52 +0000819 private void setupAllAppsStyle(Context context) {
820 TypedArray allAppsStyle;
821 if (inv.allAppsStyle != INVALID_RESOURCE_HANDLE) {
822 allAppsStyle = context.obtainStyledAttributes(inv.allAppsStyle,
823 R.styleable.AllAppsStyle);
824 } else {
825 allAppsStyle = context.obtainStyledAttributes(R.style.AllAppsStyleDefault,
826 R.styleable.AllAppsStyle);
827 }
828 allAppsLeftRightPadding = allAppsStyle.getDimensionPixelSize(
829 R.styleable.AllAppsStyle_horizontalPadding, 0);
830 allAppsStyle.recycle();
831 }
832
Jon Miranda228877d2021-02-09 11:05:00 -0500833 /**
834 * Returns the amount of extra (or unused) vertical space.
835 */
836 private int updateAvailableDimensions(Resources res) {
Alex Chaua68164d2022-12-15 16:16:03 +0000837 float invIconSizeDp = inv.iconSize[mTypeIndex];
838 float invIconTextSizeSp = inv.iconTextSize[mTypeIndex];
839 iconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mMetrics));
840 iconTextSizePx = pxFromSp(invIconTextSizeSp, mMetrics);
841
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700842 updateIconSize(1f, res);
Winson Chung59a488a2013-12-10 12:32:14 -0800843
Pat Manning08610ca2022-04-05 21:03:16 +0100844 updateWorkspacePadding();
Jon Mirandae126d722021-02-25 10:45:20 -0500845
846 // Check to see if the icons fit within the available height.
Pat Manninga2e14992022-04-22 11:29:17 +0100847 float usedHeight = getCellLayoutHeightSpecification();
Pat Manning25d53342022-05-10 09:58:49 +0000848 final int maxHeight = getCellLayoutHeight();
Jon Miranda228877d2021-02-09 11:05:00 -0500849 float extraHeight = Math.max(0, maxHeight - usedHeight);
Jon Mirandae126d722021-02-25 10:45:20 -0500850 float scaleY = maxHeight / usedHeight;
851 boolean shouldScale = scaleY < 1f;
852
853 float scaleX = 1f;
854 if (isScalableGrid) {
855 // We scale to fit the cellWidth and cellHeight in the available space.
856 // The benefit of scalable grids is that we can get consistent aspect ratios between
857 // devices.
Pat Manninga2e14992022-04-22 11:29:17 +0100858 float usedWidth =
859 getCellLayoutWidthSpecification() + (desiredWorkspaceHorizontalMarginPx * 2);
Jon Mirandae126d722021-02-25 10:45:20 -0500860 // We do not subtract padding here, as we also scale the workspace padding if needed.
861 scaleX = availableWidthPx / usedWidth;
862 shouldScale = true;
Winson Chungb3800242013-10-24 11:01:54 -0700863 }
Jon Mirandae126d722021-02-25 10:45:20 -0500864
865 if (shouldScale) {
866 float scale = Math.min(scaleX, scaleY);
867 updateIconSize(scale, res);
Pat Manninga2e14992022-04-22 11:29:17 +0100868 extraHeight = Math.max(0, maxHeight - getCellLayoutHeightSpecification());
Jon Mirandae126d722021-02-25 10:45:20 -0500869 }
870
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700871 updateAvailableFolderCellDimensions(res);
Jon Miranda228877d2021-02-09 11:05:00 -0500872 return Math.round(extraHeight);
Winson Chungb3800242013-10-24 11:01:54 -0700873 }
874
Pat Manninga2e14992022-04-22 11:29:17 +0100875 private int getCellLayoutHeightSpecification() {
Pat Manning08610ca2022-04-05 21:03:16 +0100876 return (cellHeightPx * inv.numRows) + (cellLayoutBorderSpacePx.y * (inv.numRows - 1))
877 + cellLayoutPaddingPx.top + cellLayoutPaddingPx.bottom;
878 }
879
Pat Manninga2e14992022-04-22 11:29:17 +0100880 private int getCellLayoutWidthSpecification() {
Pat Manning25d53342022-05-10 09:58:49 +0000881 int numColumns = getPanelCount() * inv.numColumns;
Pat Manning08610ca2022-04-05 21:03:16 +0100882 return (cellWidthPx * numColumns) + (cellLayoutBorderSpacePx.x * (numColumns - 1))
883 + cellLayoutPaddingPx.left + cellLayoutPaddingPx.right;
Jon Mirandae126d722021-02-25 10:45:20 -0500884 }
885
Jon Miranda6f7e9702019-09-16 14:44:14 -0700886 /**
887 * Updating the iconSize affects many aspects of the launcher layout, such as: iconSizePx,
888 * iconTextSizePx, iconDrawablePaddingPx, cellWidth/Height, allApps* variants,
889 * hotseat sizes, workspaceSpringLoadedShrinkFactor, folderIconSizePx, and folderIconOffsetYPx.
890 */
Tony Wickham7ba547c2021-02-02 17:12:08 -0800891 public void updateIconSize(float scale, Resources res) {
Jon Mirandaab3c6812021-06-28 15:42:28 -0700892 // Icon scale should never exceed 1, otherwise pixellation may occur.
893 iconScale = Math.min(1f, scale);
894 cellScaleToFit = scale;
895
Jon Miranda18751b62017-07-31 17:25:27 -0700896 // Workspace
Sunny Goyal07b69292018-01-08 14:19:34 -0800897 final boolean isVerticalLayout = isVerticalBarLayout();
Jon Mirandaab3c6812021-06-28 15:42:28 -0700898 iconDrawablePaddingPx = (int) (iconDrawablePaddingOriginalPx * iconScale);
Thales Lima080d8902022-03-28 15:30:29 +0100899 cellLayoutBorderSpacePx = getCellLayoutBorderSpace(inv, scale);
Jon Mirandae126d722021-02-25 10:45:20 -0500900
901 if (isScalableGrid) {
Thales Lima83bedbf2021-10-05 17:47:39 +0100902 cellWidthPx = pxFromDp(inv.minCellSize[mTypeIndex].x, mMetrics, scale);
903 cellHeightPx = pxFromDp(inv.minCellSize[mTypeIndex].y, mMetrics, scale);
Alex Chaube753132022-12-09 16:46:54 +0000904
905 if (cellWidthPx < iconSizePx) {
906 // If cellWidth no longer fit iconSize, reduce borderSpace to make cellWidth bigger.
907 int numColumns = getPanelCount() * inv.numColumns;
908 int numBorders = numColumns - 1;
909 int extraWidthRequired = (iconSizePx - cellWidthPx) * numColumns;
910 if (cellLayoutBorderSpacePx.x * numBorders >= extraWidthRequired) {
911 cellWidthPx = iconSizePx;
912 cellLayoutBorderSpacePx.x -= extraWidthRequired / numBorders;
913 } else {
914 // If it still doesn't fit, set borderSpace to 0 and distribute the space for
915 // cellWidth, and reduce iconSize.
916 cellWidthPx = (cellWidthPx * numColumns
917 + cellLayoutBorderSpacePx.x * numBorders) / numColumns;
918 iconSizePx = Math.min(iconSizePx, cellWidthPx);
919 cellLayoutBorderSpacePx.x = 0;
920 }
921 }
922
923 int cellTextAndPaddingHeight =
924 iconDrawablePaddingPx + Utilities.calculateTextHeight(iconTextSizePx);
925 int cellContentHeight = iconSizePx + cellTextAndPaddingHeight;
926 if (cellHeightPx < cellContentHeight) {
927 // If cellHeight no longer fit iconSize, reduce borderSpace to make cellHeight
928 // bigger.
929 int numBorders = inv.numRows - 1;
930 int extraHeightRequired = (cellContentHeight - cellHeightPx) * inv.numRows;
931 if (cellLayoutBorderSpacePx.y * numBorders >= extraHeightRequired) {
932 cellHeightPx = cellContentHeight;
933 cellLayoutBorderSpacePx.y -= extraHeightRequired / numBorders;
934 } else {
Alex Chau06f36e82023-01-06 10:50:54 +0000935 // If it still doesn't fit, set borderSpace to 0 to recover space.
Alex Chaube753132022-12-09 16:46:54 +0000936 cellHeightPx = (cellHeightPx * inv.numRows
937 + cellLayoutBorderSpacePx.y * numBorders) / inv.numRows;
Alex Chaube753132022-12-09 16:46:54 +0000938 cellLayoutBorderSpacePx.y = 0;
Alex Chau06f36e82023-01-06 10:50:54 +0000939 // Reduce iconDrawablePaddingPx to make cellContentHeight smaller.
940 int cellContentWithoutPadding = cellContentHeight - iconDrawablePaddingPx;
941 if (cellContentWithoutPadding <= cellHeightPx) {
942 iconDrawablePaddingPx = cellContentHeight - cellHeightPx;
943 } else {
944 // If it still doesn't fit, set iconDrawablePaddingPx to 0 to recover space,
945 // then proportional reduce iconSizePx and iconTextSizePx to fit.
946 iconDrawablePaddingPx = 0;
947 float ratio = cellHeightPx / (float) cellContentWithoutPadding;
948 iconSizePx = (int) (iconSizePx * ratio);
949 iconTextSizePx = (int) (iconTextSizePx * ratio);
950 }
951 cellTextAndPaddingHeight =
952 iconDrawablePaddingPx + Utilities.calculateTextHeight(iconTextSizePx);
Alex Chaube753132022-12-09 16:46:54 +0000953 }
954 cellContentHeight = iconSizePx + cellTextAndPaddingHeight;
955 }
Jon Mirandae126d722021-02-25 10:45:20 -0500956 cellYPaddingPx = Math.max(0, cellHeightPx - cellContentHeight) / 2;
Thales Limad90faab2021-09-21 17:18:47 +0100957 desiredWorkspaceHorizontalMarginPx =
958 (int) (desiredWorkspaceHorizontalMarginOriginalPx * scale);
Jon Miranda228877d2021-02-09 11:05:00 -0500959 } else {
Jon Mirandae126d722021-02-25 10:45:20 -0500960 cellWidthPx = iconSizePx + iconDrawablePaddingPx;
Jon Miranda92c1b5d2021-07-20 13:57:16 -0700961 cellHeightPx = (int) Math.ceil(iconSizePx * ICON_OVERLAP_FACTOR)
962 + iconDrawablePaddingPx
Jon Miranda228877d2021-02-09 11:05:00 -0500963 + Utilities.calculateTextHeight(iconTextSizePx);
964 int cellPaddingY = (getCellSize().y - cellHeightPx) / 2;
965 if (iconDrawablePaddingPx > cellPaddingY && !isVerticalLayout
966 && !isMultiWindowMode) {
967 // Ensures that the label is closer to its corresponding icon. This is not an issue
968 // with vertical bar layout or multi-window mode since the issue is handled
969 // separately with their calls to {@link #adjustToHideWorkspaceLabels}.
970 cellHeightPx -= (iconDrawablePaddingPx - cellPaddingY);
971 iconDrawablePaddingPx = cellPaddingY;
972 }
Jon Miranda846455e2017-10-02 14:58:52 -0700973 }
Jon Miranda18751b62017-07-31 17:25:27 -0700974
Sunny Goyalae190ff2020-04-14 00:19:01 +0000975 // All apps
Brian Isganitis25b2ac82022-01-28 16:25:13 -0500976 updateAllAppsIconSize(scale, res);
Winson Chungb3800242013-10-24 11:01:54 -0700977
Thales Limab8c05952022-05-23 16:58:38 +0100978 updateHotseatSizes(iconSizePx);
Winson Chungb3800242013-10-24 11:01:54 -0700979
Sunny Goyalbaec6ff2016-09-14 11:26:21 -0700980 // Folder icon
Jon Miranda591e3602018-03-28 11:37:00 -0700981 folderIconSizePx = IconNormalizer.getNormalizedCircleSize(iconSizePx);
982 folderIconOffsetYPx = (iconSizePx - folderIconSizePx) / 2;
Winson Chung0f785722015-04-08 10:27:49 -0700983 }
984
Thales Lima425f6822022-05-10 13:44:58 -0300985 /**
Thales Lima6a590062022-11-22 15:52:49 +0000986 * This method calculates the space between the icons to achieve a certain width.
Thales Lima425f6822022-05-10 13:44:58 -0300987 */
Thales Lima6a590062022-11-22 15:52:49 +0000988 private int calculateHotseatBorderSpace(float hotseatWidthPx, int numExtraBorder) {
Thales Lima9938c2f2022-07-25 14:38:16 +0100989 float hotseatIconsTotalPx = iconSizePx * numShownHotseatIcons;
Thales Lima6a590062022-11-22 15:52:49 +0000990 int hotseatBorderSpace =
991 (int) (hotseatWidthPx - hotseatIconsTotalPx)
992 / (numShownHotseatIcons - 1 + numExtraBorder);
993 return Math.min(hotseatBorderSpace, maxHotseatIconSpacePx);
Thales Lima425f6822022-05-10 13:44:58 -0300994 }
995
Brian Isganitis25b2ac82022-01-28 16:25:13 -0500996
997 /**
998 * Updates the iconSize for allApps* variants.
999 */
Brian Isganitisa9a78112022-05-23 18:11:47 -07001000 private void updateAllAppsIconSize(float scale, Resources res) {
Thales Lima080d8902022-03-28 15:30:29 +01001001 allAppsBorderSpacePx = new Point(
1002 pxFromDp(inv.allAppsBorderSpaces[mTypeIndex].x, mMetrics, scale),
1003 pxFromDp(inv.allAppsBorderSpaces[mTypeIndex].y, mMetrics, scale));
Brandon Dayauon07ca8842022-04-27 10:52:28 -07001004 // AllApps cells don't have real space between cells,
1005 // so we add the border space to the cell height
Alex Chaube753132022-12-09 16:46:54 +00001006 allAppsCellHeightPx = pxFromDp(inv.allAppsCellSize[mTypeIndex].y, mMetrics)
Brandon Dayauon07ca8842022-04-27 10:52:28 -07001007 + allAppsBorderSpacePx.y;
1008 // but width is just the cell,
1009 // the border is added in #updateAllAppsContainerWidth
Thales Lima080d8902022-03-28 15:30:29 +01001010 if (isScalableGrid) {
Alex Chaube753132022-12-09 16:46:54 +00001011 allAppsIconSizePx = pxFromDp(inv.allAppsIconSize[mTypeIndex], mMetrics);
1012 allAppsIconTextSizePx = pxFromSp(inv.allAppsIconTextSize[mTypeIndex], mMetrics);
Brian Isganitis25b2ac82022-01-28 16:25:13 -05001013 allAppsIconDrawablePaddingPx = iconDrawablePaddingOriginalPx;
Brandon Dayauon7a8a9ed2022-06-06 14:32:22 -07001014 allAppsCellWidthPx = pxFromDp(inv.allAppsCellSize[mTypeIndex].x, mMetrics, scale);
Alex Chaube753132022-12-09 16:46:54 +00001015
1016 if (allAppsCellWidthPx < allAppsIconSizePx) {
1017 // If allAppsCellWidth no longer fit allAppsIconSize, reduce allAppsBorderSpace to
1018 // make allAppsCellWidth bigger.
1019 int numBorders = inv.numAllAppsColumns - 1;
1020 int extraWidthRequired =
1021 (allAppsIconSizePx - allAppsCellWidthPx) * inv.numAllAppsColumns;
1022 if (allAppsBorderSpacePx.x * numBorders >= extraWidthRequired) {
1023 allAppsCellWidthPx = allAppsIconSizePx;
1024 allAppsBorderSpacePx.x -= extraWidthRequired / numBorders;
1025 } else {
1026 // If it still doesn't fit, set allAppsBorderSpace to 0 and distribute the space
1027 // for allAppsCellWidth, and reduce allAppsIconSize.
1028 allAppsCellWidthPx = (allAppsCellWidthPx * inv.numAllAppsColumns
1029 + allAppsBorderSpacePx.x * numBorders) / inv.numAllAppsColumns;
1030 allAppsIconSizePx = Math.min(allAppsIconSizePx, allAppsCellWidthPx);
1031 allAppsBorderSpacePx.x = 0;
1032 }
1033 }
1034
1035 int cellContentHeight = allAppsIconSizePx
1036 + Utilities.calculateTextHeight(allAppsIconTextSizePx) + allAppsBorderSpacePx.y;
1037 if (allAppsCellHeightPx < cellContentHeight) {
1038 // Increase allAppsCellHeight to fit its content.
1039 allAppsCellHeightPx = cellContentHeight;
1040 }
Brian Isganitis25b2ac82022-01-28 16:25:13 -05001041 } else {
Brandon Dayauon07ca8842022-04-27 10:52:28 -07001042 float invIconSizeDp = inv.allAppsIconSize[mTypeIndex];
1043 float invIconTextSizeSp = inv.allAppsIconTextSize[mTypeIndex];
Brian Isganitis25b2ac82022-01-28 16:25:13 -05001044 allAppsIconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mMetrics, scale));
1045 allAppsIconTextSizePx = (int) (pxFromSp(invIconTextSizeSp, mMetrics) * scale);
Brandon Dayauon07ca8842022-04-27 10:52:28 -07001046 allAppsIconDrawablePaddingPx =
1047 res.getDimensionPixelSize(R.dimen.all_apps_icon_drawable_padding);
Brandon Dayauon7a8a9ed2022-06-06 14:32:22 -07001048 allAppsCellWidthPx = allAppsIconSizePx + (2 * allAppsIconDrawablePaddingPx);
Brian Isganitis25b2ac82022-01-28 16:25:13 -05001049 }
1050
Thales Limab7ef5692022-03-10 10:32:36 +00001051 updateAllAppsContainerWidth(res);
Brian Isganitis25b2ac82022-01-28 16:25:13 -05001052 if (isVerticalBarLayout()) {
1053 hideWorkspaceLabelsIfNotEnoughSpace();
1054 }
1055 }
1056
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001057 private void updateAvailableFolderCellDimensions(Resources res) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001058 updateFolderCellSize(1f, res);
Jon Mirandabf7d8122016-11-03 15:29:29 -07001059
Jon Mirandac1b23992016-12-13 08:57:36 -08001060 // Don't let the folder get too close to the edges of the screen.
Jon Miranda1786df32018-09-25 13:05:23 -07001061 int folderMargin = edgeMarginPx * 2;
Sunny Goyal07b69292018-01-08 14:19:34 -08001062 Point totalWorkspacePadding = getTotalWorkspacePadding();
Jon Mirandac1b23992016-12-13 08:57:36 -08001063
1064 // Check if the icons fit within the available height.
Jon Miranda228877d2021-02-09 11:05:00 -05001065 float contentUsedHeight = folderCellHeightPx * inv.numFolderRows
Thales Limab35faed2022-09-05 16:30:01 -03001066 + ((inv.numFolderRows - 1) * folderCellLayoutBorderSpacePx);
1067 int contentMaxHeight = availableHeightPx - totalWorkspacePadding.y - folderFooterHeightPx
Jon Mirandae126d722021-02-25 10:45:20 -05001068 - folderMargin - folderContentPaddingTop;
Samuel Fufa1c8d90a2019-11-12 17:54:58 -08001069 float scaleY = contentMaxHeight / contentUsedHeight;
Jon Mirandac1b23992016-12-13 08:57:36 -08001070
1071 // Check if the icons fit within the available width.
Jon Miranda228877d2021-02-09 11:05:00 -05001072 float contentUsedWidth = folderCellWidthPx * inv.numFolderColumns
Thales Limab35faed2022-09-05 16:30:01 -03001073 + ((inv.numFolderColumns - 1) * folderCellLayoutBorderSpacePx);
Jon Mirandae126d722021-02-25 10:45:20 -05001074 int contentMaxWidth = availableWidthPx - totalWorkspacePadding.x - folderMargin
1075 - folderContentPaddingLeftRight * 2;
Samuel Fufa1c8d90a2019-11-12 17:54:58 -08001076 float scaleX = contentMaxWidth / contentUsedWidth;
Jon Mirandac1b23992016-12-13 08:57:36 -08001077
1078 float scale = Math.min(scaleX, scaleY);
1079 if (scale < 1f) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001080 updateFolderCellSize(scale, res);
Jon Mirandabf7d8122016-11-03 15:29:29 -07001081 }
1082 }
1083
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001084 private void updateFolderCellSize(float scale, Resources res) {
Alex Chau0d4f1ac2022-12-20 12:31:14 +00001085 float invIconSizeDp = inv.iconSize[mTypeIndex];
Sunny Goyal35c7b192021-04-20 16:51:10 -07001086 folderChildIconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mMetrics, scale));
Alex Chau0d4f1ac2022-12-20 12:31:14 +00001087 folderChildTextSizePx = pxFromSp(inv.iconTextSize[mTypeIndex], mMetrics, scale);
Thales Limab35faed2022-09-05 16:30:01 -03001088 folderLabelTextSizePx = Math.max(pxFromSp(MIN_FOLDER_TEXT_SIZE_SP, mMetrics),
1089 (int) (folderChildTextSizePx * folderLabelTextScale));
Jon Mirandabf7d8122016-11-03 15:29:29 -07001090
1091 int textHeight = Utilities.calculateTextHeight(folderChildTextSizePx);
Jon Mirandabf7d8122016-11-03 15:29:29 -07001092
Jon Miranda823da222021-03-23 08:08:45 -04001093 if (isScalableGrid) {
Thales Limab35faed2022-09-05 16:30:01 -03001094 if (inv.folderStyle == INVALID_RESOURCE_HANDLE) {
1095 folderCellWidthPx = pxFromDp(getCellSize().x, mMetrics, scale);
1096 folderCellHeightPx = pxFromDp(getCellSize().y, mMetrics, scale);
1097 }
Jon Mirandaf33f5b32021-07-22 17:15:31 -07001098
Thales Limab35faed2022-09-05 16:30:01 -03001099 folderContentPaddingLeftRight = folderCellLayoutBorderSpacePx;
Jon Miranda823da222021-03-23 08:08:45 -04001100 } else {
1101 int cellPaddingX = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_x_padding)
1102 * scale);
1103 int cellPaddingY = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_y_padding)
1104 * scale);
1105
1106 folderCellWidthPx = folderChildIconSizePx + 2 * cellPaddingX;
1107 folderCellHeightPx = folderChildIconSizePx + 2 * cellPaddingY + textHeight;
Thales Limab35faed2022-09-05 16:30:01 -03001108 folderContentPaddingLeftRight =
1109 res.getDimensionPixelSize(R.dimen.folder_content_padding_left_right);
1110 folderFooterHeightPx =
1111 res.getDimensionPixelSize(R.dimen.folder_footer_height_default);
Jon Miranda823da222021-03-23 08:08:45 -04001112 }
1113
Jonathan Miranda9ad87462017-07-26 17:41:02 +00001114 folderChildDrawablePaddingPx = Math.max(0,
1115 (folderCellHeightPx - folderChildIconSizePx - textHeight) / 3);
Jon Mirandabf7d8122016-11-03 15:29:29 -07001116 }
1117
Winson1f064272016-07-18 17:18:02 -07001118 public void updateInsets(Rect insets) {
1119 mInsets.set(insets);
1120 }
1121
Sunny Goyalae6e3182019-04-30 12:04:37 -07001122 /**
1123 * The current device insets. This is generally same as the insets being dispatched to
1124 * {@link Insettable} elements, but can differ if the element is using a different profile.
1125 */
Sunny Goyal1a52ef52018-01-11 10:15:03 -08001126 public Rect getInsets() {
1127 return mInsets;
1128 }
1129
Sunny Goyal756cd262015-08-20 12:33:21 -07001130 public Point getCellSize() {
Sunny Goyal19ff7282021-04-22 10:12:54 -07001131 return getCellSize(null);
Jon Miranda6f7e9702019-09-16 14:44:14 -07001132 }
1133
Sunny Goyal19ff7282021-04-22 10:12:54 -07001134 public Point getCellSize(Point result) {
1135 if (result == null) {
1136 result = new Point();
1137 }
Thales Limad1df5fc2021-09-03 18:37:19 +01001138
Pat Manning25d53342022-05-10 09:58:49 +00001139 int shortcutAndWidgetContainerWidth =
1140 getCellLayoutWidth() - (cellLayoutPaddingPx.left + cellLayoutPaddingPx.right);
1141 result.x = calculateCellWidth(shortcutAndWidgetContainerWidth, cellLayoutBorderSpacePx.x,
1142 inv.numColumns);
1143 int shortcutAndWidgetContainerHeight =
1144 getCellLayoutHeight() - (cellLayoutPaddingPx.top + cellLayoutPaddingPx.bottom);
1145 result.y = calculateCellHeight(shortcutAndWidgetContainerHeight, cellLayoutBorderSpacePx.y,
1146 inv.numRows);
Sunny Goyal3e8a04b2022-05-09 19:31:45 +00001147 return result;
Pat Manningb45d6c42022-05-03 14:32:06 +01001148 }
1149
1150 /**
Thales Lima1e8b45f2022-08-25 11:50:59 -04001151 * Returns the left and right space on the cell, which is the cell width - icon size
1152 */
1153 public int getCellHorizontalSpace() {
1154 return getCellSize().x - iconSizePx;
1155 }
1156
1157 /**
Pat Manning25d53342022-05-10 09:58:49 +00001158 * Gets the number of panels within the workspace.
1159 */
1160 public int getPanelCount() {
1161 return isTwoPanels ? 2 : 1;
1162 }
1163
1164 /**
Pat Manningde25c0d2022-04-05 19:11:26 +01001165 * Gets the space in px from the bottom of last item in the vertical-bar hotseat to the
1166 * bottom of the screen.
1167 */
Pat Manning5f74bfd2022-07-20 12:08:54 +01001168 private int getVerticalHotseatLastItemBottomOffset(Context context) {
1169 Rect hotseatBarPadding = getHotseatLayoutPadding(context);
Pat Manningde25c0d2022-04-05 19:11:26 +01001170 int cellHeight = calculateCellHeight(
Pat Manning5f74bfd2022-07-20 12:08:54 +01001171 heightPx - hotseatBarPadding.top - hotseatBarPadding.bottom, hotseatBorderSpace,
Pat Manningde25c0d2022-04-05 19:11:26 +01001172 numShownHotseatIcons);
Pat Manningde25c0d2022-04-05 19:11:26 +01001173 int extraIconEndSpacing = (cellHeight - iconSizePx) / 2;
Pat Manning5f74bfd2022-07-20 12:08:54 +01001174 return extraIconEndSpacing + hotseatBarPadding.bottom;
Pat Manningde25c0d2022-04-05 19:11:26 +01001175 }
1176
1177 /**
1178 * Gets the scaled top of the workspace in px for the spring-loaded edit state.
1179 */
Pat Manning25d53342022-05-10 09:58:49 +00001180 public float getCellLayoutSpringLoadShrunkTop() {
Pat Manning5f74bfd2022-07-20 12:08:54 +01001181 return mInsets.top + dropTargetBarTopMarginPx + dropTargetBarSizePx
Pat Manningde25c0d2022-04-05 19:11:26 +01001182 + dropTargetBarBottomMarginPx;
Pat Manningde25c0d2022-04-05 19:11:26 +01001183 }
1184
1185 /**
1186 * Gets the scaled bottom of the workspace in px for the spring-loaded edit state.
1187 */
Pat Manning5f74bfd2022-07-20 12:08:54 +01001188 public float getCellLayoutSpringLoadShrunkBottom(Context context) {
Pat Manningde25c0d2022-04-05 19:11:26 +01001189 int topOfHotseat = hotseatBarSizePx + springLoadedHotseatBarTopMarginPx;
Pat Manning5f74bfd2022-07-20 12:08:54 +01001190 return heightPx - (isVerticalBarLayout()
1191 ? getVerticalHotseatLastItemBottomOffset(context) : topOfHotseat);
Pat Manningde25c0d2022-04-05 19:11:26 +01001192 }
1193
Pat Manningea5c1d22022-04-14 10:58:16 +01001194 /**
Pat Manninga2e14992022-04-22 11:29:17 +01001195 * Gets the scale of the workspace for the spring-loaded edit state.
1196 */
Pat Manning5f74bfd2022-07-20 12:08:54 +01001197 public float getWorkspaceSpringLoadScale(Context context) {
1198 float scale =
1199 (getCellLayoutSpringLoadShrunkBottom(context) - getCellLayoutSpringLoadShrunkTop())
1200 / getCellLayoutHeight();
Pat Manninga2e14992022-04-22 11:29:17 +01001201 scale = Math.min(scale, 1f);
1202
Pat Manninge63dd252022-08-02 16:15:29 +01001203 // Reduce scale if next pages would not be visible after scaling the workspace.
Pat Manning25d53342022-05-10 09:58:49 +00001204 int workspaceWidth = availableWidthPx;
Pat Manninga2e14992022-04-22 11:29:17 +01001205 float scaledWorkspaceWidth = workspaceWidth * scale;
Alex Chau906d8822022-05-23 10:42:25 +01001206 float maxAvailableWidth = workspaceWidth - (2 * workspaceSpringLoadedMinNextPageVisiblePx);
Pat Manninga2e14992022-04-22 11:29:17 +01001207 if (scaledWorkspaceWidth > maxAvailableWidth) {
1208 scale *= maxAvailableWidth / scaledWorkspaceWidth;
1209 }
1210 return scale;
1211 }
1212
Pat Manning25d53342022-05-10 09:58:49 +00001213 /**
1214 * Gets the width of a single Cell Layout, aka a single panel within a Workspace.
1215 *
1216 * <p>This is the width of a Workspace, less its horizontal padding. Note that two-panel
1217 * layouts have two Cell Layouts per workspace.
1218 */
1219 public int getCellLayoutWidth() {
1220 return (availableWidthPx - getTotalWorkspacePadding().x) / getPanelCount();
Alex Chau60953332021-11-24 12:41:07 +00001221 }
1222
Pat Manning25d53342022-05-10 09:58:49 +00001223 /**
1224 * Gets the height of a single Cell Layout, aka a single panel within a Workspace.
1225 *
1226 * <p>This is the height of a Workspace, less its vertical padding.
1227 */
1228 public int getCellLayoutHeight() {
1229 return availableHeightPx - getTotalWorkspacePadding().y;
Pat Manning08610ca2022-04-05 21:03:16 +01001230 }
1231
Sunny Goyal6c2975e2016-07-06 09:47:56 -07001232 public Point getTotalWorkspacePadding() {
Sunny Goyal07b69292018-01-08 14:19:34 -08001233 return new Point(workspacePadding.left + workspacePadding.right,
1234 workspacePadding.top + workspacePadding.bottom);
Sunny Goyal6c2975e2016-07-06 09:47:56 -07001235 }
1236
1237 /**
Sunny Goyal07b69292018-01-08 14:19:34 -08001238 * Updates {@link #workspacePadding} as a result of any internal value change to reflect the
1239 * new workspace padding
Sunny Goyal6c2975e2016-07-06 09:47:56 -07001240 */
Sunny Goyal07b69292018-01-08 14:19:34 -08001241 private void updateWorkspacePadding() {
1242 Rect padding = workspacePadding;
Tony Wickham3a3517f2015-10-06 11:27:04 -07001243 if (isVerticalBarLayout()) {
Sunny Goyal228153d2018-01-04 15:35:22 -08001244 padding.top = 0;
1245 padding.bottom = edgeMarginPx;
Sunny Goyal7e2e67f2018-01-26 13:40:08 -08001246 if (isSeascape()) {
Tony Wickham1eeffbe2018-06-12 15:01:15 -07001247 padding.left = hotseatBarSizePx;
Tony Wickham5edf9e22020-03-27 20:06:52 -07001248 padding.right = hotseatBarSidePaddingStartPx;
Winson1f064272016-07-18 17:18:02 -07001249 } else {
Tony Wickham5edf9e22020-03-27 20:06:52 -07001250 padding.left = hotseatBarSidePaddingStartPx;
Tony Wickham1eeffbe2018-06-12 15:01:15 -07001251 padding.right = hotseatBarSizePx;
Winson1f064272016-07-18 17:18:02 -07001252 }
Winson Chungb3800242013-10-24 11:01:54 -07001253 } else {
Thales Limab8c05952022-05-23 16:58:38 +01001254 // Pad the bottom of the workspace with hotseat bar
1255 // and leave a bit of space in case a widget go all the way down
1256 int paddingBottom = hotseatBarSizePx + workspaceBottomPadding
1257 + workspacePageIndicatorHeight - mWorkspacePageIndicatorOverlapWorkspace
1258 - mInsets.bottom;
Pat Manning08610ca2022-04-05 21:03:16 +01001259 int paddingTop = workspaceTopPadding + (isScalableGrid ? 0 : edgeMarginPx);
1260 int paddingSide = desiredWorkspaceHorizontalMarginPx;
Andras Kloczl8e57cce2021-02-11 23:51:19 +01001261
Pat Manning08610ca2022-04-05 21:03:16 +01001262 padding.set(paddingSide, paddingTop, paddingSide, paddingBottom);
Winson Chungb3800242013-10-24 11:01:54 -07001263 }
Pat Manning08610ca2022-04-05 21:03:16 +01001264 insetPadding(workspacePadding, cellLayoutPaddingPx);
1265 }
1266
1267 private void insetPadding(Rect paddings, Rect insets) {
1268 insets.left = Math.min(insets.left, paddings.left);
1269 paddings.left -= insets.left;
1270
1271 insets.top = Math.min(insets.top, paddings.top);
1272 paddings.top -= insets.top;
1273
1274 insets.right = Math.min(insets.right, paddings.right);
1275 paddings.right -= insets.right;
1276
1277 insets.bottom = Math.min(insets.bottom, paddings.bottom);
1278 paddings.bottom -= insets.bottom;
Winson Chungb3800242013-10-24 11:01:54 -07001279 }
1280
Sunny Goyal57b22792021-05-25 14:35:01 -07001281 /**
1282 * Returns the padding for hotseat view
1283 */
1284 public Rect getHotseatLayoutPadding(Context context) {
Pat Manning5f74bfd2022-07-20 12:08:54 +01001285 Rect hotseatBarPadding = new Rect();
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001286 if (isVerticalBarLayout()) {
Sihua Ma38bb3b02022-03-21 22:20:14 -07001287 // The hotseat icons will be placed in the middle of the hotseat cells.
1288 // Changing the hotseatCellHeightPx is not affecting hotseat icon positions
1289 // in vertical bar layout.
1290 // Workspace icons are moved up by a small factor. The variable diffOverlapFactor
1291 // is set to account for that difference.
1292 float diffOverlapFactor = iconSizePx * (ICON_OVERLAP_FACTOR - 1) / 2;
Pat Manning08610ca2022-04-05 21:03:16 +01001293 int paddingTop = Math.max((int) (mInsets.top + cellLayoutPaddingPx.top
1294 - diffOverlapFactor), 0);
1295 int paddingBottom = Math.max((int) (mInsets.bottom + cellLayoutPaddingPx.bottom
Sihua Ma38bb3b02022-03-21 22:20:14 -07001296 + diffOverlapFactor), 0);
1297
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001298 if (isSeascape()) {
Pat Manning5f74bfd2022-07-20 12:08:54 +01001299 hotseatBarPadding.set(mInsets.left + hotseatBarSidePaddingStartPx, paddingTop,
Pat Manning08610ca2022-04-05 21:03:16 +01001300 hotseatBarSidePaddingEndPx, paddingBottom);
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001301 } else {
Pat Manning5f74bfd2022-07-20 12:08:54 +01001302 hotseatBarPadding.set(hotseatBarSidePaddingEndPx, paddingTop,
Pat Manning08610ca2022-04-05 21:03:16 +01001303 mInsets.right + hotseatBarSidePaddingStartPx, paddingBottom);
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001304 }
Sunny Goyal57b22792021-05-25 14:35:01 -07001305 } else if (isTaskbarPresent) {
Alex Chau51da2192022-05-20 13:32:10 +01001306 // Center the QSB vertically with hotseat
Thales Limab8c05952022-05-23 16:58:38 +01001307 int hotseatBarBottomPadding = getHotseatBarBottomPadding();
1308 int hotseatBarTopPadding =
1309 hotseatBarSizePx - hotseatBarBottomPadding - hotseatCellHeightPx;
Alex Chau51da2192022-05-20 13:32:10 +01001310
Thales Lima6a590062022-11-22 15:52:49 +00001311 int hotseatWidth = getHotseatRequiredWidth();
1312 int leftSpacing = (availableWidthPx - hotseatWidth) / 2;
1313 int rightSpacing = leftSpacing;
1314 // Hotseat aligns to the left with nav buttons
1315 if (hotseatBarEndOffset > 0) {
1316 leftSpacing = inlineNavButtonsEndSpacing;
1317 rightSpacing = availableWidthPx - hotseatWidth - leftSpacing + hotseatBorderSpace;
1318 }
Thales Lima612230d2022-03-31 18:04:37 +01001319
Thales Lima6a590062022-11-22 15:52:49 +00001320 hotseatBarPadding.set(leftSpacing, hotseatBarTopPadding, rightSpacing,
Thales Limab8c05952022-05-23 16:58:38 +01001321 hotseatBarBottomPadding);
Alex Chau51da2192022-05-20 13:32:10 +01001322
1323 boolean isRtl = Utilities.isRtl(context.getResources());
Thales Lima612230d2022-03-31 18:04:37 +01001324 if (isRtl) {
Thales Lima9938c2f2022-07-25 14:38:16 +01001325 hotseatBarPadding.right += getAdditionalQsbSpace();
Thales Lima612230d2022-03-31 18:04:37 +01001326 } else {
Thales Lima9938c2f2022-07-25 14:38:16 +01001327 hotseatBarPadding.left += getAdditionalQsbSpace();
Thales Lima612230d2022-03-31 18:04:37 +01001328 }
Thales Lima425f6822022-05-10 13:44:58 -03001329 } else if (isScalableGrid) {
Alex Chau206ede92022-08-01 17:46:12 +01001330 int sideSpacing = (availableWidthPx - hotseatQsbWidth) / 2;
Pat Manning5f74bfd2022-07-20 12:08:54 +01001331 hotseatBarPadding.set(sideSpacing,
Thales Limab8c05952022-05-23 16:58:38 +01001332 0,
Thales Lima425f6822022-05-10 13:44:58 -03001333 sideSpacing,
Thales Limab8c05952022-05-23 16:58:38 +01001334 getHotseatBarBottomPadding());
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001335 } else {
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001336 // We want the edges of the hotseat to line up with the edges of the workspace, but the
1337 // icons in the hotseat are a different size, and so don't line up perfectly. To account
1338 // for this, we pad the left and right of the hotseat with half of the difference of a
1339 // workspace cell vs a hotseat cell.
1340 float workspaceCellWidth = (float) widthPx / inv.numColumns;
Sunny Goyal19ff7282021-04-22 10:12:54 -07001341 float hotseatCellWidth = (float) widthPx / numShownHotseatIcons;
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001342 int hotseatAdjustment = Math.round((workspaceCellWidth - hotseatCellWidth) / 2);
Pat Manning5f74bfd2022-07-20 12:08:54 +01001343 hotseatBarPadding.set(
Thales Limab8c05952022-05-23 16:58:38 +01001344 hotseatAdjustment + workspacePadding.left + cellLayoutPaddingPx.left
1345 + mInsets.left,
1346 0,
Pat Manning08610ca2022-04-05 21:03:16 +01001347 hotseatAdjustment + workspacePadding.right + cellLayoutPaddingPx.right
Sunny Goyal786940a2020-06-02 02:31:31 -07001348 + mInsets.right,
Thales Limab8c05952022-05-23 16:58:38 +01001349 getHotseatBarBottomPadding());
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001350 }
Pat Manning5f74bfd2022-07-20 12:08:54 +01001351 return hotseatBarPadding;
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001352 }
1353
Thales Lima9938c2f2022-07-25 14:38:16 +01001354 private int getAdditionalQsbSpace() {
1355 return isQsbInline ? hotseatQsbWidth + hotseatBorderSpace : 0;
1356 }
1357
1358 /**
1359 * Calculate how much space the hotseat needs to be shown completely
1360 */
1361 private int getHotseatRequiredWidth() {
1362 int additionalQsbSpace = getAdditionalQsbSpace();
1363 return iconSizePx * numShownHotseatIcons
Thales Lima6a590062022-11-22 15:52:49 +00001364 + hotseatBorderSpace * (numShownHotseatIcons - (areNavButtonsInline ? 0 : 1))
Thales Lima9938c2f2022-07-25 14:38:16 +01001365 + additionalQsbSpace;
1366 }
1367
Winsonfadbe8f2016-07-22 16:35:37 -07001368 /**
Sunny Goyal57b22792021-05-25 14:35:01 -07001369 * Returns the number of pixels the QSB is translated from the bottom of the screen.
1370 */
1371 public int getQsbOffsetY() {
Thales Limaa1012902022-01-13 17:58:42 +00001372 if (isQsbInline) {
Thales Limab8c05952022-05-23 16:58:38 +01001373 return getHotseatBarBottomPadding() - ((hotseatQsbHeight - hotseatCellHeightPx) / 2);
1374 } else if (isTaskbarPresent) { // QSB on top
1375 return hotseatBarSizePx - hotseatQsbHeight + hotseatQsbShadowHeight;
Jonathan Miranda8f16a772021-07-23 23:10:37 +00001376 } else {
Thales Limab8c05952022-05-23 16:58:38 +01001377 return hotseatBarBottomSpacePx - hotseatQsbShadowHeight;
Jonathan Miranda7a273e22021-06-24 21:29:10 +00001378 }
Sunny Goyal57b22792021-05-25 14:35:01 -07001379 }
1380
Thales Limab8c05952022-05-23 16:58:38 +01001381 /**
1382 * Returns the number of pixels the hotseat is translated from the bottom of the screen.
1383 */
1384 private int getHotseatBarBottomPadding() {
1385 if (isTaskbarPresent) { // QSB on top or inline
1386 return hotseatBarBottomSpacePx - (Math.abs(hotseatCellHeightPx - iconSizePx) / 2);
Thales Limaa1012902022-01-13 17:58:42 +00001387 } else {
Thales Limab8c05952022-05-23 16:58:38 +01001388 return hotseatBarSizePx - hotseatCellHeightPx;
Thales Limaa1012902022-01-13 17:58:42 +00001389 }
Sunny Goyal57b22792021-05-25 14:35:01 -07001390 }
1391
1392 /**
Alex Chau51da2192022-05-20 13:32:10 +01001393 * Returns the number of pixels the taskbar is translated from the bottom of the screen.
1394 */
1395 public int getTaskbarOffsetY() {
1396 int taskbarIconBottomSpace = (taskbarSize - iconSizePx) / 2;
1397 int launcherIconBottomSpace =
1398 Math.min((hotseatCellHeightPx - iconSizePx) / 2, gridVisualizationPaddingY);
Thales Limab8c05952022-05-23 16:58:38 +01001399 return getHotseatBarBottomPadding() + launcherIconBottomSpace - taskbarIconBottomSpace;
Alex Chau51da2192022-05-20 13:32:10 +01001400 }
1401
1402 /**
Alex Chaua2fc7642022-04-21 14:20:23 +01001403 * Returns the number of pixels required below OverviewActions excluding insets.
1404 */
1405 public int getOverviewActionsClaimedSpaceBelow() {
Alex Chaud67ddc42022-09-30 18:15:56 +01001406 if (isTaskbarPresent) {
Alex Chau905e0f12022-11-14 21:55:37 +00001407 if (FeatureFlags.ENABLE_TASKBAR_IN_OVERVIEW.get()) {
Alex Chau85d664e2023-01-16 16:31:59 +00001408 return transientTaskbarSize + transientTaskbarMargin * 2;
Alex Chau905e0f12022-11-14 21:55:37 +00001409 }
1410
1411 return isGestureMode
1412 ? stashedTaskbarSize
1413 // Align vertically to where nav buttons are.
1414 : ((taskbarSize - overviewActionsHeight) / 2) + getTaskbarOffsetY();
Alex Chaud67ddc42022-09-30 18:15:56 +01001415 }
1416 return mInsets.bottom;
Alex Chaua2fc7642022-04-21 14:20:23 +01001417 }
1418
1419 /** Gets the space that the overview actions will take, including bottom margin. */
1420 public int getOverviewActionsClaimedSpace() {
1421 return overviewActionsTopMarginPx + overviewActionsHeight
1422 + getOverviewActionsClaimedSpaceBelow();
1423 }
1424
1425 /**
Sihua Mae04aa202022-07-18 12:43:56 -07001426 * Takes the View and return the scales of width and height depending on the DeviceProfile
1427 * specifications
1428 *
1429 * @param itemInfo The tag of the widget view
1430 * @return A PointF instance with the x set to be the scale of width, and y being the scale of
1431 * height
1432 */
1433 @NonNull
1434 public PointF getAppWidgetScale(@Nullable final ItemInfo itemInfo) {
1435 return mViewScaleProvider.getScaleFromItemInfo(itemInfo);
1436 }
1437
1438 /**
Winsonfadbe8f2016-07-22 16:35:37 -07001439 * @return the bounds for which the open folders should be contained within
1440 */
1441 public Rect getAbsoluteOpenFolderBounds() {
1442 if (isVerticalBarLayout()) {
1443 // Folders should only appear right of the drop target bar and left of the hotseat
1444 return new Rect(mInsets.left + dropTargetBarSizePx + edgeMarginPx,
1445 mInsets.top,
Jon Miranda18751b62017-07-31 17:25:27 -07001446 mInsets.left + availableWidthPx - hotseatBarSizePx - edgeMarginPx,
Winsonfadbe8f2016-07-22 16:35:37 -07001447 mInsets.top + availableHeightPx);
1448 } else {
1449 // Folders should only appear below the drop target bar and above the hotseat
Tony Wickhamae72b462021-03-10 16:18:40 -08001450 int hotseatTop = isTaskbarPresent ? taskbarSize : hotseatBarSizePx;
Tony Wickhamb4b7e202018-01-12 17:39:24 -08001451 return new Rect(mInsets.left + edgeMarginPx,
Winsonfadbe8f2016-07-22 16:35:37 -07001452 mInsets.top + dropTargetBarSizePx + edgeMarginPx,
Tony Wickhamb4b7e202018-01-12 17:39:24 -08001453 mInsets.left + availableWidthPx - edgeMarginPx,
Tony Wickhamae72b462021-03-10 16:18:40 -08001454 mInsets.top + availableHeightPx - hotseatTop
Tony Wickham5edf9e22020-03-27 20:06:52 -07001455 - workspacePageIndicatorHeight - edgeMarginPx);
Winsonfadbe8f2016-07-22 16:35:37 -07001456 }
1457 }
1458
Jon Miranda228877d2021-02-09 11:05:00 -05001459 public static int calculateCellWidth(int width, int borderSpacing, int countX) {
1460 return (width - ((countX - 1) * borderSpacing)) / countX;
Winson Chungb3800242013-10-24 11:01:54 -07001461 }
Pierre Barbier de Reuille578deba2021-09-24 13:47:44 +01001462
Jon Miranda228877d2021-02-09 11:05:00 -05001463 public static int calculateCellHeight(int height, int borderSpacing, int countY) {
1464 return (height - ((countY - 1) * borderSpacing)) / countY;
Winson Chungb3800242013-10-24 11:01:54 -07001465 }
1466
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -07001467 /**
Tony Wickham55616cd2015-09-23 14:55:17 -07001468 * When {@code true}, the device is in landscape mode and the hotseat is on the right column.
1469 * When {@code false}, either device is in portrait mode or the device is in landscape mode and
1470 * the hotseat is on the bottom row.
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -07001471 */
Tony Wickhamab946a12015-09-16 15:38:16 -07001472 public boolean isVerticalBarLayout() {
Winson Chungb3800242013-10-24 11:01:54 -07001473 return isLandscape && transposeLayoutWithOrientation;
1474 }
1475
Sunny Goyal59d086c2018-05-07 17:31:40 -07001476 /**
1477 * Updates orientation information and returns true if it has changed from the previous value.
1478 */
Winson Chung13c1c2c2019-09-06 11:46:19 -07001479 public boolean updateIsSeascape(Context context) {
Sunny Goyal59d086c2018-05-07 17:31:40 -07001480 if (isVerticalBarLayout()) {
Sunny Goyal35c7b192021-04-20 16:51:10 -07001481 boolean isSeascape = DisplayController.INSTANCE.get(context)
1482 .getInfo().rotation == Surface.ROTATION_270;
Sunny Goyal59d086c2018-05-07 17:31:40 -07001483 if (mIsSeascape != isSeascape) {
1484 mIsSeascape = isSeascape;
Pat Manning08610ca2022-04-05 21:03:16 +01001485 // Hotseat changing sides requires updating workspace left/right paddings
1486 updateWorkspacePadding();
Sunny Goyal59d086c2018-05-07 17:31:40 -07001487 return true;
1488 }
1489 }
1490 return false;
1491 }
1492
Sunny Goyal7e2e67f2018-01-26 13:40:08 -08001493 public boolean isSeascape() {
Sunny Goyal59d086c2018-05-07 17:31:40 -07001494 return isVerticalBarLayout() && mIsSeascape;
Sunny Goyal7e2e67f2018-01-26 13:40:08 -08001495 }
1496
Sunny Goyal07b69292018-01-08 14:19:34 -08001497 public boolean shouldFadeAdjacentWorkspaceScreens() {
Sunny Goyal19ff7282021-04-22 10:12:54 -07001498 return isVerticalBarLayout();
Winson Chungb3800242013-10-24 11:01:54 -07001499 }
1500
Jon Miranda92c1b5d2021-07-20 13:57:16 -07001501 public int getCellContentHeight(@ContainerType int containerType) {
Sunny Goyalc13403c2016-11-18 23:44:48 -08001502 switch (containerType) {
1503 case CellLayout.WORKSPACE:
1504 return cellHeightPx;
1505 case CellLayout.FOLDER:
1506 return folderCellHeightPx;
1507 case CellLayout.HOTSEAT:
Jon Miranda92c1b5d2021-07-20 13:57:16 -07001508 // The hotseat is the only container where the cell height is going to be
1509 // different from the content within that cell.
1510 return iconSizePx;
Sunny Goyalc13403c2016-11-18 23:44:48 -08001511 default:
1512 // ??
1513 return 0;
1514 }
1515 }
Sunny Goyal13178ac2016-04-04 16:35:22 -07001516
Jon Miranda58561d42021-03-17 10:51:54 -04001517 private String pxToDpStr(String name, float value) {
Sunny Goyal35c7b192021-04-20 16:51:10 -07001518 return "\t" + name + ": " + value + "px (" + dpiFromPx(value, mMetrics.densityDpi) + "dp)";
Jon Miranda58561d42021-03-17 10:51:54 -04001519 }
1520
Alex Chaue818bcb2022-09-02 17:27:11 +01001521 private String dpPointFToString(String name, PointF value) {
1522 return String.format(Locale.ENGLISH, "\t%s: PointF(%.1f, %.1f)dp", name, value.x, value.y);
1523 }
1524
Pat Manning5f74bfd2022-07-20 12:08:54 +01001525 /** Dumps various DeviceProfile variables to the specified writer. */
1526 public void dump(Context context, String prefix, PrintWriter writer) {
Jon Miranda58561d42021-03-17 10:51:54 -04001527 writer.println(prefix + "DeviceProfile:");
Sunny Goyal35c7b192021-04-20 16:51:10 -07001528 writer.println(prefix + "\t1 dp = " + mMetrics.density + " px");
Jon Miranda58561d42021-03-17 10:51:54 -04001529
1530 writer.println(prefix + "\tisTablet:" + isTablet);
Jon Miranda58561d42021-03-17 10:51:54 -04001531 writer.println(prefix + "\tisPhone:" + isPhone);
1532 writer.println(prefix + "\ttransposeLayoutWithOrientation:"
1533 + transposeLayoutWithOrientation);
Alex Chau6ed408f2022-03-04 12:58:05 +00001534 writer.println(prefix + "\tisGestureMode:" + isGestureMode);
Jon Miranda58561d42021-03-17 10:51:54 -04001535
1536 writer.println(prefix + "\tisLandscape:" + isLandscape);
1537 writer.println(prefix + "\tisMultiWindowMode:" + isMultiWindowMode);
Sunny Goyal19ff7282021-04-22 10:12:54 -07001538 writer.println(prefix + "\tisTwoPanels:" + isTwoPanels);
Jon Miranda58561d42021-03-17 10:51:54 -04001539
1540 writer.println(prefix + pxToDpStr("windowX", windowX));
1541 writer.println(prefix + pxToDpStr("windowY", windowY));
1542 writer.println(prefix + pxToDpStr("widthPx", widthPx));
1543 writer.println(prefix + pxToDpStr("heightPx", heightPx));
Jon Miranda58561d42021-03-17 10:51:54 -04001544 writer.println(prefix + pxToDpStr("availableWidthPx", availableWidthPx));
1545 writer.println(prefix + pxToDpStr("availableHeightPx", availableHeightPx));
Alex Chaue0227552022-04-06 19:44:43 +01001546 writer.println(prefix + pxToDpStr("mInsets.left", mInsets.left));
1547 writer.println(prefix + pxToDpStr("mInsets.top", mInsets.top));
1548 writer.println(prefix + pxToDpStr("mInsets.right", mInsets.right));
1549 writer.println(prefix + pxToDpStr("mInsets.bottom", mInsets.bottom));
Jon Miranda58561d42021-03-17 10:51:54 -04001550
1551 writer.println(prefix + "\taspectRatio:" + aspectRatio);
1552
1553 writer.println(prefix + "\tisScalableGrid:" + isScalableGrid);
1554
Thales Lima83bedbf2021-10-05 17:47:39 +01001555 writer.println(prefix + "\tinv.numRows: " + inv.numRows);
Alex Chau9fee3fd2021-12-01 18:43:10 +00001556 writer.println(prefix + "\tinv.numColumns: " + inv.numColumns);
1557 writer.println(prefix + "\tinv.numSearchContainerColumns: "
1558 + inv.numSearchContainerColumns);
Jon Miranda58561d42021-03-17 10:51:54 -04001559
Alex Chaue818bcb2022-09-02 17:27:11 +01001560 writer.println(prefix + dpPointFToString("minCellSize", inv.minCellSize[mTypeIndex]));
Jon Mirandaab3c6812021-06-28 15:42:28 -07001561
Jon Miranda58561d42021-03-17 10:51:54 -04001562 writer.println(prefix + pxToDpStr("cellWidthPx", cellWidthPx));
1563 writer.println(prefix + pxToDpStr("cellHeightPx", cellHeightPx));
1564
1565 writer.println(prefix + pxToDpStr("getCellSize().x", getCellSize().x));
1566 writer.println(prefix + pxToDpStr("getCellSize().y", getCellSize().y));
1567
Thales Lima83bedbf2021-10-05 17:47:39 +01001568 writer.println(prefix + pxToDpStr("cellLayoutBorderSpacePx Horizontal",
1569 cellLayoutBorderSpacePx.x));
1570 writer.println(prefix + pxToDpStr("cellLayoutBorderSpacePx Vertical",
1571 cellLayoutBorderSpacePx.y));
Pat Manning5f74bfd2022-07-20 12:08:54 +01001572 writer.println(
1573 prefix + pxToDpStr("cellLayoutPaddingPx.left", cellLayoutPaddingPx.left));
1574 writer.println(
1575 prefix + pxToDpStr("cellLayoutPaddingPx.top", cellLayoutPaddingPx.top));
1576 writer.println(
1577 prefix + pxToDpStr("cellLayoutPaddingPx.right", cellLayoutPaddingPx.right));
Pat Manning08610ca2022-04-05 21:03:16 +01001578 writer.println(
1579 prefix + pxToDpStr("cellLayoutPaddingPx.bottom", cellLayoutPaddingPx.bottom));
Thales Lima83bedbf2021-10-05 17:47:39 +01001580
Jon Miranda58561d42021-03-17 10:51:54 -04001581 writer.println(prefix + pxToDpStr("iconSizePx", iconSizePx));
1582 writer.println(prefix + pxToDpStr("iconTextSizePx", iconTextSizePx));
1583 writer.println(prefix + pxToDpStr("iconDrawablePaddingPx", iconDrawablePaddingPx));
1584
1585 writer.println(prefix + pxToDpStr("folderCellWidthPx", folderCellWidthPx));
1586 writer.println(prefix + pxToDpStr("folderCellHeightPx", folderCellHeightPx));
1587 writer.println(prefix + pxToDpStr("folderChildIconSizePx", folderChildIconSizePx));
1588 writer.println(prefix + pxToDpStr("folderChildTextSizePx", folderChildTextSizePx));
1589 writer.println(prefix + pxToDpStr("folderChildDrawablePaddingPx",
1590 folderChildDrawablePaddingPx));
Thales Limab35faed2022-09-05 16:30:01 -03001591 writer.println(prefix + pxToDpStr("folderCellLayoutBorderSpacePx",
1592 folderCellLayoutBorderSpacePx));
Thales Limaa08a4432022-08-09 09:55:17 +01001593 writer.println(prefix + pxToDpStr("folderContentPaddingLeftRight",
1594 folderContentPaddingLeftRight));
1595 writer.println(prefix + pxToDpStr("folderTopPadding", folderContentPaddingTop));
Thales Limab35faed2022-09-05 16:30:01 -03001596 writer.println(prefix + pxToDpStr("folderFooterHeight", folderFooterHeightPx));
Jon Miranda58561d42021-03-17 10:51:54 -04001597
Alex Chaue0227552022-04-06 19:44:43 +01001598 writer.println(prefix + pxToDpStr("bottomSheetTopPadding", bottomSheetTopPadding));
Alex Chau3d2c0622022-09-01 21:28:14 +01001599 writer.println(prefix + "\tbottomSheetOpenDuration: " + bottomSheetOpenDuration);
1600 writer.println(prefix + "\tbottomSheetCloseDuration: " + bottomSheetCloseDuration);
1601 writer.println(prefix + "\tbottomSheetWorkspaceScale: " + bottomSheetWorkspaceScale);
1602 writer.println(prefix + "\tbottomSheetDepth: " + bottomSheetDepth);
Alex Chaue0227552022-04-06 19:44:43 +01001603
1604 writer.println(prefix + pxToDpStr("allAppsShiftRange", allAppsShiftRange));
1605 writer.println(prefix + pxToDpStr("allAppsTopPadding", allAppsTopPadding));
Alex Chau3d2c0622022-09-01 21:28:14 +01001606 writer.println(prefix + "\tallAppsOpenDuration: " + allAppsOpenDuration);
1607 writer.println(prefix + "\tallAppsCloseDuration: " + allAppsCloseDuration);
Jon Miranda58561d42021-03-17 10:51:54 -04001608 writer.println(prefix + pxToDpStr("allAppsIconSizePx", allAppsIconSizePx));
1609 writer.println(prefix + pxToDpStr("allAppsIconTextSizePx", allAppsIconTextSizePx));
1610 writer.println(prefix + pxToDpStr("allAppsIconDrawablePaddingPx",
1611 allAppsIconDrawablePaddingPx));
1612 writer.println(prefix + pxToDpStr("allAppsCellHeightPx", allAppsCellHeightPx));
Alex Chau27b39b92022-01-14 18:02:18 +00001613 writer.println(prefix + pxToDpStr("allAppsCellWidthPx", allAppsCellWidthPx));
Pat Manning26f70f72022-07-07 13:50:39 +01001614 writer.println(prefix + pxToDpStr("allAppsBorderSpacePxX", allAppsBorderSpacePx.x));
1615 writer.println(prefix + pxToDpStr("allAppsBorderSpacePxY", allAppsBorderSpacePx.y));
Sunny Goyal19ff7282021-04-22 10:12:54 -07001616 writer.println(prefix + "\tnumShownAllAppsColumns: " + numShownAllAppsColumns);
Alex Chau62572c02022-07-25 18:36:37 +00001617 writer.println(prefix + pxToDpStr("allAppsLeftRightPadding", allAppsLeftRightPadding));
Alex Chau27b39b92022-01-14 18:02:18 +00001618 writer.println(prefix + pxToDpStr("allAppsLeftRightMargin", allAppsLeftRightMargin));
Jon Miranda58561d42021-03-17 10:51:54 -04001619
1620 writer.println(prefix + pxToDpStr("hotseatBarSizePx", hotseatBarSizePx));
Thales Lima425f6822022-05-10 13:44:58 -03001621 writer.println(prefix + "\tinv.hotseatColumnSpan: " + inv.hotseatColumnSpan[mTypeIndex]);
Jon Miranda58561d42021-03-17 10:51:54 -04001622 writer.println(prefix + pxToDpStr("hotseatCellHeightPx", hotseatCellHeightPx));
Alex Chau62572c02022-07-25 18:36:37 +00001623 writer.println(prefix + pxToDpStr("hotseatBarBottomSpacePx", hotseatBarBottomSpacePx));
Jon Miranda58561d42021-03-17 10:51:54 -04001624 writer.println(prefix + pxToDpStr("hotseatBarSidePaddingStartPx",
1625 hotseatBarSidePaddingStartPx));
1626 writer.println(prefix + pxToDpStr("hotseatBarSidePaddingEndPx",
1627 hotseatBarSidePaddingEndPx));
Pat Manning26f70f72022-07-07 13:50:39 +01001628 writer.println(prefix + pxToDpStr("hotseatBarEndOffset", hotseatBarEndOffset));
Thales Limab8c05952022-05-23 16:58:38 +01001629 writer.println(prefix + pxToDpStr("hotseatQsbSpace", hotseatQsbSpace));
1630 writer.println(prefix + pxToDpStr("hotseatQsbHeight", hotseatQsbHeight));
Pat Manningde25c0d2022-04-05 19:11:26 +01001631 writer.println(prefix + pxToDpStr("springLoadedHotseatBarTopMarginPx",
1632 springLoadedHotseatBarTopMarginPx));
Pat Manning5f74bfd2022-07-20 12:08:54 +01001633 Rect hotseatLayoutPadding = getHotseatLayoutPadding(context);
1634 writer.println(prefix + pxToDpStr("getHotseatLayoutPadding(context).top",
1635 hotseatLayoutPadding.top));
1636 writer.println(prefix + pxToDpStr("getHotseatLayoutPadding(context).bottom",
1637 hotseatLayoutPadding.bottom));
1638 writer.println(prefix + pxToDpStr("getHotseatLayoutPadding(context).left",
1639 hotseatLayoutPadding.left));
1640 writer.println(prefix + pxToDpStr("getHotseatLayoutPadding(context).right",
1641 hotseatLayoutPadding.right));
Sunny Goyal19ff7282021-04-22 10:12:54 -07001642 writer.println(prefix + "\tnumShownHotseatIcons: " + numShownHotseatIcons);
Thales Lima116b51a2022-02-03 16:19:47 +00001643 writer.println(prefix + pxToDpStr("hotseatBorderSpace", hotseatBorderSpace));
Thales Limaa1012902022-01-13 17:58:42 +00001644 writer.println(prefix + "\tisQsbInline: " + isQsbInline);
Alex Chau206ede92022-08-01 17:46:12 +01001645 writer.println(prefix + pxToDpStr("hotseatQsbWidth", hotseatQsbWidth));
Jon Miranda58561d42021-03-17 10:51:54 -04001646
1647 writer.println(prefix + "\tisTaskbarPresent:" + isTaskbarPresent);
Tony Wickham635e1802021-07-22 14:28:04 -10001648 writer.println(prefix + "\tisTaskbarPresentInApps:" + isTaskbarPresentInApps);
Jon Miranda58561d42021-03-17 10:51:54 -04001649 writer.println(prefix + pxToDpStr("taskbarSize", taskbarSize));
Jon Miranda58561d42021-03-17 10:51:54 -04001650
Thales Lima83bedbf2021-10-05 17:47:39 +01001651 writer.println(prefix + pxToDpStr("desiredWorkspaceHorizontalMarginPx",
1652 desiredWorkspaceHorizontalMarginPx));
Jon Miranda58561d42021-03-17 10:51:54 -04001653 writer.println(prefix + pxToDpStr("workspacePadding.left", workspacePadding.left));
1654 writer.println(prefix + pxToDpStr("workspacePadding.top", workspacePadding.top));
1655 writer.println(prefix + pxToDpStr("workspacePadding.right", workspacePadding.right));
Alex Chau62572c02022-07-25 18:36:37 +00001656 writer.println(prefix + pxToDpStr("workspacePadding.bottom", workspacePadding.bottom));
Jon Miranda58561d42021-03-17 10:51:54 -04001657
Jon Mirandaab3c6812021-06-28 15:42:28 -07001658 writer.println(prefix + pxToDpStr("iconScale", iconScale));
1659 writer.println(prefix + pxToDpStr("cellScaleToFit ", cellScaleToFit));
Jon Miranda58561d42021-03-17 10:51:54 -04001660 writer.println(prefix + pxToDpStr("extraSpace", extraSpace));
Alex Chau62572c02022-07-25 18:36:37 +00001661 writer.println(prefix + pxToDpStr("unscaled extraSpace", extraSpace / iconScale));
Jon Mirandac9e69fa2021-03-22 17:13:34 -04001662
Thales Lima171ee662022-11-22 15:52:49 +00001663 writer.println(prefix + pxToDpStr("maxEmptySpace", maxEmptySpace));
Jon Miranda58561d42021-03-17 10:51:54 -04001664 writer.println(prefix + pxToDpStr("workspaceTopPadding", workspaceTopPadding));
1665 writer.println(prefix + pxToDpStr("workspaceBottomPadding", workspaceBottomPadding));
Alex Chau635b3ab2022-01-26 16:49:10 +00001666
1667 writer.println(prefix + pxToDpStr("overviewTaskMarginPx", overviewTaskMarginPx));
Alex Chau635b3ab2022-01-26 16:49:10 +00001668 writer.println(prefix + pxToDpStr("overviewTaskIconSizePx", overviewTaskIconSizePx));
1669 writer.println(prefix + pxToDpStr("overviewTaskIconDrawableSizePx",
1670 overviewTaskIconDrawableSizePx));
1671 writer.println(prefix + pxToDpStr("overviewTaskIconDrawableSizeGridPx",
1672 overviewTaskIconDrawableSizeGridPx));
1673 writer.println(prefix + pxToDpStr("overviewTaskThumbnailTopMarginPx",
1674 overviewTaskThumbnailTopMarginPx));
Alex Chaua2fc7642022-04-21 14:20:23 +01001675 writer.println(prefix + pxToDpStr("overviewActionsTopMarginPx",
1676 overviewActionsTopMarginPx));
1677 writer.println(prefix + pxToDpStr("overviewActionsHeight",
1678 overviewActionsHeight));
Alex Chau1b276a12022-12-19 14:01:36 +00001679 writer.println(prefix + pxToDpStr("overviewActionsClaimedSpaceBelow",
1680 getOverviewActionsClaimedSpaceBelow()));
Alex Chau635b3ab2022-01-26 16:49:10 +00001681 writer.println(prefix + pxToDpStr("overviewActionsButtonSpacing",
1682 overviewActionsButtonSpacing));
1683 writer.println(prefix + pxToDpStr("overviewPageSpacing", overviewPageSpacing));
1684 writer.println(prefix + pxToDpStr("overviewRowSpacing", overviewRowSpacing));
1685 writer.println(prefix + pxToDpStr("overviewGridSideMargin", overviewGridSideMargin));
Pat Manningde25c0d2022-04-05 19:11:26 +01001686
Alex Chau62572c02022-07-25 18:36:37 +00001687 writer.println(prefix + pxToDpStr("dropTargetBarTopMarginPx", dropTargetBarTopMarginPx));
Pat Manningde25c0d2022-04-05 19:11:26 +01001688 writer.println(prefix + pxToDpStr("dropTargetBarSizePx", dropTargetBarSizePx));
Alex Chau62572c02022-07-25 18:36:37 +00001689 writer.println(
1690 prefix + pxToDpStr("dropTargetBarBottomMarginPx", dropTargetBarBottomMarginPx));
Pat Manningde25c0d2022-04-05 19:11:26 +01001691
Pat Manning5f74bfd2022-07-20 12:08:54 +01001692 writer.println(prefix + pxToDpStr("getCellLayoutSpringLoadShrunkTop()",
1693 getCellLayoutSpringLoadShrunkTop()));
1694 writer.println(prefix + pxToDpStr("getCellLayoutSpringLoadShrunkBottom()",
1695 getCellLayoutSpringLoadShrunkBottom(context)));
Alex Chau906d8822022-05-23 10:42:25 +01001696 writer.println(prefix + pxToDpStr("workspaceSpringLoadedMinNextPageVisiblePx",
1697 workspaceSpringLoadedMinNextPageVisiblePx));
Pat Manning5f74bfd2022-07-20 12:08:54 +01001698 writer.println(prefix + pxToDpStr("getWorkspaceSpringLoadScale()",
1699 getWorkspaceSpringLoadScale(context)));
Thales Limab8c05952022-05-23 16:58:38 +01001700 writer.println(prefix + pxToDpStr("getCellLayoutHeight()", getCellLayoutHeight()));
1701 writer.println(prefix + pxToDpStr("getCellLayoutWidth()", getCellLayoutWidth()));
Jon Miranda58561d42021-03-17 10:51:54 -04001702 }
1703
Nicolo' Mazzucatocb7bd502023-01-16 19:46:30 +00001704 /** Returns a reduced representation of this DeviceProfile. */
1705 public String toSmallString() {
1706 return "isTablet:" + isTablet + ", "
1707 + "isMultiDisplay:" + isMultiDisplay + ", "
1708 + "widthPx:" + widthPx + ", "
1709 + "heightPx:" + heightPx + ", "
1710 + "insets:" + mInsets + ", "
1711 + "rotationHint:" + rotationHint;
1712 }
1713
Alex Chaua6907dc2022-03-18 15:24:07 +00001714 private static Context getContext(Context c, Info info, int orientation, WindowBounds bounds) {
Sunny Goyal1890f672020-04-30 12:28:00 -07001715 Configuration config = new Configuration(c.getResources().getConfiguration());
1716 config.orientation = orientation;
Thales Lima425f6822022-05-10 13:44:58 -03001717 config.densityDpi = info.getDensityDpi();
Alex Chaua6907dc2022-03-18 15:24:07 +00001718 config.smallestScreenWidthDp = (int) info.smallestSizeDp(bounds);
Sunny Goyal1890f672020-04-30 12:28:00 -07001719 return c.createConfigurationContext(config);
Jon Mirandab28c4fc2017-06-20 10:58:36 -07001720 }
Sunny Goyalfde55052018-02-01 14:46:13 -08001721
1722 /**
1723 * Callback when a component changes the DeviceProfile associated with it, as a result of
1724 * configuration change
1725 */
1726 public interface OnDeviceProfileChangeListener {
1727
1728 /**
1729 * Called when the device profile is reassigned. Note that for layout and measurements, it
1730 * is sufficient to listen for inset changes. Use this callback when you need to perform
1731 * a one time operation.
1732 */
1733 void onDeviceProfileChanged(DeviceProfile dp);
1734 }
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001735
Sihua Mae04aa202022-07-18 12:43:56 -07001736 /**
1737 * Handler that deals with ItemInfo of the views for the DeviceProfile
1738 */
1739 @FunctionalInterface
1740 public interface ViewScaleProvider {
1741 /**
1742 * Get the scales from the view
1743 *
1744 * @param itemInfo The tag of the widget view
1745 * @return PointF instance containing the scale information, or null if using the default
1746 * app widget scale of this device profile.
1747 */
1748 @NonNull
1749 PointF getScaleFromItemInfo(@Nullable ItemInfo itemInfo);
1750 }
1751
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001752 public static class Builder {
1753 private Context mContext;
1754 private InvariantDeviceProfile mInv;
Sunny Goyalfd58da62020-08-11 12:06:49 -07001755 private Info mInfo;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001756
Sunny Goyal19ff7282021-04-22 10:12:54 -07001757 private WindowBounds mWindowBounds;
Alex Chauab800f72022-12-13 17:46:06 +00001758 private boolean mIsMultiDisplay;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001759
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001760 private boolean mIsMultiWindowMode = false;
Sunny Goyal19ff7282021-04-22 10:12:54 -07001761 private Boolean mTransposeLayoutWithOrientation;
Alex Chau6ed408f2022-03-04 12:58:05 +00001762 private Boolean mIsGestureMode;
Sihua Mae04aa202022-07-18 12:43:56 -07001763 private ViewScaleProvider mViewScaleProvider = null;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001764
Sunny Goyal65190ae2022-08-02 14:16:26 -07001765 private SparseArray<DotRenderer> mDotRendererCache;
1766
Sunny Goyalfd58da62020-08-11 12:06:49 -07001767 public Builder(Context context, InvariantDeviceProfile inv, Info info) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001768 mContext = context;
1769 mInv = inv;
1770 mInfo = info;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001771 }
1772
1773 public Builder setMultiWindowMode(boolean isMultiWindowMode) {
1774 mIsMultiWindowMode = isMultiWindowMode;
1775 return this;
1776 }
1777
Alex Chauab800f72022-12-13 17:46:06 +00001778 public Builder setIsMultiDisplay(boolean isMultiDisplay) {
1779 mIsMultiDisplay = isMultiDisplay;
Sunny Goyal19ff7282021-04-22 10:12:54 -07001780 return this;
1781 }
1782
Sunny Goyal65190ae2022-08-02 14:16:26 -07001783 public Builder setDotRendererCache(SparseArray<DotRenderer> dotRendererCache) {
1784 mDotRendererCache = dotRendererCache;
1785 return this;
1786 }
Sunny Goyal19ff7282021-04-22 10:12:54 -07001787
1788 public Builder setWindowBounds(WindowBounds bounds) {
1789 mWindowBounds = bounds;
Sunny Goyal0addbf02020-04-28 14:17:35 -07001790 return this;
1791 }
1792
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001793 public Builder setTransposeLayoutWithOrientation(boolean transposeLayoutWithOrientation) {
1794 mTransposeLayoutWithOrientation = transposeLayoutWithOrientation;
1795 return this;
1796 }
1797
Alex Chau6ed408f2022-03-04 12:58:05 +00001798 public Builder setGestureMode(boolean isGestureMode) {
1799 mIsGestureMode = isGestureMode;
1800 return this;
1801 }
1802
Sihua Mae04aa202022-07-18 12:43:56 -07001803 /**
1804 * Set the viewScaleProvider for the builder
1805 *
1806 * @param viewScaleProvider The viewScaleProvider to be set for the
Thales Limae9273ea2023-01-26 12:33:52 +00001807 * DeviceProfile
Sihua Mae04aa202022-07-18 12:43:56 -07001808 * @return This builder
1809 */
1810 @NonNull
1811 public Builder setViewScaleProvider(@Nullable ViewScaleProvider viewScaleProvider) {
1812 mViewScaleProvider = viewScaleProvider;
1813 return this;
1814 }
1815
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001816 public DeviceProfile build() {
Sunny Goyal19ff7282021-04-22 10:12:54 -07001817 if (mWindowBounds == null) {
1818 throw new IllegalArgumentException("Window bounds not set");
1819 }
1820 if (mTransposeLayoutWithOrientation == null) {
1821 mTransposeLayoutWithOrientation = !mInfo.isTablet(mWindowBounds);
1822 }
Alex Chau6ed408f2022-03-04 12:58:05 +00001823 if (mIsGestureMode == null) {
Alex Chaue818bcb2022-09-02 17:27:11 +01001824 mIsGestureMode = mInfo.navigationMode.hasGestures;
Alex Chau6ed408f2022-03-04 12:58:05 +00001825 }
Sunny Goyal65190ae2022-08-02 14:16:26 -07001826 if (mDotRendererCache == null) {
1827 mDotRendererCache = new SparseArray<>();
1828 }
Sihua Mae04aa202022-07-18 12:43:56 -07001829 if (mViewScaleProvider == null) {
1830 mViewScaleProvider = DEFAULT_PROVIDER;
1831 }
Sunny Goyal65190ae2022-08-02 14:16:26 -07001832 return new DeviceProfile(mContext, mInv, mInfo, mWindowBounds, mDotRendererCache,
Alex Chauab800f72022-12-13 17:46:06 +00001833 mIsMultiWindowMode, mTransposeLayoutWithOrientation, mIsMultiDisplay,
Sihua Mae04aa202022-07-18 12:43:56 -07001834 mIsGestureMode, mViewScaleProvider);
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001835 }
1836 }
1837
Winson Chungb3800242013-10-24 11:01:54 -07001838}