blob: a2324ac3444369361d078fbfe53c2703ae0f6110 [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;
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -070064
Sunny Goyalc6205602015-05-21 20:46:33 -070065 // Device properties in current orientation
Sunny Goyald792a772018-04-05 13:37:46 -070066 public final boolean isLandscape;
Sunny Goyald70e75a2018-02-22 10:07:32 -080067 public final boolean isMultiWindowMode;
68
Sunny Goyal0addbf02020-04-28 14:17:35 -070069 public final int windowX;
70 public final int windowY;
Sunny Goyalc6205602015-05-21 20:46:33 -070071 public final int widthPx;
72 public final int heightPx;
73 public final int availableWidthPx;
74 public final int availableHeightPx;
Jon Mirandabba64512019-03-27 10:54:17 -070075
76 public final float aspectRatio;
77
Jon Mirandae126d722021-02-25 10:45:20 -050078 public final boolean isScalableGrid;
Thales Lima83bedbf2021-10-05 17:47:39 +010079 private final int mTypeIndex;
Jon Mirandae126d722021-02-25 10:45:20 -050080
Tony Wickhamd6b40372015-09-23 18:37:57 -070081 /**
82 * The maximum amount of left/right workspace padding as a percentage of the screen width.
83 * To be clear, this means that up to 7% of the screen width can be used as left padding, and
84 * 7% of the screen width can be used as right padding.
85 */
86 private static final float MAX_HORIZONTAL_PADDING_PERCENT = 0.14f;
Winson Chungb3800242013-10-24 11:01:54 -070087
Jon Miranda3f9bab22017-07-28 14:50:17 -070088 private static final float TALL_DEVICE_ASPECT_RATIO_THRESHOLD = 2.0f;
Jon Miranda80cddbc2021-07-22 13:51:16 -070089 private static final float TALLER_DEVICE_ASPECT_RATIO_THRESHOLD = 2.15f;
Jon Miranda80dda302021-07-28 14:14:59 -070090 private static final float TALL_DEVICE_EXTRA_SPACE_THRESHOLD_DP = 252;
91 private static final float TALL_DEVICE_MORE_EXTRA_SPACE_THRESHOLD_DP = 268;
Jon Miranda30d0aa22017-07-25 15:55:29 -070092
Jon Miranda5eacbb72018-07-31 11:14:46 -070093 // To evenly space the icons, increase the left/right margins for tablets in portrait mode.
94 private static final int PORTRAIT_TABLET_LEFT_RIGHT_PADDING_MULTIPLIER = 4;
95
Sunny Goyalc6205602015-05-21 20:46:33 -070096 // Workspace
Thales Limad90faab2021-09-21 17:18:47 +010097 public final int desiredWorkspaceHorizontalMarginOriginalPx;
98 public int desiredWorkspaceHorizontalMarginPx;
Thales Lima78d00ad2021-09-30 11:29:06 +010099 public Point cellLayoutBorderSpaceOriginalPx;
100 public Point cellLayoutBorderSpacePx;
Jon Miranda28032002017-07-13 16:18:56 -0700101 public final int cellLayoutPaddingLeftRightPx;
Jon Miranda18751b62017-07-31 17:25:27 -0700102 public final int cellLayoutBottomPaddingPx;
Sunny Goyalc6205602015-05-21 20:46:33 -0700103 public final int edgeMarginPx;
Sunny Goyal47328fd2016-05-25 18:56:41 -0700104 public float workspaceSpringLoadShrinkFactor;
105 public final int workspaceSpringLoadedBottomSpace;
Sunny Goyalc6205602015-05-21 20:46:33 -0700106
Jon Miranda58561d42021-03-17 10:51:54 -0400107 private final int extraSpace;
Jon Miranda228877d2021-02-09 11:05:00 -0500108 public int workspaceTopPadding;
109 public int workspaceBottomPadding;
Jon Miranda58561d42021-03-17 10:51:54 -0400110 public int extraHotseatBottomPadding;
Jon Miranda228877d2021-02-09 11:05:00 -0500111
Tony Wickham5edf9e22020-03-27 20:06:52 -0700112 // Workspace page indicator
113 public final int workspacePageIndicatorHeight;
114 private final int mWorkspacePageIndicatorOverlapWorkspace;
Winson1f064272016-07-18 17:18:02 -0700115
Sunny Goyalc6205602015-05-21 20:46:33 -0700116 // Workspace icons
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400117 public float iconScale;
Sunny Goyalc6205602015-05-21 20:46:33 -0700118 public int iconSizePx;
119 public int iconTextSizePx;
120 public int iconDrawablePaddingPx;
Winson Chung5f4e0fd2015-05-22 11:12:27 -0700121 public int iconDrawablePaddingOriginalPx;
Winson Chungb3800242013-10-24 11:01:54 -0700122
Jon Mirandaab3c6812021-06-28 15:42:28 -0700123 public float cellScaleToFit;
Adam Cohen59400422014-03-05 18:07:04 -0800124 public int cellWidthPx;
125 public int cellHeightPx;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700126 public int workspaceCellPaddingXPx;
Adam Cohen59400422014-03-05 18:07:04 -0800127
Jon Mirandae126d722021-02-25 10:45:20 -0500128 public int cellYPaddingPx;
Jon Mirandae126d722021-02-25 10:45:20 -0500129
Sunny Goyalc6205602015-05-21 20:46:33 -0700130 // Folder
Jon Mirandae126d722021-02-25 10:45:20 -0500131 public float folderLabelTextScale;
132 public int folderLabelTextSizePx;
Sunny Goyalc6205602015-05-21 20:46:33 -0700133 public int folderIconSizePx;
Jon Miranda591e3602018-03-28 11:37:00 -0700134 public int folderIconOffsetYPx;
Jon Mirandabf7d8122016-11-03 15:29:29 -0700135
Jon Mirandae126d722021-02-25 10:45:20 -0500136 // Folder content
Thales Lima78d00ad2021-09-30 11:29:06 +0100137 public Point folderCellLayoutBorderSpacePx;
138 public int folderCellLayoutBorderSpaceOriginalPx;
Jon Mirandae126d722021-02-25 10:45:20 -0500139 public int folderContentPaddingLeftRight;
140 public int folderContentPaddingTop;
141
Jon Mirandabf7d8122016-11-03 15:29:29 -0700142 // Folder cell
Sunny Goyalc6205602015-05-21 20:46:33 -0700143 public int folderCellWidthPx;
144 public int folderCellHeightPx;
Jon Mirandabf7d8122016-11-03 15:29:29 -0700145
146 // Folder child
147 public int folderChildIconSizePx;
148 public int folderChildTextSizePx;
Sunny Goyalbaec6ff2016-09-14 11:26:21 -0700149 public int folderChildDrawablePaddingPx;
Winson Chungb3800242013-10-24 11:01:54 -0700150
Sunny Goyalc6205602015-05-21 20:46:33 -0700151 // Hotseat
Jon Miranda80cddbc2021-07-22 13:51:16 -0700152 public int hotseatBarSizeExtraSpacePx;
Tony Wickhamb87f3cd2021-04-07 15:02:37 -0700153 public final int numShownHotseatIcons;
Sunny Goyalc6205602015-05-21 20:46:33 -0700154 public int hotseatCellHeightPx;
Jon Miranda0d284852021-06-22 14:50:55 -0700155 private final int hotseatExtraVerticalSize;
Jon Miranda18751b62017-07-31 17:25:27 -0700156 // In portrait: size = height, in landscape: size = width
157 public int hotseatBarSizePx;
Jon Miranda80cddbc2021-07-22 13:51:16 -0700158 public int hotseatBarTopPaddingPx;
Jon Miranda0d284852021-06-22 14:50:55 -0700159 public final int hotseatBarBottomPaddingPx;
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700160 // Start is the side next to the nav bar, end is the side next to the workspace
161 public final int hotseatBarSidePaddingStartPx;
162 public final int hotseatBarSidePaddingEndPx;
Sunny Goyal57b22792021-05-25 14:35:01 -0700163 public final int hotseatQsbHeight;
Thales Limadd027342022-01-07 12:54:37 +0000164 public int hotseatBorderSpace;
Adam Cohen2e6da152015-05-06 11:42:25 -0700165
Jon Miranda8bdb2222021-06-23 18:10:10 -0700166 public final float qsbBottomMarginOriginalPx;
167 public int qsbBottomMarginPx;
168
Sunny Goyalc6205602015-05-21 20:46:33 -0700169 // All apps
Thales Lima85c942f2021-12-31 13:04:20 +0000170 public Point allAppsBorderSpacePx;
Samuel Fufaee9aff92021-04-05 13:30:40 -0500171 public int allAppsOpenVerticalTranslate;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700172 public int allAppsCellHeightPx;
Samuel Fufaf1424a32019-10-04 15:15:19 -0700173 public int allAppsCellWidthPx;
Winson1f064272016-07-18 17:18:02 -0700174 public int allAppsIconSizePx;
175 public int allAppsIconDrawablePaddingPx;
sfufa@google.comde013292021-09-21 18:22:44 -0700176 public int allAppsLeftRightPadding;
Alex Chau27b39b92022-01-14 18:02:18 +0000177 public int allAppsLeftRightMargin;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700178 public final int numShownAllAppsColumns;
Winson1f064272016-07-18 17:18:02 -0700179 public float allAppsIconTextSizePx;
180
Zak Cohen334efeb2021-03-19 16:42:07 -0700181 // Overview
Alex Chau646f8042021-07-26 11:56:22 +0100182 public final boolean overviewShowAsGrid;
Zak Cohen334efeb2021-03-19 16:42:07 -0700183 public int overviewTaskMarginPx;
Alex Chaueaa6d682021-08-17 12:56:15 +0100184 public int overviewTaskMarginGridPx;
Alex Chaudedbc8a2021-03-17 16:53:26 +0000185 public int overviewTaskIconSizePx;
Alex Chauac9df382021-08-02 19:08:41 +0100186 public int overviewTaskIconDrawableSizePx;
187 public int overviewTaskIconDrawableSizeGridPx;
Alex Chaudedbc8a2021-03-17 16:53:26 +0000188 public int overviewTaskThumbnailTopMarginPx;
zakcohendad8a802021-05-20 09:52:26 -0700189 public final int overviewActionsMarginThreeButtonPx;
Alex Chau5fd9d492021-07-22 17:27:11 +0100190 public final int overviewActionsTopMarginGesturePx;
191 public final int overviewActionsBottomMarginGesturePx;
Alex Chau1bf0fe12021-11-30 15:32:45 +0000192 public final int overviewActionsButtonSpacing;
Alex Chau5fd9d492021-07-22 17:27:11 +0100193 public int overviewPageSpacing;
194 public int overviewRowSpacing;
Alex Chau56bd2572021-11-03 18:48:18 +0000195 public int overviewGridSideMargin;
Zak Cohen334efeb2021-03-19 16:42:07 -0700196
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800197 // Widgets
198 public final PointF appWidgetScale = new PointF(1.0f, 1.0f);
199
Sunny Goyal47328fd2016-05-25 18:56:41 -0700200 // Drop Target
201 public int dropTargetBarSizePx;
Alex Chaua02eddc2021-04-29 00:36:06 +0100202 public int dropTargetDragPaddingPx;
203 public int dropTargetTextSizePx;
Adam Cohen4ae96ce2014-08-29 15:05:48 -0700204
Winson1f064272016-07-18 17:18:02 -0700205 // Insets
Sunny Goyal07b69292018-01-08 14:19:34 -0800206 private final Rect mInsets = new Rect();
207 public final Rect workspacePadding = new Rect();
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700208 private final Rect mHotseatPadding = new Rect();
Jon Miranda0bd63d12019-03-06 17:29:29 -0800209 // When true, nav bar is on the left side of the screen.
Sunny Goyal59d086c2018-05-07 17:31:40 -0700210 private boolean mIsSeascape;
Winson1f064272016-07-18 17:18:02 -0700211
Tony Wickhamf34bee82018-12-03 18:11:39 -0800212 // Notification dots
Samuel Fufac96fa242019-09-26 23:06:32 -0700213 public DotRenderer mDotRendererWorkSpace;
214 public DotRenderer mDotRendererAllApps;
Tony Wickham9a8d11f2017-01-11 09:53:12 -0800215
Pierre Barbier de Reuille578deba2021-09-24 13:47:44 +0100216 // Taskbar
Tony Wickham15883892021-02-12 11:24:40 -0800217 public boolean isTaskbarPresent;
Tony Wickham635e1802021-07-22 14:28:04 -1000218 // Whether Taskbar will inset the bottom of apps by taskbarSize.
219 public boolean isTaskbarPresentInApps;
Tony Wickham15883892021-02-12 11:24:40 -0800220 public int taskbarSize;
221
Alex Chaua02eddc2021-04-29 00:36:06 +0100222 // DragController
223 public int flingToDeleteThresholdVelocity;
224
Vinit Nayak17c4b332021-08-05 12:54:58 -0700225 /** TODO: Once we fully migrate to staged split, remove "isMultiWindowMode" */
Sunny Goyal19ff7282021-04-22 10:12:54 -0700226 DeviceProfile(Context context, InvariantDeviceProfile inv, Info info, WindowBounds windowBounds,
Sunny Goyal0addbf02020-04-28 14:17:35 -0700227 boolean isMultiWindowMode, boolean transposeLayoutWithOrientation,
Sunny Goyal19ff7282021-04-22 10:12:54 -0700228 boolean useTwoPanels) {
Sunny Goyalfee35bb2015-05-11 11:38:19 -0700229
Adam Cohen2e6da152015-05-06 11:42:25 -0700230 this.inv = inv;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700231 this.isLandscape = windowBounds.isLandscape();
Sunny Goyald70e75a2018-02-22 10:07:32 -0800232 this.isMultiWindowMode = isMultiWindowMode;
Jon Mirandae126d722021-02-25 10:45:20 -0500233 this.transposeLayoutWithOrientation = transposeLayoutWithOrientation;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700234 windowX = windowBounds.bounds.left;
235 windowY = windowBounds.bounds.top;
Winson Chungb3800242013-10-24 11:01:54 -0700236
Jon Mirandae126d722021-02-25 10:45:20 -0500237 isScalableGrid = inv.isScalable && !isVerticalBarLayout() && !isMultiWindowMode;
238
Jon Miranda7e183c32018-06-20 11:05:27 -0700239 // Determine sizes.
Sunny Goyal19ff7282021-04-22 10:12:54 -0700240 widthPx = windowBounds.bounds.width();
241 heightPx = windowBounds.bounds.height();
242 availableWidthPx = windowBounds.availableSize.x;
Tony Wickham21970cc2021-09-15 15:44:05 -0700243 availableHeightPx = windowBounds.availableSize.y;
Jon Miranda7e183c32018-06-20 11:05:27 -0700244
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700245 mInfo = info;
Alex Chau29983072021-11-19 15:14:20 +0000246 isTablet = info.isTablet(windowBounds);
Sunny Goyal19ff7282021-04-22 10:12:54 -0700247 isPhone = !isTablet;
Alex Chau90125822021-11-17 14:16:58 +0000248 isTwoPanels = isTablet && useTwoPanels;
Adam Cohen2e6da152015-05-06 11:42:25 -0700249
Jon Mirandabba64512019-03-27 10:54:17 -0700250 aspectRatio = ((float) Math.max(widthPx, heightPx)) / Math.min(widthPx, heightPx);
Jon Miranda7e183c32018-06-20 11:05:27 -0700251 boolean isTallDevice = Float.compare(aspectRatio, TALL_DEVICE_ASPECT_RATIO_THRESHOLD) >= 0;
Pratyush9afe1ea2021-10-13 11:13:27 +0000252 mQsbCenterFactor = context.getResources().getFloat(R.dimen.qsb_center_factor);
Sunny Goyalc6205602015-05-21 20:46:33 -0700253 // Some more constants
Sunny Goyal1890f672020-04-30 12:28:00 -0700254 context = getContext(context, info, isVerticalBarLayout()
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700255 ? Configuration.ORIENTATION_LANDSCAPE
256 : Configuration.ORIENTATION_PORTRAIT);
Sunny Goyal35c7b192021-04-20 16:51:10 -0700257 mMetrics = context.getResources().getDisplayMetrics();
Sunny Goyal1890f672020-04-30 12:28:00 -0700258 final Resources res = context.getResources();
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700259
Thales Lima83bedbf2021-10-05 17:47:39 +0100260 if (isTwoPanels) {
261 if (isLandscape) {
262 mTypeIndex = InvariantDeviceProfile.INDEX_TWO_PANEL_LANDSCAPE;
263 } else {
264 mTypeIndex = InvariantDeviceProfile.INDEX_TWO_PANEL_PORTRAIT;
265 }
266 } else {
267 if (isLandscape) {
268 mTypeIndex = InvariantDeviceProfile.INDEX_LANDSCAPE;
269 } else {
270 mTypeIndex = InvariantDeviceProfile.INDEX_DEFAULT;
271 }
272 }
273
Sunny Goyal57b22792021-05-25 14:35:01 -0700274 hotseatQsbHeight = res.getDimensionPixelSize(R.dimen.qsb_widget_height);
Sunny Goyal71ef9682021-07-29 12:59:27 -0700275 isTaskbarPresent = isTablet && ApiWrapper.TASKBAR_DRAWN_IN_PROCESS
276 && FeatureFlags.ENABLE_TASKBAR.get();
Tony Wickham15883892021-02-12 11:24:40 -0800277 if (isTaskbarPresent) {
Tony Wickham15883892021-02-12 11:24:40 -0800278 taskbarSize = res.getDimensionPixelSize(R.dimen.taskbar_size);
Tony Wickham15883892021-02-12 11:24:40 -0800279 }
Tony Wickham15883892021-02-12 11:24:40 -0800280
Winson Chungb3800242013-10-24 11:01:54 -0700281 edgeMarginPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_edge_margin);
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700282
Thales Limad90faab2021-09-21 17:18:47 +0100283 desiredWorkspaceHorizontalMarginPx = getHorizontalMarginPx(inv, res);
284 desiredWorkspaceHorizontalMarginOriginalPx = desiredWorkspaceHorizontalMarginPx;
Samuel Fufaee9aff92021-04-05 13:30:40 -0500285
286 allAppsOpenVerticalTranslate = res.getDimensionPixelSize(
287 R.dimen.all_apps_open_vertical_translate);
288
Jon Mirandae126d722021-02-25 10:45:20 -0500289 folderLabelTextScale = res.getFloat(R.dimen.folder_label_text_scale);
290 folderContentPaddingLeftRight =
291 res.getDimensionPixelSize(R.dimen.folder_content_padding_left_right);
292 folderContentPaddingTop = res.getDimensionPixelSize(R.dimen.folder_content_padding_top);
293
Thales Lima78d00ad2021-09-30 11:29:06 +0100294 cellLayoutBorderSpacePx = getCellLayoutBorderSpace(inv);
Thales Lima85c942f2021-12-31 13:04:20 +0000295 allAppsBorderSpacePx = new Point(
Thales Limabb7d3882021-12-22 12:56:29 +0000296 pxFromDp(inv.allAppsBorderSpaces[mTypeIndex].x, mMetrics),
297 pxFromDp(inv.allAppsBorderSpaces[mTypeIndex].y, mMetrics));
Thales Lima78d00ad2021-09-30 11:29:06 +0100298 cellLayoutBorderSpaceOriginalPx = new Point(cellLayoutBorderSpacePx);
299 folderCellLayoutBorderSpaceOriginalPx = pxFromDp(inv.folderBorderSpace, mMetrics, 1f);
300 folderCellLayoutBorderSpacePx = new Point(folderCellLayoutBorderSpaceOriginalPx,
301 folderCellLayoutBorderSpaceOriginalPx);
Jon Mirandae126d722021-02-25 10:45:20 -0500302
Jon Miranda5eacbb72018-07-31 11:14:46 -0700303 int cellLayoutPaddingLeftRightMultiplier = !isVerticalBarLayout() && isTablet
304 ? PORTRAIT_TABLET_LEFT_RIGHT_PADDING_MULTIPLIER : 1;
Jon Mirandae126d722021-02-25 10:45:20 -0500305 int cellLayoutPadding = isScalableGrid
306 ? 0
307 : res.getDimensionPixelSize(R.dimen.dynamic_grid_cell_layout_padding);
Andras Kloczl8e57cce2021-02-11 23:51:19 +0100308
Sunny Goyal19ff7282021-04-22 10:12:54 -0700309 if (isTwoPanels) {
Thales Lima7a6752d2021-09-23 14:31:00 +0100310 cellLayoutPaddingLeftRightPx = 0;
Andras Kloczl8e57cce2021-02-11 23:51:19 +0100311 cellLayoutBottomPaddingPx = 0;
312 } else if (isLandscape) {
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700313 cellLayoutPaddingLeftRightPx = 0;
314 cellLayoutBottomPaddingPx = cellLayoutPadding;
315 } else {
316 cellLayoutPaddingLeftRightPx = cellLayoutPaddingLeftRightMultiplier * cellLayoutPadding;
317 cellLayoutBottomPaddingPx = 0;
318 }
319
Tony Wickham5edf9e22020-03-27 20:06:52 -0700320 workspacePageIndicatorHeight = res.getDimensionPixelSize(
321 R.dimen.workspace_page_indicator_height);
322 mWorkspacePageIndicatorOverlapWorkspace =
323 res.getDimensionPixelSize(R.dimen.workspace_page_indicator_overlap_workspace);
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700324
Winson Chungb3800242013-10-24 11:01:54 -0700325 iconDrawablePaddingOriginalPx =
326 res.getDimensionPixelSize(R.dimen.dynamic_grid_icon_drawable_padding);
Alex Chaua02eddc2021-04-29 00:36:06 +0100327
Sunny Goyal47328fd2016-05-25 18:56:41 -0700328 dropTargetBarSizePx = res.getDimensionPixelSize(R.dimen.dynamic_grid_drop_target_size);
Alex Chaua02eddc2021-04-29 00:36:06 +0100329 dropTargetDragPaddingPx = res.getDimensionPixelSize(R.dimen.drop_target_drag_padding);
330 dropTargetTextSizePx = res.getDimensionPixelSize(R.dimen.drop_target_text_size);
331
Sunny Goyal47328fd2016-05-25 18:56:41 -0700332 workspaceSpringLoadedBottomSpace =
333 res.getDimensionPixelSize(R.dimen.dynamic_grid_min_spring_loaded_space);
Sunny Goyald5190522017-04-24 03:06:54 -0700334
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700335 workspaceCellPaddingXPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_cell_padding_x);
Jon Miranda09660722017-06-14 14:20:14 -0700336
Sunny Goyal19ff7282021-04-22 10:12:54 -0700337 numShownHotseatIcons =
338 isTwoPanels ? inv.numDatabaseHotseatIcons : inv.numShownHotseatIcons;
339 numShownAllAppsColumns =
340 isTwoPanels ? inv.numDatabaseAllAppsColumns : inv.numAllAppsColumns;
Jon Miranda80cddbc2021-07-22 13:51:16 -0700341 hotseatBarSizeExtraSpacePx = 0;
Winson1f064272016-07-18 17:18:02 -0700342 hotseatBarTopPaddingPx =
343 res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_top_padding);
Pratyush9afe1ea2021-10-13 11:13:27 +0000344 hotseatBarBottomPaddingPx = (isTallDevice ? res.getDimensionPixelSize(
345 R.dimen.dynamic_grid_hotseat_bottom_tall_padding)
Jon Miranda7e183c32018-06-20 11:05:27 -0700346 : res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_bottom_non_tall_padding))
347 + res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_bottom_padding);
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700348 hotseatBarSidePaddingEndPx =
Sunny Goyal228153d2018-01-04 15:35:22 -0800349 res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_side_padding);
Jon Miranda3f411e72019-05-16 17:15:16 -0700350 // Add a bit of space between nav bar and hotseat in vertical bar layout.
Tony Wickham5edf9e22020-03-27 20:06:52 -0700351 hotseatBarSidePaddingStartPx = isVerticalBarLayout() ? workspacePageIndicatorHeight : 0;
Jon Miranda0d284852021-06-22 14:50:55 -0700352 hotseatExtraVerticalSize =
Jon Miranda228877d2021-02-09 11:05:00 -0500353 res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_extra_vertical_size);
Thales Lima6e7f36c2022-01-04 12:14:11 +0000354 hotseatBorderSpace = pxFromDp(inv.hotseatBorderSpaces[mTypeIndex], mMetrics);
Thales Lima83bedbf2021-10-05 17:47:39 +0100355 updateHotseatIconSize(
Thales Lima6e7f36c2022-01-04 12:14:11 +0000356 pxFromDp(inv.iconSize[InvariantDeviceProfile.INDEX_DEFAULT], mMetrics));
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700357
Jon Miranda8bdb2222021-06-23 18:10:10 -0700358 qsbBottomMarginOriginalPx = isScalableGrid
359 ? res.getDimensionPixelSize(R.dimen.scalable_grid_qsb_bottom_margin)
360 : 0;
361
Alex Chau646f8042021-07-26 11:56:22 +0100362 overviewShowAsGrid = isTablet && FeatureFlags.ENABLE_OVERVIEW_GRID.get();
Alex Chau5fd9d492021-07-22 17:27:11 +0100363 overviewTaskMarginPx = overviewShowAsGrid
Alex Chaueaa6d682021-08-17 12:56:15 +0100364 ? res.getDimensionPixelSize(R.dimen.overview_task_margin_focused)
Alex Chau5fd9d492021-07-22 17:27:11 +0100365 : res.getDimensionPixelSize(R.dimen.overview_task_margin);
Alex Chaueaa6d682021-08-17 12:56:15 +0100366 overviewTaskMarginGridPx = res.getDimensionPixelSize(R.dimen.overview_task_margin_grid);
Alex Chau5fd9d492021-07-22 17:27:11 +0100367 overviewTaskIconSizePx = res.getDimensionPixelSize(R.dimen.task_thumbnail_icon_size);
Alex Chauac9df382021-08-02 19:08:41 +0100368 overviewTaskIconDrawableSizePx =
369 res.getDimensionPixelSize(R.dimen.task_thumbnail_icon_drawable_size);
370 overviewTaskIconDrawableSizeGridPx =
371 res.getDimensionPixelSize(R.dimen.task_thumbnail_icon_drawable_size_grid);
Alex Chaudedbc8a2021-03-17 16:53:26 +0000372 overviewTaskThumbnailTopMarginPx = overviewTaskIconSizePx + overviewTaskMarginPx * 2;
Alex Chau5fd9d492021-07-22 17:27:11 +0100373 if (overviewShowAsGrid) {
374 if (isLandscape) {
375 overviewActionsTopMarginGesturePx = res.getDimensionPixelSize(
376 R.dimen.overview_actions_top_margin_gesture_grid_landscape);
377 overviewActionsBottomMarginGesturePx = res.getDimensionPixelSize(
378 R.dimen.overview_actions_bottom_margin_gesture_grid_landscape);
Alex Chau4f7952e2021-12-06 13:04:57 +0000379 overviewPageSpacing = res.getDimensionPixelSize(
380 R.dimen.overview_page_spacing_grid_landscape);
Alex Chau5fd9d492021-07-22 17:27:11 +0100381 } else {
382 overviewActionsTopMarginGesturePx = res.getDimensionPixelSize(
383 R.dimen.overview_actions_top_margin_gesture_grid_portrait);
384 overviewActionsBottomMarginGesturePx = res.getDimensionPixelSize(
385 R.dimen.overview_actions_bottom_margin_gesture_grid_portrait);
Alex Chau4f7952e2021-12-06 13:04:57 +0000386 overviewPageSpacing = res.getDimensionPixelSize(
387 R.dimen.overview_page_spacing_grid_portrait);
Alex Chau5fd9d492021-07-22 17:27:11 +0100388 }
Alex Chau1bf0fe12021-11-30 15:32:45 +0000389 overviewActionsButtonSpacing = res.getDimensionPixelSize(
390 R.dimen.overview_actions_button_spacing_grid);
Alex Chau5fd9d492021-07-22 17:27:11 +0100391 } else {
392 overviewActionsTopMarginGesturePx = res.getDimensionPixelSize(
393 R.dimen.overview_actions_margin_gesture);
394 overviewActionsBottomMarginGesturePx = overviewActionsTopMarginGesturePx;
Alex Chau4f7952e2021-12-06 13:04:57 +0000395 overviewPageSpacing = res.getDimensionPixelSize(R.dimen.overview_page_spacing);
Alex Chau1bf0fe12021-11-30 15:32:45 +0000396 overviewActionsButtonSpacing = res.getDimensionPixelSize(
397 R.dimen.overview_actions_button_spacing);
Alex Chau5fd9d492021-07-22 17:27:11 +0100398 }
zakcohendad8a802021-05-20 09:52:26 -0700399 overviewActionsMarginThreeButtonPx = res.getDimensionPixelSize(
Alex Chau5fd9d492021-07-22 17:27:11 +0100400 R.dimen.overview_actions_margin_three_button);
Alex Chau4c983742021-12-10 13:09:53 +0000401 // Grid task's top margin is only overviewTaskIconSizePx + overviewTaskMarginGridPx, but
402 // overviewTaskThumbnailTopMarginPx is applied to all TaskThumbnailView, so exclude the
403 // extra margin when calculating row spacing.
404 int extraTopMargin = overviewTaskThumbnailTopMarginPx - overviewTaskIconSizePx
405 - overviewTaskMarginGridPx;
406 overviewRowSpacing = res.getDimensionPixelSize(R.dimen.overview_grid_row_spacing)
407 - extraTopMargin;
Alex Chau56bd2572021-11-03 18:48:18 +0000408 overviewGridSideMargin = isLandscape
409 ? res.getDimensionPixelSize(R.dimen.overview_grid_side_margin_landscape)
410 : res.getDimensionPixelSize(R.dimen.overview_grid_side_margin_portrait);
Zak Cohen334efeb2021-03-19 16:42:07 -0700411
Jon Miranda2ed276e2017-06-29 11:36:34 -0700412 // Calculate all of the remaining variables.
Jon Miranda58561d42021-03-17 10:51:54 -0400413 extraSpace = updateAvailableDimensions(res);
Jon Miranda80cddbc2021-07-22 13:51:16 -0700414
Jon Miranda2ed276e2017-06-29 11:36:34 -0700415 // Now that we have all of the variables calculated, we can tune certain sizes.
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400416 if (isScalableGrid && inv.devicePaddings != null) {
417 // Paddings were created assuming no scaling, so we first unscale the extra space.
Jon Mirandaab3c6812021-06-28 15:42:28 -0700418 int unscaledExtraSpace = (int) (extraSpace / cellScaleToFit);
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400419 DevicePadding padding = inv.devicePaddings.getDevicePadding(unscaledExtraSpace);
Jon Miranda228877d2021-02-09 11:05:00 -0500420
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400421 int paddingWorkspaceTop = padding.getWorkspaceTopPadding(unscaledExtraSpace);
422 int paddingWorkspaceBottom = padding.getWorkspaceBottomPadding(unscaledExtraSpace);
423 int paddingHotseatBottom = padding.getHotseatBottomPadding(unscaledExtraSpace);
424
Jon Mirandaab3c6812021-06-28 15:42:28 -0700425 workspaceTopPadding = Math.round(paddingWorkspaceTop * cellScaleToFit);
426 workspaceBottomPadding = Math.round(paddingWorkspaceBottom * cellScaleToFit);
427 extraHotseatBottomPadding = Math.round(paddingHotseatBottom * cellScaleToFit);
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400428
Jon Miranda58561d42021-03-17 10:51:54 -0400429 hotseatBarSizePx += extraHotseatBottomPadding;
Jon Miranda8bdb2222021-06-23 18:10:10 -0700430
Jon Mirandaab3c6812021-06-28 15:42:28 -0700431 qsbBottomMarginPx = Math.round(qsbBottomMarginOriginalPx * cellScaleToFit);
Jon Miranda228877d2021-02-09 11:05:00 -0500432 } else if (!isVerticalBarLayout() && isPhone && isTallDevice) {
Jon Miranda3f9bab22017-07-28 14:50:17 -0700433 // We increase the hotseat size when there is extra space.
Jon Miranda80cddbc2021-07-22 13:51:16 -0700434
Jon Miranda80dda302021-07-28 14:14:59 -0700435 if (Float.compare(aspectRatio, TALLER_DEVICE_ASPECT_RATIO_THRESHOLD) >= 0
436 && extraSpace >= Utilities.dpToPx(TALL_DEVICE_EXTRA_SPACE_THRESHOLD_DP)) {
437 // For taller devices, we will take a piece of the extra space from each row,
Jon Miranda80cddbc2021-07-22 13:51:16 -0700438 // and add it to the space above and below the hotseat.
Jon Miranda80dda302021-07-28 14:14:59 -0700439
440 // For devices with more extra space, we take a larger piece from each cell.
441 int piece = extraSpace < Utilities.dpToPx(TALL_DEVICE_MORE_EXTRA_SPACE_THRESHOLD_DP)
Jon Mirandaa56cb842021-08-03 17:26:44 -0700442 ? 7 : 5;
Jon Miranda80dda302021-07-28 14:14:59 -0700443
Jon Miranda80cddbc2021-07-22 13:51:16 -0700444 int extraSpace = ((getCellSize().y - iconSizePx - iconDrawablePaddingPx * 2)
Jon Miranda80dda302021-07-28 14:14:59 -0700445 * inv.numRows) / piece;
Jon Miranda80cddbc2021-07-22 13:51:16 -0700446
Jon Mirandaa56cb842021-08-03 17:26:44 -0700447 workspaceTopPadding = extraSpace / 8;
448 int halfLeftOver = (extraSpace - workspaceTopPadding) / 2;
449 hotseatBarTopPaddingPx += halfLeftOver;
450 hotseatBarSizeExtraSpacePx = halfLeftOver;
Jon Miranda80cddbc2021-07-22 13:51:16 -0700451 } else {
452 // ie. For a display with a large aspect ratio, we can keep the icons on the
453 // workspace in portrait mode closer together by adding more height to the hotseat.
454 // Note: This calculation was created after noticing a pattern in the design spec.
455 hotseatBarSizeExtraSpacePx = getCellSize().y - iconSizePx
456 - iconDrawablePaddingPx * 2 - workspacePageIndicatorHeight;
457 }
458
459 updateHotseatIconSize(iconSizePx);
Jon Miranda30d0aa22017-07-25 15:55:29 -0700460
Jon Miranda3f9bab22017-07-28 14:50:17 -0700461 // Recalculate the available dimensions using the new hotseat size.
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700462 updateAvailableDimensions(res);
Jon Miranda2ed276e2017-06-29 11:36:34 -0700463 }
Sunny Goyal07b69292018-01-08 14:19:34 -0800464 updateWorkspacePadding();
Tony Wickham1237df02017-02-24 08:59:36 -0800465
Alex Chaua02eddc2021-04-29 00:36:06 +0100466 flingToDeleteThresholdVelocity = res.getDimensionPixelSize(
467 R.dimen.drag_flingToDeleteMinVelocity);
468
Tony Wickham1237df02017-02-24 08:59:36 -0800469 // This is done last, after iconSizePx is calculated above.
Sunny Goyal8b9919d2021-04-07 14:45:17 -0700470 Path dotPath = GraphicsUtils.getShapePath(DEFAULT_DOT_SIZE);
471 mDotRendererWorkSpace = new DotRenderer(iconSizePx, dotPath, DEFAULT_DOT_SIZE);
Samuel Fufac96fa242019-09-26 23:06:32 -0700472 mDotRendererAllApps = iconSizePx == allAppsIconSizePx ? mDotRendererWorkSpace :
Sunny Goyal8b9919d2021-04-07 14:45:17 -0700473 new DotRenderer(allAppsIconSizePx, dotPath, DEFAULT_DOT_SIZE);
Adam Cohen63f1ec02014-08-12 09:23:13 -0700474 }
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);
Jon Miranda0d284852021-06-22 14:50:55 -0700726 updateHotseatIconSize(iconSizePx);
Winson Chungb3800242013-10-24 11:01:54 -0700727
Sunny Goyal07b69292018-01-08 14:19:34 -0800728 if (!isVerticalLayout) {
Jon Miranda18751b62017-07-31 17:25:27 -0700729 int expectedWorkspaceHeight = availableHeightPx - hotseatBarSizePx
Tony Wickham5edf9e22020-03-27 20:06:52 -0700730 - workspacePageIndicatorHeight - edgeMarginPx;
Sunny Goyal47328fd2016-05-25 18:56:41 -0700731 float minRequiredHeight = dropTargetBarSizePx + workspaceSpringLoadedBottomSpace;
732 workspaceSpringLoadShrinkFactor = Math.min(
733 res.getInteger(R.integer.config_workspaceSpringLoadShrinkPercentage) / 100.0f,
734 1 - (minRequiredHeight / expectedWorkspaceHeight));
735 } else {
736 workspaceSpringLoadShrinkFactor =
737 res.getInteger(R.integer.config_workspaceSpringLoadShrinkPercentage) / 100.0f;
738 }
739
Sunny Goyalbaec6ff2016-09-14 11:26:21 -0700740 // Folder icon
Jon Miranda591e3602018-03-28 11:37:00 -0700741 folderIconSizePx = IconNormalizer.getNormalizedCircleSize(iconSizePx);
742 folderIconOffsetYPx = (iconSizePx - folderIconSizePx) / 2;
Winson Chung0f785722015-04-08 10:27:49 -0700743 }
744
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700745 private void updateAvailableFolderCellDimensions(Resources res) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700746 updateFolderCellSize(1f, res);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700747
Jon Mirandae126d722021-02-25 10:45:20 -0500748 final int folderBottomPanelSize = res.getDimensionPixelSize(R.dimen.folder_label_height);
749
Jon Mirandac1b23992016-12-13 08:57:36 -0800750 // Don't let the folder get too close to the edges of the screen.
Jon Miranda1786df32018-09-25 13:05:23 -0700751 int folderMargin = edgeMarginPx * 2;
Sunny Goyal07b69292018-01-08 14:19:34 -0800752 Point totalWorkspacePadding = getTotalWorkspacePadding();
Jon Mirandac1b23992016-12-13 08:57:36 -0800753
754 // Check if the icons fit within the available height.
Jon Miranda228877d2021-02-09 11:05:00 -0500755 float contentUsedHeight = folderCellHeightPx * inv.numFolderRows
Thales Lima78d00ad2021-09-30 11:29:06 +0100756 + ((inv.numFolderRows - 1) * folderCellLayoutBorderSpacePx.y);
Samuel Fufa1c8d90a2019-11-12 17:54:58 -0800757 int contentMaxHeight = availableHeightPx - totalWorkspacePadding.y - folderBottomPanelSize
Jon Mirandae126d722021-02-25 10:45:20 -0500758 - folderMargin - folderContentPaddingTop;
Samuel Fufa1c8d90a2019-11-12 17:54:58 -0800759 float scaleY = contentMaxHeight / contentUsedHeight;
Jon Mirandac1b23992016-12-13 08:57:36 -0800760
761 // Check if the icons fit within the available width.
Jon Miranda228877d2021-02-09 11:05:00 -0500762 float contentUsedWidth = folderCellWidthPx * inv.numFolderColumns
Thales Lima78d00ad2021-09-30 11:29:06 +0100763 + ((inv.numFolderColumns - 1) * folderCellLayoutBorderSpacePx.x);
Jon Mirandae126d722021-02-25 10:45:20 -0500764 int contentMaxWidth = availableWidthPx - totalWorkspacePadding.x - folderMargin
765 - folderContentPaddingLeftRight * 2;
Samuel Fufa1c8d90a2019-11-12 17:54:58 -0800766 float scaleX = contentMaxWidth / contentUsedWidth;
Jon Mirandac1b23992016-12-13 08:57:36 -0800767
768 float scale = Math.min(scaleX, scaleY);
769 if (scale < 1f) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700770 updateFolderCellSize(scale, res);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700771 }
772 }
773
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700774 private void updateFolderCellSize(float scale, Resources res) {
Thales Lima83bedbf2021-10-05 17:47:39 +0100775 float invIconSizeDp = isVerticalBarLayout()
776 ? inv.iconSize[InvariantDeviceProfile.INDEX_LANDSCAPE]
777 : inv.iconSize[InvariantDeviceProfile.INDEX_DEFAULT];
Sunny Goyal35c7b192021-04-20 16:51:10 -0700778 folderChildIconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mMetrics, scale));
Thales Lima83bedbf2021-10-05 17:47:39 +0100779 folderChildTextSizePx =
780 pxFromSp(inv.iconTextSize[InvariantDeviceProfile.INDEX_DEFAULT], mMetrics, scale);
Jon Mirandae126d722021-02-25 10:45:20 -0500781 folderLabelTextSizePx = (int) (folderChildTextSizePx * folderLabelTextScale);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700782
783 int textHeight = Utilities.calculateTextHeight(folderChildTextSizePx);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700784
Jon Miranda823da222021-03-23 08:08:45 -0400785 if (isScalableGrid) {
Jon Mirandaf33f5b32021-07-22 17:15:31 -0700786 int minWidth = folderChildIconSizePx + iconDrawablePaddingPx * 2;
787 int minHeight = folderChildIconSizePx + iconDrawablePaddingPx * 2 + textHeight;
788
789 folderCellWidthPx = (int) Math.max(minWidth, cellWidthPx * scale);
790 folderCellHeightPx = (int) Math.max(minHeight, cellHeightPx * scale);
Jon Miranda823da222021-03-23 08:08:45 -0400791
Thales Lima78d00ad2021-09-30 11:29:06 +0100792 int scaledSpace = (int) (folderCellLayoutBorderSpaceOriginalPx * scale);
793 folderCellLayoutBorderSpacePx = new Point(scaledSpace, scaledSpace);
794 folderContentPaddingLeftRight = scaledSpace;
795 folderContentPaddingTop = scaledSpace;
Jon Miranda823da222021-03-23 08:08:45 -0400796 } else {
797 int cellPaddingX = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_x_padding)
798 * scale);
799 int cellPaddingY = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_y_padding)
800 * scale);
801
802 folderCellWidthPx = folderChildIconSizePx + 2 * cellPaddingX;
803 folderCellHeightPx = folderChildIconSizePx + 2 * cellPaddingY + textHeight;
804 }
805
Jonathan Miranda9ad87462017-07-26 17:41:02 +0000806 folderChildDrawablePaddingPx = Math.max(0,
807 (folderCellHeightPx - folderChildIconSizePx - textHeight) / 3);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700808 }
809
Winson1f064272016-07-18 17:18:02 -0700810 public void updateInsets(Rect insets) {
811 mInsets.set(insets);
Sunny Goyal07b69292018-01-08 14:19:34 -0800812 updateWorkspacePadding();
Winson1f064272016-07-18 17:18:02 -0700813 }
814
Sunny Goyalae6e3182019-04-30 12:04:37 -0700815 /**
816 * The current device insets. This is generally same as the insets being dispatched to
817 * {@link Insettable} elements, but can differ if the element is using a different profile.
818 */
Sunny Goyal1a52ef52018-01-11 10:15:03 -0800819 public Rect getInsets() {
820 return mInsets;
821 }
822
Sunny Goyal756cd262015-08-20 12:33:21 -0700823 public Point getCellSize() {
Sunny Goyal19ff7282021-04-22 10:12:54 -0700824 return getCellSize(null);
Jon Miranda6f7e9702019-09-16 14:44:14 -0700825 }
826
Sunny Goyal19ff7282021-04-22 10:12:54 -0700827 public Point getCellSize(Point result) {
828 if (result == null) {
829 result = new Point();
830 }
Thales Limad1df5fc2021-09-03 18:37:19 +0100831
Sunny Goyal756cd262015-08-20 12:33:21 -0700832 // Since we are only concerned with the overall padding, layout direction does
833 // not matter.
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700834 Point padding = getTotalWorkspacePadding();
Thales Limad1df5fc2021-09-03 18:37:19 +0100835
836 int numColumns = isTwoPanels ? inv.numColumns * 2 : inv.numColumns;
Alex Chau60953332021-11-24 12:41:07 +0000837 int screenWidthPx = getWorkspaceWidth(padding);
Thales Lima78d00ad2021-09-30 11:29:06 +0100838 result.x = calculateCellWidth(screenWidthPx, cellLayoutBorderSpacePx.x, numColumns);
Jon Miranda18751b62017-07-31 17:25:27 -0700839 result.y = calculateCellHeight(availableHeightPx - padding.y
Thales Lima78d00ad2021-09-30 11:29:06 +0100840 - cellLayoutBottomPaddingPx, cellLayoutBorderSpacePx.y, inv.numRows);
Sunny Goyal756cd262015-08-20 12:33:21 -0700841 return result;
842 }
843
Alex Chau60953332021-11-24 12:41:07 +0000844 public int getWorkspaceWidth() {
845 return getWorkspaceWidth(getTotalWorkspacePadding());
846 }
847
848 public int getWorkspaceWidth(Point workspacePadding) {
849 int cellLayoutTotalPadding =
850 isTwoPanels ? 4 * cellLayoutPaddingLeftRightPx : 2 * cellLayoutPaddingLeftRightPx;
851 return availableWidthPx - workspacePadding.x - cellLayoutTotalPadding;
852 }
853
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700854 public Point getTotalWorkspacePadding() {
Sunny Goyal07b69292018-01-08 14:19:34 -0800855 updateWorkspacePadding();
856 return new Point(workspacePadding.left + workspacePadding.right,
857 workspacePadding.top + workspacePadding.bottom);
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700858 }
859
860 /**
Sunny Goyal07b69292018-01-08 14:19:34 -0800861 * Updates {@link #workspacePadding} as a result of any internal value change to reflect the
862 * new workspace padding
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700863 */
Sunny Goyal07b69292018-01-08 14:19:34 -0800864 private void updateWorkspacePadding() {
865 Rect padding = workspacePadding;
Tony Wickham3a3517f2015-10-06 11:27:04 -0700866 if (isVerticalBarLayout()) {
Sunny Goyal228153d2018-01-04 15:35:22 -0800867 padding.top = 0;
868 padding.bottom = edgeMarginPx;
Sunny Goyal7e2e67f2018-01-26 13:40:08 -0800869 if (isSeascape()) {
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700870 padding.left = hotseatBarSizePx;
Tony Wickham5edf9e22020-03-27 20:06:52 -0700871 padding.right = hotseatBarSidePaddingStartPx;
Winson1f064272016-07-18 17:18:02 -0700872 } else {
Tony Wickham5edf9e22020-03-27 20:06:52 -0700873 padding.left = hotseatBarSidePaddingStartPx;
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700874 padding.right = hotseatBarSizePx;
Winson1f064272016-07-18 17:18:02 -0700875 }
Winson Chungb3800242013-10-24 11:01:54 -0700876 } else {
Thales Lima7a6752d2021-09-23 14:31:00 +0100877 // Pad the bottom of the workspace with search/hotseat bar sizes
Tony Wickham21970cc2021-09-15 15:44:05 -0700878 int hotseatTop = hotseatBarSizePx;
Tony Wickhama29a0462021-03-02 12:28:25 -0800879 int paddingBottom = hotseatTop + workspacePageIndicatorHeight
Jon Miranda228877d2021-02-09 11:05:00 -0500880 + workspaceBottomPadding - mWorkspacePageIndicatorOverlapWorkspace;
Andras Kloczl8e57cce2021-02-11 23:51:19 +0100881
Thales Limad90faab2021-09-21 17:18:47 +0100882 padding.set(desiredWorkspaceHorizontalMarginPx,
Thales Lima83bedbf2021-10-05 17:47:39 +0100883 workspaceTopPadding + (isScalableGrid ? 0 : edgeMarginPx),
Thales Limad90faab2021-09-21 17:18:47 +0100884 desiredWorkspaceHorizontalMarginPx,
Thales Lima7a6752d2021-09-23 14:31:00 +0100885 paddingBottom);
Winson Chungb3800242013-10-24 11:01:54 -0700886 }
Winson Chungb3800242013-10-24 11:01:54 -0700887 }
888
Sunny Goyal57b22792021-05-25 14:35:01 -0700889 /**
890 * Returns the padding for hotseat view
891 */
892 public Rect getHotseatLayoutPadding(Context context) {
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700893 if (isVerticalBarLayout()) {
894 if (isSeascape()) {
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700895 mHotseatPadding.set(mInsets.left + hotseatBarSidePaddingStartPx,
896 mInsets.top, hotseatBarSidePaddingEndPx, mInsets.bottom);
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700897 } else {
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700898 mHotseatPadding.set(hotseatBarSidePaddingEndPx, mInsets.top,
899 mInsets.right + hotseatBarSidePaddingStartPx, mInsets.bottom);
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700900 }
Sunny Goyal57b22792021-05-25 14:35:01 -0700901 } else if (isTaskbarPresent) {
Tony Wickham21970cc2021-09-15 15:44:05 -0700902 int hotseatHeight = workspacePadding.bottom;
Sunny Goyal57b22792021-05-25 14:35:01 -0700903 int taskbarOffset = getTaskbarOffsetY();
Tony Wickham21970cc2021-09-15 15:44:05 -0700904 int hotseatTopDiff = hotseatHeight - taskbarOffset;
Sunny Goyal57b22792021-05-25 14:35:01 -0700905
Vinit Nayak8dcbde82021-07-19 12:53:28 -0700906 int endOffset = ApiWrapper.getHotseatEndOffset(context);
Thales Lima6e7f36c2022-01-04 12:14:11 +0000907 int requiredWidth = iconSizePx * numShownHotseatIcons
908 + hotseatBorderSpace * (numShownHotseatIcons - 1);
Sunny Goyal57b22792021-05-25 14:35:01 -0700909
Thales Lima6e7f36c2022-01-04 12:14:11 +0000910 int hotseatSize = Math.min(requiredWidth, availableWidthPx - endOffset);
Sunny Goyal57b22792021-05-25 14:35:01 -0700911 int sideSpacing = (availableWidthPx - hotseatSize) / 2;
912 mHotseatPadding.set(sideSpacing, hotseatTopDiff, sideSpacing, taskbarOffset);
913
Vinit Nayak8dcbde82021-07-19 12:53:28 -0700914 if (endOffset > sideSpacing) {
Sunny Goyal57b22792021-05-25 14:35:01 -0700915 int diff = Utilities.isRtl(context.getResources())
Vinit Nayak8dcbde82021-07-19 12:53:28 -0700916 ? sideSpacing - endOffset
917 : endOffset - sideSpacing;
918 mHotseatPadding.left -= diff;
919 mHotseatPadding.right += diff;
Sunny Goyal57b22792021-05-25 14:35:01 -0700920 }
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700921 } else {
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700922 // We want the edges of the hotseat to line up with the edges of the workspace, but the
923 // icons in the hotseat are a different size, and so don't line up perfectly. To account
924 // for this, we pad the left and right of the hotseat with half of the difference of a
925 // workspace cell vs a hotseat cell.
926 float workspaceCellWidth = (float) widthPx / inv.numColumns;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700927 float hotseatCellWidth = (float) widthPx / numShownHotseatIcons;
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700928 int hotseatAdjustment = Math.round((workspaceCellWidth - hotseatCellWidth) / 2);
929 mHotseatPadding.set(
Sunny Goyal786940a2020-06-02 02:31:31 -0700930 hotseatAdjustment + workspacePadding.left + cellLayoutPaddingLeftRightPx
931 + mInsets.left,
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700932 hotseatBarTopPaddingPx,
Sunny Goyal786940a2020-06-02 02:31:31 -0700933 hotseatAdjustment + workspacePadding.right + cellLayoutPaddingLeftRightPx
934 + mInsets.right,
Jon Miranda0d284852021-06-22 14:50:55 -0700935 hotseatBarSizePx - hotseatCellHeightPx - hotseatBarTopPaddingPx
936 + cellLayoutBottomPaddingPx + mInsets.bottom);
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700937 }
938 return mHotseatPadding;
939 }
940
Winsonfadbe8f2016-07-22 16:35:37 -0700941 /**
Sunny Goyal57b22792021-05-25 14:35:01 -0700942 * Returns the number of pixels the QSB is translated from the bottom of the screen.
943 */
944 public int getQsbOffsetY() {
945 int freeSpace = isTaskbarPresent
946 ? workspacePadding.bottom
947 : hotseatBarSizePx - hotseatCellHeightPx - hotseatQsbHeight;
Jonathan Miranda7a273e22021-06-24 21:29:10 +0000948
Jonathan Miranda8f16a772021-07-23 23:10:37 +0000949 if (isScalableGrid && qsbBottomMarginPx > mInsets.bottom) {
Tony Wickham21970cc2021-09-15 15:44:05 -0700950 // Note that taskbarSize = 0 unless isTaskbarPresent.
951 return Math.min(qsbBottomMarginPx + taskbarSize, freeSpace);
Jonathan Miranda8f16a772021-07-23 23:10:37 +0000952 } else {
Pratyush9afe1ea2021-10-13 11:13:27 +0000953 return (int) (freeSpace * mQsbCenterFactor)
954 + (isTaskbarPresent ? taskbarSize : mInsets.bottom);
Jonathan Miranda7a273e22021-06-24 21:29:10 +0000955 }
Sunny Goyal57b22792021-05-25 14:35:01 -0700956 }
957
958 /**
959 * Returns the number of pixels the taskbar is translated from the bottom of the screen.
960 */
961 public int getTaskbarOffsetY() {
962 return (getQsbOffsetY() - taskbarSize) / 2;
963 }
964
965 /**
Winsonfadbe8f2016-07-22 16:35:37 -0700966 * @return the bounds for which the open folders should be contained within
967 */
968 public Rect getAbsoluteOpenFolderBounds() {
969 if (isVerticalBarLayout()) {
970 // Folders should only appear right of the drop target bar and left of the hotseat
971 return new Rect(mInsets.left + dropTargetBarSizePx + edgeMarginPx,
972 mInsets.top,
Jon Miranda18751b62017-07-31 17:25:27 -0700973 mInsets.left + availableWidthPx - hotseatBarSizePx - edgeMarginPx,
Winsonfadbe8f2016-07-22 16:35:37 -0700974 mInsets.top + availableHeightPx);
975 } else {
976 // Folders should only appear below the drop target bar and above the hotseat
Tony Wickhamae72b462021-03-10 16:18:40 -0800977 int hotseatTop = isTaskbarPresent ? taskbarSize : hotseatBarSizePx;
Tony Wickhamb4b7e202018-01-12 17:39:24 -0800978 return new Rect(mInsets.left + edgeMarginPx,
Winsonfadbe8f2016-07-22 16:35:37 -0700979 mInsets.top + dropTargetBarSizePx + edgeMarginPx,
Tony Wickhamb4b7e202018-01-12 17:39:24 -0800980 mInsets.left + availableWidthPx - edgeMarginPx,
Tony Wickhamae72b462021-03-10 16:18:40 -0800981 mInsets.top + availableHeightPx - hotseatTop
Tony Wickham5edf9e22020-03-27 20:06:52 -0700982 - workspacePageIndicatorHeight - edgeMarginPx);
Winsonfadbe8f2016-07-22 16:35:37 -0700983 }
984 }
985
Jon Miranda228877d2021-02-09 11:05:00 -0500986 public static int calculateCellWidth(int width, int borderSpacing, int countX) {
987 return (width - ((countX - 1) * borderSpacing)) / countX;
Winson Chungb3800242013-10-24 11:01:54 -0700988 }
Pierre Barbier de Reuille578deba2021-09-24 13:47:44 +0100989
Jon Miranda228877d2021-02-09 11:05:00 -0500990 public static int calculateCellHeight(int height, int borderSpacing, int countY) {
991 return (height - ((countY - 1) * borderSpacing)) / countY;
Winson Chungb3800242013-10-24 11:01:54 -0700992 }
993
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -0700994 /**
Tony Wickham55616cd2015-09-23 14:55:17 -0700995 * When {@code true}, the device is in landscape mode and the hotseat is on the right column.
996 * When {@code false}, either device is in portrait mode or the device is in landscape mode and
997 * the hotseat is on the bottom row.
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -0700998 */
Tony Wickhamab946a12015-09-16 15:38:16 -0700999 public boolean isVerticalBarLayout() {
Winson Chungb3800242013-10-24 11:01:54 -07001000 return isLandscape && transposeLayoutWithOrientation;
1001 }
1002
Sunny Goyal59d086c2018-05-07 17:31:40 -07001003 /**
1004 * Updates orientation information and returns true if it has changed from the previous value.
1005 */
Winson Chung13c1c2c2019-09-06 11:46:19 -07001006 public boolean updateIsSeascape(Context context) {
Sunny Goyal59d086c2018-05-07 17:31:40 -07001007 if (isVerticalBarLayout()) {
Sunny Goyal35c7b192021-04-20 16:51:10 -07001008 boolean isSeascape = DisplayController.INSTANCE.get(context)
1009 .getInfo().rotation == Surface.ROTATION_270;
Sunny Goyal59d086c2018-05-07 17:31:40 -07001010 if (mIsSeascape != isSeascape) {
1011 mIsSeascape = isSeascape;
1012 return true;
1013 }
1014 }
1015 return false;
1016 }
1017
Sunny Goyal7e2e67f2018-01-26 13:40:08 -08001018 public boolean isSeascape() {
Sunny Goyal59d086c2018-05-07 17:31:40 -07001019 return isVerticalBarLayout() && mIsSeascape;
Sunny Goyal7e2e67f2018-01-26 13:40:08 -08001020 }
1021
Sunny Goyal07b69292018-01-08 14:19:34 -08001022 public boolean shouldFadeAdjacentWorkspaceScreens() {
Sunny Goyal19ff7282021-04-22 10:12:54 -07001023 return isVerticalBarLayout();
Winson Chungb3800242013-10-24 11:01:54 -07001024 }
1025
Jon Miranda92c1b5d2021-07-20 13:57:16 -07001026 public int getCellContentHeight(@ContainerType int containerType) {
Sunny Goyalc13403c2016-11-18 23:44:48 -08001027 switch (containerType) {
1028 case CellLayout.WORKSPACE:
1029 return cellHeightPx;
1030 case CellLayout.FOLDER:
1031 return folderCellHeightPx;
1032 case CellLayout.HOTSEAT:
Jon Miranda92c1b5d2021-07-20 13:57:16 -07001033 // The hotseat is the only container where the cell height is going to be
1034 // different from the content within that cell.
1035 return iconSizePx;
Sunny Goyalc13403c2016-11-18 23:44:48 -08001036 default:
1037 // ??
1038 return 0;
1039 }
1040 }
Sunny Goyal13178ac2016-04-04 16:35:22 -07001041
Jon Miranda58561d42021-03-17 10:51:54 -04001042 private String pxToDpStr(String name, float value) {
Sunny Goyal35c7b192021-04-20 16:51:10 -07001043 return "\t" + name + ": " + value + "px (" + dpiFromPx(value, mMetrics.densityDpi) + "dp)";
Jon Miranda58561d42021-03-17 10:51:54 -04001044 }
1045
1046 public void dump(String prefix, PrintWriter writer) {
1047 writer.println(prefix + "DeviceProfile:");
Sunny Goyal35c7b192021-04-20 16:51:10 -07001048 writer.println(prefix + "\t1 dp = " + mMetrics.density + " px");
Jon Miranda58561d42021-03-17 10:51:54 -04001049
1050 writer.println(prefix + "\tisTablet:" + isTablet);
Jon Miranda58561d42021-03-17 10:51:54 -04001051 writer.println(prefix + "\tisPhone:" + isPhone);
1052 writer.println(prefix + "\ttransposeLayoutWithOrientation:"
1053 + transposeLayoutWithOrientation);
1054
1055 writer.println(prefix + "\tisLandscape:" + isLandscape);
1056 writer.println(prefix + "\tisMultiWindowMode:" + isMultiWindowMode);
Sunny Goyal19ff7282021-04-22 10:12:54 -07001057 writer.println(prefix + "\tisTwoPanels:" + isTwoPanels);
Jon Miranda58561d42021-03-17 10:51:54 -04001058
1059 writer.println(prefix + pxToDpStr("windowX", windowX));
1060 writer.println(prefix + pxToDpStr("windowY", windowY));
1061 writer.println(prefix + pxToDpStr("widthPx", widthPx));
1062 writer.println(prefix + pxToDpStr("heightPx", heightPx));
1063
1064 writer.println(prefix + pxToDpStr("availableWidthPx", availableWidthPx));
1065 writer.println(prefix + pxToDpStr("availableHeightPx", availableHeightPx));
1066
1067 writer.println(prefix + "\taspectRatio:" + aspectRatio);
1068
1069 writer.println(prefix + "\tisScalableGrid:" + isScalableGrid);
1070
Thales Lima83bedbf2021-10-05 17:47:39 +01001071 writer.println(prefix + "\tinv.numRows: " + inv.numRows);
Alex Chau9fee3fd2021-12-01 18:43:10 +00001072 writer.println(prefix + "\tinv.numColumns: " + inv.numColumns);
1073 writer.println(prefix + "\tinv.numSearchContainerColumns: "
1074 + inv.numSearchContainerColumns);
Jon Miranda58561d42021-03-17 10:51:54 -04001075
Thales Lima83bedbf2021-10-05 17:47:39 +01001076 writer.println(prefix + "\tminCellSize: " + inv.minCellSize[mTypeIndex] + "dp");
Jon Mirandaab3c6812021-06-28 15:42:28 -07001077
Jon Miranda58561d42021-03-17 10:51:54 -04001078 writer.println(prefix + pxToDpStr("cellWidthPx", cellWidthPx));
1079 writer.println(prefix + pxToDpStr("cellHeightPx", cellHeightPx));
1080
1081 writer.println(prefix + pxToDpStr("getCellSize().x", getCellSize().x));
1082 writer.println(prefix + pxToDpStr("getCellSize().y", getCellSize().y));
1083
Thales Lima83bedbf2021-10-05 17:47:39 +01001084 writer.println(prefix + pxToDpStr("cellLayoutBorderSpacePx Horizontal",
1085 cellLayoutBorderSpacePx.x));
1086 writer.println(prefix + pxToDpStr("cellLayoutBorderSpacePx Vertical",
1087 cellLayoutBorderSpacePx.y));
1088
Jon Miranda58561d42021-03-17 10:51:54 -04001089 writer.println(prefix + pxToDpStr("iconSizePx", iconSizePx));
1090 writer.println(prefix + pxToDpStr("iconTextSizePx", iconTextSizePx));
1091 writer.println(prefix + pxToDpStr("iconDrawablePaddingPx", iconDrawablePaddingPx));
1092
1093 writer.println(prefix + pxToDpStr("folderCellWidthPx", folderCellWidthPx));
1094 writer.println(prefix + pxToDpStr("folderCellHeightPx", folderCellHeightPx));
1095 writer.println(prefix + pxToDpStr("folderChildIconSizePx", folderChildIconSizePx));
1096 writer.println(prefix + pxToDpStr("folderChildTextSizePx", folderChildTextSizePx));
1097 writer.println(prefix + pxToDpStr("folderChildDrawablePaddingPx",
1098 folderChildDrawablePaddingPx));
Thales Lima78d00ad2021-09-30 11:29:06 +01001099 writer.println(prefix + pxToDpStr("folderCellLayoutBorderSpaceOriginalPx",
1100 folderCellLayoutBorderSpaceOriginalPx));
1101 writer.println(prefix + pxToDpStr("folderCellLayoutBorderSpacePx Horizontal",
1102 folderCellLayoutBorderSpacePx.x));
1103 writer.println(prefix + pxToDpStr("folderCellLayoutBorderSpacePx Vertical",
1104 folderCellLayoutBorderSpacePx.y));
Jon Miranda58561d42021-03-17 10:51:54 -04001105
Jon Miranda58561d42021-03-17 10:51:54 -04001106 writer.println(prefix + pxToDpStr("allAppsIconSizePx", allAppsIconSizePx));
1107 writer.println(prefix + pxToDpStr("allAppsIconTextSizePx", allAppsIconTextSizePx));
1108 writer.println(prefix + pxToDpStr("allAppsIconDrawablePaddingPx",
1109 allAppsIconDrawablePaddingPx));
1110 writer.println(prefix + pxToDpStr("allAppsCellHeightPx", allAppsCellHeightPx));
Alex Chau27b39b92022-01-14 18:02:18 +00001111 writer.println(prefix + pxToDpStr("allAppsCellWidthPx", allAppsCellWidthPx));
Sunny Goyal19ff7282021-04-22 10:12:54 -07001112 writer.println(prefix + "\tnumShownAllAppsColumns: " + numShownAllAppsColumns);
Alex Chau27b39b92022-01-14 18:02:18 +00001113 writer.println(prefix + pxToDpStr("allAppsLeftRightPadding", allAppsLeftRightPadding));
1114 writer.println(prefix + pxToDpStr("allAppsLeftRightMargin", allAppsLeftRightMargin));
Jon Miranda58561d42021-03-17 10:51:54 -04001115
1116 writer.println(prefix + pxToDpStr("hotseatBarSizePx", hotseatBarSizePx));
1117 writer.println(prefix + pxToDpStr("hotseatCellHeightPx", hotseatCellHeightPx));
1118 writer.println(prefix + pxToDpStr("hotseatBarTopPaddingPx", hotseatBarTopPaddingPx));
1119 writer.println(prefix + pxToDpStr("hotseatBarBottomPaddingPx", hotseatBarBottomPaddingPx));
1120 writer.println(prefix + pxToDpStr("hotseatBarSidePaddingStartPx",
1121 hotseatBarSidePaddingStartPx));
1122 writer.println(prefix + pxToDpStr("hotseatBarSidePaddingEndPx",
1123 hotseatBarSidePaddingEndPx));
Sunny Goyal19ff7282021-04-22 10:12:54 -07001124 writer.println(prefix + "\tnumShownHotseatIcons: " + numShownHotseatIcons);
Jon Miranda58561d42021-03-17 10:51:54 -04001125
1126 writer.println(prefix + "\tisTaskbarPresent:" + isTaskbarPresent);
Tony Wickham635e1802021-07-22 14:28:04 -10001127 writer.println(prefix + "\tisTaskbarPresentInApps:" + isTaskbarPresentInApps);
Jon Miranda58561d42021-03-17 10:51:54 -04001128 writer.println(prefix + pxToDpStr("taskbarSize", taskbarSize));
Jon Miranda58561d42021-03-17 10:51:54 -04001129
Thales Lima83bedbf2021-10-05 17:47:39 +01001130 writer.println(prefix + pxToDpStr("desiredWorkspaceHorizontalMarginPx",
1131 desiredWorkspaceHorizontalMarginPx));
Jon Miranda58561d42021-03-17 10:51:54 -04001132 writer.println(prefix + pxToDpStr("workspacePadding.left", workspacePadding.left));
1133 writer.println(prefix + pxToDpStr("workspacePadding.top", workspacePadding.top));
1134 writer.println(prefix + pxToDpStr("workspacePadding.right", workspacePadding.right));
1135 writer.println(prefix + pxToDpStr("workspacePadding.bottom", workspacePadding.bottom));
1136
Jon Mirandaab3c6812021-06-28 15:42:28 -07001137 writer.println(prefix + pxToDpStr("iconScale", iconScale));
1138 writer.println(prefix + pxToDpStr("cellScaleToFit ", cellScaleToFit));
Jon Miranda58561d42021-03-17 10:51:54 -04001139 writer.println(prefix + pxToDpStr("extraSpace", extraSpace));
Thales Lima7a6752d2021-09-23 14:31:00 +01001140 writer.println(prefix + pxToDpStr("unscaled extraSpace", extraSpace / iconScale));
Jon Mirandac9e69fa2021-03-22 17:13:34 -04001141
1142 if (inv.devicePaddings != null) {
1143 int unscaledExtraSpace = (int) (extraSpace / iconScale);
1144 writer.println(prefix + pxToDpStr("maxEmptySpace",
1145 inv.devicePaddings.getDevicePadding(unscaledExtraSpace).getMaxEmptySpacePx()));
1146 }
Jon Miranda58561d42021-03-17 10:51:54 -04001147 writer.println(prefix + pxToDpStr("workspaceTopPadding", workspaceTopPadding));
1148 writer.println(prefix + pxToDpStr("workspaceBottomPadding", workspaceBottomPadding));
1149 writer.println(prefix + pxToDpStr("extraHotseatBottomPadding", extraHotseatBottomPadding));
1150 }
1151
Sunny Goyalfd58da62020-08-11 12:06:49 -07001152 private static Context getContext(Context c, Info info, int orientation) {
Sunny Goyal1890f672020-04-30 12:28:00 -07001153 Configuration config = new Configuration(c.getResources().getConfiguration());
1154 config.orientation = orientation;
Sunny Goyal35c7b192021-04-20 16:51:10 -07001155 config.densityDpi = info.densityDpi;
Sunny Goyal1890f672020-04-30 12:28:00 -07001156 return c.createConfigurationContext(config);
Jon Mirandab28c4fc2017-06-20 10:58:36 -07001157 }
Sunny Goyalfde55052018-02-01 14:46:13 -08001158
1159 /**
1160 * Callback when a component changes the DeviceProfile associated with it, as a result of
1161 * configuration change
1162 */
1163 public interface OnDeviceProfileChangeListener {
1164
1165 /**
1166 * Called when the device profile is reassigned. Note that for layout and measurements, it
1167 * is sufficient to listen for inset changes. Use this callback when you need to perform
1168 * a one time operation.
1169 */
1170 void onDeviceProfileChanged(DeviceProfile dp);
1171 }
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001172
1173 public static class Builder {
1174 private Context mContext;
1175 private InvariantDeviceProfile mInv;
Sunny Goyalfd58da62020-08-11 12:06:49 -07001176 private Info mInfo;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001177
Sunny Goyal19ff7282021-04-22 10:12:54 -07001178 private WindowBounds mWindowBounds;
1179 private boolean mUseTwoPanels;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001180
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001181 private boolean mIsMultiWindowMode = false;
Sunny Goyal19ff7282021-04-22 10:12:54 -07001182 private Boolean mTransposeLayoutWithOrientation;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001183
Sunny Goyalfd58da62020-08-11 12:06:49 -07001184 public Builder(Context context, InvariantDeviceProfile inv, Info info) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001185 mContext = context;
1186 mInv = inv;
1187 mInfo = info;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001188 }
1189
1190 public Builder setMultiWindowMode(boolean isMultiWindowMode) {
1191 mIsMultiWindowMode = isMultiWindowMode;
1192 return this;
1193 }
1194
Sunny Goyal19ff7282021-04-22 10:12:54 -07001195 public Builder setUseTwoPanels(boolean useTwoPanels) {
1196 mUseTwoPanels = useTwoPanels;
1197 return this;
1198 }
1199
1200
1201 public Builder setWindowBounds(WindowBounds bounds) {
1202 mWindowBounds = bounds;
Sunny Goyal0addbf02020-04-28 14:17:35 -07001203 return this;
1204 }
1205
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001206 public Builder setTransposeLayoutWithOrientation(boolean transposeLayoutWithOrientation) {
1207 mTransposeLayoutWithOrientation = transposeLayoutWithOrientation;
1208 return this;
1209 }
1210
1211 public DeviceProfile build() {
Sunny Goyal19ff7282021-04-22 10:12:54 -07001212 if (mWindowBounds == null) {
1213 throw new IllegalArgumentException("Window bounds not set");
1214 }
1215 if (mTransposeLayoutWithOrientation == null) {
1216 mTransposeLayoutWithOrientation = !mInfo.isTablet(mWindowBounds);
1217 }
1218 return new DeviceProfile(mContext, mInv, mInfo, mWindowBounds,
1219 mIsMultiWindowMode, mTransposeLayoutWithOrientation, mUseTwoPanels);
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001220 }
1221 }
1222
Winson Chungb3800242013-10-24 11:01:54 -07001223}