blob: 3121bfc9eeac3116198ab773f7566ebdeb50a57d [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
Alex Chaua02eddc2021-04-29 00:36:06 +010019import static android.util.DisplayMetrics.DENSITY_DEVICE_STABLE;
Sunny Goyal35c7b192021-04-20 16:51:10 -070020
Jon Mirandae126d722021-02-25 10:45:20 -050021import static com.android.launcher3.ResourceUtils.pxFromDp;
Jon Miranda58561d42021-03-17 10:51:54 -040022import static com.android.launcher3.Utilities.dpiFromPx;
Jon Mirandaaf3aed02021-05-06 18:28:45 -070023import static com.android.launcher3.Utilities.pxFromSp;
Jon Miranda92c1b5d2021-07-20 13:57:16 -070024import static com.android.launcher3.folder.ClippedFolderIconLayoutRule.ICON_OVERLAP_FACTOR;
Alex Chaua02eddc2021-04-29 00:36:06 +010025import static com.android.launcher3.util.WindowManagerCompat.MIN_TABLET_WIDTH;
Jon Miranda228877d2021-02-09 11:05:00 -050026
Sunny Goyal35c7b192021-04-20 16:51:10 -070027import android.annotation.SuppressLint;
Winson Chungb3800242013-10-24 11:01:54 -070028import android.content.Context;
Jon Mirandab28c4fc2017-06-20 10:58:36 -070029import android.content.res.Configuration;
Winson Chungb3800242013-10-24 11:01:54 -070030import android.content.res.Resources;
Sunny Goyal8b9919d2021-04-07 14:45:17 -070031import android.graphics.Path;
Winson Chungb3800242013-10-24 11:01:54 -070032import android.graphics.Point;
Jon Miranda7ae64ff2016-11-21 16:18:46 -080033import android.graphics.PointF;
Winson Chungb3800242013-10-24 11:01:54 -070034import android.graphics.Rect;
Sunny Goyal35c7b192021-04-20 16:51:10 -070035import android.util.DisplayMetrics;
Thales Limad1df5fc2021-09-03 18:37:19 +010036import android.util.Pair;
Sunny Goyal59d086c2018-05-07 17:31:40 -070037import android.view.Surface;
Winson Chungb3800242013-10-24 11:01:54 -070038
Sunny Goyalc13403c2016-11-18 23:44:48 -080039import com.android.launcher3.CellLayout.ContainerType;
Jon Miranda228877d2021-02-09 11:05:00 -050040import com.android.launcher3.DevicePaddings.DevicePadding;
Tony Wickham15883892021-02-12 11:24:40 -080041import com.android.launcher3.config.FeatureFlags;
Tony Wickham8912b042018-11-29 15:28:53 -080042import com.android.launcher3.icons.DotRenderer;
Sunny Goyal8b9919d2021-04-07 14:45:17 -070043import com.android.launcher3.icons.GraphicsUtils;
Hyunyoung Song48cb7bc2018-09-25 17:03:34 -070044import com.android.launcher3.icons.IconNormalizer;
Sunny Goyal57b22792021-05-25 14:35:01 -070045import com.android.launcher3.uioverrides.ApiWrapper;
Sunny Goyalfd58da62020-08-11 12:06:49 -070046import com.android.launcher3.util.DisplayController;
47import com.android.launcher3.util.DisplayController.Info;
Sunny Goyalb46703d2020-05-27 17:52:03 -070048import com.android.launcher3.util.WindowBounds;
Winson1f064272016-07-18 17:18:02 -070049
Jon Miranda58561d42021-03-17 10:51:54 -040050import java.io.PrintWriter;
51
Sunny Goyal35c7b192021-04-20 16:51:10 -070052@SuppressLint("NewApi")
Winson Chungb3800242013-10-24 11:01:54 -070053public class DeviceProfile {
Adam Cohen2e6da152015-05-06 11:42:25 -070054
Sunny Goyal8b9919d2021-04-07 14:45:17 -070055 private static final int DEFAULT_DOT_SIZE = 100;
Sunny Goyal57b22792021-05-25 14:35:01 -070056 // Ratio of empty space, qsb should take up to appear visually centered.
57 private static final float QSB_CENTER_FACTOR = .325f;
Sunny Goyal1890f672020-04-30 12:28:00 -070058
Adam Cohen2e6da152015-05-06 11:42:25 -070059 public final InvariantDeviceProfile inv;
Sunny Goyalfd58da62020-08-11 12:06:49 -070060 private final Info mInfo;
Sunny Goyal35c7b192021-04-20 16:51:10 -070061 private final DisplayMetrics mMetrics;
Winson Chungbe876472014-05-14 14:15:20 -070062
Sunny Goyalc6205602015-05-21 20:46:33 -070063 // Device properties
64 public final boolean isTablet;
Sunny Goyalc6205602015-05-21 20:46:33 -070065 public final boolean isPhone;
66 public final boolean transposeLayoutWithOrientation;
Sunny Goyal19ff7282021-04-22 10:12:54 -070067 public final boolean isTwoPanels;
Alex Chaua02eddc2021-04-29 00:36:06 +010068 public final boolean allowRotation;
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -070069
Sunny Goyalc6205602015-05-21 20:46:33 -070070 // Device properties in current orientation
Sunny Goyald792a772018-04-05 13:37:46 -070071 public final boolean isLandscape;
Sunny Goyald70e75a2018-02-22 10:07:32 -080072 public final boolean isMultiWindowMode;
73
Sunny Goyal0addbf02020-04-28 14:17:35 -070074 public final int windowX;
75 public final int windowY;
Sunny Goyalc6205602015-05-21 20:46:33 -070076 public final int widthPx;
77 public final int heightPx;
78 public final int availableWidthPx;
79 public final int availableHeightPx;
Jon Mirandabba64512019-03-27 10:54:17 -070080
81 public final float aspectRatio;
82
Jon Mirandae126d722021-02-25 10:45:20 -050083 public final boolean isScalableGrid;
84
Tony Wickhamd6b40372015-09-23 18:37:57 -070085 /**
86 * The maximum amount of left/right workspace padding as a percentage of the screen width.
87 * To be clear, this means that up to 7% of the screen width can be used as left padding, and
88 * 7% of the screen width can be used as right padding.
89 */
90 private static final float MAX_HORIZONTAL_PADDING_PERCENT = 0.14f;
Winson Chungb3800242013-10-24 11:01:54 -070091
Jon Miranda3f9bab22017-07-28 14:50:17 -070092 private static final float TALL_DEVICE_ASPECT_RATIO_THRESHOLD = 2.0f;
Jon Miranda80cddbc2021-07-22 13:51:16 -070093 private static final float TALLER_DEVICE_ASPECT_RATIO_THRESHOLD = 2.15f;
Jon Miranda80dda302021-07-28 14:14:59 -070094 private static final float TALL_DEVICE_EXTRA_SPACE_THRESHOLD_DP = 252;
95 private static final float TALL_DEVICE_MORE_EXTRA_SPACE_THRESHOLD_DP = 268;
Jon Miranda30d0aa22017-07-25 15:55:29 -070096
Jon Miranda5eacbb72018-07-31 11:14:46 -070097 // To evenly space the icons, increase the left/right margins for tablets in portrait mode.
98 private static final int PORTRAIT_TABLET_LEFT_RIGHT_PADDING_MULTIPLIER = 4;
99
Sunny Goyalc6205602015-05-21 20:46:33 -0700100 // Workspace
Jon Mirandae126d722021-02-25 10:45:20 -0500101 public final int desiredWorkspaceLeftRightOriginalPx;
102 public int desiredWorkspaceLeftRightMarginPx;
103 public final int cellLayoutBorderSpacingOriginalPx;
104 public int cellLayoutBorderSpacingPx;
Jon Miranda28032002017-07-13 16:18:56 -0700105 public final int cellLayoutPaddingLeftRightPx;
Jon Miranda18751b62017-07-31 17:25:27 -0700106 public final int cellLayoutBottomPaddingPx;
Sunny Goyalc6205602015-05-21 20:46:33 -0700107 public final int edgeMarginPx;
Sunny Goyal47328fd2016-05-25 18:56:41 -0700108 public float workspaceSpringLoadShrinkFactor;
109 public final int workspaceSpringLoadedBottomSpace;
Sunny Goyalc6205602015-05-21 20:46:33 -0700110
Jon Miranda58561d42021-03-17 10:51:54 -0400111 private final int extraSpace;
Jon Miranda228877d2021-02-09 11:05:00 -0500112 public int workspaceTopPadding;
113 public int workspaceBottomPadding;
Jon Miranda58561d42021-03-17 10:51:54 -0400114 public int extraHotseatBottomPadding;
Jon Miranda228877d2021-02-09 11:05:00 -0500115
Tony Wickham5edf9e22020-03-27 20:06:52 -0700116 // Workspace page indicator
117 public final int workspacePageIndicatorHeight;
118 private final int mWorkspacePageIndicatorOverlapWorkspace;
Winson1f064272016-07-18 17:18:02 -0700119
Sunny Goyalc6205602015-05-21 20:46:33 -0700120 // Workspace icons
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400121 public float iconScale;
Sunny Goyalc6205602015-05-21 20:46:33 -0700122 public int iconSizePx;
123 public int iconTextSizePx;
124 public int iconDrawablePaddingPx;
Winson Chung5f4e0fd2015-05-22 11:12:27 -0700125 public int iconDrawablePaddingOriginalPx;
Winson Chungb3800242013-10-24 11:01:54 -0700126
Jon Mirandaab3c6812021-06-28 15:42:28 -0700127 public float cellScaleToFit;
Adam Cohen59400422014-03-05 18:07:04 -0800128 public int cellWidthPx;
129 public int cellHeightPx;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700130 public int workspaceCellPaddingXPx;
Adam Cohen59400422014-03-05 18:07:04 -0800131
Jon Mirandae126d722021-02-25 10:45:20 -0500132 public int cellYPaddingPx;
Jon Mirandae126d722021-02-25 10:45:20 -0500133
Sunny Goyalc6205602015-05-21 20:46:33 -0700134 // Folder
Jon Mirandae126d722021-02-25 10:45:20 -0500135 public float folderLabelTextScale;
136 public int folderLabelTextSizePx;
Sunny Goyalc6205602015-05-21 20:46:33 -0700137 public int folderIconSizePx;
Jon Miranda591e3602018-03-28 11:37:00 -0700138 public int folderIconOffsetYPx;
Jon Mirandabf7d8122016-11-03 15:29:29 -0700139
Jon Mirandae126d722021-02-25 10:45:20 -0500140 // Folder content
Jon Miranda823da222021-03-23 08:08:45 -0400141 public int folderCellLayoutBorderSpacingPx;
Jon Mirandae126d722021-02-25 10:45:20 -0500142 public int folderContentPaddingLeftRight;
143 public int folderContentPaddingTop;
144
Jon Mirandabf7d8122016-11-03 15:29:29 -0700145 // Folder cell
Sunny Goyalc6205602015-05-21 20:46:33 -0700146 public int folderCellWidthPx;
147 public int folderCellHeightPx;
Jon Mirandabf7d8122016-11-03 15:29:29 -0700148
149 // Folder child
150 public int folderChildIconSizePx;
151 public int folderChildTextSizePx;
Sunny Goyalbaec6ff2016-09-14 11:26:21 -0700152 public int folderChildDrawablePaddingPx;
Winson Chungb3800242013-10-24 11:01:54 -0700153
Sunny Goyalc6205602015-05-21 20:46:33 -0700154 // Hotseat
Jon Miranda80cddbc2021-07-22 13:51:16 -0700155 public int hotseatBarSizeExtraSpacePx;
Tony Wickhamb87f3cd2021-04-07 15:02:37 -0700156 public final int numShownHotseatIcons;
Sunny Goyalc6205602015-05-21 20:46:33 -0700157 public int hotseatCellHeightPx;
Jon Miranda0d284852021-06-22 14:50:55 -0700158 private final int hotseatExtraVerticalSize;
Jon Miranda18751b62017-07-31 17:25:27 -0700159 // In portrait: size = height, in landscape: size = width
160 public int hotseatBarSizePx;
Jon Miranda80cddbc2021-07-22 13:51:16 -0700161 public int hotseatBarTopPaddingPx;
Jon Miranda0d284852021-06-22 14:50:55 -0700162 public final int hotseatBarBottomPaddingPx;
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700163 // Start is the side next to the nav bar, end is the side next to the workspace
164 public final int hotseatBarSidePaddingStartPx;
165 public final int hotseatBarSidePaddingEndPx;
Sunny Goyal57b22792021-05-25 14:35:01 -0700166 public final int hotseatQsbHeight;
Adam Cohen2e6da152015-05-06 11:42:25 -0700167
Jon Miranda8bdb2222021-06-23 18:10:10 -0700168 public final float qsbBottomMarginOriginalPx;
169 public int qsbBottomMarginPx;
170
Sunny Goyalc6205602015-05-21 20:46:33 -0700171 // All apps
Samuel Fufaee9aff92021-04-05 13:30:40 -0500172 public int allAppsOpenVerticalTranslate;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700173 public int allAppsCellHeightPx;
Samuel Fufaf1424a32019-10-04 15:15:19 -0700174 public int allAppsCellWidthPx;
Winson1f064272016-07-18 17:18:02 -0700175 public int allAppsIconSizePx;
176 public int allAppsIconDrawablePaddingPx;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700177 public final int numShownAllAppsColumns;
Winson1f064272016-07-18 17:18:02 -0700178 public float allAppsIconTextSizePx;
179
Zak Cohen334efeb2021-03-19 16:42:07 -0700180 // Overview
Alex Chau646f8042021-07-26 11:56:22 +0100181 public final boolean overviewShowAsGrid;
Zak Cohen334efeb2021-03-19 16:42:07 -0700182 public int overviewTaskMarginPx;
Alex Chaueaa6d682021-08-17 12:56:15 +0100183 public int overviewTaskMarginGridPx;
Alex Chaudedbc8a2021-03-17 16:53:26 +0000184 public int overviewTaskIconSizePx;
Alex Chauac9df382021-08-02 19:08:41 +0100185 public int overviewTaskIconDrawableSizePx;
186 public int overviewTaskIconDrawableSizeGridPx;
Alex Chaudedbc8a2021-03-17 16:53:26 +0000187 public int overviewTaskThumbnailTopMarginPx;
zakcohendad8a802021-05-20 09:52:26 -0700188 public final int overviewActionsMarginThreeButtonPx;
Alex Chau5fd9d492021-07-22 17:27:11 +0100189 public final int overviewActionsTopMarginGesturePx;
190 public final int overviewActionsBottomMarginGesturePx;
191 public int overviewPageSpacing;
192 public int overviewRowSpacing;
Zak Cohen334efeb2021-03-19 16:42:07 -0700193
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800194 // Widgets
195 public final PointF appWidgetScale = new PointF(1.0f, 1.0f);
196
Sunny Goyal47328fd2016-05-25 18:56:41 -0700197 // Drop Target
198 public int dropTargetBarSizePx;
Alex Chaua02eddc2021-04-29 00:36:06 +0100199 public int dropTargetDragPaddingPx;
200 public int dropTargetTextSizePx;
Adam Cohen4ae96ce2014-08-29 15:05:48 -0700201
Winson1f064272016-07-18 17:18:02 -0700202 // Insets
Sunny Goyal07b69292018-01-08 14:19:34 -0800203 private final Rect mInsets = new Rect();
204 public final Rect workspacePadding = new Rect();
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700205 private final Rect mHotseatPadding = new Rect();
Jon Miranda0bd63d12019-03-06 17:29:29 -0800206 // When true, nav bar is on the left side of the screen.
Sunny Goyal59d086c2018-05-07 17:31:40 -0700207 private boolean mIsSeascape;
Winson1f064272016-07-18 17:18:02 -0700208
Tony Wickhamf34bee82018-12-03 18:11:39 -0800209 // Notification dots
Samuel Fufac96fa242019-09-26 23:06:32 -0700210 public DotRenderer mDotRendererWorkSpace;
211 public DotRenderer mDotRendererAllApps;
Tony Wickham9a8d11f2017-01-11 09:53:12 -0800212
Tony Wickham15883892021-02-12 11:24:40 -0800213 // Taskbar
214 public boolean isTaskbarPresent;
Tony Wickham635e1802021-07-22 14:28:04 -1000215 // Whether Taskbar will inset the bottom of apps by taskbarSize.
216 public boolean isTaskbarPresentInApps;
Tony Wickham15883892021-02-12 11:24:40 -0800217 public int taskbarSize;
Tony Wickham145b7fd2021-03-11 10:03:12 -0800218 // How much of the bottom inset is due to Taskbar rather than other system elements.
219 public int nonOverlappingTaskbarInset;
Tony Wickham15883892021-02-12 11:24:40 -0800220
Alex Chaua02eddc2021-04-29 00:36:06 +0100221 // DragController
222 public int flingToDeleteThresholdVelocity;
223
Vinit Nayak17c4b332021-08-05 12:54:58 -0700224 /** TODO: Once we fully migrate to staged split, remove "isMultiWindowMode" */
Sunny Goyal19ff7282021-04-22 10:12:54 -0700225 DeviceProfile(Context context, InvariantDeviceProfile inv, Info info, WindowBounds windowBounds,
Sunny Goyal0addbf02020-04-28 14:17:35 -0700226 boolean isMultiWindowMode, boolean transposeLayoutWithOrientation,
Sunny Goyal19ff7282021-04-22 10:12:54 -0700227 boolean useTwoPanels) {
Sunny Goyalfee35bb2015-05-11 11:38:19 -0700228
Adam Cohen2e6da152015-05-06 11:42:25 -0700229 this.inv = inv;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700230 this.isLandscape = windowBounds.isLandscape();
Sunny Goyald70e75a2018-02-22 10:07:32 -0800231 this.isMultiWindowMode = isMultiWindowMode;
Jon Mirandae126d722021-02-25 10:45:20 -0500232 this.transposeLayoutWithOrientation = transposeLayoutWithOrientation;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700233 windowX = windowBounds.bounds.left;
234 windowY = windowBounds.bounds.top;
Winson Chungb3800242013-10-24 11:01:54 -0700235
Jon Mirandae126d722021-02-25 10:45:20 -0500236 isScalableGrid = inv.isScalable && !isVerticalBarLayout() && !isMultiWindowMode;
237
Jon Miranda7e183c32018-06-20 11:05:27 -0700238 // Determine sizes.
Sunny Goyal19ff7282021-04-22 10:12:54 -0700239 widthPx = windowBounds.bounds.width();
240 heightPx = windowBounds.bounds.height();
241 availableWidthPx = windowBounds.availableSize.x;
242 int nonFinalAvailableHeightPx = windowBounds.availableSize.y;
Jon Miranda7e183c32018-06-20 11:05:27 -0700243
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700244 mInfo = info;
Alex Chaua02eddc2021-04-29 00:36:06 +0100245 // If the device's pixel density was scaled (usually via settings for A11y), use the
246 // original dimensions to determine if rotation is allowed of not.
247 float originalSmallestWidth = dpiFromPx(Math.min(widthPx, heightPx), DENSITY_DEVICE_STABLE);
248 allowRotation = originalSmallestWidth >= MIN_TABLET_WIDTH;
249 // Tablet UI does not support emulated landscape.
250 isTablet = allowRotation && info.isTablet(windowBounds);
Sunny Goyal19ff7282021-04-22 10:12:54 -0700251 isPhone = !isTablet;
Alex Chaub1c36ce2021-08-25 11:54:08 +0100252 isTwoPanels = isTablet && useTwoPanels
253 && (isLandscape || FeatureFlags.ENABLE_TWO_PANEL_HOME_IN_PORTRAIT.get());
Adam Cohen2e6da152015-05-06 11:42:25 -0700254
Jon Mirandabba64512019-03-27 10:54:17 -0700255 aspectRatio = ((float) Math.max(widthPx, heightPx)) / Math.min(widthPx, heightPx);
Jon Miranda7e183c32018-06-20 11:05:27 -0700256 boolean isTallDevice = Float.compare(aspectRatio, TALL_DEVICE_ASPECT_RATIO_THRESHOLD) >= 0;
Sunny Goyalc6205602015-05-21 20:46:33 -0700257
258 // Some more constants
Sunny Goyal1890f672020-04-30 12:28:00 -0700259 context = getContext(context, info, isVerticalBarLayout()
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700260 ? Configuration.ORIENTATION_LANDSCAPE
261 : Configuration.ORIENTATION_PORTRAIT);
Sunny Goyal35c7b192021-04-20 16:51:10 -0700262 mMetrics = context.getResources().getDisplayMetrics();
Sunny Goyal1890f672020-04-30 12:28:00 -0700263 final Resources res = context.getResources();
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700264
Sunny Goyal57b22792021-05-25 14:35:01 -0700265 hotseatQsbHeight = res.getDimensionPixelSize(R.dimen.qsb_widget_height);
Sunny Goyal71ef9682021-07-29 12:59:27 -0700266 isTaskbarPresent = isTablet && ApiWrapper.TASKBAR_DRAWN_IN_PROCESS
267 && FeatureFlags.ENABLE_TASKBAR.get();
Tony Wickham15883892021-02-12 11:24:40 -0800268 if (isTaskbarPresent) {
269 // Taskbar will be added later, but provides bottom insets that we should subtract
270 // from availableHeightPx.
271 taskbarSize = res.getDimensionPixelSize(R.dimen.taskbar_size);
Tony Wickhamf5ce2f62021-08-16 15:21:11 -0700272 nonOverlappingTaskbarInset = taskbarSize - windowBounds.insets.bottom;
Tony Wickham15883892021-02-12 11:24:40 -0800273 if (nonOverlappingTaskbarInset > 0) {
274 nonFinalAvailableHeightPx -= nonOverlappingTaskbarInset;
275 }
276 }
277 availableHeightPx = nonFinalAvailableHeightPx;
278
Winson Chungb3800242013-10-24 11:01:54 -0700279 edgeMarginPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_edge_margin);
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700280
Jon Mirandae126d722021-02-25 10:45:20 -0500281 desiredWorkspaceLeftRightMarginPx = isVerticalBarLayout() ? 0 : isScalableGrid
282 ? res.getDimensionPixelSize(R.dimen.scalable_grid_left_right_margin)
283 : res.getDimensionPixelSize(R.dimen.dynamic_grid_left_right_margin);
284 desiredWorkspaceLeftRightOriginalPx = desiredWorkspaceLeftRightMarginPx;
285
Samuel Fufaee9aff92021-04-05 13:30:40 -0500286
287 allAppsOpenVerticalTranslate = res.getDimensionPixelSize(
288 R.dimen.all_apps_open_vertical_translate);
289
Jon Mirandae126d722021-02-25 10:45:20 -0500290 folderLabelTextScale = res.getFloat(R.dimen.folder_label_text_scale);
291 folderContentPaddingLeftRight =
292 res.getDimensionPixelSize(R.dimen.folder_content_padding_left_right);
293 folderContentPaddingTop = res.getDimensionPixelSize(R.dimen.folder_content_padding_top);
294
Sunny Goyal35c7b192021-04-20 16:51:10 -0700295 setCellLayoutBorderSpacing(pxFromDp(inv.borderSpacing, mMetrics, 1f));
Jon Mirandae126d722021-02-25 10:45:20 -0500296 cellLayoutBorderSpacingOriginalPx = cellLayoutBorderSpacingPx;
Jon Miranda823da222021-03-23 08:08:45 -0400297 folderCellLayoutBorderSpacingPx = cellLayoutBorderSpacingPx;
Jon Mirandae126d722021-02-25 10:45:20 -0500298
Jon Miranda5eacbb72018-07-31 11:14:46 -0700299 int cellLayoutPaddingLeftRightMultiplier = !isVerticalBarLayout() && isTablet
300 ? PORTRAIT_TABLET_LEFT_RIGHT_PADDING_MULTIPLIER : 1;
Jon Mirandae126d722021-02-25 10:45:20 -0500301 int cellLayoutPadding = isScalableGrid
302 ? 0
303 : res.getDimensionPixelSize(R.dimen.dynamic_grid_cell_layout_padding);
Andras Kloczl8e57cce2021-02-11 23:51:19 +0100304
Sunny Goyal19ff7282021-04-22 10:12:54 -0700305 if (isTwoPanels) {
Steven Ng2a5c5942021-07-29 17:27:00 +0100306 cellLayoutPaddingLeftRightPx = res.getDimensionPixelSize(
307 isLandscape
308 ? R.dimen.two_panels_home_side_padding_landscape
309 : R.dimen.two_panels_home_side_padding_portrait);
Andras Kloczl8e57cce2021-02-11 23:51:19 +0100310 cellLayoutBottomPaddingPx = 0;
311 } else if (isLandscape) {
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700312 cellLayoutPaddingLeftRightPx = 0;
313 cellLayoutBottomPaddingPx = cellLayoutPadding;
314 } else {
315 cellLayoutPaddingLeftRightPx = cellLayoutPaddingLeftRightMultiplier * cellLayoutPadding;
316 cellLayoutBottomPaddingPx = 0;
317 }
318
Tony Wickham5edf9e22020-03-27 20:06:52 -0700319 workspacePageIndicatorHeight = res.getDimensionPixelSize(
320 R.dimen.workspace_page_indicator_height);
321 mWorkspacePageIndicatorOverlapWorkspace =
322 res.getDimensionPixelSize(R.dimen.workspace_page_indicator_overlap_workspace);
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700323
Winson Chungb3800242013-10-24 11:01:54 -0700324 iconDrawablePaddingOriginalPx =
325 res.getDimensionPixelSize(R.dimen.dynamic_grid_icon_drawable_padding);
Alex Chaua02eddc2021-04-29 00:36:06 +0100326
Sunny Goyal47328fd2016-05-25 18:56:41 -0700327 dropTargetBarSizePx = res.getDimensionPixelSize(R.dimen.dynamic_grid_drop_target_size);
Alex Chaua02eddc2021-04-29 00:36:06 +0100328 dropTargetDragPaddingPx = res.getDimensionPixelSize(R.dimen.drop_target_drag_padding);
329 dropTargetTextSizePx = res.getDimensionPixelSize(R.dimen.drop_target_text_size);
330
Sunny Goyal47328fd2016-05-25 18:56:41 -0700331 workspaceSpringLoadedBottomSpace =
332 res.getDimensionPixelSize(R.dimen.dynamic_grid_min_spring_loaded_space);
Sunny Goyald5190522017-04-24 03:06:54 -0700333
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700334 workspaceCellPaddingXPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_cell_padding_x);
Jon Miranda09660722017-06-14 14:20:14 -0700335
Sunny Goyal19ff7282021-04-22 10:12:54 -0700336 numShownHotseatIcons =
337 isTwoPanels ? inv.numDatabaseHotseatIcons : inv.numShownHotseatIcons;
338 numShownAllAppsColumns =
339 isTwoPanels ? inv.numDatabaseAllAppsColumns : inv.numAllAppsColumns;
Jon Miranda80cddbc2021-07-22 13:51:16 -0700340 hotseatBarSizeExtraSpacePx = 0;
Winson1f064272016-07-18 17:18:02 -0700341 hotseatBarTopPaddingPx =
342 res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_top_padding);
Jon Miranda7e183c32018-06-20 11:05:27 -0700343 hotseatBarBottomPaddingPx = (isTallDevice ? 0
344 : res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_bottom_non_tall_padding))
345 + res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_bottom_padding);
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700346 hotseatBarSidePaddingEndPx =
Sunny Goyal228153d2018-01-04 15:35:22 -0800347 res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_side_padding);
Jon Miranda3f411e72019-05-16 17:15:16 -0700348 // Add a bit of space between nav bar and hotseat in vertical bar layout.
Tony Wickham5edf9e22020-03-27 20:06:52 -0700349 hotseatBarSidePaddingStartPx = isVerticalBarLayout() ? workspacePageIndicatorHeight : 0;
Jon Miranda0d284852021-06-22 14:50:55 -0700350 hotseatExtraVerticalSize =
Jon Miranda228877d2021-02-09 11:05:00 -0500351 res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_extra_vertical_size);
Jon Miranda0d284852021-06-22 14:50:55 -0700352 updateHotseatIconSize(pxFromDp(inv.iconSize, mMetrics, 1f));
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700353
Jon Miranda8bdb2222021-06-23 18:10:10 -0700354 qsbBottomMarginOriginalPx = isScalableGrid
355 ? res.getDimensionPixelSize(R.dimen.scalable_grid_qsb_bottom_margin)
356 : 0;
357
Alex Chau646f8042021-07-26 11:56:22 +0100358 overviewShowAsGrid = isTablet && FeatureFlags.ENABLE_OVERVIEW_GRID.get();
Alex Chau5fd9d492021-07-22 17:27:11 +0100359 overviewTaskMarginPx = overviewShowAsGrid
Alex Chaueaa6d682021-08-17 12:56:15 +0100360 ? res.getDimensionPixelSize(R.dimen.overview_task_margin_focused)
Alex Chau5fd9d492021-07-22 17:27:11 +0100361 : res.getDimensionPixelSize(R.dimen.overview_task_margin);
Alex Chaueaa6d682021-08-17 12:56:15 +0100362 overviewTaskMarginGridPx = res.getDimensionPixelSize(R.dimen.overview_task_margin_grid);
Alex Chau5fd9d492021-07-22 17:27:11 +0100363 overviewTaskIconSizePx = res.getDimensionPixelSize(R.dimen.task_thumbnail_icon_size);
Alex Chauac9df382021-08-02 19:08:41 +0100364 overviewTaskIconDrawableSizePx =
365 res.getDimensionPixelSize(R.dimen.task_thumbnail_icon_drawable_size);
366 overviewTaskIconDrawableSizeGridPx =
367 res.getDimensionPixelSize(R.dimen.task_thumbnail_icon_drawable_size_grid);
Alex Chaudedbc8a2021-03-17 16:53:26 +0000368 overviewTaskThumbnailTopMarginPx = overviewTaskIconSizePx + overviewTaskMarginPx * 2;
Alex Chau5fd9d492021-07-22 17:27:11 +0100369 if (overviewShowAsGrid) {
370 if (isLandscape) {
371 overviewActionsTopMarginGesturePx = res.getDimensionPixelSize(
372 R.dimen.overview_actions_top_margin_gesture_grid_landscape);
373 overviewActionsBottomMarginGesturePx = res.getDimensionPixelSize(
374 R.dimen.overview_actions_bottom_margin_gesture_grid_landscape);
375 } else {
376 overviewActionsTopMarginGesturePx = res.getDimensionPixelSize(
377 R.dimen.overview_actions_top_margin_gesture_grid_portrait);
378 overviewActionsBottomMarginGesturePx = res.getDimensionPixelSize(
379 R.dimen.overview_actions_bottom_margin_gesture_grid_portrait);
380 }
381 } else {
382 overviewActionsTopMarginGesturePx = res.getDimensionPixelSize(
383 R.dimen.overview_actions_margin_gesture);
384 overviewActionsBottomMarginGesturePx = overviewActionsTopMarginGesturePx;
385 }
zakcohendad8a802021-05-20 09:52:26 -0700386 overviewActionsMarginThreeButtonPx = res.getDimensionPixelSize(
Alex Chau5fd9d492021-07-22 17:27:11 +0100387 R.dimen.overview_actions_margin_three_button);
388 overviewPageSpacing = overviewShowAsGrid
389 ? res.getDimensionPixelSize(R.dimen.recents_page_spacing_grid)
390 : res.getDimensionPixelSize(R.dimen.recents_page_spacing);
391 overviewRowSpacing = isLandscape
392 ? res.getDimensionPixelSize(R.dimen.overview_grid_row_spacing_landscape)
393 : res.getDimensionPixelSize(R.dimen.overview_grid_row_spacing_portrait);
Zak Cohen334efeb2021-03-19 16:42:07 -0700394
Jon Miranda2ed276e2017-06-29 11:36:34 -0700395 // Calculate all of the remaining variables.
Jon Miranda58561d42021-03-17 10:51:54 -0400396 extraSpace = updateAvailableDimensions(res);
Jon Miranda80cddbc2021-07-22 13:51:16 -0700397
Jon Miranda2ed276e2017-06-29 11:36:34 -0700398 // Now that we have all of the variables calculated, we can tune certain sizes.
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400399 if (isScalableGrid && inv.devicePaddings != null) {
400 // Paddings were created assuming no scaling, so we first unscale the extra space.
Jon Mirandaab3c6812021-06-28 15:42:28 -0700401 int unscaledExtraSpace = (int) (extraSpace / cellScaleToFit);
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400402 DevicePadding padding = inv.devicePaddings.getDevicePadding(unscaledExtraSpace);
Jon Miranda228877d2021-02-09 11:05:00 -0500403
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400404 int paddingWorkspaceTop = padding.getWorkspaceTopPadding(unscaledExtraSpace);
405 int paddingWorkspaceBottom = padding.getWorkspaceBottomPadding(unscaledExtraSpace);
406 int paddingHotseatBottom = padding.getHotseatBottomPadding(unscaledExtraSpace);
407
Jon Mirandaab3c6812021-06-28 15:42:28 -0700408 workspaceTopPadding = Math.round(paddingWorkspaceTop * cellScaleToFit);
409 workspaceBottomPadding = Math.round(paddingWorkspaceBottom * cellScaleToFit);
410 extraHotseatBottomPadding = Math.round(paddingHotseatBottom * cellScaleToFit);
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400411
Jon Miranda58561d42021-03-17 10:51:54 -0400412 hotseatBarSizePx += extraHotseatBottomPadding;
Jon Miranda8bdb2222021-06-23 18:10:10 -0700413
Jon Mirandaab3c6812021-06-28 15:42:28 -0700414 qsbBottomMarginPx = Math.round(qsbBottomMarginOriginalPx * cellScaleToFit);
Jon Miranda228877d2021-02-09 11:05:00 -0500415 } else if (!isVerticalBarLayout() && isPhone && isTallDevice) {
Jon Miranda3f9bab22017-07-28 14:50:17 -0700416 // We increase the hotseat size when there is extra space.
Jon Miranda80cddbc2021-07-22 13:51:16 -0700417
Jon Miranda80dda302021-07-28 14:14:59 -0700418 if (Float.compare(aspectRatio, TALLER_DEVICE_ASPECT_RATIO_THRESHOLD) >= 0
419 && extraSpace >= Utilities.dpToPx(TALL_DEVICE_EXTRA_SPACE_THRESHOLD_DP)) {
420 // For taller devices, we will take a piece of the extra space from each row,
Jon Miranda80cddbc2021-07-22 13:51:16 -0700421 // and add it to the space above and below the hotseat.
Jon Miranda80dda302021-07-28 14:14:59 -0700422
423 // For devices with more extra space, we take a larger piece from each cell.
424 int piece = extraSpace < Utilities.dpToPx(TALL_DEVICE_MORE_EXTRA_SPACE_THRESHOLD_DP)
Jon Mirandaa56cb842021-08-03 17:26:44 -0700425 ? 7 : 5;
Jon Miranda80dda302021-07-28 14:14:59 -0700426
Jon Miranda80cddbc2021-07-22 13:51:16 -0700427 int extraSpace = ((getCellSize().y - iconSizePx - iconDrawablePaddingPx * 2)
Jon Miranda80dda302021-07-28 14:14:59 -0700428 * inv.numRows) / piece;
Jon Miranda80cddbc2021-07-22 13:51:16 -0700429
Jon Mirandaa56cb842021-08-03 17:26:44 -0700430 workspaceTopPadding = extraSpace / 8;
431 int halfLeftOver = (extraSpace - workspaceTopPadding) / 2;
432 hotseatBarTopPaddingPx += halfLeftOver;
433 hotseatBarSizeExtraSpacePx = halfLeftOver;
Jon Miranda80cddbc2021-07-22 13:51:16 -0700434 } else {
435 // ie. For a display with a large aspect ratio, we can keep the icons on the
436 // workspace in portrait mode closer together by adding more height to the hotseat.
437 // Note: This calculation was created after noticing a pattern in the design spec.
438 hotseatBarSizeExtraSpacePx = getCellSize().y - iconSizePx
439 - iconDrawablePaddingPx * 2 - workspacePageIndicatorHeight;
440 }
441
442 updateHotseatIconSize(iconSizePx);
Jon Miranda30d0aa22017-07-25 15:55:29 -0700443
Jon Miranda3f9bab22017-07-28 14:50:17 -0700444 // Recalculate the available dimensions using the new hotseat size.
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700445 updateAvailableDimensions(res);
Jon Miranda2ed276e2017-06-29 11:36:34 -0700446 }
Sunny Goyal07b69292018-01-08 14:19:34 -0800447 updateWorkspacePadding();
Tony Wickham1237df02017-02-24 08:59:36 -0800448
Alex Chaua02eddc2021-04-29 00:36:06 +0100449 flingToDeleteThresholdVelocity = res.getDimensionPixelSize(
450 R.dimen.drag_flingToDeleteMinVelocity);
451
Tony Wickham1237df02017-02-24 08:59:36 -0800452 // This is done last, after iconSizePx is calculated above.
Sunny Goyal8b9919d2021-04-07 14:45:17 -0700453 Path dotPath = GraphicsUtils.getShapePath(DEFAULT_DOT_SIZE);
454 mDotRendererWorkSpace = new DotRenderer(iconSizePx, dotPath, DEFAULT_DOT_SIZE);
Samuel Fufac96fa242019-09-26 23:06:32 -0700455 mDotRendererAllApps = iconSizePx == allAppsIconSizePx ? mDotRendererWorkSpace :
Sunny Goyal8b9919d2021-04-07 14:45:17 -0700456 new DotRenderer(allAppsIconSizePx, dotPath, DEFAULT_DOT_SIZE);
Adam Cohen63f1ec02014-08-12 09:23:13 -0700457 }
458
Jon Miranda0d284852021-06-22 14:50:55 -0700459 private void updateHotseatIconSize(int hotseatIconSizePx) {
Jon Miranda92c1b5d2021-07-20 13:57:16 -0700460 // Ensure there is enough space for folder icons, which have a slightly larger radius.
461 hotseatCellHeightPx = (int) Math.ceil(hotseatIconSizePx * ICON_OVERLAP_FACTOR);
Jon Miranda0d284852021-06-22 14:50:55 -0700462 if (isVerticalBarLayout()) {
463 hotseatBarSizePx = hotseatIconSizePx + hotseatBarSidePaddingStartPx
464 + hotseatBarSidePaddingEndPx;
465 } else {
466 hotseatBarSizePx = hotseatIconSizePx + hotseatBarTopPaddingPx
Jon Miranda80cddbc2021-07-22 13:51:16 -0700467 + hotseatBarBottomPaddingPx + (isScalableGrid ? 0 : hotseatExtraVerticalSize)
468 + hotseatBarSizeExtraSpacePx;
Jon Miranda0d284852021-06-22 14:50:55 -0700469 }
470 }
471
Jon Mirandae126d722021-02-25 10:45:20 -0500472 private void setCellLayoutBorderSpacing(int borderSpacing) {
Jon Miranda823da222021-03-23 08:08:45 -0400473 cellLayoutBorderSpacingPx = isScalableGrid ? borderSpacing : 0;
Jon Mirandae126d722021-02-25 10:45:20 -0500474 }
475
Sunny Goyal69a8eec2021-07-22 10:02:50 -0700476 public Info getDisplayInfo() {
477 return mInfo;
478 }
479
Jon Miranda611dba42021-03-02 14:12:13 -0500480 /**
481 * We inset the widget padding added by the system and instead rely on the border spacing
482 * between cells to create reliable consistency between widgets
483 */
484 public boolean shouldInsetWidgets() {
485 Rect widgetPadding = inv.defaultWidgetPadding;
486
Jon Miranda49811182021-06-03 09:52:40 -0700487 // Check all sides to ensure that the widget won't overlap into another cell, or into
488 // status bar.
489 return workspaceTopPadding > widgetPadding.top
490 && cellLayoutBorderSpacingPx > widgetPadding.left
Jon Miranda611dba42021-03-02 14:12:13 -0500491 && cellLayoutBorderSpacingPx > widgetPadding.top
492 && cellLayoutBorderSpacingPx > widgetPadding.right
493 && cellLayoutBorderSpacingPx > widgetPadding.bottom;
494 }
Jon Mirandae126d722021-02-25 10:45:20 -0500495
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700496 public Builder toBuilder(Context context) {
Sunny Goyal19ff7282021-04-22 10:12:54 -0700497 WindowBounds bounds =
498 new WindowBounds(widthPx, heightPx, availableWidthPx, availableHeightPx);
499 bounds.bounds.offsetTo(windowX, windowY);
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700500 return new Builder(context, inv, mInfo)
Sunny Goyal19ff7282021-04-22 10:12:54 -0700501 .setWindowBounds(bounds)
502 .setUseTwoPanels(isTwoPanels)
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700503 .setMultiWindowMode(isMultiWindowMode);
Sunny Goyal1a52ef52018-01-11 10:15:03 -0800504 }
505
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700506 public DeviceProfile copy(Context context) {
507 return toBuilder(context).build();
508 }
509
510 /**
511 * TODO: Move this to the builder as part of setMultiWindowMode
512 */
Sunny Goyalb46703d2020-05-27 17:52:03 -0700513 public DeviceProfile getMultiWindowProfile(Context context, WindowBounds windowBounds) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700514 DeviceProfile profile = toBuilder(context)
Sunny Goyal19ff7282021-04-22 10:12:54 -0700515 .setWindowBounds(windowBounds)
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700516 .setMultiWindowMode(true)
517 .build();
Jon Miranda93e1f042016-11-11 14:13:04 -0800518
Jon Miranda941375e2021-03-31 13:10:45 -0400519 profile.hideWorkspaceLabelsIfNotEnoughSpace();
Jon Miranda93e1f042016-11-11 14:13:04 -0800520
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800521 // We use these scales to measure and layout the widgets using their full invariant profile
522 // sizes and then draw them scaled and centered to fit in their multi-window mode cellspans.
523 float appWidgetScaleX = (float) profile.getCellSize().x / getCellSize().x;
524 float appWidgetScaleY = (float) profile.getCellSize().y / getCellSize().y;
525 profile.appWidgetScale.set(appWidgetScaleX, appWidgetScaleY);
Sunny Goyal07b69292018-01-08 14:19:34 -0800526 profile.updateWorkspacePadding();
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800527
Jon Miranda93e1f042016-11-11 14:13:04 -0800528 return profile;
Jon Mirandacc42c5b2016-10-27 17:15:27 -0700529 }
530
Adam Cohen63f1ec02014-08-12 09:23:13 -0700531 /**
Jon Miranda941375e2021-03-31 13:10:45 -0400532 * Checks if there is enough space for labels on the workspace.
533 * If there is not, labels on the Workspace are hidden.
Jon Miranda1091e532017-07-21 13:31:50 -0700534 * It is important to call this method after the All Apps variables have been set.
535 */
Jon Miranda941375e2021-03-31 13:10:45 -0400536 private void hideWorkspaceLabelsIfNotEnoughSpace() {
537 float iconTextHeight = Utilities.calculateTextHeight(iconTextSizePx);
538 float workspaceCellPaddingY = getCellSize().y - iconSizePx - iconDrawablePaddingPx
539 - iconTextHeight;
540
541 // We want enough space so that the text is closer to its corresponding icon.
542 if (workspaceCellPaddingY < iconTextHeight) {
543 iconTextSizePx = 0;
544 iconDrawablePaddingPx = 0;
Jon Miranda92c1b5d2021-07-20 13:57:16 -0700545 cellHeightPx = (int) Math.ceil(iconSizePx * ICON_OVERLAP_FACTOR);
Jon Miranda941375e2021-03-31 13:10:45 -0400546 autoResizeAllAppsCells();
547 }
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700548 }
Jon Miranda1091e532017-07-21 13:31:50 -0700549
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700550 /**
551 * Re-computes the all-apps cell size to be independent of workspace
552 */
553 public void autoResizeAllAppsCells() {
Jon Miranda941375e2021-03-31 13:10:45 -0400554 int textHeight = Utilities.calculateTextHeight(allAppsIconTextSizePx);
555 int topBottomPadding = textHeight;
Jon Miranda1091e532017-07-21 13:31:50 -0700556 allAppsCellHeightPx = allAppsIconSizePx + allAppsIconDrawablePaddingPx
Jon Miranda941375e2021-03-31 13:10:45 -0400557 + textHeight + (topBottomPadding * 2);
Jon Miranda1091e532017-07-21 13:31:50 -0700558 }
559
Jon Miranda228877d2021-02-09 11:05:00 -0500560 /**
561 * Returns the amount of extra (or unused) vertical space.
562 */
563 private int updateAvailableDimensions(Resources res) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700564 updateIconSize(1f, res);
Winson Chung59a488a2013-12-10 12:32:14 -0800565
Jon Mirandae126d722021-02-25 10:45:20 -0500566 Point workspacePadding = getTotalWorkspacePadding();
567
568 // Check to see if the icons fit within the available height.
569 float usedHeight = getCellLayoutHeight();
570 final int maxHeight = availableHeightPx - workspacePadding.y;
Jon Miranda228877d2021-02-09 11:05:00 -0500571 float extraHeight = Math.max(0, maxHeight - usedHeight);
Jon Mirandae126d722021-02-25 10:45:20 -0500572 float scaleY = maxHeight / usedHeight;
573 boolean shouldScale = scaleY < 1f;
574
575 float scaleX = 1f;
576 if (isScalableGrid) {
577 // We scale to fit the cellWidth and cellHeight in the available space.
578 // The benefit of scalable grids is that we can get consistent aspect ratios between
579 // devices.
Thales Limad1df5fc2021-09-03 18:37:19 +0100580 int numColumns = isTwoPanels ? inv.numColumns * 2 : inv.numColumns;
581 float usedWidth = (cellWidthPx * numColumns)
582 + (cellLayoutBorderSpacingPx * (numColumns - 1))
Jon Mirandae126d722021-02-25 10:45:20 -0500583 + (desiredWorkspaceLeftRightMarginPx * 2);
584 // We do not subtract padding here, as we also scale the workspace padding if needed.
585 scaleX = availableWidthPx / usedWidth;
586 shouldScale = true;
Winson Chungb3800242013-10-24 11:01:54 -0700587 }
Jon Mirandae126d722021-02-25 10:45:20 -0500588
589 if (shouldScale) {
590 float scale = Math.min(scaleX, scaleY);
591 updateIconSize(scale, res);
592 extraHeight = Math.max(0, maxHeight - getCellLayoutHeight());
593 }
594
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700595 updateAvailableFolderCellDimensions(res);
Jon Miranda228877d2021-02-09 11:05:00 -0500596 return Math.round(extraHeight);
Winson Chungb3800242013-10-24 11:01:54 -0700597 }
598
Jon Mirandae126d722021-02-25 10:45:20 -0500599 private int getCellLayoutHeight() {
600 return (cellHeightPx * inv.numRows) + (cellLayoutBorderSpacingPx * (inv.numRows - 1));
601 }
602
Jon Miranda6f7e9702019-09-16 14:44:14 -0700603 /**
604 * Updating the iconSize affects many aspects of the launcher layout, such as: iconSizePx,
605 * iconTextSizePx, iconDrawablePaddingPx, cellWidth/Height, allApps* variants,
606 * hotseat sizes, workspaceSpringLoadedShrinkFactor, folderIconSizePx, and folderIconOffsetYPx.
607 */
Tony Wickham7ba547c2021-02-02 17:12:08 -0800608 public void updateIconSize(float scale, Resources res) {
Jon Mirandaab3c6812021-06-28 15:42:28 -0700609 // Icon scale should never exceed 1, otherwise pixellation may occur.
610 iconScale = Math.min(1f, scale);
611 cellScaleToFit = scale;
612
Jon Miranda18751b62017-07-31 17:25:27 -0700613 // Workspace
Sunny Goyal07b69292018-01-08 14:19:34 -0800614 final boolean isVerticalLayout = isVerticalBarLayout();
Andras Kloczl30fe9152021-08-05 18:02:29 +0200615 float invIconSizeDp;
616 float invIconTextSizeSp;
617
618 if (isTwoPanels) {
619 if (isLandscape) {
620 invIconSizeDp = inv.twoPanelLandscapeIconSize;
621 invIconTextSizeSp = inv.twoPanelLandscapeIconTextSize;
622 } else {
623 invIconSizeDp = inv.twoPanelPortraitIconSize;
624 invIconTextSizeSp = inv.twoPanelPortraitIconTextSize;
625 }
626 } else {
627 if (isLandscape) {
628 invIconSizeDp = inv.landscapeIconSize;
629 invIconTextSizeSp = inv.landscapeIconTextSize;
630 } else {
631 invIconSizeDp = inv.iconSize;
632 invIconTextSizeSp = inv.iconTextSize;
633 }
634 }
635
Jon Mirandaab3c6812021-06-28 15:42:28 -0700636 iconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mMetrics, iconScale));
Jon Mirandaab3c6812021-06-28 15:42:28 -0700637 iconTextSizePx = (int) (pxFromSp(invIconTextSizeSp, mMetrics) * iconScale);
638 iconDrawablePaddingPx = (int) (iconDrawablePaddingOriginalPx * iconScale);
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700639
Jon Mirandae126d722021-02-25 10:45:20 -0500640 setCellLayoutBorderSpacing((int) (cellLayoutBorderSpacingOriginalPx * scale));
641
642 if (isScalableGrid) {
Thales Limad1df5fc2021-09-03 18:37:19 +0100643 PointF minCellHeightAndWidth = getMinCellHeightAndWidth();
644 cellWidthPx = pxFromDp(minCellHeightAndWidth.x, mMetrics, scale);
645 cellHeightPx = pxFromDp(minCellHeightAndWidth.y, mMetrics, scale);
Jon Mirandae126d722021-02-25 10:45:20 -0500646 int cellContentHeight = iconSizePx + iconDrawablePaddingPx
647 + Utilities.calculateTextHeight(iconTextSizePx);
648 cellYPaddingPx = Math.max(0, cellHeightPx - cellContentHeight) / 2;
649 desiredWorkspaceLeftRightMarginPx = (int) (desiredWorkspaceLeftRightOriginalPx * scale);
Jon Miranda228877d2021-02-09 11:05:00 -0500650 } else {
Jon Mirandae126d722021-02-25 10:45:20 -0500651 cellWidthPx = iconSizePx + iconDrawablePaddingPx;
Jon Miranda92c1b5d2021-07-20 13:57:16 -0700652 cellHeightPx = (int) Math.ceil(iconSizePx * ICON_OVERLAP_FACTOR)
653 + iconDrawablePaddingPx
Jon Miranda228877d2021-02-09 11:05:00 -0500654 + Utilities.calculateTextHeight(iconTextSizePx);
655 int cellPaddingY = (getCellSize().y - cellHeightPx) / 2;
656 if (iconDrawablePaddingPx > cellPaddingY && !isVerticalLayout
657 && !isMultiWindowMode) {
658 // Ensures that the label is closer to its corresponding icon. This is not an issue
659 // with vertical bar layout or multi-window mode since the issue is handled
660 // separately with their calls to {@link #adjustToHideWorkspaceLabels}.
661 cellHeightPx -= (iconDrawablePaddingPx - cellPaddingY);
662 iconDrawablePaddingPx = cellPaddingY;
663 }
Jon Miranda846455e2017-10-02 14:58:52 -0700664 }
Jon Miranda18751b62017-07-31 17:25:27 -0700665
Sunny Goyalae190ff2020-04-14 00:19:01 +0000666 // All apps
Sunny Goyal19ff7282021-04-22 10:12:54 -0700667 if (numShownAllAppsColumns != inv.numColumns) {
Sunny Goyal35c7b192021-04-20 16:51:10 -0700668 allAppsIconSizePx = pxFromDp(inv.allAppsIconSize, mMetrics);
Jon Mirandaaf3aed02021-05-06 18:28:45 -0700669 allAppsIconTextSizePx = pxFromSp(inv.allAppsIconTextSize, mMetrics);
Sunny Goyalae190ff2020-04-14 00:19:01 +0000670 allAppsIconDrawablePaddingPx = iconDrawablePaddingOriginalPx;
Jon Miranda941375e2021-03-31 13:10:45 -0400671 autoResizeAllAppsCells();
Sunny Goyalae190ff2020-04-14 00:19:01 +0000672 } else {
673 allAppsIconSizePx = iconSizePx;
674 allAppsIconTextSizePx = iconTextSizePx;
675 allAppsIconDrawablePaddingPx = iconDrawablePaddingPx;
676 allAppsCellHeightPx = getCellSize().y;
677 }
678 allAppsCellWidthPx = allAppsIconSizePx + allAppsIconDrawablePaddingPx;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700679
Jon Miranda941375e2021-03-31 13:10:45 -0400680 if (isVerticalLayout) {
681 hideWorkspaceLabelsIfNotEnoughSpace();
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700682 }
Winson Chungb3800242013-10-24 11:01:54 -0700683
Winson Chungb3800242013-10-24 11:01:54 -0700684 // Hotseat
Jon Miranda0d284852021-06-22 14:50:55 -0700685 updateHotseatIconSize(iconSizePx);
Winson Chungb3800242013-10-24 11:01:54 -0700686
Sunny Goyal07b69292018-01-08 14:19:34 -0800687 if (!isVerticalLayout) {
Jon Miranda18751b62017-07-31 17:25:27 -0700688 int expectedWorkspaceHeight = availableHeightPx - hotseatBarSizePx
Tony Wickham5edf9e22020-03-27 20:06:52 -0700689 - workspacePageIndicatorHeight - edgeMarginPx;
Sunny Goyal47328fd2016-05-25 18:56:41 -0700690 float minRequiredHeight = dropTargetBarSizePx + workspaceSpringLoadedBottomSpace;
691 workspaceSpringLoadShrinkFactor = Math.min(
692 res.getInteger(R.integer.config_workspaceSpringLoadShrinkPercentage) / 100.0f,
693 1 - (minRequiredHeight / expectedWorkspaceHeight));
694 } else {
695 workspaceSpringLoadShrinkFactor =
696 res.getInteger(R.integer.config_workspaceSpringLoadShrinkPercentage) / 100.0f;
697 }
698
Sunny Goyalbaec6ff2016-09-14 11:26:21 -0700699 // Folder icon
Jon Miranda591e3602018-03-28 11:37:00 -0700700 folderIconSizePx = IconNormalizer.getNormalizedCircleSize(iconSizePx);
701 folderIconOffsetYPx = (iconSizePx - folderIconSizePx) / 2;
Winson Chung0f785722015-04-08 10:27:49 -0700702 }
703
Thales Limad1df5fc2021-09-03 18:37:19 +0100704 /**
705 * Returns the minimum cell height and width as a pair.
706 */
707 private PointF getMinCellHeightAndWidth() {
708 PointF result = new PointF();
709
710 if (isTwoPanels) {
711 if (isLandscape) {
712 result.x = inv.twoPanelLandscapeMinCellWidthDps;
713 result.y = inv.twoPanelLandscapeMinCellHeightDps;
714 } else {
715 result.x = inv.twoPanelPortraitMinCellWidthDps;
716 result.y = inv.twoPanelPortraitMinCellHeightDps;
717 }
718 } else {
719 result.x = inv.minCellWidth;
720 result.y = inv.minCellHeight;
721 }
722
723 return result;
724 }
725
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700726 private void updateAvailableFolderCellDimensions(Resources res) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700727 updateFolderCellSize(1f, res);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700728
Jon Mirandae126d722021-02-25 10:45:20 -0500729 final int folderBottomPanelSize = res.getDimensionPixelSize(R.dimen.folder_label_height);
730
Jon Mirandac1b23992016-12-13 08:57:36 -0800731 // Don't let the folder get too close to the edges of the screen.
Jon Miranda1786df32018-09-25 13:05:23 -0700732 int folderMargin = edgeMarginPx * 2;
Sunny Goyal07b69292018-01-08 14:19:34 -0800733 Point totalWorkspacePadding = getTotalWorkspacePadding();
Jon Mirandac1b23992016-12-13 08:57:36 -0800734
735 // Check if the icons fit within the available height.
Jon Miranda228877d2021-02-09 11:05:00 -0500736 float contentUsedHeight = folderCellHeightPx * inv.numFolderRows
Jon Miranda823da222021-03-23 08:08:45 -0400737 + ((inv.numFolderRows - 1) * folderCellLayoutBorderSpacingPx);
Samuel Fufa1c8d90a2019-11-12 17:54:58 -0800738 int contentMaxHeight = availableHeightPx - totalWorkspacePadding.y - folderBottomPanelSize
Jon Mirandae126d722021-02-25 10:45:20 -0500739 - folderMargin - folderContentPaddingTop;
Samuel Fufa1c8d90a2019-11-12 17:54:58 -0800740 float scaleY = contentMaxHeight / contentUsedHeight;
Jon Mirandac1b23992016-12-13 08:57:36 -0800741
742 // Check if the icons fit within the available width.
Jon Miranda228877d2021-02-09 11:05:00 -0500743 float contentUsedWidth = folderCellWidthPx * inv.numFolderColumns
Jon Miranda823da222021-03-23 08:08:45 -0400744 + ((inv.numFolderColumns - 1) * folderCellLayoutBorderSpacingPx);
Jon Mirandae126d722021-02-25 10:45:20 -0500745 int contentMaxWidth = availableWidthPx - totalWorkspacePadding.x - folderMargin
746 - folderContentPaddingLeftRight * 2;
Samuel Fufa1c8d90a2019-11-12 17:54:58 -0800747 float scaleX = contentMaxWidth / contentUsedWidth;
Jon Mirandac1b23992016-12-13 08:57:36 -0800748
749 float scale = Math.min(scaleX, scaleY);
750 if (scale < 1f) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700751 updateFolderCellSize(scale, res);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700752 }
753 }
754
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700755 private void updateFolderCellSize(float scale, Resources res) {
Jon Mirandae126d722021-02-25 10:45:20 -0500756 float invIconSizeDp = isVerticalBarLayout() ? inv.landscapeIconSize : inv.iconSize;
Sunny Goyal35c7b192021-04-20 16:51:10 -0700757 folderChildIconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mMetrics, scale));
Jon Mirandaaf3aed02021-05-06 18:28:45 -0700758 folderChildTextSizePx = pxFromSp(inv.iconTextSize, mMetrics, scale);
Jon Mirandae126d722021-02-25 10:45:20 -0500759 folderLabelTextSizePx = (int) (folderChildTextSizePx * folderLabelTextScale);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700760
761 int textHeight = Utilities.calculateTextHeight(folderChildTextSizePx);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700762
Jon Miranda823da222021-03-23 08:08:45 -0400763 if (isScalableGrid) {
Jon Mirandaf33f5b32021-07-22 17:15:31 -0700764 int minWidth = folderChildIconSizePx + iconDrawablePaddingPx * 2;
765 int minHeight = folderChildIconSizePx + iconDrawablePaddingPx * 2 + textHeight;
766
767 folderCellWidthPx = (int) Math.max(minWidth, cellWidthPx * scale);
768 folderCellHeightPx = (int) Math.max(minHeight, cellHeightPx * scale);
Jon Miranda823da222021-03-23 08:08:45 -0400769
770 int borderSpacing = (int) (cellLayoutBorderSpacingOriginalPx * scale);
771 folderCellLayoutBorderSpacingPx = borderSpacing;
772 folderContentPaddingLeftRight = borderSpacing;
773 folderContentPaddingTop = borderSpacing;
774 } else {
775 int cellPaddingX = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_x_padding)
776 * scale);
777 int cellPaddingY = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_y_padding)
778 * scale);
779
780 folderCellWidthPx = folderChildIconSizePx + 2 * cellPaddingX;
781 folderCellHeightPx = folderChildIconSizePx + 2 * cellPaddingY + textHeight;
782 }
783
Jonathan Miranda9ad87462017-07-26 17:41:02 +0000784 folderChildDrawablePaddingPx = Math.max(0,
785 (folderCellHeightPx - folderChildIconSizePx - textHeight) / 3);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700786 }
787
Winson1f064272016-07-18 17:18:02 -0700788 public void updateInsets(Rect insets) {
789 mInsets.set(insets);
Sunny Goyal07b69292018-01-08 14:19:34 -0800790 updateWorkspacePadding();
Winson1f064272016-07-18 17:18:02 -0700791 }
792
Sunny Goyalae6e3182019-04-30 12:04:37 -0700793 /**
794 * The current device insets. This is generally same as the insets being dispatched to
795 * {@link Insettable} elements, but can differ if the element is using a different profile.
796 */
Sunny Goyal1a52ef52018-01-11 10:15:03 -0800797 public Rect getInsets() {
798 return mInsets;
799 }
800
Sunny Goyal756cd262015-08-20 12:33:21 -0700801 public Point getCellSize() {
Sunny Goyal19ff7282021-04-22 10:12:54 -0700802 return getCellSize(null);
Jon Miranda6f7e9702019-09-16 14:44:14 -0700803 }
804
Sunny Goyal19ff7282021-04-22 10:12:54 -0700805 public Point getCellSize(Point result) {
806 if (result == null) {
807 result = new Point();
808 }
Thales Limad1df5fc2021-09-03 18:37:19 +0100809
Sunny Goyal756cd262015-08-20 12:33:21 -0700810 // Since we are only concerned with the overall padding, layout direction does
811 // not matter.
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700812 Point padding = getTotalWorkspacePadding();
Thales Limad1df5fc2021-09-03 18:37:19 +0100813
814 int numColumns = isTwoPanels ? inv.numColumns * 2 : inv.numColumns;
815 int screenWidthPx = availableWidthPx - padding.x;
816 result.x = calculateCellWidth(screenWidthPx, cellLayoutBorderSpacingPx, numColumns);
Jon Miranda18751b62017-07-31 17:25:27 -0700817 result.y = calculateCellHeight(availableHeightPx - padding.y
Sunny Goyal19ff7282021-04-22 10:12:54 -0700818 - cellLayoutBottomPaddingPx, cellLayoutBorderSpacingPx, inv.numRows);
Sunny Goyal756cd262015-08-20 12:33:21 -0700819 return result;
820 }
821
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700822 public Point getTotalWorkspacePadding() {
Sunny Goyal07b69292018-01-08 14:19:34 -0800823 updateWorkspacePadding();
824 return new Point(workspacePadding.left + workspacePadding.right,
825 workspacePadding.top + workspacePadding.bottom);
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700826 }
827
828 /**
Sunny Goyal07b69292018-01-08 14:19:34 -0800829 * Updates {@link #workspacePadding} as a result of any internal value change to reflect the
830 * new workspace padding
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700831 */
Sunny Goyal07b69292018-01-08 14:19:34 -0800832 private void updateWorkspacePadding() {
833 Rect padding = workspacePadding;
Tony Wickham3a3517f2015-10-06 11:27:04 -0700834 if (isVerticalBarLayout()) {
Sunny Goyal228153d2018-01-04 15:35:22 -0800835 padding.top = 0;
836 padding.bottom = edgeMarginPx;
Sunny Goyal7e2e67f2018-01-26 13:40:08 -0800837 if (isSeascape()) {
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700838 padding.left = hotseatBarSizePx;
Tony Wickham5edf9e22020-03-27 20:06:52 -0700839 padding.right = hotseatBarSidePaddingStartPx;
Winson1f064272016-07-18 17:18:02 -0700840 } else {
Tony Wickham5edf9e22020-03-27 20:06:52 -0700841 padding.left = hotseatBarSidePaddingStartPx;
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700842 padding.right = hotseatBarSizePx;
Winson1f064272016-07-18 17:18:02 -0700843 }
Winson Chungb3800242013-10-24 11:01:54 -0700844 } else {
Tony Wickhama29a0462021-03-02 12:28:25 -0800845 int hotseatTop = isTaskbarPresent ? taskbarSize : hotseatBarSizePx;
846 int paddingBottom = hotseatTop + workspacePageIndicatorHeight
Jon Miranda228877d2021-02-09 11:05:00 -0500847 + workspaceBottomPadding - mWorkspacePageIndicatorOverlapWorkspace;
Sunny Goyalc6205602015-05-21 20:46:33 -0700848 if (isTablet) {
Winson Chungb3800242013-10-24 11:01:54 -0700849 // Pad the left and right of the workspace to ensure consistent spacing
850 // between all icons
Tony Wickhamd6b40372015-09-23 18:37:57 -0700851 // The amount of screen space available for left/right padding.
Sunny Goyal228153d2018-01-04 15:35:22 -0800852 int availablePaddingX = Math.max(0, widthPx - ((inv.numColumns * cellWidthPx) +
Sunny Goyalf5440cb2016-12-14 15:13:00 -0800853 ((inv.numColumns - 1) * cellWidthPx)));
Tony Wickhamd6b40372015-09-23 18:37:57 -0700854 availablePaddingX = (int) Math.min(availablePaddingX,
Sunny Goyal07b69292018-01-08 14:19:34 -0800855 widthPx * MAX_HORIZONTAL_PADDING_PERCENT);
Tony Wickhama29a0462021-03-02 12:28:25 -0800856 int hotseatVerticalPadding = isTaskbarPresent ? 0
857 : hotseatBarTopPaddingPx + hotseatBarBottomPaddingPx;
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700858 int availablePaddingY = Math.max(0, heightPx - edgeMarginPx - paddingBottom
Tony Wickhama29a0462021-03-02 12:28:25 -0800859 - (2 * inv.numRows * cellHeightPx) - hotseatVerticalPadding);
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700860 padding.set(availablePaddingX / 2, edgeMarginPx + availablePaddingY / 2,
Tony Wickhamd6b40372015-09-23 18:37:57 -0700861 availablePaddingX / 2, paddingBottom + availablePaddingY / 2);
Andras Kloczl8e57cce2021-02-11 23:51:19 +0100862
Sunny Goyal19ff7282021-04-22 10:12:54 -0700863 if (isTwoPanels) {
Andras Kloczl8e57cce2021-02-11 23:51:19 +0100864 padding.set(0, padding.top, 0, padding.bottom);
865 }
Winson Chungb3800242013-10-24 11:01:54 -0700866 } else {
867 // Pad the top and bottom of the workspace with search/hotseat bar sizes
Winson1f064272016-07-18 17:18:02 -0700868 padding.set(desiredWorkspaceLeftRightMarginPx,
Jon Mirandae126d722021-02-25 10:45:20 -0500869 workspaceTopPadding + (isScalableGrid ? 0 : edgeMarginPx),
Winson1f064272016-07-18 17:18:02 -0700870 desiredWorkspaceLeftRightMarginPx,
Winsonfadbe8f2016-07-22 16:35:37 -0700871 paddingBottom);
Winson Chungb3800242013-10-24 11:01:54 -0700872 }
873 }
Winson Chungb3800242013-10-24 11:01:54 -0700874 }
875
Sunny Goyal57b22792021-05-25 14:35:01 -0700876 /**
877 * Returns the padding for hotseat view
878 */
879 public Rect getHotseatLayoutPadding(Context context) {
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700880 if (isVerticalBarLayout()) {
881 if (isSeascape()) {
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700882 mHotseatPadding.set(mInsets.left + hotseatBarSidePaddingStartPx,
883 mInsets.top, hotseatBarSidePaddingEndPx, mInsets.bottom);
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700884 } else {
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700885 mHotseatPadding.set(hotseatBarSidePaddingEndPx, mInsets.top,
886 mInsets.right + hotseatBarSidePaddingStartPx, mInsets.bottom);
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700887 }
Sunny Goyal57b22792021-05-25 14:35:01 -0700888 } else if (isTaskbarPresent) {
889 int hotseatHeight = workspacePadding.bottom + taskbarSize;
890 int taskbarOffset = getTaskbarOffsetY();
891 int hotseatTopDiff = hotseatHeight - taskbarSize - taskbarOffset;
892
Vinit Nayak8dcbde82021-07-19 12:53:28 -0700893 int endOffset = ApiWrapper.getHotseatEndOffset(context);
Sunny Goyal57b22792021-05-25 14:35:01 -0700894 int requiredWidth = iconSizePx * numShownHotseatIcons;
895
896 Resources res = context.getResources();
897 float taskbarIconSize = res.getDimension(R.dimen.taskbar_icon_size);
898 float taskbarIconSpacing = 2 * res.getDimension(R.dimen.taskbar_icon_spacing);
899 int maxSize = (int) (requiredWidth
900 * (taskbarIconSize + taskbarIconSpacing) / taskbarIconSize);
Vinit Nayak8dcbde82021-07-19 12:53:28 -0700901 int hotseatSize = Math.min(maxSize, availableWidthPx - endOffset);
Sunny Goyal57b22792021-05-25 14:35:01 -0700902 int sideSpacing = (availableWidthPx - hotseatSize) / 2;
903 mHotseatPadding.set(sideSpacing, hotseatTopDiff, sideSpacing, taskbarOffset);
904
Vinit Nayak8dcbde82021-07-19 12:53:28 -0700905 if (endOffset > sideSpacing) {
Sunny Goyal57b22792021-05-25 14:35:01 -0700906 int diff = Utilities.isRtl(context.getResources())
Vinit Nayak8dcbde82021-07-19 12:53:28 -0700907 ? sideSpacing - endOffset
908 : endOffset - sideSpacing;
909 mHotseatPadding.left -= diff;
910 mHotseatPadding.right += diff;
Sunny Goyal57b22792021-05-25 14:35:01 -0700911 }
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700912 } else {
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700913 // We want the edges of the hotseat to line up with the edges of the workspace, but the
914 // icons in the hotseat are a different size, and so don't line up perfectly. To account
915 // for this, we pad the left and right of the hotseat with half of the difference of a
916 // workspace cell vs a hotseat cell.
917 float workspaceCellWidth = (float) widthPx / inv.numColumns;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700918 float hotseatCellWidth = (float) widthPx / numShownHotseatIcons;
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700919 int hotseatAdjustment = Math.round((workspaceCellWidth - hotseatCellWidth) / 2);
920 mHotseatPadding.set(
Sunny Goyal786940a2020-06-02 02:31:31 -0700921 hotseatAdjustment + workspacePadding.left + cellLayoutPaddingLeftRightPx
922 + mInsets.left,
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700923 hotseatBarTopPaddingPx,
Sunny Goyal786940a2020-06-02 02:31:31 -0700924 hotseatAdjustment + workspacePadding.right + cellLayoutPaddingLeftRightPx
925 + mInsets.right,
Jon Miranda0d284852021-06-22 14:50:55 -0700926 hotseatBarSizePx - hotseatCellHeightPx - hotseatBarTopPaddingPx
927 + cellLayoutBottomPaddingPx + mInsets.bottom);
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700928 }
929 return mHotseatPadding;
930 }
931
Winsonfadbe8f2016-07-22 16:35:37 -0700932 /**
Sunny Goyal57b22792021-05-25 14:35:01 -0700933 * Returns the number of pixels the QSB is translated from the bottom of the screen.
934 */
935 public int getQsbOffsetY() {
936 int freeSpace = isTaskbarPresent
937 ? workspacePadding.bottom
938 : hotseatBarSizePx - hotseatCellHeightPx - hotseatQsbHeight;
Jonathan Miranda7a273e22021-06-24 21:29:10 +0000939
Jonathan Miranda8f16a772021-07-23 23:10:37 +0000940 if (isScalableGrid && qsbBottomMarginPx > mInsets.bottom) {
Jonathan Mirandac2a49ee2021-07-22 00:38:43 +0000941 return Math.min(qsbBottomMarginPx, freeSpace);
Jonathan Miranda8f16a772021-07-23 23:10:37 +0000942 } else {
Jonathan Miranda7a273e22021-06-24 21:29:10 +0000943 return (int) (freeSpace * QSB_CENTER_FACTOR)
Jonathan Miranda8f16a772021-07-23 23:10:37 +0000944 + (isTaskbarPresent ? taskbarSize : mInsets.bottom);
Jonathan Miranda7a273e22021-06-24 21:29:10 +0000945 }
Sunny Goyal57b22792021-05-25 14:35:01 -0700946 }
947
948 /**
949 * Returns the number of pixels the taskbar is translated from the bottom of the screen.
950 */
951 public int getTaskbarOffsetY() {
952 return (getQsbOffsetY() - taskbarSize) / 2;
953 }
954
955 /**
Winsonfadbe8f2016-07-22 16:35:37 -0700956 * @return the bounds for which the open folders should be contained within
957 */
958 public Rect getAbsoluteOpenFolderBounds() {
959 if (isVerticalBarLayout()) {
960 // Folders should only appear right of the drop target bar and left of the hotseat
961 return new Rect(mInsets.left + dropTargetBarSizePx + edgeMarginPx,
962 mInsets.top,
Jon Miranda18751b62017-07-31 17:25:27 -0700963 mInsets.left + availableWidthPx - hotseatBarSizePx - edgeMarginPx,
Winsonfadbe8f2016-07-22 16:35:37 -0700964 mInsets.top + availableHeightPx);
965 } else {
966 // Folders should only appear below the drop target bar and above the hotseat
Tony Wickhamae72b462021-03-10 16:18:40 -0800967 int hotseatTop = isTaskbarPresent ? taskbarSize : hotseatBarSizePx;
Tony Wickhamb4b7e202018-01-12 17:39:24 -0800968 return new Rect(mInsets.left + edgeMarginPx,
Winsonfadbe8f2016-07-22 16:35:37 -0700969 mInsets.top + dropTargetBarSizePx + edgeMarginPx,
Tony Wickhamb4b7e202018-01-12 17:39:24 -0800970 mInsets.left + availableWidthPx - edgeMarginPx,
Tony Wickhamae72b462021-03-10 16:18:40 -0800971 mInsets.top + availableHeightPx - hotseatTop
Tony Wickham5edf9e22020-03-27 20:06:52 -0700972 - workspacePageIndicatorHeight - edgeMarginPx);
Winsonfadbe8f2016-07-22 16:35:37 -0700973 }
974 }
975
Jon Miranda228877d2021-02-09 11:05:00 -0500976 public static int calculateCellWidth(int width, int borderSpacing, int countX) {
977 return (width - ((countX - 1) * borderSpacing)) / countX;
Winson Chungb3800242013-10-24 11:01:54 -0700978 }
Jon Miranda228877d2021-02-09 11:05:00 -0500979 public static int calculateCellHeight(int height, int borderSpacing, int countY) {
980 return (height - ((countY - 1) * borderSpacing)) / countY;
Winson Chungb3800242013-10-24 11:01:54 -0700981 }
982
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -0700983 /**
Tony Wickham55616cd2015-09-23 14:55:17 -0700984 * When {@code true}, the device is in landscape mode and the hotseat is on the right column.
985 * When {@code false}, either device is in portrait mode or the device is in landscape mode and
986 * the hotseat is on the bottom row.
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -0700987 */
Tony Wickhamab946a12015-09-16 15:38:16 -0700988 public boolean isVerticalBarLayout() {
Winson Chungb3800242013-10-24 11:01:54 -0700989 return isLandscape && transposeLayoutWithOrientation;
990 }
991
Sunny Goyal59d086c2018-05-07 17:31:40 -0700992 /**
993 * Updates orientation information and returns true if it has changed from the previous value.
994 */
Winson Chung13c1c2c2019-09-06 11:46:19 -0700995 public boolean updateIsSeascape(Context context) {
Sunny Goyal59d086c2018-05-07 17:31:40 -0700996 if (isVerticalBarLayout()) {
Sunny Goyal35c7b192021-04-20 16:51:10 -0700997 boolean isSeascape = DisplayController.INSTANCE.get(context)
998 .getInfo().rotation == Surface.ROTATION_270;
Sunny Goyal59d086c2018-05-07 17:31:40 -0700999 if (mIsSeascape != isSeascape) {
1000 mIsSeascape = isSeascape;
1001 return true;
1002 }
1003 }
1004 return false;
1005 }
1006
Sunny Goyal7e2e67f2018-01-26 13:40:08 -08001007 public boolean isSeascape() {
Sunny Goyal59d086c2018-05-07 17:31:40 -07001008 return isVerticalBarLayout() && mIsSeascape;
Sunny Goyal7e2e67f2018-01-26 13:40:08 -08001009 }
1010
Sunny Goyal07b69292018-01-08 14:19:34 -08001011 public boolean shouldFadeAdjacentWorkspaceScreens() {
Sunny Goyal19ff7282021-04-22 10:12:54 -07001012 return isVerticalBarLayout();
Winson Chungb3800242013-10-24 11:01:54 -07001013 }
1014
Jon Miranda92c1b5d2021-07-20 13:57:16 -07001015 public int getCellContentHeight(@ContainerType int containerType) {
Sunny Goyalc13403c2016-11-18 23:44:48 -08001016 switch (containerType) {
1017 case CellLayout.WORKSPACE:
1018 return cellHeightPx;
1019 case CellLayout.FOLDER:
1020 return folderCellHeightPx;
1021 case CellLayout.HOTSEAT:
Jon Miranda92c1b5d2021-07-20 13:57:16 -07001022 // The hotseat is the only container where the cell height is going to be
1023 // different from the content within that cell.
1024 return iconSizePx;
Sunny Goyalc13403c2016-11-18 23:44:48 -08001025 default:
1026 // ??
1027 return 0;
1028 }
1029 }
Sunny Goyal13178ac2016-04-04 16:35:22 -07001030
Jon Miranda58561d42021-03-17 10:51:54 -04001031 private String pxToDpStr(String name, float value) {
Sunny Goyal35c7b192021-04-20 16:51:10 -07001032 return "\t" + name + ": " + value + "px (" + dpiFromPx(value, mMetrics.densityDpi) + "dp)";
Jon Miranda58561d42021-03-17 10:51:54 -04001033 }
1034
1035 public void dump(String prefix, PrintWriter writer) {
1036 writer.println(prefix + "DeviceProfile:");
Sunny Goyal35c7b192021-04-20 16:51:10 -07001037 writer.println(prefix + "\t1 dp = " + mMetrics.density + " px");
Jon Miranda58561d42021-03-17 10:51:54 -04001038
Alex Chaua02eddc2021-04-29 00:36:06 +01001039 writer.println(prefix + "\tallowRotation:" + allowRotation);
Jon Miranda58561d42021-03-17 10:51:54 -04001040 writer.println(prefix + "\tisTablet:" + isTablet);
Jon Miranda58561d42021-03-17 10:51:54 -04001041 writer.println(prefix + "\tisPhone:" + isPhone);
1042 writer.println(prefix + "\ttransposeLayoutWithOrientation:"
1043 + transposeLayoutWithOrientation);
1044
1045 writer.println(prefix + "\tisLandscape:" + isLandscape);
1046 writer.println(prefix + "\tisMultiWindowMode:" + isMultiWindowMode);
Sunny Goyal19ff7282021-04-22 10:12:54 -07001047 writer.println(prefix + "\tisTwoPanels:" + isTwoPanels);
Jon Miranda58561d42021-03-17 10:51:54 -04001048
1049 writer.println(prefix + pxToDpStr("windowX", windowX));
1050 writer.println(prefix + pxToDpStr("windowY", windowY));
1051 writer.println(prefix + pxToDpStr("widthPx", widthPx));
1052 writer.println(prefix + pxToDpStr("heightPx", heightPx));
1053
1054 writer.println(prefix + pxToDpStr("availableWidthPx", availableWidthPx));
1055 writer.println(prefix + pxToDpStr("availableHeightPx", availableHeightPx));
1056
1057 writer.println(prefix + "\taspectRatio:" + aspectRatio);
1058
1059 writer.println(prefix + "\tisScalableGrid:" + isScalableGrid);
1060
1061 writer.println(prefix + "\tinv.minCellWidth:" + inv.minCellWidth + "dp");
1062 writer.println(prefix + "\tinv.minCellHeight:" + inv.minCellHeight + "dp");
Thales Limad1df5fc2021-09-03 18:37:19 +01001063 writer.println(prefix + "\tinv.twoPanelPortraitMinCellHeightDps:"
1064 + inv.twoPanelPortraitMinCellHeightDps + "dp");
1065 writer.println(prefix + "\tinv.twoPanelPortraitMinCellWidthDps:"
1066 + inv.twoPanelPortraitMinCellWidthDps + "dp");
1067 writer.println(prefix + "\tinv.twoPanelLandscapeMinCellHeightDps:"
1068 + inv.twoPanelLandscapeMinCellHeightDps + "dp");
1069 writer.println(prefix + "\tinv.twoPanelLandscapeMinCellWidthDps:"
1070 + inv.twoPanelLandscapeMinCellWidthDps + "dp");
Jon Miranda58561d42021-03-17 10:51:54 -04001071
Jon Mirandaab3c6812021-06-28 15:42:28 -07001072 writer.println(prefix + "\tinv.numColumns:" + inv.numColumns);
1073 writer.println(prefix + "\tinv.numRows:" + inv.numRows);
1074
Jon Miranda58561d42021-03-17 10:51:54 -04001075 writer.println(prefix + pxToDpStr("cellWidthPx", cellWidthPx));
1076 writer.println(prefix + pxToDpStr("cellHeightPx", cellHeightPx));
1077
1078 writer.println(prefix + pxToDpStr("getCellSize().x", getCellSize().x));
1079 writer.println(prefix + pxToDpStr("getCellSize().y", getCellSize().y));
1080
1081 writer.println(prefix + "\tinv.iconSize:" + inv.iconSize + "dp");
1082 writer.println(prefix + pxToDpStr("iconSizePx", iconSizePx));
1083 writer.println(prefix + pxToDpStr("iconTextSizePx", iconTextSizePx));
1084 writer.println(prefix + pxToDpStr("iconDrawablePaddingPx", iconDrawablePaddingPx));
1085
1086 writer.println(prefix + pxToDpStr("folderCellWidthPx", folderCellWidthPx));
1087 writer.println(prefix + pxToDpStr("folderCellHeightPx", folderCellHeightPx));
1088 writer.println(prefix + pxToDpStr("folderChildIconSizePx", folderChildIconSizePx));
1089 writer.println(prefix + pxToDpStr("folderChildTextSizePx", folderChildTextSizePx));
1090 writer.println(prefix + pxToDpStr("folderChildDrawablePaddingPx",
1091 folderChildDrawablePaddingPx));
Jon Miranda823da222021-03-23 08:08:45 -04001092 writer.println(prefix + pxToDpStr("folderCellLayoutBorderSpacingPx",
1093 folderCellLayoutBorderSpacingPx));
Jon Miranda58561d42021-03-17 10:51:54 -04001094
1095 writer.println(prefix + pxToDpStr("cellLayoutBorderSpacingPx",
1096 cellLayoutBorderSpacingPx));
1097 writer.println(prefix + pxToDpStr("desiredWorkspaceLeftRightMarginPx",
1098 desiredWorkspaceLeftRightMarginPx));
1099
1100 writer.println(prefix + pxToDpStr("allAppsIconSizePx", allAppsIconSizePx));
1101 writer.println(prefix + pxToDpStr("allAppsIconTextSizePx", allAppsIconTextSizePx));
1102 writer.println(prefix + pxToDpStr("allAppsIconDrawablePaddingPx",
1103 allAppsIconDrawablePaddingPx));
1104 writer.println(prefix + pxToDpStr("allAppsCellHeightPx", allAppsCellHeightPx));
Sunny Goyal19ff7282021-04-22 10:12:54 -07001105 writer.println(prefix + "\tnumShownAllAppsColumns: " + numShownAllAppsColumns);
Jon Miranda58561d42021-03-17 10:51:54 -04001106
1107 writer.println(prefix + pxToDpStr("hotseatBarSizePx", hotseatBarSizePx));
1108 writer.println(prefix + pxToDpStr("hotseatCellHeightPx", hotseatCellHeightPx));
1109 writer.println(prefix + pxToDpStr("hotseatBarTopPaddingPx", hotseatBarTopPaddingPx));
1110 writer.println(prefix + pxToDpStr("hotseatBarBottomPaddingPx", hotseatBarBottomPaddingPx));
1111 writer.println(prefix + pxToDpStr("hotseatBarSidePaddingStartPx",
1112 hotseatBarSidePaddingStartPx));
1113 writer.println(prefix + pxToDpStr("hotseatBarSidePaddingEndPx",
1114 hotseatBarSidePaddingEndPx));
Sunny Goyal19ff7282021-04-22 10:12:54 -07001115 writer.println(prefix + "\tnumShownHotseatIcons: " + numShownHotseatIcons);
Jon Miranda58561d42021-03-17 10:51:54 -04001116
1117 writer.println(prefix + "\tisTaskbarPresent:" + isTaskbarPresent);
Tony Wickham635e1802021-07-22 14:28:04 -10001118 writer.println(prefix + "\tisTaskbarPresentInApps:" + isTaskbarPresentInApps);
Jon Miranda58561d42021-03-17 10:51:54 -04001119
1120 writer.println(prefix + pxToDpStr("taskbarSize", taskbarSize));
1121 writer.println(prefix + pxToDpStr("nonOverlappingTaskbarInset",
1122 nonOverlappingTaskbarInset));
1123
1124 writer.println(prefix + pxToDpStr("workspacePadding.left", workspacePadding.left));
1125 writer.println(prefix + pxToDpStr("workspacePadding.top", workspacePadding.top));
1126 writer.println(prefix + pxToDpStr("workspacePadding.right", workspacePadding.right));
1127 writer.println(prefix + pxToDpStr("workspacePadding.bottom", workspacePadding.bottom));
1128
Jon Mirandaab3c6812021-06-28 15:42:28 -07001129 writer.println(prefix + pxToDpStr("iconScale", iconScale));
1130 writer.println(prefix + pxToDpStr("cellScaleToFit ", cellScaleToFit));
Jon Miranda58561d42021-03-17 10:51:54 -04001131 writer.println(prefix + pxToDpStr("extraSpace", extraSpace));
Jon Mirandac9e69fa2021-03-22 17:13:34 -04001132
1133 if (inv.devicePaddings != null) {
1134 int unscaledExtraSpace = (int) (extraSpace / iconScale);
1135 writer.println(prefix + pxToDpStr("maxEmptySpace",
1136 inv.devicePaddings.getDevicePadding(unscaledExtraSpace).getMaxEmptySpacePx()));
1137 }
Jon Miranda58561d42021-03-17 10:51:54 -04001138 writer.println(prefix + pxToDpStr("workspaceTopPadding", workspaceTopPadding));
1139 writer.println(prefix + pxToDpStr("workspaceBottomPadding", workspaceBottomPadding));
1140 writer.println(prefix + pxToDpStr("extraHotseatBottomPadding", extraHotseatBottomPadding));
1141 }
1142
Sunny Goyalfd58da62020-08-11 12:06:49 -07001143 private static Context getContext(Context c, Info info, int orientation) {
Sunny Goyal1890f672020-04-30 12:28:00 -07001144 Configuration config = new Configuration(c.getResources().getConfiguration());
1145 config.orientation = orientation;
Sunny Goyal35c7b192021-04-20 16:51:10 -07001146 config.densityDpi = info.densityDpi;
Sunny Goyal1890f672020-04-30 12:28:00 -07001147 return c.createConfigurationContext(config);
Jon Mirandab28c4fc2017-06-20 10:58:36 -07001148 }
Sunny Goyalfde55052018-02-01 14:46:13 -08001149
1150 /**
1151 * Callback when a component changes the DeviceProfile associated with it, as a result of
1152 * configuration change
1153 */
1154 public interface OnDeviceProfileChangeListener {
1155
1156 /**
1157 * Called when the device profile is reassigned. Note that for layout and measurements, it
1158 * is sufficient to listen for inset changes. Use this callback when you need to perform
1159 * a one time operation.
1160 */
1161 void onDeviceProfileChanged(DeviceProfile dp);
1162 }
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001163
1164 public static class Builder {
1165 private Context mContext;
1166 private InvariantDeviceProfile mInv;
Sunny Goyalfd58da62020-08-11 12:06:49 -07001167 private Info mInfo;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001168
Sunny Goyal19ff7282021-04-22 10:12:54 -07001169 private WindowBounds mWindowBounds;
1170 private boolean mUseTwoPanels;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001171
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001172 private boolean mIsMultiWindowMode = false;
Sunny Goyal19ff7282021-04-22 10:12:54 -07001173 private Boolean mTransposeLayoutWithOrientation;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001174
Sunny Goyalfd58da62020-08-11 12:06:49 -07001175 public Builder(Context context, InvariantDeviceProfile inv, Info info) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001176 mContext = context;
1177 mInv = inv;
1178 mInfo = info;
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001179 }
1180
1181 public Builder setMultiWindowMode(boolean isMultiWindowMode) {
1182 mIsMultiWindowMode = isMultiWindowMode;
1183 return this;
1184 }
1185
Sunny Goyal19ff7282021-04-22 10:12:54 -07001186 public Builder setUseTwoPanels(boolean useTwoPanels) {
1187 mUseTwoPanels = useTwoPanels;
1188 return this;
1189 }
1190
1191
1192 public Builder setWindowBounds(WindowBounds bounds) {
1193 mWindowBounds = bounds;
Sunny Goyal0addbf02020-04-28 14:17:35 -07001194 return this;
1195 }
1196
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001197 public Builder setTransposeLayoutWithOrientation(boolean transposeLayoutWithOrientation) {
1198 mTransposeLayoutWithOrientation = transposeLayoutWithOrientation;
1199 return this;
1200 }
1201
1202 public DeviceProfile build() {
Sunny Goyal19ff7282021-04-22 10:12:54 -07001203 if (mWindowBounds == null) {
1204 throw new IllegalArgumentException("Window bounds not set");
1205 }
1206 if (mTransposeLayoutWithOrientation == null) {
1207 mTransposeLayoutWithOrientation = !mInfo.isTablet(mWindowBounds);
1208 }
1209 return new DeviceProfile(mContext, mInv, mInfo, mWindowBounds,
1210 mIsMultiWindowMode, mTransposeLayoutWithOrientation, mUseTwoPanels);
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001211 }
1212 }
1213
Winson Chungb3800242013-10-24 11:01:54 -07001214}