blob: 1616ae94a2bb07e3570c7fafa92165e786af50af [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;
Jon Miranda92c1b5d2021-07-20 13:57:16 -070026import static com.android.launcher3.folder.ClippedFolderIconLayoutRule.ICON_OVERLAP_FACTOR;
Sunny Goyal65190ae2022-08-02 14:16:26 -070027import static com.android.launcher3.icons.GraphicsUtils.getShapePath;
Thales Limab35faed2022-09-05 16:30:01 -030028import static com.android.launcher3.testing.shared.ResourceUtils.INVALID_RESOURCE_HANDLE;
Pat Manning5f74bfd2022-07-20 12:08:54 +010029import static com.android.launcher3.testing.shared.ResourceUtils.pxFromDp;
Jon Miranda228877d2021-02-09 11:05:00 -050030
Sunny Goyal35c7b192021-04-20 16:51:10 -070031import android.annotation.SuppressLint;
Winson Chungb3800242013-10-24 11:01:54 -070032import android.content.Context;
Jon Mirandab28c4fc2017-06-20 10:58:36 -070033import android.content.res.Configuration;
Winson Chungb3800242013-10-24 11:01:54 -070034import android.content.res.Resources;
Thales Limab35faed2022-09-05 16:30:01 -030035import android.content.res.TypedArray;
Winson Chungb3800242013-10-24 11:01:54 -070036import android.graphics.Point;
Jon Miranda7ae64ff2016-11-21 16:18:46 -080037import android.graphics.PointF;
Winson Chungb3800242013-10-24 11:01:54 -070038import android.graphics.Rect;
Sunny Goyal35c7b192021-04-20 16:51:10 -070039import android.util.DisplayMetrics;
Sunny Goyal65190ae2022-08-02 14:16:26 -070040import android.util.SparseArray;
Sunny Goyal59d086c2018-05-07 17:31:40 -070041import android.view.Surface;
Winson Chungb3800242013-10-24 11:01:54 -070042
Sunny Goyal65190ae2022-08-02 14:16:26 -070043import androidx.annotation.NonNull;
Sihua Mae04aa202022-07-18 12:43:56 -070044import androidx.annotation.Nullable;
Sunny Goyal65190ae2022-08-02 14:16:26 -070045
Sunny Goyalc13403c2016-11-18 23:44:48 -080046import com.android.launcher3.CellLayout.ContainerType;
Jon Miranda228877d2021-02-09 11:05:00 -050047import com.android.launcher3.DevicePaddings.DevicePadding;
Alex Chaud67ddc42022-09-30 18:15:56 +010048import com.android.launcher3.config.FeatureFlags;
Tony Wickham8912b042018-11-29 15:28:53 -080049import com.android.launcher3.icons.DotRenderer;
Hyunyoung Song48cb7bc2018-09-25 17:03:34 -070050import com.android.launcher3.icons.IconNormalizer;
Sihua Mae04aa202022-07-18 12:43:56 -070051import com.android.launcher3.model.data.ItemInfo;
Sunny Goyal57b22792021-05-25 14:35:01 -070052import com.android.launcher3.uioverrides.ApiWrapper;
Sunny Goyalfd58da62020-08-11 12:06:49 -070053import com.android.launcher3.util.DisplayController;
54import com.android.launcher3.util.DisplayController.Info;
Sunny Goyalb46703d2020-05-27 17:52:03 -070055import com.android.launcher3.util.WindowBounds;
Winson1f064272016-07-18 17:18:02 -070056
Jon Miranda58561d42021-03-17 10:51:54 -040057import java.io.PrintWriter;
Brian Isganitis099945b2022-01-31 18:15:00 -050058import java.util.List;
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;
Sunny Goyal19ff7282021-04-22 10:12:54 -070082 public final boolean isTwoPanels;
Thales Limaa1012902022-01-13 17:58:42 +000083 public final boolean isQsbInline;
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -070084
Sunny Goyalc6205602015-05-21 20:46:33 -070085 // Device properties in current orientation
Sunny Goyald792a772018-04-05 13:37:46 -070086 public final boolean isLandscape;
Sunny Goyald70e75a2018-02-22 10:07:32 -080087 public final boolean isMultiWindowMode;
Alex Chau6ed408f2022-03-04 12:58:05 +000088 public final boolean isGestureMode;
Sunny Goyald70e75a2018-02-22 10:07:32 -080089
Sunny Goyal0addbf02020-04-28 14:17:35 -070090 public final int windowX;
91 public final int windowY;
Sunny Goyalc6205602015-05-21 20:46:33 -070092 public final int widthPx;
93 public final int heightPx;
94 public final int availableWidthPx;
95 public final int availableHeightPx;
Sunny Goyal187b16c2022-03-01 16:53:23 -080096 public final int rotationHint;
Jon Mirandabba64512019-03-27 10:54:17 -070097
98 public final float aspectRatio;
99
Jon Mirandae126d722021-02-25 10:45:20 -0500100 public final boolean isScalableGrid;
Thales Lima83bedbf2021-10-05 17:47:39 +0100101 private final int mTypeIndex;
Jon Mirandae126d722021-02-25 10:45:20 -0500102
Tony Wickhamd6b40372015-09-23 18:37:57 -0700103 /**
104 * The maximum amount of left/right workspace padding as a percentage of the screen width.
105 * To be clear, this means that up to 7% of the screen width can be used as left padding, and
106 * 7% of the screen width can be used as right padding.
107 */
108 private static final float MAX_HORIZONTAL_PADDING_PERCENT = 0.14f;
Winson Chungb3800242013-10-24 11:01:54 -0700109
Jon Miranda3f9bab22017-07-28 14:50:17 -0700110 private static final float TALL_DEVICE_ASPECT_RATIO_THRESHOLD = 2.0f;
Jon Miranda80cddbc2021-07-22 13:51:16 -0700111 private static final float TALLER_DEVICE_ASPECT_RATIO_THRESHOLD = 2.15f;
Jon Miranda80dda302021-07-28 14:14:59 -0700112 private static final float TALL_DEVICE_EXTRA_SPACE_THRESHOLD_DP = 252;
113 private static final float TALL_DEVICE_MORE_EXTRA_SPACE_THRESHOLD_DP = 268;
Jon Miranda30d0aa22017-07-25 15:55:29 -0700114
Sunny Goyalc6205602015-05-21 20:46:33 -0700115 // Workspace
Thales Limad90faab2021-09-21 17:18:47 +0100116 public final int desiredWorkspaceHorizontalMarginOriginalPx;
117 public int desiredWorkspaceHorizontalMarginPx;
Alex Chau51da2192022-05-20 13:32:10 +0100118 public int gridVisualizationPaddingX;
119 public int gridVisualizationPaddingY;
Thales Lima78d00ad2021-09-30 11:29:06 +0100120 public Point cellLayoutBorderSpaceOriginalPx;
121 public Point cellLayoutBorderSpacePx;
Pat Manning08610ca2022-04-05 21:03:16 +0100122 public Rect cellLayoutPaddingPx = new Rect();
123
Sunny Goyalc6205602015-05-21 20:46:33 -0700124 public final int edgeMarginPx;
Alex Chau0c4e11b2022-07-08 18:41:36 +0100125 public final float workspaceContentScale;
Alex Chau906d8822022-05-23 10:42:25 +0100126 public final int workspaceSpringLoadedMinNextPageVisiblePx;
Sunny Goyalc6205602015-05-21 20:46:33 -0700127
Jon Miranda58561d42021-03-17 10:51:54 -0400128 private final int extraSpace;
Jon Miranda228877d2021-02-09 11:05:00 -0500129 public int workspaceTopPadding;
130 public int workspaceBottomPadding;
131
Tony Wickham5edf9e22020-03-27 20:06:52 -0700132 // Workspace page indicator
133 public final int workspacePageIndicatorHeight;
134 private final int mWorkspacePageIndicatorOverlapWorkspace;
Winson1f064272016-07-18 17:18:02 -0700135
Sunny Goyalc6205602015-05-21 20:46:33 -0700136 // Workspace icons
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400137 public float iconScale;
Sunny Goyalc6205602015-05-21 20:46:33 -0700138 public int iconSizePx;
139 public int iconTextSizePx;
140 public int iconDrawablePaddingPx;
Winson Chung5f4e0fd2015-05-22 11:12:27 -0700141 public int iconDrawablePaddingOriginalPx;
Winson Chungb3800242013-10-24 11:01:54 -0700142
Jon Mirandaab3c6812021-06-28 15:42:28 -0700143 public float cellScaleToFit;
Adam Cohen59400422014-03-05 18:07:04 -0800144 public int cellWidthPx;
145 public int cellHeightPx;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700146 public int workspaceCellPaddingXPx;
Adam Cohen59400422014-03-05 18:07:04 -0800147
Jon Mirandae126d722021-02-25 10:45:20 -0500148 public int cellYPaddingPx;
Jon Mirandae126d722021-02-25 10:45:20 -0500149
Sunny Goyalc6205602015-05-21 20:46:33 -0700150 // Folder
Jon Mirandae126d722021-02-25 10:45:20 -0500151 public float folderLabelTextScale;
152 public int folderLabelTextSizePx;
Thales Limab35faed2022-09-05 16:30:01 -0300153 public int folderFooterHeightPx;
Sunny Goyalc6205602015-05-21 20:46:33 -0700154 public int folderIconSizePx;
Jon Miranda591e3602018-03-28 11:37:00 -0700155 public int folderIconOffsetYPx;
Jon Mirandabf7d8122016-11-03 15:29:29 -0700156
Jon Mirandae126d722021-02-25 10:45:20 -0500157 // Folder content
Thales Limab35faed2022-09-05 16:30:01 -0300158 public int folderCellLayoutBorderSpacePx;
Jon Mirandae126d722021-02-25 10:45:20 -0500159 public int folderContentPaddingLeftRight;
160 public int folderContentPaddingTop;
161
Jon Mirandabf7d8122016-11-03 15:29:29 -0700162 // Folder cell
Sunny Goyalc6205602015-05-21 20:46:33 -0700163 public int folderCellWidthPx;
164 public int folderCellHeightPx;
Jon Mirandabf7d8122016-11-03 15:29:29 -0700165
166 // Folder child
167 public int folderChildIconSizePx;
168 public int folderChildTextSizePx;
Sunny Goyalbaec6ff2016-09-14 11:26:21 -0700169 public int folderChildDrawablePaddingPx;
Winson Chungb3800242013-10-24 11:01:54 -0700170
Sunny Goyalc6205602015-05-21 20:46:33 -0700171 // Hotseat
Thales Lima9938c2f2022-07-25 14:38:16 +0100172 public int numShownHotseatIcons;
Sunny Goyalc6205602015-05-21 20:46:33 -0700173 public int hotseatCellHeightPx;
Pat Manning26f70f72022-07-07 13:50:39 +0100174 public final boolean areNavButtonsInline;
Jon Miranda18751b62017-07-31 17:25:27 -0700175 // In portrait: size = height, in landscape: size = width
176 public int hotseatBarSizePx;
Thales Limab8c05952022-05-23 16:58:38 +0100177 public int hotseatBarBottomSpacePx;
Pat Manning26f70f72022-07-07 13:50:39 +0100178 public int hotseatBarEndOffset;
Thales Limab8c05952022-05-23 16:58:38 +0100179 public int hotseatQsbSpace;
Pat Manningde25c0d2022-04-05 19:11:26 +0100180 public int springLoadedHotseatBarTopMarginPx;
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700181 // Start is the side next to the nav bar, end is the side next to the workspace
182 public final int hotseatBarSidePaddingStartPx;
183 public final int hotseatBarSidePaddingEndPx;
Alex Chau206ede92022-08-01 17:46:12 +0100184 public int hotseatQsbWidth; // only used when isQsbInline
Sunny Goyal57b22792021-05-25 14:35:01 -0700185 public final int hotseatQsbHeight;
Thales Limab8c05952022-05-23 16:58:38 +0100186 public final int hotseatQsbVisualHeight;
187 private final int hotseatQsbShadowHeight;
Thales Limadd027342022-01-07 12:54:37 +0000188 public int hotseatBorderSpace;
Adam Cohen2e6da152015-05-06 11:42:25 -0700189
Alex Chau3d2c0622022-09-01 21:28:14 +0100190 // Bottom sheets
191 public int bottomSheetTopPadding;
192 public int bottomSheetOpenDuration;
193 public int bottomSheetCloseDuration;
194 public float bottomSheetWorkspaceScale;
195 public float bottomSheetDepth;
196
Sunny Goyalc6205602015-05-21 20:46:33 -0700197 // All apps
Thales Lima85c942f2021-12-31 13:04:20 +0000198 public Point allAppsBorderSpacePx;
Alex Chaub8c22e12022-02-14 18:35:58 +0000199 public int allAppsShiftRange;
200 public int allAppsTopPadding;
Alex Chau3d2c0622022-09-01 21:28:14 +0100201 public int allAppsOpenDuration;
202 public int allAppsCloseDuration;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700203 public int allAppsCellHeightPx;
Samuel Fufaf1424a32019-10-04 15:15:19 -0700204 public int allAppsCellWidthPx;
Winson1f064272016-07-18 17:18:02 -0700205 public int allAppsIconSizePx;
206 public int allAppsIconDrawablePaddingPx;
sfufa@google.comde013292021-09-21 18:22:44 -0700207 public int allAppsLeftRightPadding;
Alex Chau27b39b92022-01-14 18:02:18 +0000208 public int allAppsLeftRightMargin;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700209 public final int numShownAllAppsColumns;
Winson1f064272016-07-18 17:18:02 -0700210 public float allAppsIconTextSizePx;
211
Zak Cohen334efeb2021-03-19 16:42:07 -0700212 // Overview
Zak Cohen334efeb2021-03-19 16:42:07 -0700213 public int overviewTaskMarginPx;
Alex Chaudedbc8a2021-03-17 16:53:26 +0000214 public int overviewTaskIconSizePx;
Alex Chauac9df382021-08-02 19:08:41 +0100215 public int overviewTaskIconDrawableSizePx;
216 public int overviewTaskIconDrawableSizeGridPx;
Alex Chaudedbc8a2021-03-17 16:53:26 +0000217 public int overviewTaskThumbnailTopMarginPx;
Alex Chau19c6eca2022-03-10 20:12:56 +0000218 public final int overviewActionsHeight;
Alex Chaua2fc7642022-04-21 14:20:23 +0100219 public final int overviewActionsTopMarginPx;
Alex Chau1bf0fe12021-11-30 15:32:45 +0000220 public final int overviewActionsButtonSpacing;
Alex Chau5fd9d492021-07-22 17:27:11 +0100221 public int overviewPageSpacing;
222 public int overviewRowSpacing;
Alex Chau56bd2572021-11-03 18:48:18 +0000223 public int overviewGridSideMargin;
Zak Cohen334efeb2021-03-19 16:42:07 -0700224
Jeremy Sim0ac47082022-10-10 13:59:40 -0700225 // Split staging
226 public int splitPlaceholderInset;
227
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800228 // Widgets
Sihua Mae04aa202022-07-18 12:43:56 -0700229 private final ViewScaleProvider mViewScaleProvider;
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800230
Sunny Goyal47328fd2016-05-25 18:56:41 -0700231 // Drop Target
232 public int dropTargetBarSizePx;
Pat Manningde25c0d2022-04-05 19:11:26 +0100233 public int dropTargetBarTopMarginPx;
234 public int dropTargetBarBottomMarginPx;
Alex Chaua02eddc2021-04-29 00:36:06 +0100235 public int dropTargetDragPaddingPx;
236 public int dropTargetTextSizePx;
Pat Manningde25c0d2022-04-05 19:11:26 +0100237 public int dropTargetHorizontalPaddingPx;
238 public int dropTargetVerticalPaddingPx;
239 public int dropTargetGapPx;
Alex Chau5b019302022-05-23 10:42:25 +0100240 public int dropTargetButtonWorkspaceEdgeGapPx;
Adam Cohen4ae96ce2014-08-29 15:05:48 -0700241
Winson1f064272016-07-18 17:18:02 -0700242 // Insets
Sunny Goyal07b69292018-01-08 14:19:34 -0800243 private final Rect mInsets = new Rect();
244 public final Rect workspacePadding = new Rect();
Jon Miranda0bd63d12019-03-06 17:29:29 -0800245 // When true, nav bar is on the left side of the screen.
Sunny Goyal59d086c2018-05-07 17:31:40 -0700246 private boolean mIsSeascape;
Winson1f064272016-07-18 17:18:02 -0700247
Tony Wickhamf34bee82018-12-03 18:11:39 -0800248 // Notification dots
Sunny Goyal65190ae2022-08-02 14:16:26 -0700249 public final DotRenderer mDotRendererWorkSpace;
250 public final DotRenderer mDotRendererAllApps;
Tony Wickham9a8d11f2017-01-11 09:53:12 -0800251
Pierre Barbier de Reuille578deba2021-09-24 13:47:44 +0100252 // Taskbar
Tony Wickham15883892021-02-12 11:24:40 -0800253 public boolean isTaskbarPresent;
Tony Wickham635e1802021-07-22 14:28:04 -1000254 // Whether Taskbar will inset the bottom of apps by taskbarSize.
255 public boolean isTaskbarPresentInApps;
Tony Wickham15883892021-02-12 11:24:40 -0800256 public int taskbarSize;
Alex Chau6a7d1e22022-01-20 19:54:17 +0000257 public int stashedTaskbarSize;
Tony Wickham15883892021-02-12 11:24:40 -0800258
Alex Chaua02eddc2021-04-29 00:36:06 +0100259 // DragController
260 public int flingToDeleteThresholdVelocity;
261
Vinit Nayak17c4b332021-08-05 12:54:58 -0700262 /** TODO: Once we fully migrate to staged split, remove "isMultiWindowMode" */
Sunny Goyal19ff7282021-04-22 10:12:54 -0700263 DeviceProfile(Context context, InvariantDeviceProfile inv, Info info, WindowBounds windowBounds,
Sunny Goyal65190ae2022-08-02 14:16:26 -0700264 SparseArray<DotRenderer> dotRendererCache, boolean isMultiWindowMode,
Sihua Mae04aa202022-07-18 12:43:56 -0700265 boolean transposeLayoutWithOrientation, boolean useTwoPanels, boolean isGestureMode,
266 @NonNull final ViewScaleProvider viewScaleProvider) {
Sunny Goyalfee35bb2015-05-11 11:38:19 -0700267
Adam Cohen2e6da152015-05-06 11:42:25 -0700268 this.inv = inv;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700269 this.isLandscape = windowBounds.isLandscape();
Sunny Goyald70e75a2018-02-22 10:07:32 -0800270 this.isMultiWindowMode = isMultiWindowMode;
Jon Mirandae126d722021-02-25 10:45:20 -0500271 this.transposeLayoutWithOrientation = transposeLayoutWithOrientation;
Alex Chau6ed408f2022-03-04 12:58:05 +0000272 this.isGestureMode = isGestureMode;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700273 windowX = windowBounds.bounds.left;
274 windowY = windowBounds.bounds.top;
Sunny Goyal187b16c2022-03-01 16:53:23 -0800275 this.rotationHint = windowBounds.rotationHint;
Alex Chaue0227552022-04-06 19:44:43 +0100276 mInsets.set(windowBounds.insets);
Winson Chungb3800242013-10-24 11:01:54 -0700277
Jon Mirandae126d722021-02-25 10:45:20 -0500278 isScalableGrid = inv.isScalable && !isVerticalBarLayout() && !isMultiWindowMode;
Alex Chaudfc8ddf2022-01-25 11:26:25 +0000279 // Determine device posture.
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700280 mInfo = info;
Alex Chau29983072021-11-19 15:14:20 +0000281 isTablet = info.isTablet(windowBounds);
Sunny Goyal19ff7282021-04-22 10:12:54 -0700282 isPhone = !isTablet;
Alex Chau90125822021-11-17 14:16:58 +0000283 isTwoPanels = isTablet && useTwoPanels;
Vinit Nayak58c27cc2022-02-16 17:42:21 -0800284 isTaskbarPresent = isTablet && ApiWrapper.TASKBAR_DRAWN_IN_PROCESS;
Adam Cohen2e6da152015-05-06 11:42:25 -0700285
Alex Chaudfc8ddf2022-01-25 11:26:25 +0000286 // Some more constants.
Alex Chau635b3ab2022-01-26 16:49:10 +0000287 context = getContext(context, info, isVerticalBarLayout() || (isTablet && isLandscape)
Brandon Dayauon07ca8842022-04-27 10:52:28 -0700288 ? Configuration.ORIENTATION_LANDSCAPE
289 : Configuration.ORIENTATION_PORTRAIT,
Alex Chaua6907dc2022-03-18 15:24:07 +0000290 windowBounds);
Sunny Goyal1890f672020-04-30 12:28:00 -0700291 final Resources res = context.getResources();
Alex Chaudfc8ddf2022-01-25 11:26:25 +0000292 mMetrics = res.getDisplayMetrics();
293
294 // Determine sizes.
295 widthPx = windowBounds.bounds.width();
296 heightPx = windowBounds.bounds.height();
297 availableWidthPx = windowBounds.availableSize.x;
Thales Limab8c05952022-05-23 16:58:38 +0100298 availableHeightPx = windowBounds.availableSize.y;
Alex Chaudfc8ddf2022-01-25 11:26:25 +0000299
300 aspectRatio = ((float) Math.max(widthPx, heightPx)) / Math.min(widthPx, heightPx);
301 boolean isTallDevice = Float.compare(aspectRatio, TALL_DEVICE_ASPECT_RATIO_THRESHOLD) >= 0;
302 mQsbCenterFactor = res.getFloat(R.dimen.qsb_center_factor);
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700303
Thales Lima83bedbf2021-10-05 17:47:39 +0100304 if (isTwoPanels) {
305 if (isLandscape) {
Thales Lima12d0eff2022-03-25 17:06:11 +0000306 mTypeIndex = INDEX_TWO_PANEL_LANDSCAPE;
Thales Lima83bedbf2021-10-05 17:47:39 +0100307 } else {
Thales Lima12d0eff2022-03-25 17:06:11 +0000308 mTypeIndex = INDEX_TWO_PANEL_PORTRAIT;
Thales Lima83bedbf2021-10-05 17:47:39 +0100309 }
310 } else {
311 if (isLandscape) {
Thales Lima12d0eff2022-03-25 17:06:11 +0000312 mTypeIndex = INDEX_LANDSCAPE;
Thales Lima83bedbf2021-10-05 17:47:39 +0100313 } else {
Thales Lima12d0eff2022-03-25 17:06:11 +0000314 mTypeIndex = INDEX_DEFAULT;
Thales Lima83bedbf2021-10-05 17:47:39 +0100315 }
316 }
317
Tony Wickham15883892021-02-12 11:24:40 -0800318 if (isTaskbarPresent) {
Jon Miranda184a0422022-10-20 13:15:19 -0700319 taskbarSize = DisplayController.isTransientTaskbar(context)
320 ? res.getDimensionPixelSize(R.dimen.transient_taskbar_size)
321 : res.getDimensionPixelSize(R.dimen.taskbar_size);
Alex Chau6a7d1e22022-01-20 19:54:17 +0000322 stashedTaskbarSize = res.getDimensionPixelSize(R.dimen.taskbar_stashed_size);
Tony Wickham15883892021-02-12 11:24:40 -0800323 }
Tony Wickham15883892021-02-12 11:24:40 -0800324
Winson Chungb3800242013-10-24 11:01:54 -0700325 edgeMarginPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_edge_margin);
Alex Chau0c4e11b2022-07-08 18:41:36 +0100326 workspaceContentScale = res.getFloat(R.dimen.workspace_content_scale);
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700327
Thales Limad90faab2021-09-21 17:18:47 +0100328 desiredWorkspaceHorizontalMarginPx = getHorizontalMarginPx(inv, res);
329 desiredWorkspaceHorizontalMarginOriginalPx = desiredWorkspaceHorizontalMarginPx;
Alex Chau51da2192022-05-20 13:32:10 +0100330 gridVisualizationPaddingX = res.getDimensionPixelSize(
331 R.dimen.grid_visualization_horizontal_cell_spacing);
332 gridVisualizationPaddingY = res.getDimensionPixelSize(
333 R.dimen.grid_visualization_vertical_cell_spacing);
Samuel Fufaee9aff92021-04-05 13:30:40 -0500334
Alex Chaue0227552022-04-06 19:44:43 +0100335 bottomSheetTopPadding = mInsets.top // statusbar height
Andras Kloczl142b0542022-03-09 21:26:02 +0000336 + res.getDimensionPixelSize(R.dimen.bottom_sheet_extra_top_padding)
337 + (isTablet ? 0 : edgeMarginPx); // phones need edgeMarginPx additional padding
Alex Chau3d2c0622022-09-01 21:28:14 +0100338 bottomSheetOpenDuration = res.getInteger(R.integer.config_bottomSheetOpenDuration);
339 bottomSheetCloseDuration = res.getInteger(R.integer.config_bottomSheetCloseDuration);
340 if (isTablet) {
341 bottomSheetWorkspaceScale = workspaceContentScale;
342 // The goal is to set wallpaper to zoom at workspaceContentScale when in AllApps.
343 // When depth is 0, wallpaper zoom is set to maxWallpaperScale.
344 // When depth is 1, wallpaper zoom is set to 1.
345 // For depth to achieve zoom set to maxWallpaperScale * workspaceContentScale:
346 float maxWallpaperScale = res.getFloat(R.dimen.config_wallpaperMaxScale);
347 bottomSheetDepth = Utilities.mapToRange(maxWallpaperScale * workspaceContentScale,
348 maxWallpaperScale, 1f, 0f, 1f, LINEAR);
349 } else {
350 bottomSheetWorkspaceScale = 1f;
351 bottomSheetDepth = 0f;
352 }
Andras Kloczl142b0542022-03-09 21:26:02 +0000353
Jon Mirandae126d722021-02-25 10:45:20 -0500354 folderLabelTextScale = res.getFloat(R.dimen.folder_label_text_scale);
Thales Limab35faed2022-09-05 16:30:01 -0300355
356 if (inv.folderStyle != INVALID_RESOURCE_HANDLE) {
357 TypedArray folderStyle = context.obtainStyledAttributes(inv.folderStyle,
358 R.styleable.FolderDisplayStyle);
359 // These are re-set in #updateFolderCellSize if the grid is not scalable
360 folderCellHeightPx = folderStyle.getDimensionPixelSize(
361 R.styleable.FolderDisplayStyle_folderCellHeight, 0);
362 folderCellWidthPx = folderStyle.getDimensionPixelSize(
363 R.styleable.FolderDisplayStyle_folderCellWidth, 0);
364
365 folderContentPaddingTop = folderStyle.getDimensionPixelSize(
366 R.styleable.FolderDisplayStyle_folderTopPadding, 0);
367 folderCellLayoutBorderSpacePx = folderStyle.getDimensionPixelSize(
368 R.styleable.FolderDisplayStyle_folderBorderSpace, 0);
369 folderFooterHeightPx = folderStyle.getDimensionPixelSize(
370 R.styleable.FolderDisplayStyle_folderFooterHeight, 0);
371 folderStyle.recycle();
372 } else {
373 folderCellLayoutBorderSpacePx = 0;
374 folderFooterHeightPx = 0;
375 folderContentPaddingTop = res.getDimensionPixelSize(R.dimen.folder_top_padding_default);
376 }
Jon Mirandae126d722021-02-25 10:45:20 -0500377
Thales Lima78d00ad2021-09-30 11:29:06 +0100378 cellLayoutBorderSpacePx = getCellLayoutBorderSpace(inv);
Thales Limab35faed2022-09-05 16:30:01 -0300379 cellLayoutBorderSpaceOriginalPx = new Point(cellLayoutBorderSpacePx);
Thales Lima85c942f2021-12-31 13:04:20 +0000380 allAppsBorderSpacePx = new Point(
Thales Limabb7d3882021-12-22 12:56:29 +0000381 pxFromDp(inv.allAppsBorderSpaces[mTypeIndex].x, mMetrics),
382 pxFromDp(inv.allAppsBorderSpaces[mTypeIndex].y, mMetrics));
Jon Mirandae126d722021-02-25 10:45:20 -0500383
Tony Wickham5edf9e22020-03-27 20:06:52 -0700384 workspacePageIndicatorHeight = res.getDimensionPixelSize(
385 R.dimen.workspace_page_indicator_height);
386 mWorkspacePageIndicatorOverlapWorkspace =
387 res.getDimensionPixelSize(R.dimen.workspace_page_indicator_overlap_workspace);
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700388
Winson Chungb3800242013-10-24 11:01:54 -0700389 iconDrawablePaddingOriginalPx =
390 res.getDimensionPixelSize(R.dimen.dynamic_grid_icon_drawable_padding);
Alex Chaua02eddc2021-04-29 00:36:06 +0100391
Sunny Goyal47328fd2016-05-25 18:56:41 -0700392 dropTargetBarSizePx = res.getDimensionPixelSize(R.dimen.dynamic_grid_drop_target_size);
Pat Manningde25c0d2022-04-05 19:11:26 +0100393 dropTargetBarTopMarginPx = res.getDimensionPixelSize(R.dimen.drop_target_top_margin);
394 dropTargetBarBottomMarginPx = res.getDimensionPixelSize(R.dimen.drop_target_bottom_margin);
Alex Chaua02eddc2021-04-29 00:36:06 +0100395 dropTargetDragPaddingPx = res.getDimensionPixelSize(R.dimen.drop_target_drag_padding);
396 dropTargetTextSizePx = res.getDimensionPixelSize(R.dimen.drop_target_text_size);
Pat Manningde25c0d2022-04-05 19:11:26 +0100397 dropTargetHorizontalPaddingPx = res.getDimensionPixelSize(
398 R.dimen.drop_target_button_drawable_horizontal_padding);
399 dropTargetVerticalPaddingPx = res.getDimensionPixelSize(
400 R.dimen.drop_target_button_drawable_vertical_padding);
401 dropTargetGapPx = res.getDimensionPixelSize(R.dimen.drop_target_button_gap);
Alex Chau5b019302022-05-23 10:42:25 +0100402 dropTargetButtonWorkspaceEdgeGapPx = res.getDimensionPixelSize(
403 R.dimen.drop_target_button_workspace_edge_gap);
Alex Chaua02eddc2021-04-29 00:36:06 +0100404
Alex Chau906d8822022-05-23 10:42:25 +0100405 workspaceSpringLoadedMinNextPageVisiblePx = res.getDimensionPixelSize(
406 R.dimen.dynamic_grid_spring_loaded_min_next_space_visible);
Sunny Goyald5190522017-04-24 03:06:54 -0700407
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700408 workspaceCellPaddingXPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_cell_padding_x);
Jon Miranda09660722017-06-14 14:20:14 -0700409
Thales Limaa1012902022-01-13 17:58:42 +0000410 hotseatQsbHeight = res.getDimensionPixelSize(R.dimen.qsb_widget_height);
Thales Limab8c05952022-05-23 16:58:38 +0100411 hotseatQsbShadowHeight = res.getDimensionPixelSize(R.dimen.qsb_shadow_height);
412 hotseatQsbVisualHeight = hotseatQsbHeight - 2 * hotseatQsbShadowHeight;
413
Thales Lima12d0eff2022-03-25 17:06:11 +0000414 // Whether QSB might be inline in appropriate orientation (e.g. landscape).
415 boolean canQsbInline = (isTwoPanels ? inv.inlineQsb[INDEX_TWO_PANEL_PORTRAIT]
416 || inv.inlineQsb[INDEX_TWO_PANEL_LANDSCAPE]
417 : inv.inlineQsb[INDEX_DEFAULT] || inv.inlineQsb[INDEX_LANDSCAPE])
418 && hotseatQsbHeight > 0;
419 isQsbInline = inv.inlineQsb[mTypeIndex] && canQsbInline;
Alex Chau6ed408f2022-03-04 12:58:05 +0000420
Thales Lima425f6822022-05-10 13:44:58 -0300421 areNavButtonsInline = isTaskbarPresent && !isGestureMode;
Thales Lima9938c2f2022-07-25 14:38:16 +0100422 numShownHotseatIcons =
423 isTwoPanels ? inv.numDatabaseHotseatIcons : inv.numShownHotseatIcons;
Alex Chau6ed408f2022-03-04 12:58:05 +0000424
Sunny Goyal19ff7282021-04-22 10:12:54 -0700425 numShownAllAppsColumns =
426 isTwoPanels ? inv.numDatabaseAllAppsColumns : inv.numAllAppsColumns;
Thales Limab8c05952022-05-23 16:58:38 +0100427
428 int hotseatBarBottomSpace = pxFromDp(inv.hotseatBarBottomSpace[mTypeIndex], mMetrics);
429 int minQsbMargin = res.getDimensionPixelSize(R.dimen.min_qsb_margin);
430 hotseatQsbSpace = pxFromDp(inv.hotseatQsbSpace[mTypeIndex], mMetrics);
431 // Have a little space between the inset and the QSB
432 if (mInsets.bottom + minQsbMargin > hotseatBarBottomSpace) {
433 int availableSpace = hotseatQsbSpace - (mInsets.bottom - hotseatBarBottomSpace);
434
435 // Only change the spaces if there is space
436 if (availableSpace > 0) {
437 // Make sure there is enough space between hotseat/QSB and QSB/navBar
438 if (availableSpace < minQsbMargin * 2) {
439 minQsbMargin = availableSpace / 2;
440 hotseatQsbSpace = minQsbMargin;
441 } else {
442 hotseatQsbSpace -= minQsbMargin;
443 }
444 }
445 hotseatBarBottomSpacePx = mInsets.bottom + minQsbMargin;
446
Thales Limaa1012902022-01-13 17:58:42 +0000447 } else {
Thales Limab8c05952022-05-23 16:58:38 +0100448 hotseatBarBottomSpacePx = hotseatBarBottomSpace;
Thales Limaa1012902022-01-13 17:58:42 +0000449 }
Thales Lima425f6822022-05-10 13:44:58 -0300450
Pat Manningde25c0d2022-04-05 19:11:26 +0100451 springLoadedHotseatBarTopMarginPx = res.getDimensionPixelSize(
452 R.dimen.spring_loaded_hotseat_top_margin);
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700453 hotseatBarSidePaddingEndPx =
Sunny Goyal228153d2018-01-04 15:35:22 -0800454 res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_side_padding);
Jon Miranda3f411e72019-05-16 17:15:16 -0700455 // Add a bit of space between nav bar and hotseat in vertical bar layout.
Tony Wickham5edf9e22020-03-27 20:06:52 -0700456 hotseatBarSidePaddingStartPx = isVerticalBarLayout() ? workspacePageIndicatorHeight : 0;
Thales Limab8c05952022-05-23 16:58:38 +0100457 updateHotseatSizes(pxFromDp(inv.iconSize[INDEX_DEFAULT], mMetrics));
Vinit Nayak8a3d0552022-08-05 10:43:29 -0700458 if (areNavButtonsInline && !isPhone) {
Pat Manning26f70f72022-07-07 13:50:39 +0100459 /*
460 * 3 nav buttons +
Vinit Nayakc7293172022-07-18 16:41:50 -0700461 * Spacing between nav buttons +
Pat Manning26f70f72022-07-07 13:50:39 +0100462 * Little space at the end for contextual buttons +
463 * Little space between icons and nav buttons
464 */
465 hotseatBarEndOffset = 3 * res.getDimensionPixelSize(R.dimen.taskbar_nav_buttons_size)
Vinit Nayakc7293172022-07-18 16:41:50 -0700466 + 2 * res.getDimensionPixelSize(R.dimen.taskbar_button_space_inbetween)
467 + res.getDimensionPixelSize(inv.inlineNavButtonsEndSpacing)
Pat Manning26f70f72022-07-07 13:50:39 +0100468 + res.getDimensionPixelSize(R.dimen.taskbar_hotseat_nav_spacing);
469 } else {
470 hotseatBarEndOffset = 0;
471 }
Jon Miranda8bdb2222021-06-23 18:10:10 -0700472
Alex Chau635b3ab2022-01-26 16:49:10 +0000473 overviewTaskMarginPx = res.getDimensionPixelSize(R.dimen.overview_task_margin);
Alex Chau5fd9d492021-07-22 17:27:11 +0100474 overviewTaskIconSizePx = res.getDimensionPixelSize(R.dimen.task_thumbnail_icon_size);
Alex Chauac9df382021-08-02 19:08:41 +0100475 overviewTaskIconDrawableSizePx =
476 res.getDimensionPixelSize(R.dimen.task_thumbnail_icon_drawable_size);
477 overviewTaskIconDrawableSizeGridPx =
478 res.getDimensionPixelSize(R.dimen.task_thumbnail_icon_drawable_size_grid);
Jeremy Sim1cfe6d42022-07-15 14:40:38 -0700479 overviewTaskThumbnailTopMarginPx = overviewTaskIconSizePx + overviewTaskMarginPx;
Jeremy Sim3c2c3f12022-05-16 20:37:43 -0700480 overviewActionsTopMarginPx = res.getDimensionPixelSize(R.dimen.overview_actions_top_margin);
Alex Chau635b3ab2022-01-26 16:49:10 +0000481 overviewPageSpacing = res.getDimensionPixelSize(R.dimen.overview_page_spacing);
482 overviewActionsButtonSpacing = res.getDimensionPixelSize(
483 R.dimen.overview_actions_button_spacing);
Alex Chau19c6eca2022-03-10 20:12:56 +0000484 overviewActionsHeight = res.getDimensionPixelSize(R.dimen.overview_actions_height);
Jeremy Sim1cfe6d42022-07-15 14:40:38 -0700485 overviewRowSpacing = res.getDimensionPixelSize(R.dimen.overview_grid_row_spacing);
Alex Chau635b3ab2022-01-26 16:49:10 +0000486 overviewGridSideMargin = res.getDimensionPixelSize(R.dimen.overview_grid_side_margin);
Zak Cohen334efeb2021-03-19 16:42:07 -0700487
Jeremy Sim0ac47082022-10-10 13:59:40 -0700488 splitPlaceholderInset = res.getDimensionPixelSize(R.dimen.split_placeholder_inset);
489
Jon Miranda2ed276e2017-06-29 11:36:34 -0700490 // Calculate all of the remaining variables.
Jon Miranda58561d42021-03-17 10:51:54 -0400491 extraSpace = updateAvailableDimensions(res);
Jon Miranda80cddbc2021-07-22 13:51:16 -0700492
Jon Miranda2ed276e2017-06-29 11:36:34 -0700493 // Now that we have all of the variables calculated, we can tune certain sizes.
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400494 if (isScalableGrid && inv.devicePaddings != null) {
495 // Paddings were created assuming no scaling, so we first unscale the extra space.
Jon Mirandaab3c6812021-06-28 15:42:28 -0700496 int unscaledExtraSpace = (int) (extraSpace / cellScaleToFit);
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400497 DevicePadding padding = inv.devicePaddings.getDevicePadding(unscaledExtraSpace);
Jon Miranda228877d2021-02-09 11:05:00 -0500498
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400499 int paddingWorkspaceTop = padding.getWorkspaceTopPadding(unscaledExtraSpace);
500 int paddingWorkspaceBottom = padding.getWorkspaceBottomPadding(unscaledExtraSpace);
501 int paddingHotseatBottom = padding.getHotseatBottomPadding(unscaledExtraSpace);
502
Jon Mirandaab3c6812021-06-28 15:42:28 -0700503 workspaceTopPadding = Math.round(paddingWorkspaceTop * cellScaleToFit);
504 workspaceBottomPadding = Math.round(paddingWorkspaceBottom * cellScaleToFit);
Jon Miranda2ed276e2017-06-29 11:36:34 -0700505 }
Pat Manning08610ca2022-04-05 21:03:16 +0100506
507 int cellLayoutPadding =
508 isTwoPanels ? cellLayoutBorderSpacePx.x / 2 : res.getDimensionPixelSize(
509 R.dimen.cell_layout_padding);
510 cellLayoutPaddingPx = new Rect(cellLayoutPadding, cellLayoutPadding, cellLayoutPadding,
511 cellLayoutPadding);
Sunny Goyal07b69292018-01-08 14:19:34 -0800512 updateWorkspacePadding();
Tony Wickham1237df02017-02-24 08:59:36 -0800513
Thales Lima425f6822022-05-10 13:44:58 -0300514 // Hotseat and QSB width depends on updated cellSize and workspace padding
Thales Lima9938c2f2022-07-25 14:38:16 +0100515 recalculateHotseatWidthAndBorderSpace(res);
Alex Chau206ede92022-08-01 17:46:12 +0100516
517 // AllApps height calculation depends on updated cellSize
518 if (isTablet) {
519 int collapseHandleHeight =
520 res.getDimensionPixelOffset(R.dimen.bottom_sheet_handle_area_height);
521 int contentHeight = heightPx - collapseHandleHeight - hotseatQsbHeight;
522 int targetContentHeight = (int) (allAppsCellHeightPx * ALL_APPS_TABLET_MAX_ROWS);
523 allAppsTopPadding = Math.max(mInsets.top, contentHeight - targetContentHeight);
524 allAppsShiftRange = heightPx - allAppsTopPadding;
525 } else {
526 allAppsTopPadding = 0;
527 allAppsShiftRange =
528 res.getDimensionPixelSize(R.dimen.all_apps_starting_vertical_translate);
529 }
Alex Chau3d2c0622022-09-01 21:28:14 +0100530 allAppsOpenDuration = res.getInteger(R.integer.config_allAppsOpenDuration);
531 allAppsCloseDuration = res.getInteger(R.integer.config_allAppsCloseDuration);
Thales Lima425f6822022-05-10 13:44:58 -0300532
Alex Chaua02eddc2021-04-29 00:36:06 +0100533 flingToDeleteThresholdVelocity = res.getDimensionPixelSize(
534 R.dimen.drag_flingToDeleteMinVelocity);
535
Sihua Mae04aa202022-07-18 12:43:56 -0700536 mViewScaleProvider = viewScaleProvider;
537
Tony Wickham1237df02017-02-24 08:59:36 -0800538 // This is done last, after iconSizePx is calculated above.
Sunny Goyal65190ae2022-08-02 14:16:26 -0700539 mDotRendererWorkSpace = createDotRenderer(iconSizePx, dotRendererCache);
540 mDotRendererAllApps = createDotRenderer(allAppsIconSizePx, dotRendererCache);
541 }
542
543 private static DotRenderer createDotRenderer(
544 int size, @NonNull SparseArray<DotRenderer> cache) {
545 DotRenderer renderer = cache.get(size);
546 if (renderer == null) {
547 renderer = new DotRenderer(size, getShapePath(DEFAULT_DOT_SIZE), DEFAULT_DOT_SIZE);
548 cache.put(size, renderer);
549 }
550 return renderer;
Adam Cohen63f1ec02014-08-12 09:23:13 -0700551 }
552
Thales Lima425f6822022-05-10 13:44:58 -0300553 /**
554 * QSB width is always calculated because when in 3 button nav the width doesn't follow the
555 * width of the hotseat.
556 */
Thales Lima9938c2f2022-07-25 14:38:16 +0100557 private int calculateQsbWidth(int hotseatBorderSpace) {
Thales Lima425f6822022-05-10 13:44:58 -0300558 if (isQsbInline) {
Alex Chau906d8822022-05-23 10:42:25 +0100559 int columns = getPanelCount() * inv.numColumns;
Thales Lima425f6822022-05-10 13:44:58 -0300560 return getIconToIconWidthForColumns(columns)
561 - iconSizePx * numShownHotseatIcons
562 - hotseatBorderSpace * numShownHotseatIcons;
563 } else {
564 int columns = inv.hotseatColumnSpan[mTypeIndex];
565 return getIconToIconWidthForColumns(columns);
566 }
567 }
Thales Lima2903a622022-03-17 13:52:19 +0000568
Thales Lima425f6822022-05-10 13:44:58 -0300569 private int getIconToIconWidthForColumns(int columns) {
570 return columns * getCellSize().x
571 + (columns - 1) * cellLayoutBorderSpacePx.x
Thales Lima1e8b45f2022-08-25 11:50:59 -0400572 - getCellHorizontalSpace();
Thales Limaa1012902022-01-13 17:58:42 +0000573 }
574
Thales Limad90faab2021-09-21 17:18:47 +0100575 private int getHorizontalMarginPx(InvariantDeviceProfile idp, Resources res) {
576 if (isVerticalBarLayout()) {
577 return 0;
578 }
579
Thales Lima83bedbf2021-10-05 17:47:39 +0100580 return isScalableGrid
581 ? pxFromDp(idp.horizontalMargin[mTypeIndex], mMetrics)
582 : res.getDimensionPixelSize(R.dimen.dynamic_grid_left_right_margin);
Thales Limad90faab2021-09-21 17:18:47 +0100583 }
584
Thales Limab8c05952022-05-23 16:58:38 +0100585 /** Updates hotseatCellHeightPx and hotseatBarSizePx */
586 private void updateHotseatSizes(int hotseatIconSizePx) {
Jon Miranda92c1b5d2021-07-20 13:57:16 -0700587 // Ensure there is enough space for folder icons, which have a slightly larger radius.
588 hotseatCellHeightPx = (int) Math.ceil(hotseatIconSizePx * ICON_OVERLAP_FACTOR);
Thales Limab8c05952022-05-23 16:58:38 +0100589
Jon Miranda0d284852021-06-22 14:50:55 -0700590 if (isVerticalBarLayout()) {
591 hotseatBarSizePx = hotseatIconSizePx + hotseatBarSidePaddingStartPx
592 + hotseatBarSidePaddingEndPx;
Thales Limab8c05952022-05-23 16:58:38 +0100593 } else if (isQsbInline) {
594 hotseatBarSizePx = Math.max(hotseatIconSizePx, hotseatQsbVisualHeight)
595 + hotseatBarBottomSpacePx;
Jon Miranda0d284852021-06-22 14:50:55 -0700596 } else {
Thales Limab8c05952022-05-23 16:58:38 +0100597 hotseatBarSizePx = hotseatIconSizePx
598 + hotseatQsbSpace
599 + hotseatQsbVisualHeight
600 + hotseatBarBottomSpacePx;
Jon Miranda0d284852021-06-22 14:50:55 -0700601 }
602 }
603
Thales Lima9938c2f2022-07-25 14:38:16 +0100604 private void recalculateHotseatWidthAndBorderSpace(Resources res) {
605 hotseatBorderSpace = calculateHotseatBorderSpace();
606 hotseatQsbWidth = calculateQsbWidth(hotseatBorderSpace);
607 // Spaces should be correct when there nav buttons are not inline
608 if (!areNavButtonsInline) {
609 return;
610 }
611
612 // Get the maximum width that the hotseat can be
613 int columns = getPanelCount() * inv.numColumns;
614 int maxHotseatWidth = getIconToIconWidthForColumns(columns);
615 int sideSpace = (availableWidthPx - maxHotseatWidth) / 2;
616 int inlineButtonsOverlap = Math.max(0, hotseatBarEndOffset - sideSpace);
617 // decrease how much the nav buttons go "inside" the hotseat
618 maxHotseatWidth -= inlineButtonsOverlap;
619
620 // Get how much space is required to show the hotseat with QSB
621 int requiredWidth = getHotseatRequiredWidth();
622
623 // If spaces are fine, use them
624 if (requiredWidth <= maxHotseatWidth) {
625 return;
626 }
627
628 // Calculate the difference of widths and remove a little from each space between icons
629 // and QSB if it's inline
630 int spaceDiff = requiredWidth - maxHotseatWidth;
631 int numOfSpaces = numShownHotseatIcons - (isQsbInline ? 0 : 1);
632 hotseatBorderSpace -= (spaceDiff / numOfSpaces);
633
634 int minHotseatIconSpaceDp = res.getDimensionPixelSize(R.dimen.min_hotseat_icon_space);
635 int minHotseatQsbWidthDp = res.getDimensionPixelSize(R.dimen.min_hotseat_qsb_width);
636
637 if (hotseatBorderSpace >= minHotseatIconSpaceDp) {
638 return;
639 }
640
641 // Border space can't be less than the minimum
642 hotseatBorderSpace = minHotseatIconSpaceDp;
643 requiredWidth = getHotseatRequiredWidth();
644
645 // If there is an inline qsb, change its size
646 if (isQsbInline) {
647 hotseatQsbWidth -= requiredWidth - maxHotseatWidth;
648 if (hotseatQsbWidth >= minHotseatQsbWidthDp) {
649 return;
650 }
651
652 // QSB can't be less than the minimum
653 hotseatQsbWidth = minHotseatQsbWidthDp;
654 }
655
656 // If it still doesn't fit, start removing icons
657 do {
658 numShownHotseatIcons--;
659 requiredWidth = getHotseatRequiredWidth();
660 } while (requiredWidth > maxHotseatWidth && numShownHotseatIcons > 1);
661
662 // Add back some space between the icons
663 spaceDiff = maxHotseatWidth - requiredWidth;
664 numOfSpaces = numShownHotseatIcons - (isQsbInline ? 0 : 1);
665 hotseatBorderSpace += (spaceDiff / numOfSpaces);
666 }
667
Thales Lima78d00ad2021-09-30 11:29:06 +0100668 private Point getCellLayoutBorderSpace(InvariantDeviceProfile idp) {
Thales Lima080d8902022-03-28 15:30:29 +0100669 return getCellLayoutBorderSpace(idp, 1f);
Thales Lima080d8902022-03-28 15:30:29 +0100670 }
671
672 private Point getCellLayoutBorderSpace(InvariantDeviceProfile idp, float scale) {
Thales Lima78d00ad2021-09-30 11:29:06 +0100673 if (!isScalableGrid) {
674 return new Point(0, 0);
675 }
676
Thales Lima080d8902022-03-28 15:30:29 +0100677 int horizontalSpacePx = pxFromDp(idp.borderSpaces[mTypeIndex].x, mMetrics, scale);
678 int verticalSpacePx = pxFromDp(idp.borderSpaces[mTypeIndex].y, mMetrics, scale);
Thales Lima78d00ad2021-09-30 11:29:06 +0100679
680 return new Point(horizontalSpacePx, verticalSpacePx);
681 }
682
Sunny Goyal69a8eec2021-07-22 10:02:50 -0700683 public Info getDisplayInfo() {
684 return mInfo;
685 }
686
Jon Miranda611dba42021-03-02 14:12:13 -0500687 /**
688 * We inset the widget padding added by the system and instead rely on the border spacing
689 * between cells to create reliable consistency between widgets
690 */
691 public boolean shouldInsetWidgets() {
692 Rect widgetPadding = inv.defaultWidgetPadding;
693
Jon Miranda49811182021-06-03 09:52:40 -0700694 // Check all sides to ensure that the widget won't overlap into another cell, or into
695 // status bar.
696 return workspaceTopPadding > widgetPadding.top
Thales Lima78d00ad2021-09-30 11:29:06 +0100697 && cellLayoutBorderSpacePx.x > widgetPadding.left
698 && cellLayoutBorderSpacePx.y > widgetPadding.top
699 && cellLayoutBorderSpacePx.x > widgetPadding.right
700 && cellLayoutBorderSpacePx.y > widgetPadding.bottom;
Jon Miranda611dba42021-03-02 14:12:13 -0500701 }
Jon Mirandae126d722021-02-25 10:45:20 -0500702
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700703 public Builder toBuilder(Context context) {
Sunny Goyal187b16c2022-03-01 16:53:23 -0800704 WindowBounds bounds = new WindowBounds(
705 widthPx, heightPx, availableWidthPx, availableHeightPx, rotationHint);
Sunny Goyal19ff7282021-04-22 10:12:54 -0700706 bounds.bounds.offsetTo(windowX, windowY);
Alex Chaue0227552022-04-06 19:44:43 +0100707 bounds.insets.set(mInsets);
Sunny Goyal65190ae2022-08-02 14:16:26 -0700708
709 SparseArray<DotRenderer> dotRendererCache = new SparseArray<>();
710 dotRendererCache.put(iconSizePx, mDotRendererWorkSpace);
711 dotRendererCache.put(allAppsIconSizePx, mDotRendererAllApps);
712
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700713 return new Builder(context, inv, mInfo)
Sunny Goyal19ff7282021-04-22 10:12:54 -0700714 .setWindowBounds(bounds)
715 .setUseTwoPanels(isTwoPanels)
Alex Chau6ed408f2022-03-04 12:58:05 +0000716 .setMultiWindowMode(isMultiWindowMode)
Sunny Goyal65190ae2022-08-02 14:16:26 -0700717 .setDotRendererCache(dotRendererCache)
Alex Chau6ed408f2022-03-04 12:58:05 +0000718 .setGestureMode(isGestureMode);
Sunny Goyal1a52ef52018-01-11 10:15:03 -0800719 }
720
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700721 public DeviceProfile copy(Context context) {
722 return toBuilder(context).build();
723 }
724
725 /**
726 * TODO: Move this to the builder as part of setMultiWindowMode
727 */
Sunny Goyalb46703d2020-05-27 17:52:03 -0700728 public DeviceProfile getMultiWindowProfile(Context context, WindowBounds windowBounds) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700729 DeviceProfile profile = toBuilder(context)
Sunny Goyal19ff7282021-04-22 10:12:54 -0700730 .setWindowBounds(windowBounds)
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700731 .setMultiWindowMode(true)
732 .build();
Jon Miranda93e1f042016-11-11 14:13:04 -0800733
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800734 // We use these scales to measure and layout the widgets using their full invariant profile
735 // sizes and then draw them scaled and centered to fit in their multi-window mode cellspans.
736 float appWidgetScaleX = (float) profile.getCellSize().x / getCellSize().x;
737 float appWidgetScaleY = (float) profile.getCellSize().y / getCellSize().y;
Sihua Mae04aa202022-07-18 12:43:56 -0700738 if (appWidgetScaleX != 1 || appWidgetScaleY != 1) {
739 final PointF p = new PointF(appWidgetScaleX, appWidgetScaleY);
740 profile = profile.toBuilder(context)
741 .setViewScaleProvider(i -> p)
742 .build();
743 }
744
745 profile.hideWorkspaceLabelsIfNotEnoughSpace();
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800746
Jon Miranda93e1f042016-11-11 14:13:04 -0800747 return profile;
Jon Mirandacc42c5b2016-10-27 17:15:27 -0700748 }
749
Adam Cohen63f1ec02014-08-12 09:23:13 -0700750 /**
Jon Miranda941375e2021-03-31 13:10:45 -0400751 * Checks if there is enough space for labels on the workspace.
752 * If there is not, labels on the Workspace are hidden.
Jon Miranda1091e532017-07-21 13:31:50 -0700753 * It is important to call this method after the All Apps variables have been set.
754 */
Jon Miranda941375e2021-03-31 13:10:45 -0400755 private void hideWorkspaceLabelsIfNotEnoughSpace() {
756 float iconTextHeight = Utilities.calculateTextHeight(iconTextSizePx);
757 float workspaceCellPaddingY = getCellSize().y - iconSizePx - iconDrawablePaddingPx
758 - iconTextHeight;
759
760 // We want enough space so that the text is closer to its corresponding icon.
761 if (workspaceCellPaddingY < iconTextHeight) {
762 iconTextSizePx = 0;
763 iconDrawablePaddingPx = 0;
Jon Miranda92c1b5d2021-07-20 13:57:16 -0700764 cellHeightPx = (int) Math.ceil(iconSizePx * ICON_OVERLAP_FACTOR);
Jon Miranda941375e2021-03-31 13:10:45 -0400765 autoResizeAllAppsCells();
766 }
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700767 }
Jon Miranda1091e532017-07-21 13:31:50 -0700768
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700769 /**
770 * Re-computes the all-apps cell size to be independent of workspace
771 */
772 public void autoResizeAllAppsCells() {
Jon Miranda941375e2021-03-31 13:10:45 -0400773 int textHeight = Utilities.calculateTextHeight(allAppsIconTextSizePx);
774 int topBottomPadding = textHeight;
Jon Miranda1091e532017-07-21 13:31:50 -0700775 allAppsCellHeightPx = allAppsIconSizePx + allAppsIconDrawablePaddingPx
Jon Miranda941375e2021-03-31 13:10:45 -0400776 + textHeight + (topBottomPadding * 2);
Jon Miranda1091e532017-07-21 13:31:50 -0700777 }
778
Thales Limab7ef5692022-03-10 10:32:36 +0000779 private void updateAllAppsContainerWidth(Resources res) {
Pat Manning08610ca2022-04-05 21:03:16 +0100780 int cellLayoutHorizontalPadding =
781 (cellLayoutPaddingPx.left + cellLayoutPaddingPx.right) / 2;
Alex Chau27b39b92022-01-14 18:02:18 +0000782 if (isTablet) {
Thales Limab7ef5692022-03-10 10:32:36 +0000783 allAppsLeftRightPadding =
Pat Manning08610ca2022-04-05 21:03:16 +0100784 res.getDimensionPixelSize(R.dimen.all_apps_bottom_sheet_horizontal_padding);
785
sfufa@google.comde013292021-09-21 18:22:44 -0700786 int usedWidth = (allAppsCellWidthPx * numShownAllAppsColumns)
Thales Limab7ef5692022-03-10 10:32:36 +0000787 + (allAppsBorderSpacePx.x * (numShownAllAppsColumns - 1))
Alex Chau27b39b92022-01-14 18:02:18 +0000788 + allAppsLeftRightPadding * 2;
789 allAppsLeftRightMargin = Math.max(1, (availableWidthPx - usedWidth) / 2);
sfufa@google.comde013292021-09-21 18:22:44 -0700790 } else {
791 allAppsLeftRightPadding =
Pat Manning08610ca2022-04-05 21:03:16 +0100792 desiredWorkspaceHorizontalMarginPx + cellLayoutHorizontalPadding;
sfufa@google.comde013292021-09-21 18:22:44 -0700793 }
794 }
795
Jon Miranda228877d2021-02-09 11:05:00 -0500796 /**
797 * Returns the amount of extra (or unused) vertical space.
798 */
799 private int updateAvailableDimensions(Resources res) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700800 updateIconSize(1f, res);
Winson Chung59a488a2013-12-10 12:32:14 -0800801
Pat Manning08610ca2022-04-05 21:03:16 +0100802 updateWorkspacePadding();
Jon Mirandae126d722021-02-25 10:45:20 -0500803
804 // Check to see if the icons fit within the available height.
Pat Manninga2e14992022-04-22 11:29:17 +0100805 float usedHeight = getCellLayoutHeightSpecification();
Pat Manning25d53342022-05-10 09:58:49 +0000806 final int maxHeight = getCellLayoutHeight();
Jon Miranda228877d2021-02-09 11:05:00 -0500807 float extraHeight = Math.max(0, maxHeight - usedHeight);
Jon Mirandae126d722021-02-25 10:45:20 -0500808 float scaleY = maxHeight / usedHeight;
809 boolean shouldScale = scaleY < 1f;
810
811 float scaleX = 1f;
812 if (isScalableGrid) {
813 // We scale to fit the cellWidth and cellHeight in the available space.
814 // The benefit of scalable grids is that we can get consistent aspect ratios between
815 // devices.
Pat Manninga2e14992022-04-22 11:29:17 +0100816 float usedWidth =
817 getCellLayoutWidthSpecification() + (desiredWorkspaceHorizontalMarginPx * 2);
Jon Mirandae126d722021-02-25 10:45:20 -0500818 // We do not subtract padding here, as we also scale the workspace padding if needed.
819 scaleX = availableWidthPx / usedWidth;
820 shouldScale = true;
Winson Chungb3800242013-10-24 11:01:54 -0700821 }
Jon Mirandae126d722021-02-25 10:45:20 -0500822
823 if (shouldScale) {
824 float scale = Math.min(scaleX, scaleY);
825 updateIconSize(scale, res);
Pat Manninga2e14992022-04-22 11:29:17 +0100826 extraHeight = Math.max(0, maxHeight - getCellLayoutHeightSpecification());
Jon Mirandae126d722021-02-25 10:45:20 -0500827 }
828
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700829 updateAvailableFolderCellDimensions(res);
Jon Miranda228877d2021-02-09 11:05:00 -0500830 return Math.round(extraHeight);
Winson Chungb3800242013-10-24 11:01:54 -0700831 }
832
Pat Manninga2e14992022-04-22 11:29:17 +0100833 private int getCellLayoutHeightSpecification() {
Pat Manning08610ca2022-04-05 21:03:16 +0100834 return (cellHeightPx * inv.numRows) + (cellLayoutBorderSpacePx.y * (inv.numRows - 1))
835 + cellLayoutPaddingPx.top + cellLayoutPaddingPx.bottom;
836 }
837
Pat Manninga2e14992022-04-22 11:29:17 +0100838 private int getCellLayoutWidthSpecification() {
Pat Manning25d53342022-05-10 09:58:49 +0000839 int numColumns = getPanelCount() * inv.numColumns;
Pat Manning08610ca2022-04-05 21:03:16 +0100840 return (cellWidthPx * numColumns) + (cellLayoutBorderSpacePx.x * (numColumns - 1))
841 + cellLayoutPaddingPx.left + cellLayoutPaddingPx.right;
Jon Mirandae126d722021-02-25 10:45:20 -0500842 }
843
Jon Miranda6f7e9702019-09-16 14:44:14 -0700844 /**
845 * Updating the iconSize affects many aspects of the launcher layout, such as: iconSizePx,
846 * iconTextSizePx, iconDrawablePaddingPx, cellWidth/Height, allApps* variants,
847 * hotseat sizes, workspaceSpringLoadedShrinkFactor, folderIconSizePx, and folderIconOffsetYPx.
848 */
Tony Wickham7ba547c2021-02-02 17:12:08 -0800849 public void updateIconSize(float scale, Resources res) {
Jon Mirandaab3c6812021-06-28 15:42:28 -0700850 // Icon scale should never exceed 1, otherwise pixellation may occur.
851 iconScale = Math.min(1f, scale);
852 cellScaleToFit = scale;
853
Jon Miranda18751b62017-07-31 17:25:27 -0700854 // Workspace
Sunny Goyal07b69292018-01-08 14:19:34 -0800855 final boolean isVerticalLayout = isVerticalBarLayout();
Thales Lima83bedbf2021-10-05 17:47:39 +0100856 float invIconSizeDp = inv.iconSize[mTypeIndex];
857 float invIconTextSizeSp = inv.iconTextSize[mTypeIndex];
Andras Kloczl30fe9152021-08-05 18:02:29 +0200858
Jon Mirandaab3c6812021-06-28 15:42:28 -0700859 iconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mMetrics, iconScale));
Jon Mirandaab3c6812021-06-28 15:42:28 -0700860 iconTextSizePx = (int) (pxFromSp(invIconTextSizeSp, mMetrics) * iconScale);
861 iconDrawablePaddingPx = (int) (iconDrawablePaddingOriginalPx * iconScale);
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700862
Thales Lima080d8902022-03-28 15:30:29 +0100863 cellLayoutBorderSpacePx = getCellLayoutBorderSpace(inv, scale);
Jon Mirandae126d722021-02-25 10:45:20 -0500864
865 if (isScalableGrid) {
Thales Lima83bedbf2021-10-05 17:47:39 +0100866 cellWidthPx = pxFromDp(inv.minCellSize[mTypeIndex].x, mMetrics, scale);
867 cellHeightPx = pxFromDp(inv.minCellSize[mTypeIndex].y, mMetrics, scale);
Jon Mirandae126d722021-02-25 10:45:20 -0500868 int cellContentHeight = iconSizePx + iconDrawablePaddingPx
869 + Utilities.calculateTextHeight(iconTextSizePx);
870 cellYPaddingPx = Math.max(0, cellHeightPx - cellContentHeight) / 2;
Thales Limad90faab2021-09-21 17:18:47 +0100871 desiredWorkspaceHorizontalMarginPx =
872 (int) (desiredWorkspaceHorizontalMarginOriginalPx * scale);
Jon Miranda228877d2021-02-09 11:05:00 -0500873 } else {
Jon Mirandae126d722021-02-25 10:45:20 -0500874 cellWidthPx = iconSizePx + iconDrawablePaddingPx;
Jon Miranda92c1b5d2021-07-20 13:57:16 -0700875 cellHeightPx = (int) Math.ceil(iconSizePx * ICON_OVERLAP_FACTOR)
876 + iconDrawablePaddingPx
Jon Miranda228877d2021-02-09 11:05:00 -0500877 + Utilities.calculateTextHeight(iconTextSizePx);
878 int cellPaddingY = (getCellSize().y - cellHeightPx) / 2;
879 if (iconDrawablePaddingPx > cellPaddingY && !isVerticalLayout
880 && !isMultiWindowMode) {
881 // Ensures that the label is closer to its corresponding icon. This is not an issue
882 // with vertical bar layout or multi-window mode since the issue is handled
883 // separately with their calls to {@link #adjustToHideWorkspaceLabels}.
884 cellHeightPx -= (iconDrawablePaddingPx - cellPaddingY);
885 iconDrawablePaddingPx = cellPaddingY;
886 }
Jon Miranda846455e2017-10-02 14:58:52 -0700887 }
Jon Miranda18751b62017-07-31 17:25:27 -0700888
Sunny Goyalae190ff2020-04-14 00:19:01 +0000889 // All apps
Brian Isganitis25b2ac82022-01-28 16:25:13 -0500890 updateAllAppsIconSize(scale, res);
Winson Chungb3800242013-10-24 11:01:54 -0700891
Thales Limab8c05952022-05-23 16:58:38 +0100892 updateHotseatSizes(iconSizePx);
Winson Chungb3800242013-10-24 11:01:54 -0700893
Sunny Goyalbaec6ff2016-09-14 11:26:21 -0700894 // Folder icon
Jon Miranda591e3602018-03-28 11:37:00 -0700895 folderIconSizePx = IconNormalizer.getNormalizedCircleSize(iconSizePx);
896 folderIconOffsetYPx = (iconSizePx - folderIconSizePx) / 2;
Winson Chung0f785722015-04-08 10:27:49 -0700897 }
898
Thales Lima425f6822022-05-10 13:44:58 -0300899 /**
900 * Hotseat width spans a certain number of columns on scalable grids.
901 * This method calculates the space between the icons to achieve that width.
902 */
903 private int calculateHotseatBorderSpace() {
904 if (!isScalableGrid) return 0;
Thales Lima9938c2f2022-07-25 14:38:16 +0100905 int columns = inv.hotseatColumnSpan[mTypeIndex];
906 float hotseatWidthPx = getIconToIconWidthForColumns(columns);
907 float hotseatIconsTotalPx = iconSizePx * numShownHotseatIcons;
908 return (int) (hotseatWidthPx - hotseatIconsTotalPx) / (numShownHotseatIcons - 1);
Thales Lima425f6822022-05-10 13:44:58 -0300909 }
910
Brian Isganitis25b2ac82022-01-28 16:25:13 -0500911
912 /**
913 * Updates the iconSize for allApps* variants.
914 */
Brian Isganitisa9a78112022-05-23 18:11:47 -0700915 private void updateAllAppsIconSize(float scale, Resources res) {
Thales Lima080d8902022-03-28 15:30:29 +0100916 allAppsBorderSpacePx = new Point(
917 pxFromDp(inv.allAppsBorderSpaces[mTypeIndex].x, mMetrics, scale),
918 pxFromDp(inv.allAppsBorderSpaces[mTypeIndex].y, mMetrics, scale));
Brandon Dayauon07ca8842022-04-27 10:52:28 -0700919 // AllApps cells don't have real space between cells,
920 // so we add the border space to the cell height
921 allAppsCellHeightPx = pxFromDp(inv.allAppsCellSize[mTypeIndex].y, mMetrics, scale)
922 + allAppsBorderSpacePx.y;
923 // but width is just the cell,
924 // the border is added in #updateAllAppsContainerWidth
Thales Lima080d8902022-03-28 15:30:29 +0100925 if (isScalableGrid) {
Brian Isganitis25b2ac82022-01-28 16:25:13 -0500926 allAppsIconSizePx =
Brandon Dayauon969f6a82022-05-19 09:46:47 -0700927 pxFromDp(inv.allAppsIconSize[mTypeIndex], mMetrics, scale);
Brian Isganitis25b2ac82022-01-28 16:25:13 -0500928 allAppsIconTextSizePx =
Brandon Dayauon969f6a82022-05-19 09:46:47 -0700929 pxFromSp(inv.allAppsIconTextSize[mTypeIndex], mMetrics, scale);
Brian Isganitis25b2ac82022-01-28 16:25:13 -0500930 allAppsIconDrawablePaddingPx = iconDrawablePaddingOriginalPx;
Brandon Dayauon7a8a9ed2022-06-06 14:32:22 -0700931 allAppsCellWidthPx = pxFromDp(inv.allAppsCellSize[mTypeIndex].x, mMetrics, scale);
Brian Isganitis25b2ac82022-01-28 16:25:13 -0500932 } else {
Brandon Dayauon07ca8842022-04-27 10:52:28 -0700933 float invIconSizeDp = inv.allAppsIconSize[mTypeIndex];
934 float invIconTextSizeSp = inv.allAppsIconTextSize[mTypeIndex];
Brian Isganitis25b2ac82022-01-28 16:25:13 -0500935 allAppsIconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mMetrics, scale));
936 allAppsIconTextSizePx = (int) (pxFromSp(invIconTextSizeSp, mMetrics) * scale);
Brandon Dayauon07ca8842022-04-27 10:52:28 -0700937 allAppsIconDrawablePaddingPx =
938 res.getDimensionPixelSize(R.dimen.all_apps_icon_drawable_padding);
Brandon Dayauon7a8a9ed2022-06-06 14:32:22 -0700939 allAppsCellWidthPx = allAppsIconSizePx + (2 * allAppsIconDrawablePaddingPx);
Brian Isganitis25b2ac82022-01-28 16:25:13 -0500940 }
941
Thales Limab7ef5692022-03-10 10:32:36 +0000942 updateAllAppsContainerWidth(res);
Brian Isganitis25b2ac82022-01-28 16:25:13 -0500943 if (isVerticalBarLayout()) {
944 hideWorkspaceLabelsIfNotEnoughSpace();
945 }
946 }
947
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700948 private void updateAvailableFolderCellDimensions(Resources res) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700949 updateFolderCellSize(1f, res);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700950
Jon Mirandac1b23992016-12-13 08:57:36 -0800951 // Don't let the folder get too close to the edges of the screen.
Jon Miranda1786df32018-09-25 13:05:23 -0700952 int folderMargin = edgeMarginPx * 2;
Sunny Goyal07b69292018-01-08 14:19:34 -0800953 Point totalWorkspacePadding = getTotalWorkspacePadding();
Jon Mirandac1b23992016-12-13 08:57:36 -0800954
955 // Check if the icons fit within the available height.
Jon Miranda228877d2021-02-09 11:05:00 -0500956 float contentUsedHeight = folderCellHeightPx * inv.numFolderRows
Thales Limab35faed2022-09-05 16:30:01 -0300957 + ((inv.numFolderRows - 1) * folderCellLayoutBorderSpacePx);
958 int contentMaxHeight = availableHeightPx - totalWorkspacePadding.y - folderFooterHeightPx
Jon Mirandae126d722021-02-25 10:45:20 -0500959 - folderMargin - folderContentPaddingTop;
Samuel Fufa1c8d90a2019-11-12 17:54:58 -0800960 float scaleY = contentMaxHeight / contentUsedHeight;
Jon Mirandac1b23992016-12-13 08:57:36 -0800961
962 // Check if the icons fit within the available width.
Jon Miranda228877d2021-02-09 11:05:00 -0500963 float contentUsedWidth = folderCellWidthPx * inv.numFolderColumns
Thales Limab35faed2022-09-05 16:30:01 -0300964 + ((inv.numFolderColumns - 1) * folderCellLayoutBorderSpacePx);
Jon Mirandae126d722021-02-25 10:45:20 -0500965 int contentMaxWidth = availableWidthPx - totalWorkspacePadding.x - folderMargin
966 - folderContentPaddingLeftRight * 2;
Samuel Fufa1c8d90a2019-11-12 17:54:58 -0800967 float scaleX = contentMaxWidth / contentUsedWidth;
Jon Mirandac1b23992016-12-13 08:57:36 -0800968
969 float scale = Math.min(scaleX, scaleY);
970 if (scale < 1f) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700971 updateFolderCellSize(scale, res);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700972 }
973 }
974
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700975 private void updateFolderCellSize(float scale, Resources res) {
Thales Lima83bedbf2021-10-05 17:47:39 +0100976 float invIconSizeDp = isVerticalBarLayout()
Thales Lima12d0eff2022-03-25 17:06:11 +0000977 ? inv.iconSize[INDEX_LANDSCAPE]
978 : inv.iconSize[INDEX_DEFAULT];
Sunny Goyal35c7b192021-04-20 16:51:10 -0700979 folderChildIconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mMetrics, scale));
Thales Lima83bedbf2021-10-05 17:47:39 +0100980 folderChildTextSizePx =
Thales Lima12d0eff2022-03-25 17:06:11 +0000981 pxFromSp(inv.iconTextSize[INDEX_DEFAULT], mMetrics, scale);
Thales Limab35faed2022-09-05 16:30:01 -0300982 folderLabelTextSizePx = Math.max(pxFromSp(MIN_FOLDER_TEXT_SIZE_SP, mMetrics),
983 (int) (folderChildTextSizePx * folderLabelTextScale));
Jon Mirandabf7d8122016-11-03 15:29:29 -0700984
985 int textHeight = Utilities.calculateTextHeight(folderChildTextSizePx);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700986
Jon Miranda823da222021-03-23 08:08:45 -0400987 if (isScalableGrid) {
Thales Limab35faed2022-09-05 16:30:01 -0300988 if (inv.folderStyle == INVALID_RESOURCE_HANDLE) {
989 folderCellWidthPx = pxFromDp(getCellSize().x, mMetrics, scale);
990 folderCellHeightPx = pxFromDp(getCellSize().y, mMetrics, scale);
991 }
Jon Mirandaf33f5b32021-07-22 17:15:31 -0700992
Thales Limab35faed2022-09-05 16:30:01 -0300993 folderContentPaddingLeftRight = folderCellLayoutBorderSpacePx;
Jon Miranda823da222021-03-23 08:08:45 -0400994 } else {
995 int cellPaddingX = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_x_padding)
996 * scale);
997 int cellPaddingY = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_y_padding)
998 * scale);
999
1000 folderCellWidthPx = folderChildIconSizePx + 2 * cellPaddingX;
1001 folderCellHeightPx = folderChildIconSizePx + 2 * cellPaddingY + textHeight;
Thales Limab35faed2022-09-05 16:30:01 -03001002 folderContentPaddingLeftRight =
1003 res.getDimensionPixelSize(R.dimen.folder_content_padding_left_right);
1004 folderFooterHeightPx =
1005 res.getDimensionPixelSize(R.dimen.folder_footer_height_default);
Jon Miranda823da222021-03-23 08:08:45 -04001006 }
1007
Jonathan Miranda9ad87462017-07-26 17:41:02 +00001008 folderChildDrawablePaddingPx = Math.max(0,
1009 (folderCellHeightPx - folderChildIconSizePx - textHeight) / 3);
Jon Mirandabf7d8122016-11-03 15:29:29 -07001010 }
1011
Winson1f064272016-07-18 17:18:02 -07001012 public void updateInsets(Rect insets) {
1013 mInsets.set(insets);
1014 }
1015
Sunny Goyalae6e3182019-04-30 12:04:37 -07001016 /**
1017 * The current device insets. This is generally same as the insets being dispatched to
1018 * {@link Insettable} elements, but can differ if the element is using a different profile.
1019 */
Sunny Goyal1a52ef52018-01-11 10:15:03 -08001020 public Rect getInsets() {
1021 return mInsets;
1022 }
1023
Sunny Goyal756cd262015-08-20 12:33:21 -07001024 public Point getCellSize() {
Sunny Goyal19ff7282021-04-22 10:12:54 -07001025 return getCellSize(null);
Jon Miranda6f7e9702019-09-16 14:44:14 -07001026 }
1027
Sunny Goyal19ff7282021-04-22 10:12:54 -07001028 public Point getCellSize(Point result) {
1029 if (result == null) {
1030 result = new Point();
1031 }
Thales Limad1df5fc2021-09-03 18:37:19 +01001032
Pat Manning25d53342022-05-10 09:58:49 +00001033 int shortcutAndWidgetContainerWidth =
1034 getCellLayoutWidth() - (cellLayoutPaddingPx.left + cellLayoutPaddingPx.right);
1035 result.x = calculateCellWidth(shortcutAndWidgetContainerWidth, cellLayoutBorderSpacePx.x,
1036 inv.numColumns);
1037 int shortcutAndWidgetContainerHeight =
1038 getCellLayoutHeight() - (cellLayoutPaddingPx.top + cellLayoutPaddingPx.bottom);
1039 result.y = calculateCellHeight(shortcutAndWidgetContainerHeight, cellLayoutBorderSpacePx.y,
1040 inv.numRows);
Sunny Goyal3e8a04b2022-05-09 19:31:45 +00001041 return result;
Pat Manningb45d6c42022-05-03 14:32:06 +01001042 }
1043
1044 /**
Thales Lima1e8b45f2022-08-25 11:50:59 -04001045 * Returns the left and right space on the cell, which is the cell width - icon size
1046 */
1047 public int getCellHorizontalSpace() {
1048 return getCellSize().x - iconSizePx;
1049 }
1050
1051 /**
Pat Manning25d53342022-05-10 09:58:49 +00001052 * Gets the number of panels within the workspace.
1053 */
1054 public int getPanelCount() {
1055 return isTwoPanels ? 2 : 1;
1056 }
1057
1058 /**
Pat Manningde25c0d2022-04-05 19:11:26 +01001059 * Gets the space in px from the bottom of last item in the vertical-bar hotseat to the
1060 * bottom of the screen.
1061 */
Pat Manning5f74bfd2022-07-20 12:08:54 +01001062 private int getVerticalHotseatLastItemBottomOffset(Context context) {
1063 Rect hotseatBarPadding = getHotseatLayoutPadding(context);
Pat Manningde25c0d2022-04-05 19:11:26 +01001064 int cellHeight = calculateCellHeight(
Pat Manning5f74bfd2022-07-20 12:08:54 +01001065 heightPx - hotseatBarPadding.top - hotseatBarPadding.bottom, hotseatBorderSpace,
Pat Manningde25c0d2022-04-05 19:11:26 +01001066 numShownHotseatIcons);
Pat Manningde25c0d2022-04-05 19:11:26 +01001067 int extraIconEndSpacing = (cellHeight - iconSizePx) / 2;
Pat Manning5f74bfd2022-07-20 12:08:54 +01001068 return extraIconEndSpacing + hotseatBarPadding.bottom;
Pat Manningde25c0d2022-04-05 19:11:26 +01001069 }
1070
1071 /**
1072 * Gets the scaled top of the workspace in px for the spring-loaded edit state.
1073 */
Pat Manning25d53342022-05-10 09:58:49 +00001074 public float getCellLayoutSpringLoadShrunkTop() {
Pat Manning5f74bfd2022-07-20 12:08:54 +01001075 return mInsets.top + dropTargetBarTopMarginPx + dropTargetBarSizePx
Pat Manningde25c0d2022-04-05 19:11:26 +01001076 + dropTargetBarBottomMarginPx;
Pat Manningde25c0d2022-04-05 19:11:26 +01001077 }
1078
1079 /**
1080 * Gets the scaled bottom of the workspace in px for the spring-loaded edit state.
1081 */
Pat Manning5f74bfd2022-07-20 12:08:54 +01001082 public float getCellLayoutSpringLoadShrunkBottom(Context context) {
Pat Manningde25c0d2022-04-05 19:11:26 +01001083 int topOfHotseat = hotseatBarSizePx + springLoadedHotseatBarTopMarginPx;
Pat Manning5f74bfd2022-07-20 12:08:54 +01001084 return heightPx - (isVerticalBarLayout()
1085 ? getVerticalHotseatLastItemBottomOffset(context) : topOfHotseat);
Pat Manningde25c0d2022-04-05 19:11:26 +01001086 }
1087
Pat Manningea5c1d22022-04-14 10:58:16 +01001088 /**
Pat Manninga2e14992022-04-22 11:29:17 +01001089 * Gets the scale of the workspace for the spring-loaded edit state.
1090 */
Pat Manning5f74bfd2022-07-20 12:08:54 +01001091 public float getWorkspaceSpringLoadScale(Context context) {
1092 float scale =
1093 (getCellLayoutSpringLoadShrunkBottom(context) - getCellLayoutSpringLoadShrunkTop())
1094 / getCellLayoutHeight();
Pat Manninga2e14992022-04-22 11:29:17 +01001095 scale = Math.min(scale, 1f);
1096
Pat Manninge63dd252022-08-02 16:15:29 +01001097 // Reduce scale if next pages would not be visible after scaling the workspace.
Pat Manning25d53342022-05-10 09:58:49 +00001098 int workspaceWidth = availableWidthPx;
Pat Manninga2e14992022-04-22 11:29:17 +01001099 float scaledWorkspaceWidth = workspaceWidth * scale;
Alex Chau906d8822022-05-23 10:42:25 +01001100 float maxAvailableWidth = workspaceWidth - (2 * workspaceSpringLoadedMinNextPageVisiblePx);
Pat Manninga2e14992022-04-22 11:29:17 +01001101 if (scaledWorkspaceWidth > maxAvailableWidth) {
1102 scale *= maxAvailableWidth / scaledWorkspaceWidth;
1103 }
1104 return scale;
1105 }
1106
Pat Manning25d53342022-05-10 09:58:49 +00001107 /**
1108 * Gets the width of a single Cell Layout, aka a single panel within a Workspace.
1109 *
1110 * <p>This is the width of a Workspace, less its horizontal padding. Note that two-panel
1111 * layouts have two Cell Layouts per workspace.
1112 */
1113 public int getCellLayoutWidth() {
1114 return (availableWidthPx - getTotalWorkspacePadding().x) / getPanelCount();
Alex Chau60953332021-11-24 12:41:07 +00001115 }
1116
Pat Manning25d53342022-05-10 09:58:49 +00001117 /**
1118 * Gets the height of a single Cell Layout, aka a single panel within a Workspace.
1119 *
1120 * <p>This is the height of a Workspace, less its vertical padding.
1121 */
1122 public int getCellLayoutHeight() {
1123 return availableHeightPx - getTotalWorkspacePadding().y;
Pat Manning08610ca2022-04-05 21:03:16 +01001124 }
1125
Sunny Goyal6c2975e2016-07-06 09:47:56 -07001126 public Point getTotalWorkspacePadding() {
Sunny Goyal07b69292018-01-08 14:19:34 -08001127 return new Point(workspacePadding.left + workspacePadding.right,
1128 workspacePadding.top + workspacePadding.bottom);
Sunny Goyal6c2975e2016-07-06 09:47:56 -07001129 }
1130
1131 /**
Sunny Goyal07b69292018-01-08 14:19:34 -08001132 * Updates {@link #workspacePadding} as a result of any internal value change to reflect the
1133 * new workspace padding
Sunny Goyal6c2975e2016-07-06 09:47:56 -07001134 */
Sunny Goyal07b69292018-01-08 14:19:34 -08001135 private void updateWorkspacePadding() {
1136 Rect padding = workspacePadding;
Tony Wickham3a3517f2015-10-06 11:27:04 -07001137 if (isVerticalBarLayout()) {
Sunny Goyal228153d2018-01-04 15:35:22 -08001138 padding.top = 0;
1139 padding.bottom = edgeMarginPx;
Sunny Goyal7e2e67f2018-01-26 13:40:08 -08001140 if (isSeascape()) {
Tony Wickham1eeffbe2018-06-12 15:01:15 -07001141 padding.left = hotseatBarSizePx;
Tony Wickham5edf9e22020-03-27 20:06:52 -07001142 padding.right = hotseatBarSidePaddingStartPx;
Winson1f064272016-07-18 17:18:02 -07001143 } else {
Tony Wickham5edf9e22020-03-27 20:06:52 -07001144 padding.left = hotseatBarSidePaddingStartPx;
Tony Wickham1eeffbe2018-06-12 15:01:15 -07001145 padding.right = hotseatBarSizePx;
Winson1f064272016-07-18 17:18:02 -07001146 }
Winson Chungb3800242013-10-24 11:01:54 -07001147 } else {
Thales Limab8c05952022-05-23 16:58:38 +01001148 // Pad the bottom of the workspace with hotseat bar
1149 // and leave a bit of space in case a widget go all the way down
1150 int paddingBottom = hotseatBarSizePx + workspaceBottomPadding
1151 + workspacePageIndicatorHeight - mWorkspacePageIndicatorOverlapWorkspace
1152 - mInsets.bottom;
Pat Manning08610ca2022-04-05 21:03:16 +01001153 int paddingTop = workspaceTopPadding + (isScalableGrid ? 0 : edgeMarginPx);
1154 int paddingSide = desiredWorkspaceHorizontalMarginPx;
Andras Kloczl8e57cce2021-02-11 23:51:19 +01001155
Pat Manning08610ca2022-04-05 21:03:16 +01001156 padding.set(paddingSide, paddingTop, paddingSide, paddingBottom);
Winson Chungb3800242013-10-24 11:01:54 -07001157 }
Pat Manning08610ca2022-04-05 21:03:16 +01001158 insetPadding(workspacePadding, cellLayoutPaddingPx);
1159 }
1160
1161 private void insetPadding(Rect paddings, Rect insets) {
1162 insets.left = Math.min(insets.left, paddings.left);
1163 paddings.left -= insets.left;
1164
1165 insets.top = Math.min(insets.top, paddings.top);
1166 paddings.top -= insets.top;
1167
1168 insets.right = Math.min(insets.right, paddings.right);
1169 paddings.right -= insets.right;
1170
1171 insets.bottom = Math.min(insets.bottom, paddings.bottom);
1172 paddings.bottom -= insets.bottom;
Winson Chungb3800242013-10-24 11:01:54 -07001173 }
1174
Sunny Goyal57b22792021-05-25 14:35:01 -07001175 /**
1176 * Returns the padding for hotseat view
1177 */
1178 public Rect getHotseatLayoutPadding(Context context) {
Pat Manning5f74bfd2022-07-20 12:08:54 +01001179 Rect hotseatBarPadding = new Rect();
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001180 if (isVerticalBarLayout()) {
Sihua Ma38bb3b02022-03-21 22:20:14 -07001181 // The hotseat icons will be placed in the middle of the hotseat cells.
1182 // Changing the hotseatCellHeightPx is not affecting hotseat icon positions
1183 // in vertical bar layout.
1184 // Workspace icons are moved up by a small factor. The variable diffOverlapFactor
1185 // is set to account for that difference.
1186 float diffOverlapFactor = iconSizePx * (ICON_OVERLAP_FACTOR - 1) / 2;
Pat Manning08610ca2022-04-05 21:03:16 +01001187 int paddingTop = Math.max((int) (mInsets.top + cellLayoutPaddingPx.top
1188 - diffOverlapFactor), 0);
1189 int paddingBottom = Math.max((int) (mInsets.bottom + cellLayoutPaddingPx.bottom
Sihua Ma38bb3b02022-03-21 22:20:14 -07001190 + diffOverlapFactor), 0);
1191
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001192 if (isSeascape()) {
Pat Manning5f74bfd2022-07-20 12:08:54 +01001193 hotseatBarPadding.set(mInsets.left + hotseatBarSidePaddingStartPx, paddingTop,
Pat Manning08610ca2022-04-05 21:03:16 +01001194 hotseatBarSidePaddingEndPx, paddingBottom);
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001195 } else {
Pat Manning5f74bfd2022-07-20 12:08:54 +01001196 hotseatBarPadding.set(hotseatBarSidePaddingEndPx, paddingTop,
Pat Manning08610ca2022-04-05 21:03:16 +01001197 mInsets.right + hotseatBarSidePaddingStartPx, paddingBottom);
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001198 }
Sunny Goyal57b22792021-05-25 14:35:01 -07001199 } else if (isTaskbarPresent) {
Alex Chau51da2192022-05-20 13:32:10 +01001200 // Center the QSB vertically with hotseat
Thales Limab8c05952022-05-23 16:58:38 +01001201 int hotseatBarBottomPadding = getHotseatBarBottomPadding();
1202 int hotseatBarTopPadding =
1203 hotseatBarSizePx - hotseatBarBottomPadding - hotseatCellHeightPx;
Alex Chau51da2192022-05-20 13:32:10 +01001204
Thales Lima612230d2022-03-31 18:04:37 +01001205 // Push icons to the side
Thales Lima9938c2f2022-07-25 14:38:16 +01001206 int requiredWidth = getHotseatRequiredWidth();
Pat Manning26f70f72022-07-07 13:50:39 +01001207 int hotseatWidth = Math.min(requiredWidth, availableWidthPx - hotseatBarEndOffset);
Thales Lima612230d2022-03-31 18:04:37 +01001208 int sideSpacing = (availableWidthPx - hotseatWidth) / 2;
Thales Lima612230d2022-03-31 18:04:37 +01001209
Pat Manning5f74bfd2022-07-20 12:08:54 +01001210 hotseatBarPadding.set(sideSpacing, hotseatBarTopPadding, sideSpacing,
Thales Limab8c05952022-05-23 16:58:38 +01001211 hotseatBarBottomPadding);
Alex Chau51da2192022-05-20 13:32:10 +01001212
1213 boolean isRtl = Utilities.isRtl(context.getResources());
Thales Lima612230d2022-03-31 18:04:37 +01001214 if (isRtl) {
Thales Lima9938c2f2022-07-25 14:38:16 +01001215 hotseatBarPadding.right += getAdditionalQsbSpace();
Thales Lima612230d2022-03-31 18:04:37 +01001216 } else {
Thales Lima9938c2f2022-07-25 14:38:16 +01001217 hotseatBarPadding.left += getAdditionalQsbSpace();
Thales Lima612230d2022-03-31 18:04:37 +01001218 }
Sunny Goyal57b22792021-05-25 14:35:01 -07001219
Pat Manning26f70f72022-07-07 13:50:39 +01001220 if (hotseatBarEndOffset > sideSpacing) {
Thales Lima612230d2022-03-31 18:04:37 +01001221 int diff = isRtl
Pat Manning26f70f72022-07-07 13:50:39 +01001222 ? sideSpacing - hotseatBarEndOffset
1223 : hotseatBarEndOffset - sideSpacing;
Pat Manning5f74bfd2022-07-20 12:08:54 +01001224 hotseatBarPadding.left -= diff;
1225 hotseatBarPadding.right += diff;
Sunny Goyal57b22792021-05-25 14:35:01 -07001226 }
Thales Lima425f6822022-05-10 13:44:58 -03001227 } else if (isScalableGrid) {
Alex Chau206ede92022-08-01 17:46:12 +01001228 int sideSpacing = (availableWidthPx - hotseatQsbWidth) / 2;
Pat Manning5f74bfd2022-07-20 12:08:54 +01001229 hotseatBarPadding.set(sideSpacing,
Thales Limab8c05952022-05-23 16:58:38 +01001230 0,
Thales Lima425f6822022-05-10 13:44:58 -03001231 sideSpacing,
Thales Limab8c05952022-05-23 16:58:38 +01001232 getHotseatBarBottomPadding());
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001233 } else {
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001234 // We want the edges of the hotseat to line up with the edges of the workspace, but the
1235 // icons in the hotseat are a different size, and so don't line up perfectly. To account
1236 // for this, we pad the left and right of the hotseat with half of the difference of a
1237 // workspace cell vs a hotseat cell.
1238 float workspaceCellWidth = (float) widthPx / inv.numColumns;
Sunny Goyal19ff7282021-04-22 10:12:54 -07001239 float hotseatCellWidth = (float) widthPx / numShownHotseatIcons;
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001240 int hotseatAdjustment = Math.round((workspaceCellWidth - hotseatCellWidth) / 2);
Pat Manning5f74bfd2022-07-20 12:08:54 +01001241 hotseatBarPadding.set(
Thales Limab8c05952022-05-23 16:58:38 +01001242 hotseatAdjustment + workspacePadding.left + cellLayoutPaddingPx.left
1243 + mInsets.left,
1244 0,
Pat Manning08610ca2022-04-05 21:03:16 +01001245 hotseatAdjustment + workspacePadding.right + cellLayoutPaddingPx.right
Sunny Goyal786940a2020-06-02 02:31:31 -07001246 + mInsets.right,
Thales Limab8c05952022-05-23 16:58:38 +01001247 getHotseatBarBottomPadding());
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001248 }
Pat Manning5f74bfd2022-07-20 12:08:54 +01001249 return hotseatBarPadding;
Sunny Goyal81b4c7b2018-03-26 12:10:31 -07001250 }
1251
Thales Lima9938c2f2022-07-25 14:38:16 +01001252 private int getAdditionalQsbSpace() {
1253 return isQsbInline ? hotseatQsbWidth + hotseatBorderSpace : 0;
1254 }
1255
1256 /**
1257 * Calculate how much space the hotseat needs to be shown completely
1258 */
1259 private int getHotseatRequiredWidth() {
1260 int additionalQsbSpace = getAdditionalQsbSpace();
1261 return iconSizePx * numShownHotseatIcons
1262 + hotseatBorderSpace * (numShownHotseatIcons - 1)
1263 + additionalQsbSpace;
1264 }
1265
Winsonfadbe8f2016-07-22 16:35:37 -07001266 /**
Sunny Goyal57b22792021-05-25 14:35:01 -07001267 * Returns the number of pixels the QSB is translated from the bottom of the screen.
1268 */
1269 public int getQsbOffsetY() {
Thales Limaa1012902022-01-13 17:58:42 +00001270 if (isQsbInline) {
Thales Limab8c05952022-05-23 16:58:38 +01001271 return getHotseatBarBottomPadding() - ((hotseatQsbHeight - hotseatCellHeightPx) / 2);
1272 } else if (isTaskbarPresent) { // QSB on top
1273 return hotseatBarSizePx - hotseatQsbHeight + hotseatQsbShadowHeight;
Jonathan Miranda8f16a772021-07-23 23:10:37 +00001274 } else {
Thales Limab8c05952022-05-23 16:58:38 +01001275 return hotseatBarBottomSpacePx - hotseatQsbShadowHeight;
Jonathan Miranda7a273e22021-06-24 21:29:10 +00001276 }
Sunny Goyal57b22792021-05-25 14:35:01 -07001277 }
1278
Thales Limab8c05952022-05-23 16:58:38 +01001279 /**
1280 * Returns the number of pixels the hotseat is translated from the bottom of the screen.
1281 */
1282 private int getHotseatBarBottomPadding() {
1283 if (isTaskbarPresent) { // QSB on top or inline
1284 return hotseatBarBottomSpacePx - (Math.abs(hotseatCellHeightPx - iconSizePx) / 2);
Thales Limaa1012902022-01-13 17:58:42 +00001285 } else {
Thales Limab8c05952022-05-23 16:58:38 +01001286 return hotseatBarSizePx - hotseatCellHeightPx;
Thales Limaa1012902022-01-13 17:58:42 +00001287 }
Sunny Goyal57b22792021-05-25 14:35:01 -07001288 }
1289
1290 /**
Alex Chau51da2192022-05-20 13:32:10 +01001291 * Returns the number of pixels the taskbar is translated from the bottom of the screen.
1292 */
1293 public int getTaskbarOffsetY() {
1294 int taskbarIconBottomSpace = (taskbarSize - iconSizePx) / 2;
1295 int launcherIconBottomSpace =
1296 Math.min((hotseatCellHeightPx - iconSizePx) / 2, gridVisualizationPaddingY);
Thales Limab8c05952022-05-23 16:58:38 +01001297 return getHotseatBarBottomPadding() + launcherIconBottomSpace - taskbarIconBottomSpace;
Alex Chau51da2192022-05-20 13:32:10 +01001298 }
1299
1300 /**
Alex Chaua2fc7642022-04-21 14:20:23 +01001301 * Returns the number of pixels required below OverviewActions excluding insets.
1302 */
1303 public int getOverviewActionsClaimedSpaceBelow() {
Alex Chau8949c582022-10-07 12:31:20 +01001304 if (isTaskbarPresent && !isGestureMode
1305 // If taskbar is in overview, overview action has dedicated space above nav buttons
1306 && !FeatureFlags.ENABLE_TASKBAR_IN_OVERVIEW.get()) {
Alex Chaua2fc7642022-04-21 14:20:23 +01001307 // Align vertically to where nav buttons are.
Thales Limab8c05952022-05-23 16:58:38 +01001308 return ((taskbarSize - overviewActionsHeight) / 2) + getTaskbarOffsetY();
Alex Chaua2fc7642022-04-21 14:20:23 +01001309 }
1310
Alex Chaud67ddc42022-09-30 18:15:56 +01001311 if (isTaskbarPresent) {
1312 return FeatureFlags.ENABLE_TASKBAR_IN_OVERVIEW.get() ? taskbarSize : stashedTaskbarSize;
1313 }
1314 return mInsets.bottom;
Alex Chaua2fc7642022-04-21 14:20:23 +01001315 }
1316
1317 /** Gets the space that the overview actions will take, including bottom margin. */
1318 public int getOverviewActionsClaimedSpace() {
1319 return overviewActionsTopMarginPx + overviewActionsHeight
1320 + getOverviewActionsClaimedSpaceBelow();
1321 }
1322
1323 /**
Sihua Mae04aa202022-07-18 12:43:56 -07001324 * Takes the View and return the scales of width and height depending on the DeviceProfile
1325 * specifications
1326 *
1327 * @param itemInfo The tag of the widget view
1328 * @return A PointF instance with the x set to be the scale of width, and y being the scale of
1329 * height
1330 */
1331 @NonNull
1332 public PointF getAppWidgetScale(@Nullable final ItemInfo itemInfo) {
1333 return mViewScaleProvider.getScaleFromItemInfo(itemInfo);
1334 }
1335
1336 /**
Winsonfadbe8f2016-07-22 16:35:37 -07001337 * @return the bounds for which the open folders should be contained within
1338 */
1339 public Rect getAbsoluteOpenFolderBounds() {
1340 if (isVerticalBarLayout()) {
1341 // Folders should only appear right of the drop target bar and left of the hotseat
1342 return new Rect(mInsets.left + dropTargetBarSizePx + edgeMarginPx,
1343 mInsets.top,
Jon Miranda18751b62017-07-31 17:25:27 -07001344 mInsets.left + availableWidthPx - hotseatBarSizePx - edgeMarginPx,
Winsonfadbe8f2016-07-22 16:35:37 -07001345 mInsets.top + availableHeightPx);
1346 } else {
1347 // Folders should only appear below the drop target bar and above the hotseat
Tony Wickhamae72b462021-03-10 16:18:40 -08001348 int hotseatTop = isTaskbarPresent ? taskbarSize : hotseatBarSizePx;
Tony Wickhamb4b7e202018-01-12 17:39:24 -08001349 return new Rect(mInsets.left + edgeMarginPx,
Winsonfadbe8f2016-07-22 16:35:37 -07001350 mInsets.top + dropTargetBarSizePx + edgeMarginPx,
Tony Wickhamb4b7e202018-01-12 17:39:24 -08001351 mInsets.left + availableWidthPx - edgeMarginPx,
Tony Wickhamae72b462021-03-10 16:18:40 -08001352 mInsets.top + availableHeightPx - hotseatTop
Tony Wickham5edf9e22020-03-27 20:06:52 -07001353 - workspacePageIndicatorHeight - edgeMarginPx);
Winsonfadbe8f2016-07-22 16:35:37 -07001354 }
1355 }
1356
Jon Miranda228877d2021-02-09 11:05:00 -05001357 public static int calculateCellWidth(int width, int borderSpacing, int countX) {
1358 return (width - ((countX - 1) * borderSpacing)) / countX;
Winson Chungb3800242013-10-24 11:01:54 -07001359 }
Pierre Barbier de Reuille578deba2021-09-24 13:47:44 +01001360
Jon Miranda228877d2021-02-09 11:05:00 -05001361 public static int calculateCellHeight(int height, int borderSpacing, int countY) {
1362 return (height - ((countY - 1) * borderSpacing)) / countY;
Winson Chungb3800242013-10-24 11:01:54 -07001363 }
1364
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -07001365 /**
Tony Wickham55616cd2015-09-23 14:55:17 -07001366 * When {@code true}, the device is in landscape mode and the hotseat is on the right column.
1367 * When {@code false}, either device is in portrait mode or the device is in landscape mode and
1368 * the hotseat is on the bottom row.
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -07001369 */
Tony Wickhamab946a12015-09-16 15:38:16 -07001370 public boolean isVerticalBarLayout() {
Winson Chungb3800242013-10-24 11:01:54 -07001371 return isLandscape && transposeLayoutWithOrientation;
1372 }
1373
Sunny Goyal59d086c2018-05-07 17:31:40 -07001374 /**
1375 * Updates orientation information and returns true if it has changed from the previous value.
1376 */
Winson Chung13c1c2c2019-09-06 11:46:19 -07001377 public boolean updateIsSeascape(Context context) {
Sunny Goyal59d086c2018-05-07 17:31:40 -07001378 if (isVerticalBarLayout()) {
Sunny Goyal35c7b192021-04-20 16:51:10 -07001379 boolean isSeascape = DisplayController.INSTANCE.get(context)
1380 .getInfo().rotation == Surface.ROTATION_270;
Sunny Goyal59d086c2018-05-07 17:31:40 -07001381 if (mIsSeascape != isSeascape) {
1382 mIsSeascape = isSeascape;
Pat Manning08610ca2022-04-05 21:03:16 +01001383 // Hotseat changing sides requires updating workspace left/right paddings
1384 updateWorkspacePadding();
Sunny Goyal59d086c2018-05-07 17:31:40 -07001385 return true;
1386 }
1387 }
1388 return false;
1389 }
1390
Sunny Goyal7e2e67f2018-01-26 13:40:08 -08001391 public boolean isSeascape() {
Sunny Goyal59d086c2018-05-07 17:31:40 -07001392 return isVerticalBarLayout() && mIsSeascape;
Sunny Goyal7e2e67f2018-01-26 13:40:08 -08001393 }
1394
Sunny Goyal07b69292018-01-08 14:19:34 -08001395 public boolean shouldFadeAdjacentWorkspaceScreens() {
Sunny Goyal19ff7282021-04-22 10:12:54 -07001396 return isVerticalBarLayout();
Winson Chungb3800242013-10-24 11:01:54 -07001397 }
1398
Jon Miranda92c1b5d2021-07-20 13:57:16 -07001399 public int getCellContentHeight(@ContainerType int containerType) {
Sunny Goyalc13403c2016-11-18 23:44:48 -08001400 switch (containerType) {
1401 case CellLayout.WORKSPACE:
1402 return cellHeightPx;
1403 case CellLayout.FOLDER:
1404 return folderCellHeightPx;
1405 case CellLayout.HOTSEAT:
Jon Miranda92c1b5d2021-07-20 13:57:16 -07001406 // The hotseat is the only container where the cell height is going to be
1407 // different from the content within that cell.
1408 return iconSizePx;
Sunny Goyalc13403c2016-11-18 23:44:48 -08001409 default:
1410 // ??
1411 return 0;
1412 }
1413 }
Sunny Goyal13178ac2016-04-04 16:35:22 -07001414
Jon Miranda58561d42021-03-17 10:51:54 -04001415 private String pxToDpStr(String name, float value) {
Sunny Goyal35c7b192021-04-20 16:51:10 -07001416 return "\t" + name + ": " + value + "px (" + dpiFromPx(value, mMetrics.densityDpi) + "dp)";
Jon Miranda58561d42021-03-17 10:51:54 -04001417 }
1418
Alex Chaue818bcb2022-09-02 17:27:11 +01001419 private String dpPointFToString(String name, PointF value) {
1420 return String.format(Locale.ENGLISH, "\t%s: PointF(%.1f, %.1f)dp", name, value.x, value.y);
1421 }
1422
Pat Manning5f74bfd2022-07-20 12:08:54 +01001423 /** Dumps various DeviceProfile variables to the specified writer. */
1424 public void dump(Context context, String prefix, PrintWriter writer) {
Jon Miranda58561d42021-03-17 10:51:54 -04001425 writer.println(prefix + "DeviceProfile:");
Sunny Goyal35c7b192021-04-20 16:51:10 -07001426 writer.println(prefix + "\t1 dp = " + mMetrics.density + " px");
Jon Miranda58561d42021-03-17 10:51:54 -04001427
1428 writer.println(prefix + "\tisTablet:" + isTablet);
Jon Miranda58561d42021-03-17 10:51:54 -04001429 writer.println(prefix + "\tisPhone:" + isPhone);
1430 writer.println(prefix + "\ttransposeLayoutWithOrientation:"
1431 + transposeLayoutWithOrientation);
Alex Chau6ed408f2022-03-04 12:58:05 +00001432 writer.println(prefix + "\tisGestureMode:" + isGestureMode);
Jon Miranda58561d42021-03-17 10:51:54 -04001433
1434 writer.println(prefix + "\tisLandscape:" + isLandscape);
1435 writer.println(prefix + "\tisMultiWindowMode:" + isMultiWindowMode);
Sunny Goyal19ff7282021-04-22 10:12:54 -07001436 writer.println(prefix + "\tisTwoPanels:" + isTwoPanels);
Jon Miranda58561d42021-03-17 10:51:54 -04001437
1438 writer.println(prefix + pxToDpStr("windowX", windowX));
1439 writer.println(prefix + pxToDpStr("windowY", windowY));
1440 writer.println(prefix + pxToDpStr("widthPx", widthPx));
1441 writer.println(prefix + pxToDpStr("heightPx", heightPx));
Jon Miranda58561d42021-03-17 10:51:54 -04001442 writer.println(prefix + pxToDpStr("availableWidthPx", availableWidthPx));
1443 writer.println(prefix + pxToDpStr("availableHeightPx", availableHeightPx));
Alex Chaue0227552022-04-06 19:44:43 +01001444 writer.println(prefix + pxToDpStr("mInsets.left", mInsets.left));
1445 writer.println(prefix + pxToDpStr("mInsets.top", mInsets.top));
1446 writer.println(prefix + pxToDpStr("mInsets.right", mInsets.right));
1447 writer.println(prefix + pxToDpStr("mInsets.bottom", mInsets.bottom));
Jon Miranda58561d42021-03-17 10:51:54 -04001448
1449 writer.println(prefix + "\taspectRatio:" + aspectRatio);
1450
1451 writer.println(prefix + "\tisScalableGrid:" + isScalableGrid);
1452
Thales Lima83bedbf2021-10-05 17:47:39 +01001453 writer.println(prefix + "\tinv.numRows: " + inv.numRows);
Alex Chau9fee3fd2021-12-01 18:43:10 +00001454 writer.println(prefix + "\tinv.numColumns: " + inv.numColumns);
1455 writer.println(prefix + "\tinv.numSearchContainerColumns: "
1456 + inv.numSearchContainerColumns);
Jon Miranda58561d42021-03-17 10:51:54 -04001457
Alex Chaue818bcb2022-09-02 17:27:11 +01001458 writer.println(prefix + dpPointFToString("minCellSize", inv.minCellSize[mTypeIndex]));
Jon Mirandaab3c6812021-06-28 15:42:28 -07001459
Jon Miranda58561d42021-03-17 10:51:54 -04001460 writer.println(prefix + pxToDpStr("cellWidthPx", cellWidthPx));
1461 writer.println(prefix + pxToDpStr("cellHeightPx", cellHeightPx));
1462
1463 writer.println(prefix + pxToDpStr("getCellSize().x", getCellSize().x));
1464 writer.println(prefix + pxToDpStr("getCellSize().y", getCellSize().y));
1465
Thales Lima83bedbf2021-10-05 17:47:39 +01001466 writer.println(prefix + pxToDpStr("cellLayoutBorderSpacePx Horizontal",
1467 cellLayoutBorderSpacePx.x));
1468 writer.println(prefix + pxToDpStr("cellLayoutBorderSpacePx Vertical",
1469 cellLayoutBorderSpacePx.y));
Pat Manning5f74bfd2022-07-20 12:08:54 +01001470 writer.println(
1471 prefix + pxToDpStr("cellLayoutPaddingPx.left", cellLayoutPaddingPx.left));
1472 writer.println(
1473 prefix + pxToDpStr("cellLayoutPaddingPx.top", cellLayoutPaddingPx.top));
1474 writer.println(
1475 prefix + pxToDpStr("cellLayoutPaddingPx.right", cellLayoutPaddingPx.right));
Pat Manning08610ca2022-04-05 21:03:16 +01001476 writer.println(
1477 prefix + pxToDpStr("cellLayoutPaddingPx.bottom", cellLayoutPaddingPx.bottom));
Thales Lima83bedbf2021-10-05 17:47:39 +01001478
Jon Miranda58561d42021-03-17 10:51:54 -04001479 writer.println(prefix + pxToDpStr("iconSizePx", iconSizePx));
1480 writer.println(prefix + pxToDpStr("iconTextSizePx", iconTextSizePx));
1481 writer.println(prefix + pxToDpStr("iconDrawablePaddingPx", iconDrawablePaddingPx));
1482
1483 writer.println(prefix + pxToDpStr("folderCellWidthPx", folderCellWidthPx));
1484 writer.println(prefix + pxToDpStr("folderCellHeightPx", folderCellHeightPx));
1485 writer.println(prefix + pxToDpStr("folderChildIconSizePx", folderChildIconSizePx));
1486 writer.println(prefix + pxToDpStr("folderChildTextSizePx", folderChildTextSizePx));
1487 writer.println(prefix + pxToDpStr("folderChildDrawablePaddingPx",
1488 folderChildDrawablePaddingPx));
Thales Limab35faed2022-09-05 16:30:01 -03001489 writer.println(prefix + pxToDpStr("folderCellLayoutBorderSpacePx",
1490 folderCellLayoutBorderSpacePx));
Thales Limaa08a4432022-08-09 09:55:17 +01001491 writer.println(prefix + pxToDpStr("folderContentPaddingLeftRight",
1492 folderContentPaddingLeftRight));
1493 writer.println(prefix + pxToDpStr("folderTopPadding", folderContentPaddingTop));
Thales Limab35faed2022-09-05 16:30:01 -03001494 writer.println(prefix + pxToDpStr("folderFooterHeight", folderFooterHeightPx));
Jon Miranda58561d42021-03-17 10:51:54 -04001495
Alex Chaue0227552022-04-06 19:44:43 +01001496 writer.println(prefix + pxToDpStr("bottomSheetTopPadding", bottomSheetTopPadding));
Alex Chau3d2c0622022-09-01 21:28:14 +01001497 writer.println(prefix + "\tbottomSheetOpenDuration: " + bottomSheetOpenDuration);
1498 writer.println(prefix + "\tbottomSheetCloseDuration: " + bottomSheetCloseDuration);
1499 writer.println(prefix + "\tbottomSheetWorkspaceScale: " + bottomSheetWorkspaceScale);
1500 writer.println(prefix + "\tbottomSheetDepth: " + bottomSheetDepth);
Alex Chaue0227552022-04-06 19:44:43 +01001501
1502 writer.println(prefix + pxToDpStr("allAppsShiftRange", allAppsShiftRange));
1503 writer.println(prefix + pxToDpStr("allAppsTopPadding", allAppsTopPadding));
Alex Chau3d2c0622022-09-01 21:28:14 +01001504 writer.println(prefix + "\tallAppsOpenDuration: " + allAppsOpenDuration);
1505 writer.println(prefix + "\tallAppsCloseDuration: " + allAppsCloseDuration);
Jon Miranda58561d42021-03-17 10:51:54 -04001506 writer.println(prefix + pxToDpStr("allAppsIconSizePx", allAppsIconSizePx));
1507 writer.println(prefix + pxToDpStr("allAppsIconTextSizePx", allAppsIconTextSizePx));
1508 writer.println(prefix + pxToDpStr("allAppsIconDrawablePaddingPx",
1509 allAppsIconDrawablePaddingPx));
1510 writer.println(prefix + pxToDpStr("allAppsCellHeightPx", allAppsCellHeightPx));
Alex Chau27b39b92022-01-14 18:02:18 +00001511 writer.println(prefix + pxToDpStr("allAppsCellWidthPx", allAppsCellWidthPx));
Pat Manning26f70f72022-07-07 13:50:39 +01001512 writer.println(prefix + pxToDpStr("allAppsBorderSpacePxX", allAppsBorderSpacePx.x));
1513 writer.println(prefix + pxToDpStr("allAppsBorderSpacePxY", allAppsBorderSpacePx.y));
Sunny Goyal19ff7282021-04-22 10:12:54 -07001514 writer.println(prefix + "\tnumShownAllAppsColumns: " + numShownAllAppsColumns);
Alex Chau62572c02022-07-25 18:36:37 +00001515 writer.println(prefix + pxToDpStr("allAppsLeftRightPadding", allAppsLeftRightPadding));
Alex Chau27b39b92022-01-14 18:02:18 +00001516 writer.println(prefix + pxToDpStr("allAppsLeftRightMargin", allAppsLeftRightMargin));
Jon Miranda58561d42021-03-17 10:51:54 -04001517
1518 writer.println(prefix + pxToDpStr("hotseatBarSizePx", hotseatBarSizePx));
Thales Lima425f6822022-05-10 13:44:58 -03001519 writer.println(prefix + "\tinv.hotseatColumnSpan: " + inv.hotseatColumnSpan[mTypeIndex]);
Jon Miranda58561d42021-03-17 10:51:54 -04001520 writer.println(prefix + pxToDpStr("hotseatCellHeightPx", hotseatCellHeightPx));
Alex Chau62572c02022-07-25 18:36:37 +00001521 writer.println(prefix + pxToDpStr("hotseatBarBottomSpacePx", hotseatBarBottomSpacePx));
Jon Miranda58561d42021-03-17 10:51:54 -04001522 writer.println(prefix + pxToDpStr("hotseatBarSidePaddingStartPx",
1523 hotseatBarSidePaddingStartPx));
1524 writer.println(prefix + pxToDpStr("hotseatBarSidePaddingEndPx",
1525 hotseatBarSidePaddingEndPx));
Pat Manning26f70f72022-07-07 13:50:39 +01001526 writer.println(prefix + pxToDpStr("hotseatBarEndOffset", hotseatBarEndOffset));
Thales Limab8c05952022-05-23 16:58:38 +01001527 writer.println(prefix + pxToDpStr("hotseatQsbSpace", hotseatQsbSpace));
1528 writer.println(prefix + pxToDpStr("hotseatQsbHeight", hotseatQsbHeight));
Pat Manningde25c0d2022-04-05 19:11:26 +01001529 writer.println(prefix + pxToDpStr("springLoadedHotseatBarTopMarginPx",
1530 springLoadedHotseatBarTopMarginPx));
Pat Manning5f74bfd2022-07-20 12:08:54 +01001531 Rect hotseatLayoutPadding = getHotseatLayoutPadding(context);
1532 writer.println(prefix + pxToDpStr("getHotseatLayoutPadding(context).top",
1533 hotseatLayoutPadding.top));
1534 writer.println(prefix + pxToDpStr("getHotseatLayoutPadding(context).bottom",
1535 hotseatLayoutPadding.bottom));
1536 writer.println(prefix + pxToDpStr("getHotseatLayoutPadding(context).left",
1537 hotseatLayoutPadding.left));
1538 writer.println(prefix + pxToDpStr("getHotseatLayoutPadding(context).right",
1539 hotseatLayoutPadding.right));
Sunny Goyal19ff7282021-04-22 10:12:54 -07001540 writer.println(prefix + "\tnumShownHotseatIcons: " + numShownHotseatIcons);
Thales Lima116b51a2022-02-03 16:19:47 +00001541 writer.println(prefix + pxToDpStr("hotseatBorderSpace", hotseatBorderSpace));
Thales Limaa1012902022-01-13 17:58:42 +00001542 writer.println(prefix + "\tisQsbInline: " + isQsbInline);
Alex Chau206ede92022-08-01 17:46:12 +01001543 writer.println(prefix + pxToDpStr("hotseatQsbWidth", hotseatQsbWidth));
Jon Miranda58561d42021-03-17 10:51:54 -04001544
1545 writer.println(prefix + "\tisTaskbarPresent:" + isTaskbarPresent);
Tony Wickham635e1802021-07-22 14:28:04 -10001546 writer.println(prefix + "\tisTaskbarPresentInApps:" + isTaskbarPresentInApps);
Jon Miranda58561d42021-03-17 10:51:54 -04001547 writer.println(prefix + pxToDpStr("taskbarSize", taskbarSize));
Jon Miranda58561d42021-03-17 10:51:54 -04001548
Thales Lima83bedbf2021-10-05 17:47:39 +01001549 writer.println(prefix + pxToDpStr("desiredWorkspaceHorizontalMarginPx",
1550 desiredWorkspaceHorizontalMarginPx));
Jon Miranda58561d42021-03-17 10:51:54 -04001551 writer.println(prefix + pxToDpStr("workspacePadding.left", workspacePadding.left));
1552 writer.println(prefix + pxToDpStr("workspacePadding.top", workspacePadding.top));
1553 writer.println(prefix + pxToDpStr("workspacePadding.right", workspacePadding.right));
Alex Chau62572c02022-07-25 18:36:37 +00001554 writer.println(prefix + pxToDpStr("workspacePadding.bottom", workspacePadding.bottom));
Jon Miranda58561d42021-03-17 10:51:54 -04001555
Jon Mirandaab3c6812021-06-28 15:42:28 -07001556 writer.println(prefix + pxToDpStr("iconScale", iconScale));
1557 writer.println(prefix + pxToDpStr("cellScaleToFit ", cellScaleToFit));
Jon Miranda58561d42021-03-17 10:51:54 -04001558 writer.println(prefix + pxToDpStr("extraSpace", extraSpace));
Alex Chau62572c02022-07-25 18:36:37 +00001559 writer.println(prefix + pxToDpStr("unscaled extraSpace", extraSpace / iconScale));
Jon Mirandac9e69fa2021-03-22 17:13:34 -04001560
1561 if (inv.devicePaddings != null) {
1562 int unscaledExtraSpace = (int) (extraSpace / iconScale);
1563 writer.println(prefix + pxToDpStr("maxEmptySpace",
1564 inv.devicePaddings.getDevicePadding(unscaledExtraSpace).getMaxEmptySpacePx()));
1565 }
Jon Miranda58561d42021-03-17 10:51:54 -04001566 writer.println(prefix + pxToDpStr("workspaceTopPadding", workspaceTopPadding));
1567 writer.println(prefix + pxToDpStr("workspaceBottomPadding", workspaceBottomPadding));
Alex Chau635b3ab2022-01-26 16:49:10 +00001568
1569 writer.println(prefix + pxToDpStr("overviewTaskMarginPx", overviewTaskMarginPx));
Alex Chau635b3ab2022-01-26 16:49:10 +00001570 writer.println(prefix + pxToDpStr("overviewTaskIconSizePx", overviewTaskIconSizePx));
1571 writer.println(prefix + pxToDpStr("overviewTaskIconDrawableSizePx",
1572 overviewTaskIconDrawableSizePx));
1573 writer.println(prefix + pxToDpStr("overviewTaskIconDrawableSizeGridPx",
1574 overviewTaskIconDrawableSizeGridPx));
1575 writer.println(prefix + pxToDpStr("overviewTaskThumbnailTopMarginPx",
1576 overviewTaskThumbnailTopMarginPx));
Alex Chaua2fc7642022-04-21 14:20:23 +01001577 writer.println(prefix + pxToDpStr("overviewActionsTopMarginPx",
1578 overviewActionsTopMarginPx));
1579 writer.println(prefix + pxToDpStr("overviewActionsHeight",
1580 overviewActionsHeight));
Alex Chau635b3ab2022-01-26 16:49:10 +00001581 writer.println(prefix + pxToDpStr("overviewActionsButtonSpacing",
1582 overviewActionsButtonSpacing));
1583 writer.println(prefix + pxToDpStr("overviewPageSpacing", overviewPageSpacing));
1584 writer.println(prefix + pxToDpStr("overviewRowSpacing", overviewRowSpacing));
1585 writer.println(prefix + pxToDpStr("overviewGridSideMargin", overviewGridSideMargin));
Pat Manningde25c0d2022-04-05 19:11:26 +01001586
Alex Chau62572c02022-07-25 18:36:37 +00001587 writer.println(prefix + pxToDpStr("dropTargetBarTopMarginPx", dropTargetBarTopMarginPx));
Pat Manningde25c0d2022-04-05 19:11:26 +01001588 writer.println(prefix + pxToDpStr("dropTargetBarSizePx", dropTargetBarSizePx));
Alex Chau62572c02022-07-25 18:36:37 +00001589 writer.println(
1590 prefix + pxToDpStr("dropTargetBarBottomMarginPx", dropTargetBarBottomMarginPx));
Pat Manningde25c0d2022-04-05 19:11:26 +01001591
Pat Manning5f74bfd2022-07-20 12:08:54 +01001592 writer.println(prefix + pxToDpStr("getCellLayoutSpringLoadShrunkTop()",
1593 getCellLayoutSpringLoadShrunkTop()));
1594 writer.println(prefix + pxToDpStr("getCellLayoutSpringLoadShrunkBottom()",
1595 getCellLayoutSpringLoadShrunkBottom(context)));
Alex Chau906d8822022-05-23 10:42:25 +01001596 writer.println(prefix + pxToDpStr("workspaceSpringLoadedMinNextPageVisiblePx",
1597 workspaceSpringLoadedMinNextPageVisiblePx));
Pat Manning5f74bfd2022-07-20 12:08:54 +01001598 writer.println(prefix + pxToDpStr("getWorkspaceSpringLoadScale()",
1599 getWorkspaceSpringLoadScale(context)));
Thales Limab8c05952022-05-23 16:58:38 +01001600 writer.println(prefix + pxToDpStr("getCellLayoutHeight()", getCellLayoutHeight()));
1601 writer.println(prefix + pxToDpStr("getCellLayoutWidth()", getCellLayoutWidth()));
Jon Miranda58561d42021-03-17 10:51:54 -04001602 }
1603
Alex Chaua6907dc2022-03-18 15:24:07 +00001604 private static Context getContext(Context c, Info info, int orientation, WindowBounds bounds) {
Sunny Goyal1890f672020-04-30 12:28:00 -07001605 Configuration config = new Configuration(c.getResources().getConfiguration());
1606 config.orientation = orientation;
Thales Lima425f6822022-05-10 13:44:58 -03001607 config.densityDpi = info.getDensityDpi();
Alex Chaua6907dc2022-03-18 15:24:07 +00001608 config.smallestScreenWidthDp = (int) info.smallestSizeDp(bounds);
Sunny Goyal1890f672020-04-30 12:28:00 -07001609 return c.createConfigurationContext(config);
Jon Mirandab28c4fc2017-06-20 10:58:36 -07001610 }
Sunny Goyalfde55052018-02-01 14:46:13 -08001611
1612 /**
1613 * Callback when a component changes the DeviceProfile associated with it, as a result of
1614 * configuration change
1615 */
1616 public interface OnDeviceProfileChangeListener {
1617
1618 /**
1619 * Called when the device profile is reassigned. Note that for layout and measurements, it
1620 * is sufficient to listen for inset changes. Use this callback when you need to perform
1621 * a one time operation.
1622 */
1623 void onDeviceProfileChanged(DeviceProfile dp);
1624 }
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001625
Brian Isganitis099945b2022-01-31 18:15:00 -05001626 /** Allows registering listeners for {@link DeviceProfile} changes. */
1627 public interface DeviceProfileListenable {
1628
1629 /** The current device profile. */
1630 DeviceProfile getDeviceProfile();
1631
1632 /** Registered {@link OnDeviceProfileChangeListener} instances. */
1633 List<OnDeviceProfileChangeListener> getOnDeviceProfileChangeListeners();
1634
1635 /** Notifies listeners of a {@link DeviceProfile} change. */
1636 default void dispatchDeviceProfileChanged() {
1637 DeviceProfile deviceProfile = getDeviceProfile();
1638 List<OnDeviceProfileChangeListener> listeners = getOnDeviceProfileChangeListeners();
1639 for (int i = listeners.size() - 1; i >= 0; i--) {
1640 listeners.get(i).onDeviceProfileChanged(deviceProfile);
1641 }
1642 }
1643
1644 /** Register listener for {@link DeviceProfile} changes. */
1645 default void addOnDeviceProfileChangeListener(OnDeviceProfileChangeListener listener) {
1646 getOnDeviceProfileChangeListeners().add(listener);
1647 }
1648
1649 /** Unregister listener for {@link DeviceProfile} changes. */
1650 default void removeOnDeviceProfileChangeListener(OnDeviceProfileChangeListener listener) {
1651 getOnDeviceProfileChangeListeners().remove(listener);
1652 }
1653 }
1654
Sihua Mae04aa202022-07-18 12:43:56 -07001655 /**
1656 * Handler that deals with ItemInfo of the views for the DeviceProfile
1657 */
1658 @FunctionalInterface
1659 public interface ViewScaleProvider {
1660 /**
1661 * Get the scales from the view
1662 *
1663 * @param itemInfo The tag of the widget view
1664 * @return PointF instance containing the scale information, or null if using the default
1665 * app widget scale of this device profile.
1666 */
1667 @NonNull
1668 PointF getScaleFromItemInfo(@Nullable ItemInfo itemInfo);
1669 }
1670
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001671 public static class Builder {
1672 private Context mContext;
1673 private InvariantDeviceProfile mInv;
Sunny Goyalfd58da62020-08-11 12:06:49 -07001674 private Info mInfo;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001675
Sunny Goyal19ff7282021-04-22 10:12:54 -07001676 private WindowBounds mWindowBounds;
1677 private boolean mUseTwoPanels;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001678
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001679 private boolean mIsMultiWindowMode = false;
Sunny Goyal19ff7282021-04-22 10:12:54 -07001680 private Boolean mTransposeLayoutWithOrientation;
Alex Chau6ed408f2022-03-04 12:58:05 +00001681 private Boolean mIsGestureMode;
Sihua Mae04aa202022-07-18 12:43:56 -07001682 private ViewScaleProvider mViewScaleProvider = null;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001683
Sunny Goyal65190ae2022-08-02 14:16:26 -07001684 private SparseArray<DotRenderer> mDotRendererCache;
1685
Sunny Goyalfd58da62020-08-11 12:06:49 -07001686 public Builder(Context context, InvariantDeviceProfile inv, Info info) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001687 mContext = context;
1688 mInv = inv;
1689 mInfo = info;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001690 }
1691
1692 public Builder setMultiWindowMode(boolean isMultiWindowMode) {
1693 mIsMultiWindowMode = isMultiWindowMode;
1694 return this;
1695 }
1696
Sunny Goyal19ff7282021-04-22 10:12:54 -07001697 public Builder setUseTwoPanels(boolean useTwoPanels) {
1698 mUseTwoPanels = useTwoPanels;
1699 return this;
1700 }
1701
Sunny Goyal65190ae2022-08-02 14:16:26 -07001702 public Builder setDotRendererCache(SparseArray<DotRenderer> dotRendererCache) {
1703 mDotRendererCache = dotRendererCache;
1704 return this;
1705 }
Sunny Goyal19ff7282021-04-22 10:12:54 -07001706
1707 public Builder setWindowBounds(WindowBounds bounds) {
1708 mWindowBounds = bounds;
Sunny Goyal0addbf02020-04-28 14:17:35 -07001709 return this;
1710 }
1711
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001712 public Builder setTransposeLayoutWithOrientation(boolean transposeLayoutWithOrientation) {
1713 mTransposeLayoutWithOrientation = transposeLayoutWithOrientation;
1714 return this;
1715 }
1716
Alex Chau6ed408f2022-03-04 12:58:05 +00001717 public Builder setGestureMode(boolean isGestureMode) {
1718 mIsGestureMode = isGestureMode;
1719 return this;
1720 }
1721
Sihua Mae04aa202022-07-18 12:43:56 -07001722 /**
1723 * Set the viewScaleProvider for the builder
1724 *
1725 * @param viewScaleProvider The viewScaleProvider to be set for the
1726 * DeviceProfile
1727 * @return This builder
1728 */
1729 @NonNull
1730 public Builder setViewScaleProvider(@Nullable ViewScaleProvider viewScaleProvider) {
1731 mViewScaleProvider = viewScaleProvider;
1732 return this;
1733 }
1734
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001735 public DeviceProfile build() {
Sunny Goyal19ff7282021-04-22 10:12:54 -07001736 if (mWindowBounds == null) {
1737 throw new IllegalArgumentException("Window bounds not set");
1738 }
1739 if (mTransposeLayoutWithOrientation == null) {
1740 mTransposeLayoutWithOrientation = !mInfo.isTablet(mWindowBounds);
1741 }
Alex Chau6ed408f2022-03-04 12:58:05 +00001742 if (mIsGestureMode == null) {
Alex Chaue818bcb2022-09-02 17:27:11 +01001743 mIsGestureMode = mInfo.navigationMode.hasGestures;
Alex Chau6ed408f2022-03-04 12:58:05 +00001744 }
Sunny Goyal65190ae2022-08-02 14:16:26 -07001745 if (mDotRendererCache == null) {
1746 mDotRendererCache = new SparseArray<>();
1747 }
Sihua Mae04aa202022-07-18 12:43:56 -07001748 if (mViewScaleProvider == null) {
1749 mViewScaleProvider = DEFAULT_PROVIDER;
1750 }
Sunny Goyal65190ae2022-08-02 14:16:26 -07001751 return new DeviceProfile(mContext, mInv, mInfo, mWindowBounds, mDotRendererCache,
1752 mIsMultiWindowMode, mTransposeLayoutWithOrientation, mUseTwoPanels,
Sihua Mae04aa202022-07-18 12:43:56 -07001753 mIsGestureMode, mViewScaleProvider);
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001754 }
1755 }
1756
Winson Chungb3800242013-10-24 11:01:54 -07001757}