blob: 572b3c2d979a88a92f8084ce7ac113b6c9fe9ca8 [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
Jon Mirandae126d722021-02-25 10:45:20 -050019import static com.android.launcher3.ResourceUtils.pxFromDp;
Jon Miranda58561d42021-03-17 10:51:54 -040020import static com.android.launcher3.Utilities.dpiFromPx;
Jon Mirandaaf3aed02021-05-06 18:28:45 -070021import static com.android.launcher3.Utilities.pxFromSp;
Jon Miranda92c1b5d2021-07-20 13:57:16 -070022import static com.android.launcher3.folder.ClippedFolderIconLayoutRule.ICON_OVERLAP_FACTOR;
Jon Miranda228877d2021-02-09 11:05:00 -050023
Sunny Goyal35c7b192021-04-20 16:51:10 -070024import android.annotation.SuppressLint;
Winson Chungb3800242013-10-24 11:01:54 -070025import android.content.Context;
Jon Mirandab28c4fc2017-06-20 10:58:36 -070026import android.content.res.Configuration;
Winson Chungb3800242013-10-24 11:01:54 -070027import android.content.res.Resources;
Sunny Goyal8b9919d2021-04-07 14:45:17 -070028import android.graphics.Path;
Winson Chungb3800242013-10-24 11:01:54 -070029import android.graphics.Point;
Jon Miranda7ae64ff2016-11-21 16:18:46 -080030import android.graphics.PointF;
Winson Chungb3800242013-10-24 11:01:54 -070031import android.graphics.Rect;
Sunny Goyal35c7b192021-04-20 16:51:10 -070032import android.util.DisplayMetrics;
Sunny Goyal59d086c2018-05-07 17:31:40 -070033import android.view.Surface;
Winson Chungb3800242013-10-24 11:01:54 -070034
Sunny Goyalc13403c2016-11-18 23:44:48 -080035import com.android.launcher3.CellLayout.ContainerType;
Jon Miranda228877d2021-02-09 11:05:00 -050036import com.android.launcher3.DevicePaddings.DevicePadding;
Tony Wickham15883892021-02-12 11:24:40 -080037import com.android.launcher3.config.FeatureFlags;
Tony Wickham8912b042018-11-29 15:28:53 -080038import com.android.launcher3.icons.DotRenderer;
Sunny Goyal8b9919d2021-04-07 14:45:17 -070039import com.android.launcher3.icons.GraphicsUtils;
Hyunyoung Song48cb7bc2018-09-25 17:03:34 -070040import com.android.launcher3.icons.IconNormalizer;
Sunny Goyal57b22792021-05-25 14:35:01 -070041import com.android.launcher3.uioverrides.ApiWrapper;
Sunny Goyalfd58da62020-08-11 12:06:49 -070042import com.android.launcher3.util.DisplayController;
43import com.android.launcher3.util.DisplayController.Info;
Sunny Goyalb46703d2020-05-27 17:52:03 -070044import com.android.launcher3.util.WindowBounds;
Winson1f064272016-07-18 17:18:02 -070045
Jon Miranda58561d42021-03-17 10:51:54 -040046import java.io.PrintWriter;
47
Sunny Goyal35c7b192021-04-20 16:51:10 -070048@SuppressLint("NewApi")
Winson Chungb3800242013-10-24 11:01:54 -070049public class DeviceProfile {
Adam Cohen2e6da152015-05-06 11:42:25 -070050
Sunny Goyal8b9919d2021-04-07 14:45:17 -070051 private static final int DEFAULT_DOT_SIZE = 100;
Sunny Goyal57b22792021-05-25 14:35:01 -070052 // Ratio of empty space, qsb should take up to appear visually centered.
Pratyush9afe1ea2021-10-13 11:13:27 +000053 private final float mQsbCenterFactor;
Sunny Goyal1890f672020-04-30 12:28:00 -070054
Adam Cohen2e6da152015-05-06 11:42:25 -070055 public final InvariantDeviceProfile inv;
Sunny Goyalfd58da62020-08-11 12:06:49 -070056 private final Info mInfo;
Sunny Goyal35c7b192021-04-20 16:51:10 -070057 private final DisplayMetrics mMetrics;
Winson Chungbe876472014-05-14 14:15:20 -070058
Sunny Goyalc6205602015-05-21 20:46:33 -070059 // Device properties
60 public final boolean isTablet;
Sunny Goyalc6205602015-05-21 20:46:33 -070061 public final boolean isPhone;
62 public final boolean transposeLayoutWithOrientation;
Sunny Goyal19ff7282021-04-22 10:12:54 -070063 public final boolean isTwoPanels;
Thales Limaa1012902022-01-13 17:58:42 +000064 public final boolean isQsbInline;
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -070065
Sunny Goyalc6205602015-05-21 20:46:33 -070066 // Device properties in current orientation
Sunny Goyald792a772018-04-05 13:37:46 -070067 public final boolean isLandscape;
Sunny Goyald70e75a2018-02-22 10:07:32 -080068 public final boolean isMultiWindowMode;
69
Sunny Goyal0addbf02020-04-28 14:17:35 -070070 public final int windowX;
71 public final int windowY;
Sunny Goyalc6205602015-05-21 20:46:33 -070072 public final int widthPx;
73 public final int heightPx;
74 public final int availableWidthPx;
75 public final int availableHeightPx;
Jon Mirandabba64512019-03-27 10:54:17 -070076
77 public final float aspectRatio;
78
Jon Mirandae126d722021-02-25 10:45:20 -050079 public final boolean isScalableGrid;
Thales Lima83bedbf2021-10-05 17:47:39 +010080 private final int mTypeIndex;
Jon Mirandae126d722021-02-25 10:45:20 -050081
Tony Wickhamd6b40372015-09-23 18:37:57 -070082 /**
83 * The maximum amount of left/right workspace padding as a percentage of the screen width.
84 * To be clear, this means that up to 7% of the screen width can be used as left padding, and
85 * 7% of the screen width can be used as right padding.
86 */
87 private static final float MAX_HORIZONTAL_PADDING_PERCENT = 0.14f;
Winson Chungb3800242013-10-24 11:01:54 -070088
Jon Miranda3f9bab22017-07-28 14:50:17 -070089 private static final float TALL_DEVICE_ASPECT_RATIO_THRESHOLD = 2.0f;
Jon Miranda80cddbc2021-07-22 13:51:16 -070090 private static final float TALLER_DEVICE_ASPECT_RATIO_THRESHOLD = 2.15f;
Jon Miranda80dda302021-07-28 14:14:59 -070091 private static final float TALL_DEVICE_EXTRA_SPACE_THRESHOLD_DP = 252;
92 private static final float TALL_DEVICE_MORE_EXTRA_SPACE_THRESHOLD_DP = 268;
Jon Miranda30d0aa22017-07-25 15:55:29 -070093
Jon Miranda5eacbb72018-07-31 11:14:46 -070094 // To evenly space the icons, increase the left/right margins for tablets in portrait mode.
95 private static final int PORTRAIT_TABLET_LEFT_RIGHT_PADDING_MULTIPLIER = 4;
96
Sunny Goyalc6205602015-05-21 20:46:33 -070097 // Workspace
Thales Limad90faab2021-09-21 17:18:47 +010098 public final int desiredWorkspaceHorizontalMarginOriginalPx;
99 public int desiredWorkspaceHorizontalMarginPx;
Thales Lima78d00ad2021-09-30 11:29:06 +0100100 public Point cellLayoutBorderSpaceOriginalPx;
101 public Point cellLayoutBorderSpacePx;
Jon Miranda28032002017-07-13 16:18:56 -0700102 public final int cellLayoutPaddingLeftRightPx;
Jon Miranda18751b62017-07-31 17:25:27 -0700103 public final int cellLayoutBottomPaddingPx;
Sunny Goyalc6205602015-05-21 20:46:33 -0700104 public final int edgeMarginPx;
Sunny Goyal47328fd2016-05-25 18:56:41 -0700105 public float workspaceSpringLoadShrinkFactor;
106 public final int workspaceSpringLoadedBottomSpace;
Sunny Goyalc6205602015-05-21 20:46:33 -0700107
Jon Miranda58561d42021-03-17 10:51:54 -0400108 private final int extraSpace;
Jon Miranda228877d2021-02-09 11:05:00 -0500109 public int workspaceTopPadding;
110 public int workspaceBottomPadding;
Jon Miranda58561d42021-03-17 10:51:54 -0400111 public int extraHotseatBottomPadding;
Jon Miranda228877d2021-02-09 11:05:00 -0500112
Tony Wickham5edf9e22020-03-27 20:06:52 -0700113 // Workspace page indicator
114 public final int workspacePageIndicatorHeight;
115 private final int mWorkspacePageIndicatorOverlapWorkspace;
Winson1f064272016-07-18 17:18:02 -0700116
Sunny Goyalc6205602015-05-21 20:46:33 -0700117 // Workspace icons
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400118 public float iconScale;
Sunny Goyalc6205602015-05-21 20:46:33 -0700119 public int iconSizePx;
120 public int iconTextSizePx;
121 public int iconDrawablePaddingPx;
Winson Chung5f4e0fd2015-05-22 11:12:27 -0700122 public int iconDrawablePaddingOriginalPx;
Winson Chungb3800242013-10-24 11:01:54 -0700123
Jon Mirandaab3c6812021-06-28 15:42:28 -0700124 public float cellScaleToFit;
Adam Cohen59400422014-03-05 18:07:04 -0800125 public int cellWidthPx;
126 public int cellHeightPx;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700127 public int workspaceCellPaddingXPx;
Adam Cohen59400422014-03-05 18:07:04 -0800128
Jon Mirandae126d722021-02-25 10:45:20 -0500129 public int cellYPaddingPx;
Jon Mirandae126d722021-02-25 10:45:20 -0500130
Sunny Goyalc6205602015-05-21 20:46:33 -0700131 // Folder
Jon Mirandae126d722021-02-25 10:45:20 -0500132 public float folderLabelTextScale;
133 public int folderLabelTextSizePx;
Sunny Goyalc6205602015-05-21 20:46:33 -0700134 public int folderIconSizePx;
Jon Miranda591e3602018-03-28 11:37:00 -0700135 public int folderIconOffsetYPx;
Jon Mirandabf7d8122016-11-03 15:29:29 -0700136
Jon Mirandae126d722021-02-25 10:45:20 -0500137 // Folder content
Thales Lima78d00ad2021-09-30 11:29:06 +0100138 public Point folderCellLayoutBorderSpacePx;
139 public int folderCellLayoutBorderSpaceOriginalPx;
Jon Mirandae126d722021-02-25 10:45:20 -0500140 public int folderContentPaddingLeftRight;
141 public int folderContentPaddingTop;
142
Jon Mirandabf7d8122016-11-03 15:29:29 -0700143 // Folder cell
Sunny Goyalc6205602015-05-21 20:46:33 -0700144 public int folderCellWidthPx;
145 public int folderCellHeightPx;
Jon Mirandabf7d8122016-11-03 15:29:29 -0700146
147 // Folder child
148 public int folderChildIconSizePx;
149 public int folderChildTextSizePx;
Sunny Goyalbaec6ff2016-09-14 11:26:21 -0700150 public int folderChildDrawablePaddingPx;
Winson Chungb3800242013-10-24 11:01:54 -0700151
Sunny Goyalc6205602015-05-21 20:46:33 -0700152 // Hotseat
Jon Miranda80cddbc2021-07-22 13:51:16 -0700153 public int hotseatBarSizeExtraSpacePx;
Tony Wickhamb87f3cd2021-04-07 15:02:37 -0700154 public final int numShownHotseatIcons;
Sunny Goyalc6205602015-05-21 20:46:33 -0700155 public int hotseatCellHeightPx;
Jon Miranda0d284852021-06-22 14:50:55 -0700156 private final int hotseatExtraVerticalSize;
Jon Miranda18751b62017-07-31 17:25:27 -0700157 // In portrait: size = height, in landscape: size = width
158 public int hotseatBarSizePx;
Jon Miranda80cddbc2021-07-22 13:51:16 -0700159 public int hotseatBarTopPaddingPx;
Jon Miranda0d284852021-06-22 14:50:55 -0700160 public final int hotseatBarBottomPaddingPx;
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700161 // Start is the side next to the nav bar, end is the side next to the workspace
162 public final int hotseatBarSidePaddingStartPx;
163 public final int hotseatBarSidePaddingEndPx;
Sunny Goyal57b22792021-05-25 14:35:01 -0700164 public final int hotseatQsbHeight;
Thales Limadd027342022-01-07 12:54:37 +0000165 public int hotseatBorderSpace;
Adam Cohen2e6da152015-05-06 11:42:25 -0700166
Jon Miranda8bdb2222021-06-23 18:10:10 -0700167 public final float qsbBottomMarginOriginalPx;
168 public int qsbBottomMarginPx;
Thales Limaa1012902022-01-13 17:58:42 +0000169 public int qsbWidth; // only used when isQsbInline
Jon Miranda8bdb2222021-06-23 18:10:10 -0700170
Sunny Goyalc6205602015-05-21 20:46:33 -0700171 // All apps
Thales Lima85c942f2021-12-31 13:04:20 +0000172 public Point allAppsBorderSpacePx;
Samuel Fufaee9aff92021-04-05 13:30:40 -0500173 public int allAppsOpenVerticalTranslate;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700174 public int allAppsCellHeightPx;
Samuel Fufaf1424a32019-10-04 15:15:19 -0700175 public int allAppsCellWidthPx;
Winson1f064272016-07-18 17:18:02 -0700176 public int allAppsIconSizePx;
177 public int allAppsIconDrawablePaddingPx;
sfufa@google.comde013292021-09-21 18:22:44 -0700178 public int allAppsLeftRightPadding;
Alex Chau27b39b92022-01-14 18:02:18 +0000179 public int allAppsLeftRightMargin;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700180 public final int numShownAllAppsColumns;
Winson1f064272016-07-18 17:18:02 -0700181 public float allAppsIconTextSizePx;
182
Zak Cohen334efeb2021-03-19 16:42:07 -0700183 // Overview
Zak Cohen334efeb2021-03-19 16:42:07 -0700184 public int overviewTaskMarginPx;
Alex Chaueaa6d682021-08-17 12:56:15 +0100185 public int overviewTaskMarginGridPx;
Alex Chaudedbc8a2021-03-17 16:53:26 +0000186 public int overviewTaskIconSizePx;
Alex Chauac9df382021-08-02 19:08:41 +0100187 public int overviewTaskIconDrawableSizePx;
188 public int overviewTaskIconDrawableSizeGridPx;
Alex Chaudedbc8a2021-03-17 16:53:26 +0000189 public int overviewTaskThumbnailTopMarginPx;
zakcohendad8a802021-05-20 09:52:26 -0700190 public final int overviewActionsMarginThreeButtonPx;
Alex Chau5fd9d492021-07-22 17:27:11 +0100191 public final int overviewActionsTopMarginGesturePx;
192 public final int overviewActionsBottomMarginGesturePx;
Alex Chau1bf0fe12021-11-30 15:32:45 +0000193 public final int overviewActionsButtonSpacing;
Alex Chau5fd9d492021-07-22 17:27:11 +0100194 public int overviewPageSpacing;
195 public int overviewRowSpacing;
Alex Chau56bd2572021-11-03 18:48:18 +0000196 public int overviewGridSideMargin;
Zak Cohen334efeb2021-03-19 16:42:07 -0700197
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800198 // Widgets
199 public final PointF appWidgetScale = new PointF(1.0f, 1.0f);
200
Sunny Goyal47328fd2016-05-25 18:56:41 -0700201 // Drop Target
202 public int dropTargetBarSizePx;
Alex Chaua02eddc2021-04-29 00:36:06 +0100203 public int dropTargetDragPaddingPx;
204 public int dropTargetTextSizePx;
Adam Cohen4ae96ce2014-08-29 15:05:48 -0700205
Winson1f064272016-07-18 17:18:02 -0700206 // Insets
Sunny Goyal07b69292018-01-08 14:19:34 -0800207 private final Rect mInsets = new Rect();
208 public final Rect workspacePadding = new Rect();
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700209 private final Rect mHotseatPadding = new Rect();
Jon Miranda0bd63d12019-03-06 17:29:29 -0800210 // When true, nav bar is on the left side of the screen.
Sunny Goyal59d086c2018-05-07 17:31:40 -0700211 private boolean mIsSeascape;
Winson1f064272016-07-18 17:18:02 -0700212
Tony Wickhamf34bee82018-12-03 18:11:39 -0800213 // Notification dots
Samuel Fufac96fa242019-09-26 23:06:32 -0700214 public DotRenderer mDotRendererWorkSpace;
215 public DotRenderer mDotRendererAllApps;
Tony Wickham9a8d11f2017-01-11 09:53:12 -0800216
Pierre Barbier de Reuille578deba2021-09-24 13:47:44 +0100217 // Taskbar
Tony Wickham15883892021-02-12 11:24:40 -0800218 public boolean isTaskbarPresent;
Tony Wickham635e1802021-07-22 14:28:04 -1000219 // Whether Taskbar will inset the bottom of apps by taskbarSize.
220 public boolean isTaskbarPresentInApps;
Tony Wickham15883892021-02-12 11:24:40 -0800221 public int taskbarSize;
222
Alex Chaua02eddc2021-04-29 00:36:06 +0100223 // DragController
224 public int flingToDeleteThresholdVelocity;
225
Vinit Nayak17c4b332021-08-05 12:54:58 -0700226 /** TODO: Once we fully migrate to staged split, remove "isMultiWindowMode" */
Sunny Goyal19ff7282021-04-22 10:12:54 -0700227 DeviceProfile(Context context, InvariantDeviceProfile inv, Info info, WindowBounds windowBounds,
Sunny Goyal0addbf02020-04-28 14:17:35 -0700228 boolean isMultiWindowMode, boolean transposeLayoutWithOrientation,
Sunny Goyal19ff7282021-04-22 10:12:54 -0700229 boolean useTwoPanels) {
Sunny Goyalfee35bb2015-05-11 11:38:19 -0700230
Adam Cohen2e6da152015-05-06 11:42:25 -0700231 this.inv = inv;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700232 this.isLandscape = windowBounds.isLandscape();
Sunny Goyald70e75a2018-02-22 10:07:32 -0800233 this.isMultiWindowMode = isMultiWindowMode;
Jon Mirandae126d722021-02-25 10:45:20 -0500234 this.transposeLayoutWithOrientation = transposeLayoutWithOrientation;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700235 windowX = windowBounds.bounds.left;
236 windowY = windowBounds.bounds.top;
Winson Chungb3800242013-10-24 11:01:54 -0700237
Jon Mirandae126d722021-02-25 10:45:20 -0500238 isScalableGrid = inv.isScalable && !isVerticalBarLayout() && !isMultiWindowMode;
239
Alex Chaudfc8ddf2022-01-25 11:26:25 +0000240 // Determine device posture.
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700241 mInfo = info;
Alex Chau29983072021-11-19 15:14:20 +0000242 isTablet = info.isTablet(windowBounds);
Sunny Goyal19ff7282021-04-22 10:12:54 -0700243 isPhone = !isTablet;
Alex Chau90125822021-11-17 14:16:58 +0000244 isTwoPanels = isTablet && useTwoPanels;
Alex Chaudfc8ddf2022-01-25 11:26:25 +0000245 isTaskbarPresent = isTablet && ApiWrapper.TASKBAR_DRAWN_IN_PROCESS
246 && FeatureFlags.ENABLE_TASKBAR.get();
Adam Cohen2e6da152015-05-06 11:42:25 -0700247
Alex Chaudfc8ddf2022-01-25 11:26:25 +0000248 // Some more constants.
Alex Chau635b3ab2022-01-26 16:49:10 +0000249 context = getContext(context, info, isVerticalBarLayout() || (isTablet && isLandscape)
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700250 ? Configuration.ORIENTATION_LANDSCAPE
251 : Configuration.ORIENTATION_PORTRAIT);
Sunny Goyal1890f672020-04-30 12:28:00 -0700252 final Resources res = context.getResources();
Alex Chaudfc8ddf2022-01-25 11:26:25 +0000253 mMetrics = res.getDisplayMetrics();
254
255 // Determine sizes.
256 widthPx = windowBounds.bounds.width();
257 heightPx = windowBounds.bounds.height();
258 availableWidthPx = windowBounds.availableSize.x;
259 int taskbarInset = isTaskbarPresent
260 ? ResourceUtils.getNavbarSize(
261 isLandscape ? "navigation_bar_height_landscape" : "navigation_bar_height",
262 res)
263 : 0;
264 availableHeightPx = windowBounds.availableSize.y - taskbarInset;
265
266 aspectRatio = ((float) Math.max(widthPx, heightPx)) / Math.min(widthPx, heightPx);
267 boolean isTallDevice = Float.compare(aspectRatio, TALL_DEVICE_ASPECT_RATIO_THRESHOLD) >= 0;
268 mQsbCenterFactor = res.getFloat(R.dimen.qsb_center_factor);
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700269
Thales Lima83bedbf2021-10-05 17:47:39 +0100270 if (isTwoPanels) {
271 if (isLandscape) {
272 mTypeIndex = InvariantDeviceProfile.INDEX_TWO_PANEL_LANDSCAPE;
273 } else {
274 mTypeIndex = InvariantDeviceProfile.INDEX_TWO_PANEL_PORTRAIT;
275 }
276 } else {
277 if (isLandscape) {
278 mTypeIndex = InvariantDeviceProfile.INDEX_LANDSCAPE;
279 } else {
280 mTypeIndex = InvariantDeviceProfile.INDEX_DEFAULT;
281 }
282 }
283
Tony Wickham15883892021-02-12 11:24:40 -0800284 if (isTaskbarPresent) {
Tony Wickham15883892021-02-12 11:24:40 -0800285 taskbarSize = res.getDimensionPixelSize(R.dimen.taskbar_size);
Tony Wickham15883892021-02-12 11:24:40 -0800286 }
Tony Wickham15883892021-02-12 11:24:40 -0800287
Winson Chungb3800242013-10-24 11:01:54 -0700288 edgeMarginPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_edge_margin);
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700289
Thales Limad90faab2021-09-21 17:18:47 +0100290 desiredWorkspaceHorizontalMarginPx = getHorizontalMarginPx(inv, res);
291 desiredWorkspaceHorizontalMarginOriginalPx = desiredWorkspaceHorizontalMarginPx;
Samuel Fufaee9aff92021-04-05 13:30:40 -0500292
293 allAppsOpenVerticalTranslate = res.getDimensionPixelSize(
294 R.dimen.all_apps_open_vertical_translate);
295
Jon Mirandae126d722021-02-25 10:45:20 -0500296 folderLabelTextScale = res.getFloat(R.dimen.folder_label_text_scale);
297 folderContentPaddingLeftRight =
298 res.getDimensionPixelSize(R.dimen.folder_content_padding_left_right);
299 folderContentPaddingTop = res.getDimensionPixelSize(R.dimen.folder_content_padding_top);
300
Thales Lima78d00ad2021-09-30 11:29:06 +0100301 cellLayoutBorderSpacePx = getCellLayoutBorderSpace(inv);
Thales Lima85c942f2021-12-31 13:04:20 +0000302 allAppsBorderSpacePx = new Point(
Thales Limabb7d3882021-12-22 12:56:29 +0000303 pxFromDp(inv.allAppsBorderSpaces[mTypeIndex].x, mMetrics),
304 pxFromDp(inv.allAppsBorderSpaces[mTypeIndex].y, mMetrics));
Thales Lima78d00ad2021-09-30 11:29:06 +0100305 cellLayoutBorderSpaceOriginalPx = new Point(cellLayoutBorderSpacePx);
306 folderCellLayoutBorderSpaceOriginalPx = pxFromDp(inv.folderBorderSpace, mMetrics, 1f);
307 folderCellLayoutBorderSpacePx = new Point(folderCellLayoutBorderSpaceOriginalPx,
308 folderCellLayoutBorderSpaceOriginalPx);
Jon Mirandae126d722021-02-25 10:45:20 -0500309
Jon Miranda5eacbb72018-07-31 11:14:46 -0700310 int cellLayoutPaddingLeftRightMultiplier = !isVerticalBarLayout() && isTablet
311 ? PORTRAIT_TABLET_LEFT_RIGHT_PADDING_MULTIPLIER : 1;
Jon Mirandae126d722021-02-25 10:45:20 -0500312 int cellLayoutPadding = isScalableGrid
313 ? 0
314 : res.getDimensionPixelSize(R.dimen.dynamic_grid_cell_layout_padding);
Andras Kloczl8e57cce2021-02-11 23:51:19 +0100315
Sunny Goyal19ff7282021-04-22 10:12:54 -0700316 if (isTwoPanels) {
Thales Lima7a6752d2021-09-23 14:31:00 +0100317 cellLayoutPaddingLeftRightPx = 0;
Andras Kloczl8e57cce2021-02-11 23:51:19 +0100318 cellLayoutBottomPaddingPx = 0;
319 } else if (isLandscape) {
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700320 cellLayoutPaddingLeftRightPx = 0;
321 cellLayoutBottomPaddingPx = cellLayoutPadding;
322 } else {
323 cellLayoutPaddingLeftRightPx = cellLayoutPaddingLeftRightMultiplier * cellLayoutPadding;
324 cellLayoutBottomPaddingPx = 0;
325 }
326
Tony Wickham5edf9e22020-03-27 20:06:52 -0700327 workspacePageIndicatorHeight = res.getDimensionPixelSize(
328 R.dimen.workspace_page_indicator_height);
329 mWorkspacePageIndicatorOverlapWorkspace =
330 res.getDimensionPixelSize(R.dimen.workspace_page_indicator_overlap_workspace);
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700331
Winson Chungb3800242013-10-24 11:01:54 -0700332 iconDrawablePaddingOriginalPx =
333 res.getDimensionPixelSize(R.dimen.dynamic_grid_icon_drawable_padding);
Alex Chaua02eddc2021-04-29 00:36:06 +0100334
Sunny Goyal47328fd2016-05-25 18:56:41 -0700335 dropTargetBarSizePx = res.getDimensionPixelSize(R.dimen.dynamic_grid_drop_target_size);
Alex Chaua02eddc2021-04-29 00:36:06 +0100336 dropTargetDragPaddingPx = res.getDimensionPixelSize(R.dimen.drop_target_drag_padding);
337 dropTargetTextSizePx = res.getDimensionPixelSize(R.dimen.drop_target_text_size);
338
Sunny Goyal47328fd2016-05-25 18:56:41 -0700339 workspaceSpringLoadedBottomSpace =
340 res.getDimensionPixelSize(R.dimen.dynamic_grid_min_spring_loaded_space);
Sunny Goyald5190522017-04-24 03:06:54 -0700341
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700342 workspaceCellPaddingXPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_cell_padding_x);
Jon Miranda09660722017-06-14 14:20:14 -0700343
Thales Limaa1012902022-01-13 17:58:42 +0000344 hotseatQsbHeight = res.getDimensionPixelSize(R.dimen.qsb_widget_height);
345 isQsbInline = isTablet && isLandscape && !isTwoPanels && hotseatQsbHeight > 0;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700346 numShownHotseatIcons =
347 isTwoPanels ? inv.numDatabaseHotseatIcons : inv.numShownHotseatIcons;
348 numShownAllAppsColumns =
349 isTwoPanels ? inv.numDatabaseAllAppsColumns : inv.numAllAppsColumns;
Jon Miranda80cddbc2021-07-22 13:51:16 -0700350 hotseatBarSizeExtraSpacePx = 0;
Winson1f064272016-07-18 17:18:02 -0700351 hotseatBarTopPaddingPx =
352 res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_top_padding);
Thales Limaa1012902022-01-13 17:58:42 +0000353 if (isQsbInline) {
354 hotseatBarBottomPaddingPx = res.getDimensionPixelSize(R.dimen.inline_qsb_bottom_margin);
355 qsbWidth = calculateQsbWidth();
356 } else {
357 hotseatBarBottomPaddingPx = (isTallDevice ? res.getDimensionPixelSize(
358 R.dimen.dynamic_grid_hotseat_bottom_tall_padding)
359 : res.getDimensionPixelSize(
360 R.dimen.dynamic_grid_hotseat_bottom_non_tall_padding))
361 + res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_bottom_padding);
362 qsbWidth = 0;
363 }
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700364 hotseatBarSidePaddingEndPx =
Sunny Goyal228153d2018-01-04 15:35:22 -0800365 res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_side_padding);
Jon Miranda3f411e72019-05-16 17:15:16 -0700366 // Add a bit of space between nav bar and hotseat in vertical bar layout.
Tony Wickham5edf9e22020-03-27 20:06:52 -0700367 hotseatBarSidePaddingStartPx = isVerticalBarLayout() ? workspacePageIndicatorHeight : 0;
Jon Miranda0d284852021-06-22 14:50:55 -0700368 hotseatExtraVerticalSize =
Jon Miranda228877d2021-02-09 11:05:00 -0500369 res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_extra_vertical_size);
Thales Lima6e7f36c2022-01-04 12:14:11 +0000370 hotseatBorderSpace = pxFromDp(inv.hotseatBorderSpaces[mTypeIndex], mMetrics);
Thales Lima83bedbf2021-10-05 17:47:39 +0100371 updateHotseatIconSize(
Thales Lima6e7f36c2022-01-04 12:14:11 +0000372 pxFromDp(inv.iconSize[InvariantDeviceProfile.INDEX_DEFAULT], mMetrics));
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700373
Jon Miranda8bdb2222021-06-23 18:10:10 -0700374 qsbBottomMarginOriginalPx = isScalableGrid
375 ? res.getDimensionPixelSize(R.dimen.scalable_grid_qsb_bottom_margin)
376 : 0;
377
Alex Chau635b3ab2022-01-26 16:49:10 +0000378 overviewTaskMarginPx = res.getDimensionPixelSize(R.dimen.overview_task_margin);
Alex Chaueaa6d682021-08-17 12:56:15 +0100379 overviewTaskMarginGridPx = res.getDimensionPixelSize(R.dimen.overview_task_margin_grid);
Alex Chau5fd9d492021-07-22 17:27:11 +0100380 overviewTaskIconSizePx = res.getDimensionPixelSize(R.dimen.task_thumbnail_icon_size);
Alex Chauac9df382021-08-02 19:08:41 +0100381 overviewTaskIconDrawableSizePx =
382 res.getDimensionPixelSize(R.dimen.task_thumbnail_icon_drawable_size);
383 overviewTaskIconDrawableSizeGridPx =
384 res.getDimensionPixelSize(R.dimen.task_thumbnail_icon_drawable_size_grid);
Alex Chaudedbc8a2021-03-17 16:53:26 +0000385 overviewTaskThumbnailTopMarginPx = overviewTaskIconSizePx + overviewTaskMarginPx * 2;
Alex Chau635b3ab2022-01-26 16:49:10 +0000386 overviewActionsTopMarginGesturePx = res.getDimensionPixelSize(
387 R.dimen.overview_actions_top_margin_gesture);
388 overviewActionsBottomMarginGesturePx = res.getDimensionPixelSize(
389 R.dimen.overview_actions_bottom_margin_gesture);
390 overviewPageSpacing = res.getDimensionPixelSize(R.dimen.overview_page_spacing);
391 overviewActionsButtonSpacing = res.getDimensionPixelSize(
392 R.dimen.overview_actions_button_spacing);
zakcohendad8a802021-05-20 09:52:26 -0700393 overviewActionsMarginThreeButtonPx = res.getDimensionPixelSize(
Alex Chau5fd9d492021-07-22 17:27:11 +0100394 R.dimen.overview_actions_margin_three_button);
Alex Chau4c983742021-12-10 13:09:53 +0000395 // Grid task's top margin is only overviewTaskIconSizePx + overviewTaskMarginGridPx, but
396 // overviewTaskThumbnailTopMarginPx is applied to all TaskThumbnailView, so exclude the
397 // extra margin when calculating row spacing.
398 int extraTopMargin = overviewTaskThumbnailTopMarginPx - overviewTaskIconSizePx
399 - overviewTaskMarginGridPx;
400 overviewRowSpacing = res.getDimensionPixelSize(R.dimen.overview_grid_row_spacing)
401 - extraTopMargin;
Alex Chau635b3ab2022-01-26 16:49:10 +0000402 overviewGridSideMargin = res.getDimensionPixelSize(R.dimen.overview_grid_side_margin);
Zak Cohen334efeb2021-03-19 16:42:07 -0700403
Jon Miranda2ed276e2017-06-29 11:36:34 -0700404 // Calculate all of the remaining variables.
Jon Miranda58561d42021-03-17 10:51:54 -0400405 extraSpace = updateAvailableDimensions(res);
Jon Miranda80cddbc2021-07-22 13:51:16 -0700406
Jon Miranda2ed276e2017-06-29 11:36:34 -0700407 // Now that we have all of the variables calculated, we can tune certain sizes.
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400408 if (isScalableGrid && inv.devicePaddings != null) {
409 // Paddings were created assuming no scaling, so we first unscale the extra space.
Jon Mirandaab3c6812021-06-28 15:42:28 -0700410 int unscaledExtraSpace = (int) (extraSpace / cellScaleToFit);
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400411 DevicePadding padding = inv.devicePaddings.getDevicePadding(unscaledExtraSpace);
Jon Miranda228877d2021-02-09 11:05:00 -0500412
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400413 int paddingWorkspaceTop = padding.getWorkspaceTopPadding(unscaledExtraSpace);
414 int paddingWorkspaceBottom = padding.getWorkspaceBottomPadding(unscaledExtraSpace);
415 int paddingHotseatBottom = padding.getHotseatBottomPadding(unscaledExtraSpace);
416
Jon Mirandaab3c6812021-06-28 15:42:28 -0700417 workspaceTopPadding = Math.round(paddingWorkspaceTop * cellScaleToFit);
418 workspaceBottomPadding = Math.round(paddingWorkspaceBottom * cellScaleToFit);
419 extraHotseatBottomPadding = Math.round(paddingHotseatBottom * cellScaleToFit);
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400420
Jon Miranda58561d42021-03-17 10:51:54 -0400421 hotseatBarSizePx += extraHotseatBottomPadding;
Jon Miranda8bdb2222021-06-23 18:10:10 -0700422
Jon Mirandaab3c6812021-06-28 15:42:28 -0700423 qsbBottomMarginPx = Math.round(qsbBottomMarginOriginalPx * cellScaleToFit);
Jon Miranda228877d2021-02-09 11:05:00 -0500424 } else if (!isVerticalBarLayout() && isPhone && isTallDevice) {
Jon Miranda3f9bab22017-07-28 14:50:17 -0700425 // We increase the hotseat size when there is extra space.
Jon Miranda80cddbc2021-07-22 13:51:16 -0700426
Jon Miranda80dda302021-07-28 14:14:59 -0700427 if (Float.compare(aspectRatio, TALLER_DEVICE_ASPECT_RATIO_THRESHOLD) >= 0
428 && extraSpace >= Utilities.dpToPx(TALL_DEVICE_EXTRA_SPACE_THRESHOLD_DP)) {
429 // For taller devices, we will take a piece of the extra space from each row,
Jon Miranda80cddbc2021-07-22 13:51:16 -0700430 // and add it to the space above and below the hotseat.
Jon Miranda80dda302021-07-28 14:14:59 -0700431
432 // For devices with more extra space, we take a larger piece from each cell.
433 int piece = extraSpace < Utilities.dpToPx(TALL_DEVICE_MORE_EXTRA_SPACE_THRESHOLD_DP)
Jon Mirandaa56cb842021-08-03 17:26:44 -0700434 ? 7 : 5;
Jon Miranda80dda302021-07-28 14:14:59 -0700435
Jon Miranda80cddbc2021-07-22 13:51:16 -0700436 int extraSpace = ((getCellSize().y - iconSizePx - iconDrawablePaddingPx * 2)
Jon Miranda80dda302021-07-28 14:14:59 -0700437 * inv.numRows) / piece;
Jon Miranda80cddbc2021-07-22 13:51:16 -0700438
Jon Mirandaa56cb842021-08-03 17:26:44 -0700439 workspaceTopPadding = extraSpace / 8;
440 int halfLeftOver = (extraSpace - workspaceTopPadding) / 2;
441 hotseatBarTopPaddingPx += halfLeftOver;
442 hotseatBarSizeExtraSpacePx = halfLeftOver;
Jon Miranda80cddbc2021-07-22 13:51:16 -0700443 } else {
444 // ie. For a display with a large aspect ratio, we can keep the icons on the
445 // workspace in portrait mode closer together by adding more height to the hotseat.
446 // Note: This calculation was created after noticing a pattern in the design spec.
447 hotseatBarSizeExtraSpacePx = getCellSize().y - iconSizePx
448 - iconDrawablePaddingPx * 2 - workspacePageIndicatorHeight;
449 }
450
451 updateHotseatIconSize(iconSizePx);
Jon Miranda30d0aa22017-07-25 15:55:29 -0700452
Jon Miranda3f9bab22017-07-28 14:50:17 -0700453 // Recalculate the available dimensions using the new hotseat size.
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700454 updateAvailableDimensions(res);
Jon Miranda2ed276e2017-06-29 11:36:34 -0700455 }
Sunny Goyal07b69292018-01-08 14:19:34 -0800456 updateWorkspacePadding();
Tony Wickham1237df02017-02-24 08:59:36 -0800457
Alex Chaua02eddc2021-04-29 00:36:06 +0100458 flingToDeleteThresholdVelocity = res.getDimensionPixelSize(
459 R.dimen.drag_flingToDeleteMinVelocity);
460
Tony Wickham1237df02017-02-24 08:59:36 -0800461 // This is done last, after iconSizePx is calculated above.
Sunny Goyal8b9919d2021-04-07 14:45:17 -0700462 Path dotPath = GraphicsUtils.getShapePath(DEFAULT_DOT_SIZE);
463 mDotRendererWorkSpace = new DotRenderer(iconSizePx, dotPath, DEFAULT_DOT_SIZE);
Samuel Fufac96fa242019-09-26 23:06:32 -0700464 mDotRendererAllApps = iconSizePx == allAppsIconSizePx ? mDotRendererWorkSpace :
Sunny Goyal8b9919d2021-04-07 14:45:17 -0700465 new DotRenderer(allAppsIconSizePx, dotPath, DEFAULT_DOT_SIZE);
Adam Cohen63f1ec02014-08-12 09:23:13 -0700466 }
467
Thales Limaa1012902022-01-13 17:58:42 +0000468 private int calculateQsbWidth() {
469 return cellWidthPx * inv.numColumns
470 + cellLayoutBorderSpacePx.x * (inv.numColumns - 1)
471 - (cellWidthPx - iconSizePx) // left and right cell space
472 - iconSizePx * numShownHotseatIcons
473 - hotseatBorderSpace * numShownHotseatIcons;
474 }
475
Thales Limad90faab2021-09-21 17:18:47 +0100476 private int getHorizontalMarginPx(InvariantDeviceProfile idp, Resources res) {
477 if (isVerticalBarLayout()) {
478 return 0;
479 }
480
Thales Lima83bedbf2021-10-05 17:47:39 +0100481 return isScalableGrid
482 ? pxFromDp(idp.horizontalMargin[mTypeIndex], mMetrics)
483 : res.getDimensionPixelSize(R.dimen.dynamic_grid_left_right_margin);
Thales Limad90faab2021-09-21 17:18:47 +0100484 }
485
Jon Miranda0d284852021-06-22 14:50:55 -0700486 private void updateHotseatIconSize(int hotseatIconSizePx) {
Jon Miranda92c1b5d2021-07-20 13:57:16 -0700487 // Ensure there is enough space for folder icons, which have a slightly larger radius.
488 hotseatCellHeightPx = (int) Math.ceil(hotseatIconSizePx * ICON_OVERLAP_FACTOR);
Jon Miranda0d284852021-06-22 14:50:55 -0700489 if (isVerticalBarLayout()) {
490 hotseatBarSizePx = hotseatIconSizePx + hotseatBarSidePaddingStartPx
491 + hotseatBarSidePaddingEndPx;
492 } else {
493 hotseatBarSizePx = hotseatIconSizePx + hotseatBarTopPaddingPx
Jon Miranda80cddbc2021-07-22 13:51:16 -0700494 + hotseatBarBottomPaddingPx + (isScalableGrid ? 0 : hotseatExtraVerticalSize)
495 + hotseatBarSizeExtraSpacePx;
Jon Miranda0d284852021-06-22 14:50:55 -0700496 }
497 }
498
Thales Lima78d00ad2021-09-30 11:29:06 +0100499 private Point getCellLayoutBorderSpace(InvariantDeviceProfile idp) {
500 if (!isScalableGrid) {
501 return new Point(0, 0);
502 }
503
Thales Lima83bedbf2021-10-05 17:47:39 +0100504 int horizontalSpacePx = pxFromDp(idp.borderSpaces[mTypeIndex].x, mMetrics);
505 int verticalSpacePx = pxFromDp(idp.borderSpaces[mTypeIndex].y, mMetrics);
Thales Lima78d00ad2021-09-30 11:29:06 +0100506
507 return new Point(horizontalSpacePx, verticalSpacePx);
508 }
509
510 private Point getCellLayoutBorderSpaceScaled(InvariantDeviceProfile idp, float scale) {
511 Point original = getCellLayoutBorderSpace(idp);
512 return new Point((int) (original.x * scale), (int) (original.y * scale));
Jon Mirandae126d722021-02-25 10:45:20 -0500513 }
514
Sunny Goyal69a8eec2021-07-22 10:02:50 -0700515 public Info getDisplayInfo() {
516 return mInfo;
517 }
518
Jon Miranda611dba42021-03-02 14:12:13 -0500519 /**
520 * We inset the widget padding added by the system and instead rely on the border spacing
521 * between cells to create reliable consistency between widgets
522 */
523 public boolean shouldInsetWidgets() {
524 Rect widgetPadding = inv.defaultWidgetPadding;
525
Jon Miranda49811182021-06-03 09:52:40 -0700526 // Check all sides to ensure that the widget won't overlap into another cell, or into
527 // status bar.
528 return workspaceTopPadding > widgetPadding.top
Thales Lima78d00ad2021-09-30 11:29:06 +0100529 && cellLayoutBorderSpacePx.x > widgetPadding.left
530 && cellLayoutBorderSpacePx.y > widgetPadding.top
531 && cellLayoutBorderSpacePx.x > widgetPadding.right
532 && cellLayoutBorderSpacePx.y > widgetPadding.bottom;
Jon Miranda611dba42021-03-02 14:12:13 -0500533 }
Jon Mirandae126d722021-02-25 10:45:20 -0500534
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700535 public Builder toBuilder(Context context) {
Sunny Goyal19ff7282021-04-22 10:12:54 -0700536 WindowBounds bounds =
537 new WindowBounds(widthPx, heightPx, availableWidthPx, availableHeightPx);
538 bounds.bounds.offsetTo(windowX, windowY);
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700539 return new Builder(context, inv, mInfo)
Sunny Goyal19ff7282021-04-22 10:12:54 -0700540 .setWindowBounds(bounds)
541 .setUseTwoPanels(isTwoPanels)
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700542 .setMultiWindowMode(isMultiWindowMode);
Sunny Goyal1a52ef52018-01-11 10:15:03 -0800543 }
544
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700545 public DeviceProfile copy(Context context) {
546 return toBuilder(context).build();
547 }
548
549 /**
550 * TODO: Move this to the builder as part of setMultiWindowMode
551 */
Sunny Goyalb46703d2020-05-27 17:52:03 -0700552 public DeviceProfile getMultiWindowProfile(Context context, WindowBounds windowBounds) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700553 DeviceProfile profile = toBuilder(context)
Sunny Goyal19ff7282021-04-22 10:12:54 -0700554 .setWindowBounds(windowBounds)
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700555 .setMultiWindowMode(true)
556 .build();
Jon Miranda93e1f042016-11-11 14:13:04 -0800557
Jon Miranda941375e2021-03-31 13:10:45 -0400558 profile.hideWorkspaceLabelsIfNotEnoughSpace();
Jon Miranda93e1f042016-11-11 14:13:04 -0800559
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800560 // We use these scales to measure and layout the widgets using their full invariant profile
561 // sizes and then draw them scaled and centered to fit in their multi-window mode cellspans.
562 float appWidgetScaleX = (float) profile.getCellSize().x / getCellSize().x;
563 float appWidgetScaleY = (float) profile.getCellSize().y / getCellSize().y;
564 profile.appWidgetScale.set(appWidgetScaleX, appWidgetScaleY);
Sunny Goyal07b69292018-01-08 14:19:34 -0800565 profile.updateWorkspacePadding();
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800566
Jon Miranda93e1f042016-11-11 14:13:04 -0800567 return profile;
Jon Mirandacc42c5b2016-10-27 17:15:27 -0700568 }
569
Adam Cohen63f1ec02014-08-12 09:23:13 -0700570 /**
Jon Miranda941375e2021-03-31 13:10:45 -0400571 * Checks if there is enough space for labels on the workspace.
572 * If there is not, labels on the Workspace are hidden.
Jon Miranda1091e532017-07-21 13:31:50 -0700573 * It is important to call this method after the All Apps variables have been set.
574 */
Jon Miranda941375e2021-03-31 13:10:45 -0400575 private void hideWorkspaceLabelsIfNotEnoughSpace() {
576 float iconTextHeight = Utilities.calculateTextHeight(iconTextSizePx);
577 float workspaceCellPaddingY = getCellSize().y - iconSizePx - iconDrawablePaddingPx
578 - iconTextHeight;
579
580 // We want enough space so that the text is closer to its corresponding icon.
581 if (workspaceCellPaddingY < iconTextHeight) {
582 iconTextSizePx = 0;
583 iconDrawablePaddingPx = 0;
Jon Miranda92c1b5d2021-07-20 13:57:16 -0700584 cellHeightPx = (int) Math.ceil(iconSizePx * ICON_OVERLAP_FACTOR);
Jon Miranda941375e2021-03-31 13:10:45 -0400585 autoResizeAllAppsCells();
586 }
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700587 }
Jon Miranda1091e532017-07-21 13:31:50 -0700588
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700589 /**
590 * Re-computes the all-apps cell size to be independent of workspace
591 */
592 public void autoResizeAllAppsCells() {
Jon Miranda941375e2021-03-31 13:10:45 -0400593 int textHeight = Utilities.calculateTextHeight(allAppsIconTextSizePx);
594 int topBottomPadding = textHeight;
Jon Miranda1091e532017-07-21 13:31:50 -0700595 allAppsCellHeightPx = allAppsIconSizePx + allAppsIconDrawablePaddingPx
Jon Miranda941375e2021-03-31 13:10:45 -0400596 + textHeight + (topBottomPadding * 2);
Jon Miranda1091e532017-07-21 13:31:50 -0700597 }
598
Alex Chau27b39b92022-01-14 18:02:18 +0000599 private void updateAllAppsWidth(Resources res) {
600
601 if (isTablet) {
602 allAppsLeftRightPadding =
603 res.getDimensionPixelSize(R.dimen.all_apps_bottom_sheet_horizontal_padding)
604 + cellLayoutPaddingLeftRightPx;
sfufa@google.comde013292021-09-21 18:22:44 -0700605 int usedWidth = (allAppsCellWidthPx * numShownAllAppsColumns)
Alex Chau27b39b92022-01-14 18:02:18 +0000606 + (allAppsBorderSpacePx.x * (numShownAllAppsColumns + 1))
607 + allAppsLeftRightPadding * 2;
608 allAppsLeftRightMargin = Math.max(1, (availableWidthPx - usedWidth) / 2);
sfufa@google.comde013292021-09-21 18:22:44 -0700609 } else {
610 allAppsLeftRightPadding =
Thales Limad90faab2021-09-21 17:18:47 +0100611 desiredWorkspaceHorizontalMarginPx + cellLayoutPaddingLeftRightPx;
sfufa@google.comde013292021-09-21 18:22:44 -0700612 }
613 }
614
Jon Miranda228877d2021-02-09 11:05:00 -0500615 /**
616 * Returns the amount of extra (or unused) vertical space.
617 */
618 private int updateAvailableDimensions(Resources res) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700619 updateIconSize(1f, res);
Winson Chung59a488a2013-12-10 12:32:14 -0800620
Jon Mirandae126d722021-02-25 10:45:20 -0500621 Point workspacePadding = getTotalWorkspacePadding();
622
623 // Check to see if the icons fit within the available height.
624 float usedHeight = getCellLayoutHeight();
625 final int maxHeight = availableHeightPx - workspacePadding.y;
Jon Miranda228877d2021-02-09 11:05:00 -0500626 float extraHeight = Math.max(0, maxHeight - usedHeight);
Jon Mirandae126d722021-02-25 10:45:20 -0500627 float scaleY = maxHeight / usedHeight;
628 boolean shouldScale = scaleY < 1f;
629
630 float scaleX = 1f;
631 if (isScalableGrid) {
632 // We scale to fit the cellWidth and cellHeight in the available space.
633 // The benefit of scalable grids is that we can get consistent aspect ratios between
634 // devices.
Thales Limad1df5fc2021-09-03 18:37:19 +0100635 int numColumns = isTwoPanels ? inv.numColumns * 2 : inv.numColumns;
636 float usedWidth = (cellWidthPx * numColumns)
Thales Lima78d00ad2021-09-30 11:29:06 +0100637 + (cellLayoutBorderSpacePx.x * (numColumns - 1))
Thales Limad90faab2021-09-21 17:18:47 +0100638 + (desiredWorkspaceHorizontalMarginPx * 2);
Jon Mirandae126d722021-02-25 10:45:20 -0500639 // We do not subtract padding here, as we also scale the workspace padding if needed.
640 scaleX = availableWidthPx / usedWidth;
641 shouldScale = true;
Winson Chungb3800242013-10-24 11:01:54 -0700642 }
Jon Mirandae126d722021-02-25 10:45:20 -0500643
644 if (shouldScale) {
645 float scale = Math.min(scaleX, scaleY);
646 updateIconSize(scale, res);
647 extraHeight = Math.max(0, maxHeight - getCellLayoutHeight());
648 }
649
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700650 updateAvailableFolderCellDimensions(res);
Jon Miranda228877d2021-02-09 11:05:00 -0500651 return Math.round(extraHeight);
Winson Chungb3800242013-10-24 11:01:54 -0700652 }
653
Jon Mirandae126d722021-02-25 10:45:20 -0500654 private int getCellLayoutHeight() {
Thales Lima78d00ad2021-09-30 11:29:06 +0100655 return (cellHeightPx * inv.numRows) + (cellLayoutBorderSpacePx.y * (inv.numRows - 1));
Jon Mirandae126d722021-02-25 10:45:20 -0500656 }
657
Jon Miranda6f7e9702019-09-16 14:44:14 -0700658 /**
659 * Updating the iconSize affects many aspects of the launcher layout, such as: iconSizePx,
660 * iconTextSizePx, iconDrawablePaddingPx, cellWidth/Height, allApps* variants,
661 * hotseat sizes, workspaceSpringLoadedShrinkFactor, folderIconSizePx, and folderIconOffsetYPx.
662 */
Tony Wickham7ba547c2021-02-02 17:12:08 -0800663 public void updateIconSize(float scale, Resources res) {
Jon Mirandaab3c6812021-06-28 15:42:28 -0700664 // Icon scale should never exceed 1, otherwise pixellation may occur.
665 iconScale = Math.min(1f, scale);
666 cellScaleToFit = scale;
667
Jon Miranda18751b62017-07-31 17:25:27 -0700668 // Workspace
Sunny Goyal07b69292018-01-08 14:19:34 -0800669 final boolean isVerticalLayout = isVerticalBarLayout();
Thales Lima83bedbf2021-10-05 17:47:39 +0100670 float invIconSizeDp = inv.iconSize[mTypeIndex];
671 float invIconTextSizeSp = inv.iconTextSize[mTypeIndex];
Andras Kloczl30fe9152021-08-05 18:02:29 +0200672
Jon Mirandaab3c6812021-06-28 15:42:28 -0700673 iconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mMetrics, iconScale));
Jon Mirandaab3c6812021-06-28 15:42:28 -0700674 iconTextSizePx = (int) (pxFromSp(invIconTextSizeSp, mMetrics) * iconScale);
675 iconDrawablePaddingPx = (int) (iconDrawablePaddingOriginalPx * iconScale);
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700676
Thales Lima78d00ad2021-09-30 11:29:06 +0100677 cellLayoutBorderSpacePx = getCellLayoutBorderSpaceScaled(inv, scale);
Jon Mirandae126d722021-02-25 10:45:20 -0500678
679 if (isScalableGrid) {
Thales Lima83bedbf2021-10-05 17:47:39 +0100680 cellWidthPx = pxFromDp(inv.minCellSize[mTypeIndex].x, mMetrics, scale);
681 cellHeightPx = pxFromDp(inv.minCellSize[mTypeIndex].y, mMetrics, scale);
Jon Mirandae126d722021-02-25 10:45:20 -0500682 int cellContentHeight = iconSizePx + iconDrawablePaddingPx
683 + Utilities.calculateTextHeight(iconTextSizePx);
684 cellYPaddingPx = Math.max(0, cellHeightPx - cellContentHeight) / 2;
Thales Limad90faab2021-09-21 17:18:47 +0100685 desiredWorkspaceHorizontalMarginPx =
686 (int) (desiredWorkspaceHorizontalMarginOriginalPx * scale);
Jon Miranda228877d2021-02-09 11:05:00 -0500687 } else {
Jon Mirandae126d722021-02-25 10:45:20 -0500688 cellWidthPx = iconSizePx + iconDrawablePaddingPx;
Jon Miranda92c1b5d2021-07-20 13:57:16 -0700689 cellHeightPx = (int) Math.ceil(iconSizePx * ICON_OVERLAP_FACTOR)
690 + iconDrawablePaddingPx
Jon Miranda228877d2021-02-09 11:05:00 -0500691 + Utilities.calculateTextHeight(iconTextSizePx);
692 int cellPaddingY = (getCellSize().y - cellHeightPx) / 2;
693 if (iconDrawablePaddingPx > cellPaddingY && !isVerticalLayout
694 && !isMultiWindowMode) {
695 // Ensures that the label is closer to its corresponding icon. This is not an issue
696 // with vertical bar layout or multi-window mode since the issue is handled
697 // separately with their calls to {@link #adjustToHideWorkspaceLabels}.
698 cellHeightPx -= (iconDrawablePaddingPx - cellPaddingY);
699 iconDrawablePaddingPx = cellPaddingY;
700 }
Jon Miranda846455e2017-10-02 14:58:52 -0700701 }
Jon Miranda18751b62017-07-31 17:25:27 -0700702
Sunny Goyalae190ff2020-04-14 00:19:01 +0000703 // All apps
Sunny Goyal19ff7282021-04-22 10:12:54 -0700704 if (numShownAllAppsColumns != inv.numColumns) {
Thales Lima83bedbf2021-10-05 17:47:39 +0100705 allAppsIconSizePx =
Thales Limabb7d3882021-12-22 12:56:29 +0000706 pxFromDp(inv.allAppsIconSize[mTypeIndex], mMetrics);
Thales Lima83bedbf2021-10-05 17:47:39 +0100707 allAppsIconTextSizePx =
Thales Limabb7d3882021-12-22 12:56:29 +0000708 pxFromSp(inv.allAppsIconTextSize[mTypeIndex], mMetrics);
Sunny Goyalae190ff2020-04-14 00:19:01 +0000709 allAppsIconDrawablePaddingPx = iconDrawablePaddingOriginalPx;
Jon Miranda941375e2021-03-31 13:10:45 -0400710 autoResizeAllAppsCells();
Sunny Goyalae190ff2020-04-14 00:19:01 +0000711 } else {
712 allAppsIconSizePx = iconSizePx;
713 allAppsIconTextSizePx = iconTextSizePx;
714 allAppsIconDrawablePaddingPx = iconDrawablePaddingPx;
715 allAppsCellHeightPx = getCellSize().y;
716 }
Thales Limabb7d3882021-12-22 12:56:29 +0000717 allAppsCellWidthPx = allAppsIconSizePx + (2 * allAppsIconDrawablePaddingPx);
Alex Chau27b39b92022-01-14 18:02:18 +0000718 updateAllAppsWidth(res);
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700719
Jon Miranda941375e2021-03-31 13:10:45 -0400720 if (isVerticalLayout) {
721 hideWorkspaceLabelsIfNotEnoughSpace();
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700722 }
Winson Chungb3800242013-10-24 11:01:54 -0700723
Winson Chungb3800242013-10-24 11:01:54 -0700724 // Hotseat
Thales Limadd027342022-01-07 12:54:37 +0000725 hotseatBorderSpace = pxFromDp(inv.hotseatBorderSpaces[mTypeIndex], mMetrics, scale);
Thales Limaa1012902022-01-13 17:58:42 +0000726 if (isQsbInline) {
727 qsbWidth = calculateQsbWidth();
728 } else {
729 qsbWidth = 0;
730 }
Jon Miranda0d284852021-06-22 14:50:55 -0700731 updateHotseatIconSize(iconSizePx);
Winson Chungb3800242013-10-24 11:01:54 -0700732
Sunny Goyal07b69292018-01-08 14:19:34 -0800733 if (!isVerticalLayout) {
Jon Miranda18751b62017-07-31 17:25:27 -0700734 int expectedWorkspaceHeight = availableHeightPx - hotseatBarSizePx
Tony Wickham5edf9e22020-03-27 20:06:52 -0700735 - workspacePageIndicatorHeight - edgeMarginPx;
Sunny Goyal47328fd2016-05-25 18:56:41 -0700736 float minRequiredHeight = dropTargetBarSizePx + workspaceSpringLoadedBottomSpace;
737 workspaceSpringLoadShrinkFactor = Math.min(
738 res.getInteger(R.integer.config_workspaceSpringLoadShrinkPercentage) / 100.0f,
739 1 - (minRequiredHeight / expectedWorkspaceHeight));
740 } else {
741 workspaceSpringLoadShrinkFactor =
742 res.getInteger(R.integer.config_workspaceSpringLoadShrinkPercentage) / 100.0f;
743 }
744
Sunny Goyalbaec6ff2016-09-14 11:26:21 -0700745 // Folder icon
Jon Miranda591e3602018-03-28 11:37:00 -0700746 folderIconSizePx = IconNormalizer.getNormalizedCircleSize(iconSizePx);
747 folderIconOffsetYPx = (iconSizePx - folderIconSizePx) / 2;
Winson Chung0f785722015-04-08 10:27:49 -0700748 }
749
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700750 private void updateAvailableFolderCellDimensions(Resources res) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700751 updateFolderCellSize(1f, res);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700752
Jon Mirandae126d722021-02-25 10:45:20 -0500753 final int folderBottomPanelSize = res.getDimensionPixelSize(R.dimen.folder_label_height);
754
Jon Mirandac1b23992016-12-13 08:57:36 -0800755 // Don't let the folder get too close to the edges of the screen.
Jon Miranda1786df32018-09-25 13:05:23 -0700756 int folderMargin = edgeMarginPx * 2;
Sunny Goyal07b69292018-01-08 14:19:34 -0800757 Point totalWorkspacePadding = getTotalWorkspacePadding();
Jon Mirandac1b23992016-12-13 08:57:36 -0800758
759 // Check if the icons fit within the available height.
Jon Miranda228877d2021-02-09 11:05:00 -0500760 float contentUsedHeight = folderCellHeightPx * inv.numFolderRows
Thales Lima78d00ad2021-09-30 11:29:06 +0100761 + ((inv.numFolderRows - 1) * folderCellLayoutBorderSpacePx.y);
Samuel Fufa1c8d90a2019-11-12 17:54:58 -0800762 int contentMaxHeight = availableHeightPx - totalWorkspacePadding.y - folderBottomPanelSize
Jon Mirandae126d722021-02-25 10:45:20 -0500763 - folderMargin - folderContentPaddingTop;
Samuel Fufa1c8d90a2019-11-12 17:54:58 -0800764 float scaleY = contentMaxHeight / contentUsedHeight;
Jon Mirandac1b23992016-12-13 08:57:36 -0800765
766 // Check if the icons fit within the available width.
Jon Miranda228877d2021-02-09 11:05:00 -0500767 float contentUsedWidth = folderCellWidthPx * inv.numFolderColumns
Thales Lima78d00ad2021-09-30 11:29:06 +0100768 + ((inv.numFolderColumns - 1) * folderCellLayoutBorderSpacePx.x);
Jon Mirandae126d722021-02-25 10:45:20 -0500769 int contentMaxWidth = availableWidthPx - totalWorkspacePadding.x - folderMargin
770 - folderContentPaddingLeftRight * 2;
Samuel Fufa1c8d90a2019-11-12 17:54:58 -0800771 float scaleX = contentMaxWidth / contentUsedWidth;
Jon Mirandac1b23992016-12-13 08:57:36 -0800772
773 float scale = Math.min(scaleX, scaleY);
774 if (scale < 1f) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700775 updateFolderCellSize(scale, res);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700776 }
777 }
778
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700779 private void updateFolderCellSize(float scale, Resources res) {
Thales Lima83bedbf2021-10-05 17:47:39 +0100780 float invIconSizeDp = isVerticalBarLayout()
781 ? inv.iconSize[InvariantDeviceProfile.INDEX_LANDSCAPE]
782 : inv.iconSize[InvariantDeviceProfile.INDEX_DEFAULT];
Sunny Goyal35c7b192021-04-20 16:51:10 -0700783 folderChildIconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mMetrics, scale));
Thales Lima83bedbf2021-10-05 17:47:39 +0100784 folderChildTextSizePx =
785 pxFromSp(inv.iconTextSize[InvariantDeviceProfile.INDEX_DEFAULT], mMetrics, scale);
Jon Mirandae126d722021-02-25 10:45:20 -0500786 folderLabelTextSizePx = (int) (folderChildTextSizePx * folderLabelTextScale);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700787
788 int textHeight = Utilities.calculateTextHeight(folderChildTextSizePx);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700789
Jon Miranda823da222021-03-23 08:08:45 -0400790 if (isScalableGrid) {
Jon Mirandaf33f5b32021-07-22 17:15:31 -0700791 int minWidth = folderChildIconSizePx + iconDrawablePaddingPx * 2;
792 int minHeight = folderChildIconSizePx + iconDrawablePaddingPx * 2 + textHeight;
793
794 folderCellWidthPx = (int) Math.max(minWidth, cellWidthPx * scale);
795 folderCellHeightPx = (int) Math.max(minHeight, cellHeightPx * scale);
Jon Miranda823da222021-03-23 08:08:45 -0400796
Thales Lima78d00ad2021-09-30 11:29:06 +0100797 int scaledSpace = (int) (folderCellLayoutBorderSpaceOriginalPx * scale);
798 folderCellLayoutBorderSpacePx = new Point(scaledSpace, scaledSpace);
799 folderContentPaddingLeftRight = scaledSpace;
800 folderContentPaddingTop = scaledSpace;
Jon Miranda823da222021-03-23 08:08:45 -0400801 } else {
802 int cellPaddingX = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_x_padding)
803 * scale);
804 int cellPaddingY = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_y_padding)
805 * scale);
806
807 folderCellWidthPx = folderChildIconSizePx + 2 * cellPaddingX;
808 folderCellHeightPx = folderChildIconSizePx + 2 * cellPaddingY + textHeight;
809 }
810
Jonathan Miranda9ad87462017-07-26 17:41:02 +0000811 folderChildDrawablePaddingPx = Math.max(0,
812 (folderCellHeightPx - folderChildIconSizePx - textHeight) / 3);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700813 }
814
Winson1f064272016-07-18 17:18:02 -0700815 public void updateInsets(Rect insets) {
816 mInsets.set(insets);
Sunny Goyal07b69292018-01-08 14:19:34 -0800817 updateWorkspacePadding();
Winson1f064272016-07-18 17:18:02 -0700818 }
819
Sunny Goyalae6e3182019-04-30 12:04:37 -0700820 /**
821 * The current device insets. This is generally same as the insets being dispatched to
822 * {@link Insettable} elements, but can differ if the element is using a different profile.
823 */
Sunny Goyal1a52ef52018-01-11 10:15:03 -0800824 public Rect getInsets() {
825 return mInsets;
826 }
827
Sunny Goyal756cd262015-08-20 12:33:21 -0700828 public Point getCellSize() {
Sunny Goyal19ff7282021-04-22 10:12:54 -0700829 return getCellSize(null);
Jon Miranda6f7e9702019-09-16 14:44:14 -0700830 }
831
Sunny Goyal19ff7282021-04-22 10:12:54 -0700832 public Point getCellSize(Point result) {
833 if (result == null) {
834 result = new Point();
835 }
Thales Limad1df5fc2021-09-03 18:37:19 +0100836
Sunny Goyal756cd262015-08-20 12:33:21 -0700837 // Since we are only concerned with the overall padding, layout direction does
838 // not matter.
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700839 Point padding = getTotalWorkspacePadding();
Thales Limad1df5fc2021-09-03 18:37:19 +0100840
841 int numColumns = isTwoPanels ? inv.numColumns * 2 : inv.numColumns;
Alex Chau60953332021-11-24 12:41:07 +0000842 int screenWidthPx = getWorkspaceWidth(padding);
Thales Lima78d00ad2021-09-30 11:29:06 +0100843 result.x = calculateCellWidth(screenWidthPx, cellLayoutBorderSpacePx.x, numColumns);
Jon Miranda18751b62017-07-31 17:25:27 -0700844 result.y = calculateCellHeight(availableHeightPx - padding.y
Thales Lima78d00ad2021-09-30 11:29:06 +0100845 - cellLayoutBottomPaddingPx, cellLayoutBorderSpacePx.y, inv.numRows);
Sunny Goyal756cd262015-08-20 12:33:21 -0700846 return result;
847 }
848
Alex Chau60953332021-11-24 12:41:07 +0000849 public int getWorkspaceWidth() {
850 return getWorkspaceWidth(getTotalWorkspacePadding());
851 }
852
853 public int getWorkspaceWidth(Point workspacePadding) {
854 int cellLayoutTotalPadding =
855 isTwoPanels ? 4 * cellLayoutPaddingLeftRightPx : 2 * cellLayoutPaddingLeftRightPx;
856 return availableWidthPx - workspacePadding.x - cellLayoutTotalPadding;
857 }
858
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700859 public Point getTotalWorkspacePadding() {
Sunny Goyal07b69292018-01-08 14:19:34 -0800860 updateWorkspacePadding();
861 return new Point(workspacePadding.left + workspacePadding.right,
862 workspacePadding.top + workspacePadding.bottom);
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700863 }
864
865 /**
Sunny Goyal07b69292018-01-08 14:19:34 -0800866 * Updates {@link #workspacePadding} as a result of any internal value change to reflect the
867 * new workspace padding
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700868 */
Sunny Goyal07b69292018-01-08 14:19:34 -0800869 private void updateWorkspacePadding() {
870 Rect padding = workspacePadding;
Tony Wickham3a3517f2015-10-06 11:27:04 -0700871 if (isVerticalBarLayout()) {
Sunny Goyal228153d2018-01-04 15:35:22 -0800872 padding.top = 0;
873 padding.bottom = edgeMarginPx;
Sunny Goyal7e2e67f2018-01-26 13:40:08 -0800874 if (isSeascape()) {
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700875 padding.left = hotseatBarSizePx;
Tony Wickham5edf9e22020-03-27 20:06:52 -0700876 padding.right = hotseatBarSidePaddingStartPx;
Winson1f064272016-07-18 17:18:02 -0700877 } else {
Tony Wickham5edf9e22020-03-27 20:06:52 -0700878 padding.left = hotseatBarSidePaddingStartPx;
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700879 padding.right = hotseatBarSizePx;
Winson1f064272016-07-18 17:18:02 -0700880 }
Winson Chungb3800242013-10-24 11:01:54 -0700881 } else {
Thales Lima7a6752d2021-09-23 14:31:00 +0100882 // Pad the bottom of the workspace with search/hotseat bar sizes
Tony Wickham21970cc2021-09-15 15:44:05 -0700883 int hotseatTop = hotseatBarSizePx;
Tony Wickhama29a0462021-03-02 12:28:25 -0800884 int paddingBottom = hotseatTop + workspacePageIndicatorHeight
Jon Miranda228877d2021-02-09 11:05:00 -0500885 + workspaceBottomPadding - mWorkspacePageIndicatorOverlapWorkspace;
Andras Kloczl8e57cce2021-02-11 23:51:19 +0100886
Thales Limad90faab2021-09-21 17:18:47 +0100887 padding.set(desiredWorkspaceHorizontalMarginPx,
Thales Lima83bedbf2021-10-05 17:47:39 +0100888 workspaceTopPadding + (isScalableGrid ? 0 : edgeMarginPx),
Thales Limad90faab2021-09-21 17:18:47 +0100889 desiredWorkspaceHorizontalMarginPx,
Thales Lima7a6752d2021-09-23 14:31:00 +0100890 paddingBottom);
Winson Chungb3800242013-10-24 11:01:54 -0700891 }
Winson Chungb3800242013-10-24 11:01:54 -0700892 }
893
Sunny Goyal57b22792021-05-25 14:35:01 -0700894 /**
895 * Returns the padding for hotseat view
896 */
897 public Rect getHotseatLayoutPadding(Context context) {
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700898 if (isVerticalBarLayout()) {
899 if (isSeascape()) {
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700900 mHotseatPadding.set(mInsets.left + hotseatBarSidePaddingStartPx,
901 mInsets.top, hotseatBarSidePaddingEndPx, mInsets.bottom);
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700902 } else {
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700903 mHotseatPadding.set(hotseatBarSidePaddingEndPx, mInsets.top,
904 mInsets.right + hotseatBarSidePaddingStartPx, mInsets.bottom);
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700905 }
Sunny Goyal57b22792021-05-25 14:35:01 -0700906 } else if (isTaskbarPresent) {
Tony Wickham21970cc2021-09-15 15:44:05 -0700907 int hotseatHeight = workspacePadding.bottom;
Sunny Goyal57b22792021-05-25 14:35:01 -0700908 int taskbarOffset = getTaskbarOffsetY();
Thales Limaa1012902022-01-13 17:58:42 +0000909 int additionalLeftSpace = 0;
910
911 // Center the QSB with hotseat and push icons to the right
912 if (isQsbInline) {
913 additionalLeftSpace = qsbWidth + hotseatBorderSpace;
914 }
915
Tony Wickham21970cc2021-09-15 15:44:05 -0700916 int hotseatTopDiff = hotseatHeight - taskbarOffset;
Sunny Goyal57b22792021-05-25 14:35:01 -0700917
Vinit Nayak8dcbde82021-07-19 12:53:28 -0700918 int endOffset = ApiWrapper.getHotseatEndOffset(context);
Thales Lima6e7f36c2022-01-04 12:14:11 +0000919 int requiredWidth = iconSizePx * numShownHotseatIcons
Thales Limaa1012902022-01-13 17:58:42 +0000920 + hotseatBorderSpace * (numShownHotseatIcons - 1)
921 + additionalLeftSpace;
Sunny Goyal57b22792021-05-25 14:35:01 -0700922
Thales Lima6e7f36c2022-01-04 12:14:11 +0000923 int hotseatSize = Math.min(requiredWidth, availableWidthPx - endOffset);
Sunny Goyal57b22792021-05-25 14:35:01 -0700924 int sideSpacing = (availableWidthPx - hotseatSize) / 2;
Thales Limaa1012902022-01-13 17:58:42 +0000925 mHotseatPadding.set(sideSpacing + additionalLeftSpace, hotseatTopDiff, sideSpacing,
926 taskbarOffset);
Sunny Goyal57b22792021-05-25 14:35:01 -0700927
Vinit Nayak8dcbde82021-07-19 12:53:28 -0700928 if (endOffset > sideSpacing) {
Sunny Goyal57b22792021-05-25 14:35:01 -0700929 int diff = Utilities.isRtl(context.getResources())
Vinit Nayak8dcbde82021-07-19 12:53:28 -0700930 ? sideSpacing - endOffset
931 : endOffset - sideSpacing;
932 mHotseatPadding.left -= diff;
933 mHotseatPadding.right += diff;
Sunny Goyal57b22792021-05-25 14:35:01 -0700934 }
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700935 } else {
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700936 // We want the edges of the hotseat to line up with the edges of the workspace, but the
937 // icons in the hotseat are a different size, and so don't line up perfectly. To account
938 // for this, we pad the left and right of the hotseat with half of the difference of a
939 // workspace cell vs a hotseat cell.
940 float workspaceCellWidth = (float) widthPx / inv.numColumns;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700941 float hotseatCellWidth = (float) widthPx / numShownHotseatIcons;
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700942 int hotseatAdjustment = Math.round((workspaceCellWidth - hotseatCellWidth) / 2);
943 mHotseatPadding.set(
Sunny Goyal786940a2020-06-02 02:31:31 -0700944 hotseatAdjustment + workspacePadding.left + cellLayoutPaddingLeftRightPx
945 + mInsets.left,
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700946 hotseatBarTopPaddingPx,
Sunny Goyal786940a2020-06-02 02:31:31 -0700947 hotseatAdjustment + workspacePadding.right + cellLayoutPaddingLeftRightPx
948 + mInsets.right,
Jon Miranda0d284852021-06-22 14:50:55 -0700949 hotseatBarSizePx - hotseatCellHeightPx - hotseatBarTopPaddingPx
950 + cellLayoutBottomPaddingPx + mInsets.bottom);
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700951 }
952 return mHotseatPadding;
953 }
954
Winsonfadbe8f2016-07-22 16:35:37 -0700955 /**
Sunny Goyal57b22792021-05-25 14:35:01 -0700956 * Returns the number of pixels the QSB is translated from the bottom of the screen.
957 */
958 public int getQsbOffsetY() {
Thales Limaa1012902022-01-13 17:58:42 +0000959 if (isQsbInline) {
960 return hotseatBarBottomPaddingPx;
961 }
962
Sunny Goyal57b22792021-05-25 14:35:01 -0700963 int freeSpace = isTaskbarPresent
964 ? workspacePadding.bottom
965 : hotseatBarSizePx - hotseatCellHeightPx - hotseatQsbHeight;
Jonathan Miranda7a273e22021-06-24 21:29:10 +0000966
Jonathan Miranda8f16a772021-07-23 23:10:37 +0000967 if (isScalableGrid && qsbBottomMarginPx > mInsets.bottom) {
Tony Wickham21970cc2021-09-15 15:44:05 -0700968 // Note that taskbarSize = 0 unless isTaskbarPresent.
969 return Math.min(qsbBottomMarginPx + taskbarSize, freeSpace);
Jonathan Miranda8f16a772021-07-23 23:10:37 +0000970 } else {
Pratyush9afe1ea2021-10-13 11:13:27 +0000971 return (int) (freeSpace * mQsbCenterFactor)
972 + (isTaskbarPresent ? taskbarSize : mInsets.bottom);
Jonathan Miranda7a273e22021-06-24 21:29:10 +0000973 }
Sunny Goyal57b22792021-05-25 14:35:01 -0700974 }
975
976 /**
977 * Returns the number of pixels the taskbar is translated from the bottom of the screen.
978 */
979 public int getTaskbarOffsetY() {
Thales Limaa1012902022-01-13 17:58:42 +0000980 if (isQsbInline) {
981 return getQsbOffsetY() + (Math.abs(hotseatQsbHeight - iconSizePx) / 2);
982 } else {
983 return (getQsbOffsetY() - taskbarSize) / 2;
984 }
Sunny Goyal57b22792021-05-25 14:35:01 -0700985 }
986
987 /**
Winsonfadbe8f2016-07-22 16:35:37 -0700988 * @return the bounds for which the open folders should be contained within
989 */
990 public Rect getAbsoluteOpenFolderBounds() {
991 if (isVerticalBarLayout()) {
992 // Folders should only appear right of the drop target bar and left of the hotseat
993 return new Rect(mInsets.left + dropTargetBarSizePx + edgeMarginPx,
994 mInsets.top,
Jon Miranda18751b62017-07-31 17:25:27 -0700995 mInsets.left + availableWidthPx - hotseatBarSizePx - edgeMarginPx,
Winsonfadbe8f2016-07-22 16:35:37 -0700996 mInsets.top + availableHeightPx);
997 } else {
998 // Folders should only appear below the drop target bar and above the hotseat
Tony Wickhamae72b462021-03-10 16:18:40 -0800999 int hotseatTop = isTaskbarPresent ? taskbarSize : hotseatBarSizePx;
Tony Wickhamb4b7e202018-01-12 17:39:24 -08001000 return new Rect(mInsets.left + edgeMarginPx,
Winsonfadbe8f2016-07-22 16:35:37 -07001001 mInsets.top + dropTargetBarSizePx + edgeMarginPx,
Tony Wickhamb4b7e202018-01-12 17:39:24 -08001002 mInsets.left + availableWidthPx - edgeMarginPx,
Tony Wickhamae72b462021-03-10 16:18:40 -08001003 mInsets.top + availableHeightPx - hotseatTop
Tony Wickham5edf9e22020-03-27 20:06:52 -07001004 - workspacePageIndicatorHeight - edgeMarginPx);
Winsonfadbe8f2016-07-22 16:35:37 -07001005 }
1006 }
1007
Jon Miranda228877d2021-02-09 11:05:00 -05001008 public static int calculateCellWidth(int width, int borderSpacing, int countX) {
1009 return (width - ((countX - 1) * borderSpacing)) / countX;
Winson Chungb3800242013-10-24 11:01:54 -07001010 }
Pierre Barbier de Reuille578deba2021-09-24 13:47:44 +01001011
Jon Miranda228877d2021-02-09 11:05:00 -05001012 public static int calculateCellHeight(int height, int borderSpacing, int countY) {
1013 return (height - ((countY - 1) * borderSpacing)) / countY;
Winson Chungb3800242013-10-24 11:01:54 -07001014 }
1015
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -07001016 /**
Tony Wickham55616cd2015-09-23 14:55:17 -07001017 * When {@code true}, the device is in landscape mode and the hotseat is on the right column.
1018 * When {@code false}, either device is in portrait mode or the device is in landscape mode and
1019 * the hotseat is on the bottom row.
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -07001020 */
Tony Wickhamab946a12015-09-16 15:38:16 -07001021 public boolean isVerticalBarLayout() {
Winson Chungb3800242013-10-24 11:01:54 -07001022 return isLandscape && transposeLayoutWithOrientation;
1023 }
1024
Sunny Goyal59d086c2018-05-07 17:31:40 -07001025 /**
1026 * Updates orientation information and returns true if it has changed from the previous value.
1027 */
Winson Chung13c1c2c2019-09-06 11:46:19 -07001028 public boolean updateIsSeascape(Context context) {
Sunny Goyal59d086c2018-05-07 17:31:40 -07001029 if (isVerticalBarLayout()) {
Sunny Goyal35c7b192021-04-20 16:51:10 -07001030 boolean isSeascape = DisplayController.INSTANCE.get(context)
1031 .getInfo().rotation == Surface.ROTATION_270;
Sunny Goyal59d086c2018-05-07 17:31:40 -07001032 if (mIsSeascape != isSeascape) {
1033 mIsSeascape = isSeascape;
1034 return true;
1035 }
1036 }
1037 return false;
1038 }
1039
Sunny Goyal7e2e67f2018-01-26 13:40:08 -08001040 public boolean isSeascape() {
Sunny Goyal59d086c2018-05-07 17:31:40 -07001041 return isVerticalBarLayout() && mIsSeascape;
Sunny Goyal7e2e67f2018-01-26 13:40:08 -08001042 }
1043
Sunny Goyal07b69292018-01-08 14:19:34 -08001044 public boolean shouldFadeAdjacentWorkspaceScreens() {
Sunny Goyal19ff7282021-04-22 10:12:54 -07001045 return isVerticalBarLayout();
Winson Chungb3800242013-10-24 11:01:54 -07001046 }
1047
Jon Miranda92c1b5d2021-07-20 13:57:16 -07001048 public int getCellContentHeight(@ContainerType int containerType) {
Sunny Goyalc13403c2016-11-18 23:44:48 -08001049 switch (containerType) {
1050 case CellLayout.WORKSPACE:
1051 return cellHeightPx;
1052 case CellLayout.FOLDER:
1053 return folderCellHeightPx;
1054 case CellLayout.HOTSEAT:
Jon Miranda92c1b5d2021-07-20 13:57:16 -07001055 // The hotseat is the only container where the cell height is going to be
1056 // different from the content within that cell.
1057 return iconSizePx;
Sunny Goyalc13403c2016-11-18 23:44:48 -08001058 default:
1059 // ??
1060 return 0;
1061 }
1062 }
Sunny Goyal13178ac2016-04-04 16:35:22 -07001063
Jon Miranda58561d42021-03-17 10:51:54 -04001064 private String pxToDpStr(String name, float value) {
Sunny Goyal35c7b192021-04-20 16:51:10 -07001065 return "\t" + name + ": " + value + "px (" + dpiFromPx(value, mMetrics.densityDpi) + "dp)";
Jon Miranda58561d42021-03-17 10:51:54 -04001066 }
1067
1068 public void dump(String prefix, PrintWriter writer) {
1069 writer.println(prefix + "DeviceProfile:");
Sunny Goyal35c7b192021-04-20 16:51:10 -07001070 writer.println(prefix + "\t1 dp = " + mMetrics.density + " px");
Jon Miranda58561d42021-03-17 10:51:54 -04001071
1072 writer.println(prefix + "\tisTablet:" + isTablet);
Jon Miranda58561d42021-03-17 10:51:54 -04001073 writer.println(prefix + "\tisPhone:" + isPhone);
1074 writer.println(prefix + "\ttransposeLayoutWithOrientation:"
1075 + transposeLayoutWithOrientation);
1076
1077 writer.println(prefix + "\tisLandscape:" + isLandscape);
1078 writer.println(prefix + "\tisMultiWindowMode:" + isMultiWindowMode);
Sunny Goyal19ff7282021-04-22 10:12:54 -07001079 writer.println(prefix + "\tisTwoPanels:" + isTwoPanels);
Jon Miranda58561d42021-03-17 10:51:54 -04001080
1081 writer.println(prefix + pxToDpStr("windowX", windowX));
1082 writer.println(prefix + pxToDpStr("windowY", windowY));
1083 writer.println(prefix + pxToDpStr("widthPx", widthPx));
1084 writer.println(prefix + pxToDpStr("heightPx", heightPx));
1085
1086 writer.println(prefix + pxToDpStr("availableWidthPx", availableWidthPx));
1087 writer.println(prefix + pxToDpStr("availableHeightPx", availableHeightPx));
1088
1089 writer.println(prefix + "\taspectRatio:" + aspectRatio);
1090
1091 writer.println(prefix + "\tisScalableGrid:" + isScalableGrid);
1092
Thales Lima83bedbf2021-10-05 17:47:39 +01001093 writer.println(prefix + "\tinv.numRows: " + inv.numRows);
Alex Chau9fee3fd2021-12-01 18:43:10 +00001094 writer.println(prefix + "\tinv.numColumns: " + inv.numColumns);
1095 writer.println(prefix + "\tinv.numSearchContainerColumns: "
1096 + inv.numSearchContainerColumns);
Jon Miranda58561d42021-03-17 10:51:54 -04001097
Thales Lima83bedbf2021-10-05 17:47:39 +01001098 writer.println(prefix + "\tminCellSize: " + inv.minCellSize[mTypeIndex] + "dp");
Jon Mirandaab3c6812021-06-28 15:42:28 -07001099
Jon Miranda58561d42021-03-17 10:51:54 -04001100 writer.println(prefix + pxToDpStr("cellWidthPx", cellWidthPx));
1101 writer.println(prefix + pxToDpStr("cellHeightPx", cellHeightPx));
1102
1103 writer.println(prefix + pxToDpStr("getCellSize().x", getCellSize().x));
1104 writer.println(prefix + pxToDpStr("getCellSize().y", getCellSize().y));
1105
Thales Lima83bedbf2021-10-05 17:47:39 +01001106 writer.println(prefix + pxToDpStr("cellLayoutBorderSpacePx Horizontal",
1107 cellLayoutBorderSpacePx.x));
1108 writer.println(prefix + pxToDpStr("cellLayoutBorderSpacePx Vertical",
1109 cellLayoutBorderSpacePx.y));
1110
Jon Miranda58561d42021-03-17 10:51:54 -04001111 writer.println(prefix + pxToDpStr("iconSizePx", iconSizePx));
1112 writer.println(prefix + pxToDpStr("iconTextSizePx", iconTextSizePx));
1113 writer.println(prefix + pxToDpStr("iconDrawablePaddingPx", iconDrawablePaddingPx));
1114
1115 writer.println(prefix + pxToDpStr("folderCellWidthPx", folderCellWidthPx));
1116 writer.println(prefix + pxToDpStr("folderCellHeightPx", folderCellHeightPx));
1117 writer.println(prefix + pxToDpStr("folderChildIconSizePx", folderChildIconSizePx));
1118 writer.println(prefix + pxToDpStr("folderChildTextSizePx", folderChildTextSizePx));
1119 writer.println(prefix + pxToDpStr("folderChildDrawablePaddingPx",
1120 folderChildDrawablePaddingPx));
Thales Lima78d00ad2021-09-30 11:29:06 +01001121 writer.println(prefix + pxToDpStr("folderCellLayoutBorderSpaceOriginalPx",
1122 folderCellLayoutBorderSpaceOriginalPx));
1123 writer.println(prefix + pxToDpStr("folderCellLayoutBorderSpacePx Horizontal",
1124 folderCellLayoutBorderSpacePx.x));
1125 writer.println(prefix + pxToDpStr("folderCellLayoutBorderSpacePx Vertical",
1126 folderCellLayoutBorderSpacePx.y));
Jon Miranda58561d42021-03-17 10:51:54 -04001127
Jon Miranda58561d42021-03-17 10:51:54 -04001128 writer.println(prefix + pxToDpStr("allAppsIconSizePx", allAppsIconSizePx));
1129 writer.println(prefix + pxToDpStr("allAppsIconTextSizePx", allAppsIconTextSizePx));
1130 writer.println(prefix + pxToDpStr("allAppsIconDrawablePaddingPx",
1131 allAppsIconDrawablePaddingPx));
1132 writer.println(prefix + pxToDpStr("allAppsCellHeightPx", allAppsCellHeightPx));
Alex Chau27b39b92022-01-14 18:02:18 +00001133 writer.println(prefix + pxToDpStr("allAppsCellWidthPx", allAppsCellWidthPx));
Sunny Goyal19ff7282021-04-22 10:12:54 -07001134 writer.println(prefix + "\tnumShownAllAppsColumns: " + numShownAllAppsColumns);
Alex Chau27b39b92022-01-14 18:02:18 +00001135 writer.println(prefix + pxToDpStr("allAppsLeftRightPadding", allAppsLeftRightPadding));
1136 writer.println(prefix + pxToDpStr("allAppsLeftRightMargin", allAppsLeftRightMargin));
Jon Miranda58561d42021-03-17 10:51:54 -04001137
1138 writer.println(prefix + pxToDpStr("hotseatBarSizePx", hotseatBarSizePx));
1139 writer.println(prefix + pxToDpStr("hotseatCellHeightPx", hotseatCellHeightPx));
1140 writer.println(prefix + pxToDpStr("hotseatBarTopPaddingPx", hotseatBarTopPaddingPx));
1141 writer.println(prefix + pxToDpStr("hotseatBarBottomPaddingPx", hotseatBarBottomPaddingPx));
1142 writer.println(prefix + pxToDpStr("hotseatBarSidePaddingStartPx",
1143 hotseatBarSidePaddingStartPx));
1144 writer.println(prefix + pxToDpStr("hotseatBarSidePaddingEndPx",
1145 hotseatBarSidePaddingEndPx));
Sunny Goyal19ff7282021-04-22 10:12:54 -07001146 writer.println(prefix + "\tnumShownHotseatIcons: " + numShownHotseatIcons);
Thales Limaa1012902022-01-13 17:58:42 +00001147 writer.println(prefix + "\tisQsbInline: " + isQsbInline);
1148 writer.println(prefix + pxToDpStr("qsbWidth", qsbWidth));
Jon Miranda58561d42021-03-17 10:51:54 -04001149
1150 writer.println(prefix + "\tisTaskbarPresent:" + isTaskbarPresent);
Tony Wickham635e1802021-07-22 14:28:04 -10001151 writer.println(prefix + "\tisTaskbarPresentInApps:" + isTaskbarPresentInApps);
Jon Miranda58561d42021-03-17 10:51:54 -04001152 writer.println(prefix + pxToDpStr("taskbarSize", taskbarSize));
Jon Miranda58561d42021-03-17 10:51:54 -04001153
Thales Lima83bedbf2021-10-05 17:47:39 +01001154 writer.println(prefix + pxToDpStr("desiredWorkspaceHorizontalMarginPx",
1155 desiredWorkspaceHorizontalMarginPx));
Jon Miranda58561d42021-03-17 10:51:54 -04001156 writer.println(prefix + pxToDpStr("workspacePadding.left", workspacePadding.left));
1157 writer.println(prefix + pxToDpStr("workspacePadding.top", workspacePadding.top));
1158 writer.println(prefix + pxToDpStr("workspacePadding.right", workspacePadding.right));
1159 writer.println(prefix + pxToDpStr("workspacePadding.bottom", workspacePadding.bottom));
1160
Jon Mirandaab3c6812021-06-28 15:42:28 -07001161 writer.println(prefix + pxToDpStr("iconScale", iconScale));
1162 writer.println(prefix + pxToDpStr("cellScaleToFit ", cellScaleToFit));
Jon Miranda58561d42021-03-17 10:51:54 -04001163 writer.println(prefix + pxToDpStr("extraSpace", extraSpace));
Thales Lima7a6752d2021-09-23 14:31:00 +01001164 writer.println(prefix + pxToDpStr("unscaled extraSpace", extraSpace / iconScale));
Jon Mirandac9e69fa2021-03-22 17:13:34 -04001165
1166 if (inv.devicePaddings != null) {
1167 int unscaledExtraSpace = (int) (extraSpace / iconScale);
1168 writer.println(prefix + pxToDpStr("maxEmptySpace",
1169 inv.devicePaddings.getDevicePadding(unscaledExtraSpace).getMaxEmptySpacePx()));
1170 }
Jon Miranda58561d42021-03-17 10:51:54 -04001171 writer.println(prefix + pxToDpStr("workspaceTopPadding", workspaceTopPadding));
1172 writer.println(prefix + pxToDpStr("workspaceBottomPadding", workspaceBottomPadding));
1173 writer.println(prefix + pxToDpStr("extraHotseatBottomPadding", extraHotseatBottomPadding));
Alex Chau635b3ab2022-01-26 16:49:10 +00001174
1175 writer.println(prefix + pxToDpStr("overviewTaskMarginPx", overviewTaskMarginPx));
1176 writer.println(prefix + pxToDpStr("overviewTaskMarginGridPx", overviewTaskMarginGridPx));
1177 writer.println(prefix + pxToDpStr("overviewTaskIconSizePx", overviewTaskIconSizePx));
1178 writer.println(prefix + pxToDpStr("overviewTaskIconDrawableSizePx",
1179 overviewTaskIconDrawableSizePx));
1180 writer.println(prefix + pxToDpStr("overviewTaskIconDrawableSizeGridPx",
1181 overviewTaskIconDrawableSizeGridPx));
1182 writer.println(prefix + pxToDpStr("overviewTaskThumbnailTopMarginPx",
1183 overviewTaskThumbnailTopMarginPx));
1184 writer.println(prefix + pxToDpStr("overviewActionsMarginThreeButtonPx",
1185 overviewActionsMarginThreeButtonPx));
1186 writer.println(prefix + pxToDpStr("overviewActionsTopMarginGesturePx",
1187 overviewActionsTopMarginGesturePx));
1188 writer.println(prefix + pxToDpStr("overviewActionsBottomMarginGesturePx",
1189 overviewActionsBottomMarginGesturePx));
1190 writer.println(prefix + pxToDpStr("overviewActionsButtonSpacing",
1191 overviewActionsButtonSpacing));
1192 writer.println(prefix + pxToDpStr("overviewPageSpacing", overviewPageSpacing));
1193 writer.println(prefix + pxToDpStr("overviewRowSpacing", overviewRowSpacing));
1194 writer.println(prefix + pxToDpStr("overviewGridSideMargin", overviewGridSideMargin));
Jon Miranda58561d42021-03-17 10:51:54 -04001195 }
1196
Sunny Goyalfd58da62020-08-11 12:06:49 -07001197 private static Context getContext(Context c, Info info, int orientation) {
Sunny Goyal1890f672020-04-30 12:28:00 -07001198 Configuration config = new Configuration(c.getResources().getConfiguration());
1199 config.orientation = orientation;
Sunny Goyal35c7b192021-04-20 16:51:10 -07001200 config.densityDpi = info.densityDpi;
Sunny Goyal1890f672020-04-30 12:28:00 -07001201 return c.createConfigurationContext(config);
Jon Mirandab28c4fc2017-06-20 10:58:36 -07001202 }
Sunny Goyalfde55052018-02-01 14:46:13 -08001203
1204 /**
1205 * Callback when a component changes the DeviceProfile associated with it, as a result of
1206 * configuration change
1207 */
1208 public interface OnDeviceProfileChangeListener {
1209
1210 /**
1211 * Called when the device profile is reassigned. Note that for layout and measurements, it
1212 * is sufficient to listen for inset changes. Use this callback when you need to perform
1213 * a one time operation.
1214 */
1215 void onDeviceProfileChanged(DeviceProfile dp);
1216 }
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001217
1218 public static class Builder {
1219 private Context mContext;
1220 private InvariantDeviceProfile mInv;
Sunny Goyalfd58da62020-08-11 12:06:49 -07001221 private Info mInfo;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001222
Sunny Goyal19ff7282021-04-22 10:12:54 -07001223 private WindowBounds mWindowBounds;
1224 private boolean mUseTwoPanels;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001225
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001226 private boolean mIsMultiWindowMode = false;
Sunny Goyal19ff7282021-04-22 10:12:54 -07001227 private Boolean mTransposeLayoutWithOrientation;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001228
Sunny Goyalfd58da62020-08-11 12:06:49 -07001229 public Builder(Context context, InvariantDeviceProfile inv, Info info) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001230 mContext = context;
1231 mInv = inv;
1232 mInfo = info;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001233 }
1234
1235 public Builder setMultiWindowMode(boolean isMultiWindowMode) {
1236 mIsMultiWindowMode = isMultiWindowMode;
1237 return this;
1238 }
1239
Sunny Goyal19ff7282021-04-22 10:12:54 -07001240 public Builder setUseTwoPanels(boolean useTwoPanels) {
1241 mUseTwoPanels = useTwoPanels;
1242 return this;
1243 }
1244
1245
1246 public Builder setWindowBounds(WindowBounds bounds) {
1247 mWindowBounds = bounds;
Sunny Goyal0addbf02020-04-28 14:17:35 -07001248 return this;
1249 }
1250
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001251 public Builder setTransposeLayoutWithOrientation(boolean transposeLayoutWithOrientation) {
1252 mTransposeLayoutWithOrientation = transposeLayoutWithOrientation;
1253 return this;
1254 }
1255
1256 public DeviceProfile build() {
Sunny Goyal19ff7282021-04-22 10:12:54 -07001257 if (mWindowBounds == null) {
1258 throw new IllegalArgumentException("Window bounds not set");
1259 }
1260 if (mTransposeLayoutWithOrientation == null) {
1261 mTransposeLayoutWithOrientation = !mInfo.isTablet(mWindowBounds);
1262 }
1263 return new DeviceProfile(mContext, mInv, mInfo, mWindowBounds,
1264 mIsMultiWindowMode, mTransposeLayoutWithOrientation, mUseTwoPanels);
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001265 }
1266 }
1267
Winson Chungb3800242013-10-24 11:01:54 -07001268}