blob: e9245b0819497b425742b0d552ec00eae3463fa1 [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 -070020import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION;
21
Jon Mirandae126d722021-02-25 10:45:20 -050022import static com.android.launcher3.ResourceUtils.pxFromDp;
Jon Miranda58561d42021-03-17 10:51:54 -040023import static com.android.launcher3.Utilities.dpiFromPx;
Jon Mirandaaf3aed02021-05-06 18:28:45 -070024import static com.android.launcher3.Utilities.pxFromSp;
Alex 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.hardware.display.DisplayManager;
36import android.util.DisplayMetrics;
Sunny Goyal59d086c2018-05-07 17:31:40 -070037import android.view.Surface;
Tony Wickham15883892021-02-12 11:24:40 -080038import android.view.WindowInsets;
39import android.view.WindowManager;
Winson Chungb3800242013-10-24 11:01:54 -070040
Sunny Goyalc13403c2016-11-18 23:44:48 -080041import com.android.launcher3.CellLayout.ContainerType;
Jon Miranda228877d2021-02-09 11:05:00 -050042import com.android.launcher3.DevicePaddings.DevicePadding;
Tony Wickham15883892021-02-12 11:24:40 -080043import com.android.launcher3.config.FeatureFlags;
Tony Wickham8912b042018-11-29 15:28:53 -080044import com.android.launcher3.icons.DotRenderer;
Sunny Goyal8b9919d2021-04-07 14:45:17 -070045import com.android.launcher3.icons.GraphicsUtils;
Hyunyoung Song48cb7bc2018-09-25 17:03:34 -070046import com.android.launcher3.icons.IconNormalizer;
Sunny Goyalfd58da62020-08-11 12:06:49 -070047import com.android.launcher3.util.DisplayController;
48import com.android.launcher3.util.DisplayController.Info;
Sunny Goyalb46703d2020-05-27 17:52:03 -070049import com.android.launcher3.util.WindowBounds;
Winson1f064272016-07-18 17:18:02 -070050
Jon Miranda58561d42021-03-17 10:51:54 -040051import java.io.PrintWriter;
52
Sunny Goyal35c7b192021-04-20 16:51:10 -070053@SuppressLint("NewApi")
Winson Chungb3800242013-10-24 11:01:54 -070054public class DeviceProfile {
Adam Cohen2e6da152015-05-06 11:42:25 -070055
Sunny Goyal8b9919d2021-04-07 14:45:17 -070056 private static final int DEFAULT_DOT_SIZE = 100;
Sunny Goyal1890f672020-04-30 12:28:00 -070057
Adam Cohen2e6da152015-05-06 11:42:25 -070058 public final InvariantDeviceProfile inv;
Sunny Goyalfd58da62020-08-11 12:06:49 -070059 private final Info mInfo;
Sunny Goyal35c7b192021-04-20 16:51:10 -070060 private final DisplayMetrics mMetrics;
Winson Chungbe876472014-05-14 14:15:20 -070061
Sunny Goyalc6205602015-05-21 20:46:33 -070062 // Device properties
63 public final boolean isTablet;
Sunny Goyalc6205602015-05-21 20:46:33 -070064 public final boolean isPhone;
65 public final boolean transposeLayoutWithOrientation;
Sunny Goyal19ff7282021-04-22 10:12:54 -070066 public final boolean isTwoPanels;
Alex Chaua02eddc2021-04-29 00:36:06 +010067 public final boolean allowRotation;
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -070068
Sunny Goyalc6205602015-05-21 20:46:33 -070069 // Device properties in current orientation
Sunny Goyald792a772018-04-05 13:37:46 -070070 public final boolean isLandscape;
Sunny Goyald70e75a2018-02-22 10:07:32 -080071 public final boolean isMultiWindowMode;
72
Sunny Goyal0addbf02020-04-28 14:17:35 -070073 public final int windowX;
74 public final int windowY;
Sunny Goyalc6205602015-05-21 20:46:33 -070075 public final int widthPx;
76 public final int heightPx;
77 public final int availableWidthPx;
78 public final int availableHeightPx;
Jon Mirandabba64512019-03-27 10:54:17 -070079
80 public final float aspectRatio;
81
Jon Mirandae126d722021-02-25 10:45:20 -050082 public final boolean isScalableGrid;
83
Tony Wickhamd6b40372015-09-23 18:37:57 -070084 /**
85 * The maximum amount of left/right workspace padding as a percentage of the screen width.
86 * To be clear, this means that up to 7% of the screen width can be used as left padding, and
87 * 7% of the screen width can be used as right padding.
88 */
89 private static final float MAX_HORIZONTAL_PADDING_PERCENT = 0.14f;
Winson Chungb3800242013-10-24 11:01:54 -070090
Jon Miranda3f9bab22017-07-28 14:50:17 -070091 private static final float TALL_DEVICE_ASPECT_RATIO_THRESHOLD = 2.0f;
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
Jon Mirandae126d722021-02-25 10:45:20 -050097 public final int desiredWorkspaceLeftRightOriginalPx;
98 public int desiredWorkspaceLeftRightMarginPx;
99 public final int cellLayoutBorderSpacingOriginalPx;
100 public int cellLayoutBorderSpacingPx;
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
Adam Cohen59400422014-03-05 18:07:04 -0800123 public int cellWidthPx;
124 public int cellHeightPx;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700125 public int workspaceCellPaddingXPx;
Adam Cohen59400422014-03-05 18:07:04 -0800126
Jon Mirandae126d722021-02-25 10:45:20 -0500127 public int cellYPaddingPx;
Jon Mirandae126d722021-02-25 10:45:20 -0500128
Sunny Goyalc6205602015-05-21 20:46:33 -0700129 // Folder
Jon Mirandae126d722021-02-25 10:45:20 -0500130 public float folderLabelTextScale;
131 public int folderLabelTextSizePx;
Sunny Goyalc6205602015-05-21 20:46:33 -0700132 public int folderIconSizePx;
Jon Miranda591e3602018-03-28 11:37:00 -0700133 public int folderIconOffsetYPx;
Jon Mirandabf7d8122016-11-03 15:29:29 -0700134
Jon Mirandae126d722021-02-25 10:45:20 -0500135 // Folder content
Jon Miranda823da222021-03-23 08:08:45 -0400136 public int folderCellLayoutBorderSpacingPx;
Jon Mirandae126d722021-02-25 10:45:20 -0500137 public int folderContentPaddingLeftRight;
138 public int folderContentPaddingTop;
139
Jon Mirandabf7d8122016-11-03 15:29:29 -0700140 // Folder cell
Sunny Goyalc6205602015-05-21 20:46:33 -0700141 public int folderCellWidthPx;
142 public int folderCellHeightPx;
Jon Mirandabf7d8122016-11-03 15:29:29 -0700143
144 // Folder child
145 public int folderChildIconSizePx;
146 public int folderChildTextSizePx;
Sunny Goyalbaec6ff2016-09-14 11:26:21 -0700147 public int folderChildDrawablePaddingPx;
Winson Chungb3800242013-10-24 11:01:54 -0700148
Sunny Goyalc6205602015-05-21 20:46:33 -0700149 // Hotseat
Tony Wickhamb87f3cd2021-04-07 15:02:37 -0700150 public final int numShownHotseatIcons;
Sunny Goyalc6205602015-05-21 20:46:33 -0700151 public int hotseatCellHeightPx;
Jon Miranda18751b62017-07-31 17:25:27 -0700152 // In portrait: size = height, in landscape: size = width
153 public int hotseatBarSizePx;
Sunny Goyal07b69292018-01-08 14:19:34 -0800154 public final int hotseatBarTopPaddingPx;
Jon Miranda7e183c32018-06-20 11:05:27 -0700155 public int hotseatBarBottomPaddingPx;
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700156 // Start is the side next to the nav bar, end is the side next to the workspace
157 public final int hotseatBarSidePaddingStartPx;
158 public final int hotseatBarSidePaddingEndPx;
Adam Cohen2e6da152015-05-06 11:42:25 -0700159
Sunny Goyalc6205602015-05-21 20:46:33 -0700160 // All apps
Samuel Fufaee9aff92021-04-05 13:30:40 -0500161 public int allAppsOpenVerticalTranslate;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700162 public int allAppsCellHeightPx;
Samuel Fufaf1424a32019-10-04 15:15:19 -0700163 public int allAppsCellWidthPx;
Winson1f064272016-07-18 17:18:02 -0700164 public int allAppsIconSizePx;
165 public int allAppsIconDrawablePaddingPx;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700166 public final int numShownAllAppsColumns;
Winson1f064272016-07-18 17:18:02 -0700167 public float allAppsIconTextSizePx;
168
Zak Cohen334efeb2021-03-19 16:42:07 -0700169 // Overview
Zak Cohen334efeb2021-03-19 16:42:07 -0700170 public int overviewTaskMarginPx;
Alex Chaudedbc8a2021-03-17 16:53:26 +0000171 public int overviewTaskIconSizePx;
172 public int overviewTaskThumbnailTopMarginPx;
zakcohendad8a802021-05-20 09:52:26 -0700173 public final int overviewActionsMarginThreeButtonPx;
174 public final int overviewActionsMarginGesturePx;
Zak Cohen334efeb2021-03-19 16:42:07 -0700175
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800176 // Widgets
177 public final PointF appWidgetScale = new PointF(1.0f, 1.0f);
178
Sunny Goyal47328fd2016-05-25 18:56:41 -0700179 // Drop Target
180 public int dropTargetBarSizePx;
Alex Chaua02eddc2021-04-29 00:36:06 +0100181 public int dropTargetDragPaddingPx;
182 public int dropTargetTextSizePx;
Adam Cohen4ae96ce2014-08-29 15:05:48 -0700183
Winson1f064272016-07-18 17:18:02 -0700184 // Insets
Sunny Goyal07b69292018-01-08 14:19:34 -0800185 private final Rect mInsets = new Rect();
186 public final Rect workspacePadding = new Rect();
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700187 private final Rect mHotseatPadding = new Rect();
Jon Miranda0bd63d12019-03-06 17:29:29 -0800188 // When true, nav bar is on the left side of the screen.
Sunny Goyal59d086c2018-05-07 17:31:40 -0700189 private boolean mIsSeascape;
Winson1f064272016-07-18 17:18:02 -0700190
Tony Wickhamf34bee82018-12-03 18:11:39 -0800191 // Notification dots
Samuel Fufac96fa242019-09-26 23:06:32 -0700192 public DotRenderer mDotRendererWorkSpace;
193 public DotRenderer mDotRendererAllApps;
Tony Wickham9a8d11f2017-01-11 09:53:12 -0800194
Tony Wickham15883892021-02-12 11:24:40 -0800195 // Taskbar
196 public boolean isTaskbarPresent;
197 public int taskbarSize;
Tony Wickham145b7fd2021-03-11 10:03:12 -0800198 // How much of the bottom inset is due to Taskbar rather than other system elements.
199 public int nonOverlappingTaskbarInset;
Tony Wickham15883892021-02-12 11:24:40 -0800200
Alex Chaua02eddc2021-04-29 00:36:06 +0100201 // DragController
202 public int flingToDeleteThresholdVelocity;
203
Sunny Goyal19ff7282021-04-22 10:12:54 -0700204 DeviceProfile(Context context, InvariantDeviceProfile inv, Info info, WindowBounds windowBounds,
Sunny Goyal0addbf02020-04-28 14:17:35 -0700205 boolean isMultiWindowMode, boolean transposeLayoutWithOrientation,
Sunny Goyal19ff7282021-04-22 10:12:54 -0700206 boolean useTwoPanels) {
Sunny Goyalfee35bb2015-05-11 11:38:19 -0700207
Adam Cohen2e6da152015-05-06 11:42:25 -0700208 this.inv = inv;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700209 this.isLandscape = windowBounds.isLandscape();
Sunny Goyald70e75a2018-02-22 10:07:32 -0800210 this.isMultiWindowMode = isMultiWindowMode;
Jon Mirandae126d722021-02-25 10:45:20 -0500211 this.transposeLayoutWithOrientation = transposeLayoutWithOrientation;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700212 windowX = windowBounds.bounds.left;
213 windowY = windowBounds.bounds.top;
Winson Chungb3800242013-10-24 11:01:54 -0700214
Jon Mirandae126d722021-02-25 10:45:20 -0500215 isScalableGrid = inv.isScalable && !isVerticalBarLayout() && !isMultiWindowMode;
216
Jon Miranda7e183c32018-06-20 11:05:27 -0700217 // Determine sizes.
Sunny Goyal19ff7282021-04-22 10:12:54 -0700218 widthPx = windowBounds.bounds.width();
219 heightPx = windowBounds.bounds.height();
220 availableWidthPx = windowBounds.availableSize.x;
221 int nonFinalAvailableHeightPx = windowBounds.availableSize.y;
Jon Miranda7e183c32018-06-20 11:05:27 -0700222
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700223 mInfo = info;
Alex Chaua02eddc2021-04-29 00:36:06 +0100224 // If the device's pixel density was scaled (usually via settings for A11y), use the
225 // original dimensions to determine if rotation is allowed of not.
226 float originalSmallestWidth = dpiFromPx(Math.min(widthPx, heightPx), DENSITY_DEVICE_STABLE);
227 allowRotation = originalSmallestWidth >= MIN_TABLET_WIDTH;
228 // Tablet UI does not support emulated landscape.
229 isTablet = allowRotation && info.isTablet(windowBounds);
Sunny Goyal19ff7282021-04-22 10:12:54 -0700230 isPhone = !isTablet;
231 isTwoPanels = isTablet && useTwoPanels;
Adam Cohen2e6da152015-05-06 11:42:25 -0700232
Jon Mirandabba64512019-03-27 10:54:17 -0700233 aspectRatio = ((float) Math.max(widthPx, heightPx)) / Math.min(widthPx, heightPx);
Jon Miranda7e183c32018-06-20 11:05:27 -0700234 boolean isTallDevice = Float.compare(aspectRatio, TALL_DEVICE_ASPECT_RATIO_THRESHOLD) >= 0;
Sunny Goyalc6205602015-05-21 20:46:33 -0700235
236 // Some more constants
Sunny Goyal1890f672020-04-30 12:28:00 -0700237 context = getContext(context, info, isVerticalBarLayout()
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700238 ? Configuration.ORIENTATION_LANDSCAPE
239 : Configuration.ORIENTATION_PORTRAIT);
Sunny Goyal35c7b192021-04-20 16:51:10 -0700240 mMetrics = context.getResources().getDisplayMetrics();
Sunny Goyal1890f672020-04-30 12:28:00 -0700241 final Resources res = context.getResources();
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700242
Tony Wickham15883892021-02-12 11:24:40 -0800243 isTaskbarPresent = isTablet && FeatureFlags.ENABLE_TASKBAR.get();
244 if (isTaskbarPresent) {
245 // Taskbar will be added later, but provides bottom insets that we should subtract
246 // from availableHeightPx.
247 taskbarSize = res.getDimensionPixelSize(R.dimen.taskbar_size);
Sunny Goyal35c7b192021-04-20 16:51:10 -0700248 WindowInsets windowInsets =
249 context.createWindowContext(
250 context.getSystemService(DisplayManager.class).getDisplay(mInfo.id),
251 TYPE_APPLICATION, null)
252 .getSystemService(WindowManager.class)
Tony Wickham15883892021-02-12 11:24:40 -0800253 .getCurrentWindowMetrics().getWindowInsets();
Sunny Goyal35c7b192021-04-20 16:51:10 -0700254 nonOverlappingTaskbarInset = taskbarSize - windowInsets.getSystemWindowInsetBottom();
Tony Wickham15883892021-02-12 11:24:40 -0800255 if (nonOverlappingTaskbarInset > 0) {
256 nonFinalAvailableHeightPx -= nonOverlappingTaskbarInset;
257 }
258 }
259 availableHeightPx = nonFinalAvailableHeightPx;
260
Winson Chungb3800242013-10-24 11:01:54 -0700261 edgeMarginPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_edge_margin);
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700262
Jon Mirandae126d722021-02-25 10:45:20 -0500263 desiredWorkspaceLeftRightMarginPx = isVerticalBarLayout() ? 0 : isScalableGrid
264 ? res.getDimensionPixelSize(R.dimen.scalable_grid_left_right_margin)
265 : res.getDimensionPixelSize(R.dimen.dynamic_grid_left_right_margin);
266 desiredWorkspaceLeftRightOriginalPx = desiredWorkspaceLeftRightMarginPx;
267
Samuel Fufaee9aff92021-04-05 13:30:40 -0500268
269 allAppsOpenVerticalTranslate = res.getDimensionPixelSize(
270 R.dimen.all_apps_open_vertical_translate);
271
Jon Mirandae126d722021-02-25 10:45:20 -0500272 folderLabelTextScale = res.getFloat(R.dimen.folder_label_text_scale);
273 folderContentPaddingLeftRight =
274 res.getDimensionPixelSize(R.dimen.folder_content_padding_left_right);
275 folderContentPaddingTop = res.getDimensionPixelSize(R.dimen.folder_content_padding_top);
276
Sunny Goyal35c7b192021-04-20 16:51:10 -0700277 setCellLayoutBorderSpacing(pxFromDp(inv.borderSpacing, mMetrics, 1f));
Jon Mirandae126d722021-02-25 10:45:20 -0500278 cellLayoutBorderSpacingOriginalPx = cellLayoutBorderSpacingPx;
Jon Miranda823da222021-03-23 08:08:45 -0400279 folderCellLayoutBorderSpacingPx = cellLayoutBorderSpacingPx;
Jon Mirandae126d722021-02-25 10:45:20 -0500280
Jon Miranda5eacbb72018-07-31 11:14:46 -0700281 int cellLayoutPaddingLeftRightMultiplier = !isVerticalBarLayout() && isTablet
282 ? PORTRAIT_TABLET_LEFT_RIGHT_PADDING_MULTIPLIER : 1;
Jon Mirandae126d722021-02-25 10:45:20 -0500283 int cellLayoutPadding = isScalableGrid
284 ? 0
285 : res.getDimensionPixelSize(R.dimen.dynamic_grid_cell_layout_padding);
Andras Kloczl8e57cce2021-02-11 23:51:19 +0100286
Sunny Goyal19ff7282021-04-22 10:12:54 -0700287 if (isTwoPanels) {
Andras Kloczl8e57cce2021-02-11 23:51:19 +0100288 cellLayoutPaddingLeftRightPx =
289 res.getDimensionPixelSize(R.dimen.two_panel_home_side_padding);
290 cellLayoutBottomPaddingPx = 0;
291 } else if (isLandscape) {
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700292 cellLayoutPaddingLeftRightPx = 0;
293 cellLayoutBottomPaddingPx = cellLayoutPadding;
294 } else {
295 cellLayoutPaddingLeftRightPx = cellLayoutPaddingLeftRightMultiplier * cellLayoutPadding;
296 cellLayoutBottomPaddingPx = 0;
297 }
298
Tony Wickham5edf9e22020-03-27 20:06:52 -0700299 workspacePageIndicatorHeight = res.getDimensionPixelSize(
300 R.dimen.workspace_page_indicator_height);
301 mWorkspacePageIndicatorOverlapWorkspace =
302 res.getDimensionPixelSize(R.dimen.workspace_page_indicator_overlap_workspace);
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700303
Winson Chungb3800242013-10-24 11:01:54 -0700304 iconDrawablePaddingOriginalPx =
305 res.getDimensionPixelSize(R.dimen.dynamic_grid_icon_drawable_padding);
Alex Chaua02eddc2021-04-29 00:36:06 +0100306
Sunny Goyal47328fd2016-05-25 18:56:41 -0700307 dropTargetBarSizePx = res.getDimensionPixelSize(R.dimen.dynamic_grid_drop_target_size);
Alex Chaua02eddc2021-04-29 00:36:06 +0100308 dropTargetDragPaddingPx = res.getDimensionPixelSize(R.dimen.drop_target_drag_padding);
309 dropTargetTextSizePx = res.getDimensionPixelSize(R.dimen.drop_target_text_size);
310
Sunny Goyal47328fd2016-05-25 18:56:41 -0700311 workspaceSpringLoadedBottomSpace =
312 res.getDimensionPixelSize(R.dimen.dynamic_grid_min_spring_loaded_space);
Sunny Goyald5190522017-04-24 03:06:54 -0700313
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700314 workspaceCellPaddingXPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_cell_padding_x);
Jon Miranda09660722017-06-14 14:20:14 -0700315
Sunny Goyal19ff7282021-04-22 10:12:54 -0700316 numShownHotseatIcons =
317 isTwoPanels ? inv.numDatabaseHotseatIcons : inv.numShownHotseatIcons;
318 numShownAllAppsColumns =
319 isTwoPanels ? inv.numDatabaseAllAppsColumns : inv.numAllAppsColumns;
Winson1f064272016-07-18 17:18:02 -0700320 hotseatBarTopPaddingPx =
321 res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_top_padding);
Jon Miranda7e183c32018-06-20 11:05:27 -0700322 hotseatBarBottomPaddingPx = (isTallDevice ? 0
323 : res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_bottom_non_tall_padding))
324 + res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_bottom_padding);
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700325 hotseatBarSidePaddingEndPx =
Sunny Goyal228153d2018-01-04 15:35:22 -0800326 res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_side_padding);
Jon Miranda3f411e72019-05-16 17:15:16 -0700327 // Add a bit of space between nav bar and hotseat in vertical bar layout.
Tony Wickham5edf9e22020-03-27 20:06:52 -0700328 hotseatBarSidePaddingStartPx = isVerticalBarLayout() ? workspacePageIndicatorHeight : 0;
Jon Miranda228877d2021-02-09 11:05:00 -0500329 int hotseatExtraVerticalSize =
330 res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_extra_vertical_size);
Sunny Goyal35c7b192021-04-20 16:51:10 -0700331 hotseatBarSizePx = pxFromDp(inv.iconSize, mMetrics, 1f)
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700332 + (isVerticalBarLayout()
Sunny Goyal415f1732018-11-29 10:33:47 -0800333 ? (hotseatBarSidePaddingStartPx + hotseatBarSidePaddingEndPx)
Jon Miranda228877d2021-02-09 11:05:00 -0500334 : (hotseatBarTopPaddingPx + hotseatBarBottomPaddingPx
Jon Mirandae126d722021-02-25 10:45:20 -0500335 + (isScalableGrid ? 0 : hotseatExtraVerticalSize)));
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700336
Zak Cohen334efeb2021-03-19 16:42:07 -0700337 overviewTaskMarginPx = res.getDimensionPixelSize(R.dimen.overview_task_margin);
Alex Chaudedbc8a2021-03-17 16:53:26 +0000338 overviewTaskIconSizePx =
339 isTablet && FeatureFlags.ENABLE_OVERVIEW_GRID.get() ? res.getDimensionPixelSize(
340 R.dimen.task_thumbnail_icon_size_grid) : res.getDimensionPixelSize(
341 R.dimen.task_thumbnail_icon_size);
342 overviewTaskThumbnailTopMarginPx = overviewTaskIconSizePx + overviewTaskMarginPx * 2;
zakcohendad8a802021-05-20 09:52:26 -0700343 overviewActionsMarginGesturePx = res.getDimensionPixelSize(
344 R.dimen.overview_actions_bottom_margin_gesture);
345 overviewActionsMarginThreeButtonPx = res.getDimensionPixelSize(
346 R.dimen.overview_actions_bottom_margin_three_button);
Zak Cohen334efeb2021-03-19 16:42:07 -0700347
Jon Miranda2ed276e2017-06-29 11:36:34 -0700348 // Calculate all of the remaining variables.
Jon Miranda58561d42021-03-17 10:51:54 -0400349 extraSpace = updateAvailableDimensions(res);
Jon Miranda2ed276e2017-06-29 11:36:34 -0700350 // Now that we have all of the variables calculated, we can tune certain sizes.
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400351 if (isScalableGrid && inv.devicePaddings != null) {
352 // Paddings were created assuming no scaling, so we first unscale the extra space.
353 int unscaledExtraSpace = (int) (extraSpace / iconScale);
354 DevicePadding padding = inv.devicePaddings.getDevicePadding(unscaledExtraSpace);
Jon Miranda228877d2021-02-09 11:05:00 -0500355
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400356 int paddingWorkspaceTop = padding.getWorkspaceTopPadding(unscaledExtraSpace);
357 int paddingWorkspaceBottom = padding.getWorkspaceBottomPadding(unscaledExtraSpace);
358 int paddingHotseatBottom = padding.getHotseatBottomPadding(unscaledExtraSpace);
359
360 workspaceTopPadding = Math.round(paddingWorkspaceTop * iconScale);
361 workspaceBottomPadding = Math.round(paddingWorkspaceBottom * iconScale);
362 extraHotseatBottomPadding = Math.round(paddingHotseatBottom * iconScale);
363
Jon Miranda58561d42021-03-17 10:51:54 -0400364 hotseatBarSizePx += extraHotseatBottomPadding;
365 hotseatBarBottomPaddingPx += extraHotseatBottomPadding;
Jon Miranda228877d2021-02-09 11:05:00 -0500366 } else if (!isVerticalBarLayout() && isPhone && isTallDevice) {
Jon Miranda3f9bab22017-07-28 14:50:17 -0700367 // We increase the hotseat size when there is extra space.
Jon Miranda2ed276e2017-06-29 11:36:34 -0700368 // ie. For a display with a large aspect ratio, we can keep the icons on the workspace
Jon Miranda3f9bab22017-07-28 14:50:17 -0700369 // in portrait mode closer together by adding more height to the hotseat.
Jon Miranda30d0aa22017-07-25 15:55:29 -0700370 // Note: This calculation was created after noticing a pattern in the design spec.
Jon Miranda58561d42021-03-17 10:51:54 -0400371 int extraSpace = getCellSize().y - iconSizePx - iconDrawablePaddingPx * 2
Tony Wickham5edf9e22020-03-27 20:06:52 -0700372 - workspacePageIndicatorHeight;
Jon Miranda7e183c32018-06-20 11:05:27 -0700373 hotseatBarSizePx += extraSpace;
374 hotseatBarBottomPaddingPx += extraSpace;
Jon Miranda30d0aa22017-07-25 15:55:29 -0700375
Jon Miranda3f9bab22017-07-28 14:50:17 -0700376 // Recalculate the available dimensions using the new hotseat size.
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700377 updateAvailableDimensions(res);
Jon Miranda2ed276e2017-06-29 11:36:34 -0700378 }
Sunny Goyal07b69292018-01-08 14:19:34 -0800379 updateWorkspacePadding();
Tony Wickham1237df02017-02-24 08:59:36 -0800380
Alex Chaua02eddc2021-04-29 00:36:06 +0100381 flingToDeleteThresholdVelocity = res.getDimensionPixelSize(
382 R.dimen.drag_flingToDeleteMinVelocity);
383
Tony Wickham1237df02017-02-24 08:59:36 -0800384 // This is done last, after iconSizePx is calculated above.
Sunny Goyal8b9919d2021-04-07 14:45:17 -0700385 Path dotPath = GraphicsUtils.getShapePath(DEFAULT_DOT_SIZE);
386 mDotRendererWorkSpace = new DotRenderer(iconSizePx, dotPath, DEFAULT_DOT_SIZE);
Samuel Fufac96fa242019-09-26 23:06:32 -0700387 mDotRendererAllApps = iconSizePx == allAppsIconSizePx ? mDotRendererWorkSpace :
Sunny Goyal8b9919d2021-04-07 14:45:17 -0700388 new DotRenderer(allAppsIconSizePx, dotPath, DEFAULT_DOT_SIZE);
Adam Cohen63f1ec02014-08-12 09:23:13 -0700389 }
390
Jon Mirandae126d722021-02-25 10:45:20 -0500391 private void setCellLayoutBorderSpacing(int borderSpacing) {
Jon Miranda823da222021-03-23 08:08:45 -0400392 cellLayoutBorderSpacingPx = isScalableGrid ? borderSpacing : 0;
Jon Mirandae126d722021-02-25 10:45:20 -0500393 }
394
Jon Miranda611dba42021-03-02 14:12:13 -0500395 /**
396 * We inset the widget padding added by the system and instead rely on the border spacing
397 * between cells to create reliable consistency between widgets
398 */
399 public boolean shouldInsetWidgets() {
400 Rect widgetPadding = inv.defaultWidgetPadding;
401
Jon Miranda49811182021-06-03 09:52:40 -0700402 // Check all sides to ensure that the widget won't overlap into another cell, or into
403 // status bar.
404 return workspaceTopPadding > widgetPadding.top
405 && cellLayoutBorderSpacingPx > widgetPadding.left
Jon Miranda611dba42021-03-02 14:12:13 -0500406 && cellLayoutBorderSpacingPx > widgetPadding.top
407 && cellLayoutBorderSpacingPx > widgetPadding.right
408 && cellLayoutBorderSpacingPx > widgetPadding.bottom;
409 }
Jon Mirandae126d722021-02-25 10:45:20 -0500410
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700411 public Builder toBuilder(Context context) {
Sunny Goyal19ff7282021-04-22 10:12:54 -0700412 WindowBounds bounds =
413 new WindowBounds(widthPx, heightPx, availableWidthPx, availableHeightPx);
414 bounds.bounds.offsetTo(windowX, windowY);
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700415 return new Builder(context, inv, mInfo)
Sunny Goyal19ff7282021-04-22 10:12:54 -0700416 .setWindowBounds(bounds)
417 .setUseTwoPanels(isTwoPanels)
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700418 .setMultiWindowMode(isMultiWindowMode);
Sunny Goyal1a52ef52018-01-11 10:15:03 -0800419 }
420
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700421 public DeviceProfile copy(Context context) {
422 return toBuilder(context).build();
423 }
424
425 /**
426 * TODO: Move this to the builder as part of setMultiWindowMode
427 */
Sunny Goyalb46703d2020-05-27 17:52:03 -0700428 public DeviceProfile getMultiWindowProfile(Context context, WindowBounds windowBounds) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700429 DeviceProfile profile = toBuilder(context)
Sunny Goyal19ff7282021-04-22 10:12:54 -0700430 .setWindowBounds(windowBounds)
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700431 .setMultiWindowMode(true)
432 .build();
Jon Miranda93e1f042016-11-11 14:13:04 -0800433
Jon Miranda941375e2021-03-31 13:10:45 -0400434 profile.hideWorkspaceLabelsIfNotEnoughSpace();
Jon Miranda93e1f042016-11-11 14:13:04 -0800435
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800436 // We use these scales to measure and layout the widgets using their full invariant profile
437 // sizes and then draw them scaled and centered to fit in their multi-window mode cellspans.
438 float appWidgetScaleX = (float) profile.getCellSize().x / getCellSize().x;
439 float appWidgetScaleY = (float) profile.getCellSize().y / getCellSize().y;
440 profile.appWidgetScale.set(appWidgetScaleX, appWidgetScaleY);
Sunny Goyal07b69292018-01-08 14:19:34 -0800441 profile.updateWorkspacePadding();
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800442
Jon Miranda93e1f042016-11-11 14:13:04 -0800443 return profile;
Jon Mirandacc42c5b2016-10-27 17:15:27 -0700444 }
445
Adam Cohen63f1ec02014-08-12 09:23:13 -0700446 /**
Jon Miranda941375e2021-03-31 13:10:45 -0400447 * Checks if there is enough space for labels on the workspace.
448 * If there is not, labels on the Workspace are hidden.
Jon Miranda1091e532017-07-21 13:31:50 -0700449 * It is important to call this method after the All Apps variables have been set.
450 */
Jon Miranda941375e2021-03-31 13:10:45 -0400451 private void hideWorkspaceLabelsIfNotEnoughSpace() {
452 float iconTextHeight = Utilities.calculateTextHeight(iconTextSizePx);
453 float workspaceCellPaddingY = getCellSize().y - iconSizePx - iconDrawablePaddingPx
454 - iconTextHeight;
455
456 // We want enough space so that the text is closer to its corresponding icon.
457 if (workspaceCellPaddingY < iconTextHeight) {
458 iconTextSizePx = 0;
459 iconDrawablePaddingPx = 0;
460 cellHeightPx = iconSizePx;
461 autoResizeAllAppsCells();
462 }
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700463 }
Jon Miranda1091e532017-07-21 13:31:50 -0700464
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700465 /**
466 * Re-computes the all-apps cell size to be independent of workspace
467 */
468 public void autoResizeAllAppsCells() {
Jon Miranda941375e2021-03-31 13:10:45 -0400469 int textHeight = Utilities.calculateTextHeight(allAppsIconTextSizePx);
470 int topBottomPadding = textHeight;
Jon Miranda1091e532017-07-21 13:31:50 -0700471 allAppsCellHeightPx = allAppsIconSizePx + allAppsIconDrawablePaddingPx
Jon Miranda941375e2021-03-31 13:10:45 -0400472 + textHeight + (topBottomPadding * 2);
Jon Miranda1091e532017-07-21 13:31:50 -0700473 }
474
Jon Miranda228877d2021-02-09 11:05:00 -0500475 /**
476 * Returns the amount of extra (or unused) vertical space.
477 */
478 private int updateAvailableDimensions(Resources res) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700479 updateIconSize(1f, res);
Winson Chung59a488a2013-12-10 12:32:14 -0800480
Jon Mirandae126d722021-02-25 10:45:20 -0500481 Point workspacePadding = getTotalWorkspacePadding();
482
483 // Check to see if the icons fit within the available height.
484 float usedHeight = getCellLayoutHeight();
485 final int maxHeight = availableHeightPx - workspacePadding.y;
Jon Miranda228877d2021-02-09 11:05:00 -0500486 float extraHeight = Math.max(0, maxHeight - usedHeight);
Jon Mirandae126d722021-02-25 10:45:20 -0500487 float scaleY = maxHeight / usedHeight;
488 boolean shouldScale = scaleY < 1f;
489
490 float scaleX = 1f;
491 if (isScalableGrid) {
492 // We scale to fit the cellWidth and cellHeight in the available space.
493 // The benefit of scalable grids is that we can get consistent aspect ratios between
494 // devices.
495 float usedWidth = (cellWidthPx * inv.numColumns)
496 + (cellLayoutBorderSpacingPx * (inv.numColumns - 1))
497 + (desiredWorkspaceLeftRightMarginPx * 2);
498 // We do not subtract padding here, as we also scale the workspace padding if needed.
499 scaleX = availableWidthPx / usedWidth;
500 shouldScale = true;
Winson Chungb3800242013-10-24 11:01:54 -0700501 }
Jon Mirandae126d722021-02-25 10:45:20 -0500502
503 if (shouldScale) {
504 float scale = Math.min(scaleX, scaleY);
505 updateIconSize(scale, res);
506 extraHeight = Math.max(0, maxHeight - getCellLayoutHeight());
507 }
508
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700509 updateAvailableFolderCellDimensions(res);
Jon Miranda228877d2021-02-09 11:05:00 -0500510 return Math.round(extraHeight);
Winson Chungb3800242013-10-24 11:01:54 -0700511 }
512
Jon Mirandae126d722021-02-25 10:45:20 -0500513 private int getCellLayoutHeight() {
514 return (cellHeightPx * inv.numRows) + (cellLayoutBorderSpacingPx * (inv.numRows - 1));
515 }
516
Jon Miranda6f7e9702019-09-16 14:44:14 -0700517 /**
518 * Updating the iconSize affects many aspects of the launcher layout, such as: iconSizePx,
519 * iconTextSizePx, iconDrawablePaddingPx, cellWidth/Height, allApps* variants,
520 * hotseat sizes, workspaceSpringLoadedShrinkFactor, folderIconSizePx, and folderIconOffsetYPx.
521 */
Tony Wickham7ba547c2021-02-02 17:12:08 -0800522 public void updateIconSize(float scale, Resources res) {
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400523 iconScale = scale;
524
Jon Miranda18751b62017-07-31 17:25:27 -0700525 // Workspace
Sunny Goyal07b69292018-01-08 14:19:34 -0800526 final boolean isVerticalLayout = isVerticalBarLayout();
Andras Kloczl6057cb92021-04-07 13:45:17 +0200527 float invIconSizeDp = isLandscape ? inv.landscapeIconSize : inv.iconSize;
Sunny Goyal35c7b192021-04-20 16:51:10 -0700528 iconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mMetrics, scale));
Andras Kloczl6057cb92021-04-07 13:45:17 +0200529 float invIconTextSizeSp = isLandscape ? inv.landscapeIconTextSize : inv.iconTextSize;
Jon Mirandaaf3aed02021-05-06 18:28:45 -0700530 iconTextSizePx = (int) (pxFromSp(invIconTextSizeSp, mMetrics) * scale);
Jon Miranda09660722017-06-14 14:20:14 -0700531 iconDrawablePaddingPx = (int) (iconDrawablePaddingOriginalPx * scale);
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700532
Jon Mirandae126d722021-02-25 10:45:20 -0500533 setCellLayoutBorderSpacing((int) (cellLayoutBorderSpacingOriginalPx * scale));
534
535 if (isScalableGrid) {
Sunny Goyal35c7b192021-04-20 16:51:10 -0700536 cellWidthPx = pxFromDp(inv.minCellWidth, mMetrics, scale);
537 cellHeightPx = pxFromDp(inv.minCellHeight, mMetrics, scale);
Jon Mirandae126d722021-02-25 10:45:20 -0500538 int cellContentHeight = iconSizePx + iconDrawablePaddingPx
539 + Utilities.calculateTextHeight(iconTextSizePx);
540 cellYPaddingPx = Math.max(0, cellHeightPx - cellContentHeight) / 2;
541 desiredWorkspaceLeftRightMarginPx = (int) (desiredWorkspaceLeftRightOriginalPx * scale);
Jon Miranda228877d2021-02-09 11:05:00 -0500542 } else {
Jon Mirandae126d722021-02-25 10:45:20 -0500543 cellWidthPx = iconSizePx + iconDrawablePaddingPx;
Jon Miranda228877d2021-02-09 11:05:00 -0500544 cellHeightPx = iconSizePx + iconDrawablePaddingPx
545 + Utilities.calculateTextHeight(iconTextSizePx);
546 int cellPaddingY = (getCellSize().y - cellHeightPx) / 2;
547 if (iconDrawablePaddingPx > cellPaddingY && !isVerticalLayout
548 && !isMultiWindowMode) {
549 // Ensures that the label is closer to its corresponding icon. This is not an issue
550 // with vertical bar layout or multi-window mode since the issue is handled
551 // separately with their calls to {@link #adjustToHideWorkspaceLabels}.
552 cellHeightPx -= (iconDrawablePaddingPx - cellPaddingY);
553 iconDrawablePaddingPx = cellPaddingY;
554 }
Jon Miranda846455e2017-10-02 14:58:52 -0700555 }
Jon Miranda18751b62017-07-31 17:25:27 -0700556
Sunny Goyalae190ff2020-04-14 00:19:01 +0000557 // All apps
Sunny Goyal19ff7282021-04-22 10:12:54 -0700558 if (numShownAllAppsColumns != inv.numColumns) {
Sunny Goyal35c7b192021-04-20 16:51:10 -0700559 allAppsIconSizePx = pxFromDp(inv.allAppsIconSize, mMetrics);
Jon Mirandaaf3aed02021-05-06 18:28:45 -0700560 allAppsIconTextSizePx = pxFromSp(inv.allAppsIconTextSize, mMetrics);
Sunny Goyalae190ff2020-04-14 00:19:01 +0000561 allAppsIconDrawablePaddingPx = iconDrawablePaddingOriginalPx;
Jon Miranda941375e2021-03-31 13:10:45 -0400562 autoResizeAllAppsCells();
Sunny Goyalae190ff2020-04-14 00:19:01 +0000563 } else {
564 allAppsIconSizePx = iconSizePx;
565 allAppsIconTextSizePx = iconTextSizePx;
566 allAppsIconDrawablePaddingPx = iconDrawablePaddingPx;
567 allAppsCellHeightPx = getCellSize().y;
568 }
569 allAppsCellWidthPx = allAppsIconSizePx + allAppsIconDrawablePaddingPx;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700570
Jon Miranda941375e2021-03-31 13:10:45 -0400571 if (isVerticalLayout) {
572 hideWorkspaceLabelsIfNotEnoughSpace();
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700573 }
Winson Chungb3800242013-10-24 11:01:54 -0700574
Winson Chungb3800242013-10-24 11:01:54 -0700575 // Hotseat
Sunny Goyal07b69292018-01-08 14:19:34 -0800576 if (isVerticalLayout) {
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700577 hotseatBarSizePx = iconSizePx + hotseatBarSidePaddingStartPx
578 + hotseatBarSidePaddingEndPx;
Jon Miranda18751b62017-07-31 17:25:27 -0700579 }
Jon Miranda5044c352017-08-09 11:37:59 -0700580 hotseatCellHeightPx = iconSizePx;
Winson Chungb3800242013-10-24 11:01:54 -0700581
Sunny Goyal07b69292018-01-08 14:19:34 -0800582 if (!isVerticalLayout) {
Jon Miranda18751b62017-07-31 17:25:27 -0700583 int expectedWorkspaceHeight = availableHeightPx - hotseatBarSizePx
Tony Wickham5edf9e22020-03-27 20:06:52 -0700584 - workspacePageIndicatorHeight - edgeMarginPx;
Sunny Goyal47328fd2016-05-25 18:56:41 -0700585 float minRequiredHeight = dropTargetBarSizePx + workspaceSpringLoadedBottomSpace;
586 workspaceSpringLoadShrinkFactor = Math.min(
587 res.getInteger(R.integer.config_workspaceSpringLoadShrinkPercentage) / 100.0f,
588 1 - (minRequiredHeight / expectedWorkspaceHeight));
589 } else {
590 workspaceSpringLoadShrinkFactor =
591 res.getInteger(R.integer.config_workspaceSpringLoadShrinkPercentage) / 100.0f;
592 }
593
Sunny Goyalbaec6ff2016-09-14 11:26:21 -0700594 // Folder icon
Jon Miranda591e3602018-03-28 11:37:00 -0700595 folderIconSizePx = IconNormalizer.getNormalizedCircleSize(iconSizePx);
596 folderIconOffsetYPx = (iconSizePx - folderIconSizePx) / 2;
Winson Chung0f785722015-04-08 10:27:49 -0700597 }
598
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700599 private void updateAvailableFolderCellDimensions(Resources res) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700600 updateFolderCellSize(1f, res);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700601
Jon Mirandae126d722021-02-25 10:45:20 -0500602 final int folderBottomPanelSize = res.getDimensionPixelSize(R.dimen.folder_label_height);
603
Jon Mirandac1b23992016-12-13 08:57:36 -0800604 // Don't let the folder get too close to the edges of the screen.
Jon Miranda1786df32018-09-25 13:05:23 -0700605 int folderMargin = edgeMarginPx * 2;
Sunny Goyal07b69292018-01-08 14:19:34 -0800606 Point totalWorkspacePadding = getTotalWorkspacePadding();
Jon Mirandac1b23992016-12-13 08:57:36 -0800607
608 // Check if the icons fit within the available height.
Jon Miranda228877d2021-02-09 11:05:00 -0500609 float contentUsedHeight = folderCellHeightPx * inv.numFolderRows
Jon Miranda823da222021-03-23 08:08:45 -0400610 + ((inv.numFolderRows - 1) * folderCellLayoutBorderSpacingPx);
Samuel Fufa1c8d90a2019-11-12 17:54:58 -0800611 int contentMaxHeight = availableHeightPx - totalWorkspacePadding.y - folderBottomPanelSize
Jon Mirandae126d722021-02-25 10:45:20 -0500612 - folderMargin - folderContentPaddingTop;
Samuel Fufa1c8d90a2019-11-12 17:54:58 -0800613 float scaleY = contentMaxHeight / contentUsedHeight;
Jon Mirandac1b23992016-12-13 08:57:36 -0800614
615 // Check if the icons fit within the available width.
Jon Miranda228877d2021-02-09 11:05:00 -0500616 float contentUsedWidth = folderCellWidthPx * inv.numFolderColumns
Jon Miranda823da222021-03-23 08:08:45 -0400617 + ((inv.numFolderColumns - 1) * folderCellLayoutBorderSpacingPx);
Jon Mirandae126d722021-02-25 10:45:20 -0500618 int contentMaxWidth = availableWidthPx - totalWorkspacePadding.x - folderMargin
619 - folderContentPaddingLeftRight * 2;
Samuel Fufa1c8d90a2019-11-12 17:54:58 -0800620 float scaleX = contentMaxWidth / contentUsedWidth;
Jon Mirandac1b23992016-12-13 08:57:36 -0800621
622 float scale = Math.min(scaleX, scaleY);
623 if (scale < 1f) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700624 updateFolderCellSize(scale, res);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700625 }
626 }
627
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700628 private void updateFolderCellSize(float scale, Resources res) {
Jon Mirandae126d722021-02-25 10:45:20 -0500629 float invIconSizeDp = isVerticalBarLayout() ? inv.landscapeIconSize : inv.iconSize;
Sunny Goyal35c7b192021-04-20 16:51:10 -0700630 folderChildIconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mMetrics, scale));
Jon Mirandaaf3aed02021-05-06 18:28:45 -0700631 folderChildTextSizePx = pxFromSp(inv.iconTextSize, mMetrics, scale);
Jon Mirandae126d722021-02-25 10:45:20 -0500632 folderLabelTextSizePx = (int) (folderChildTextSizePx * folderLabelTextScale);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700633
634 int textHeight = Utilities.calculateTextHeight(folderChildTextSizePx);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700635
Jon Miranda823da222021-03-23 08:08:45 -0400636 if (isScalableGrid) {
637 folderCellWidthPx = (int) (cellWidthPx * scale);
638 folderCellHeightPx = (int) (cellHeightPx * scale);
639
640 int borderSpacing = (int) (cellLayoutBorderSpacingOriginalPx * scale);
641 folderCellLayoutBorderSpacingPx = borderSpacing;
642 folderContentPaddingLeftRight = borderSpacing;
643 folderContentPaddingTop = borderSpacing;
644 } else {
645 int cellPaddingX = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_x_padding)
646 * scale);
647 int cellPaddingY = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_y_padding)
648 * scale);
649
650 folderCellWidthPx = folderChildIconSizePx + 2 * cellPaddingX;
651 folderCellHeightPx = folderChildIconSizePx + 2 * cellPaddingY + textHeight;
652 }
653
Jonathan Miranda9ad87462017-07-26 17:41:02 +0000654 folderChildDrawablePaddingPx = Math.max(0,
655 (folderCellHeightPx - folderChildIconSizePx - textHeight) / 3);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700656 }
657
Winson1f064272016-07-18 17:18:02 -0700658 public void updateInsets(Rect insets) {
659 mInsets.set(insets);
Sunny Goyal07b69292018-01-08 14:19:34 -0800660 updateWorkspacePadding();
Winson1f064272016-07-18 17:18:02 -0700661 }
662
Sunny Goyalae6e3182019-04-30 12:04:37 -0700663 /**
664 * The current device insets. This is generally same as the insets being dispatched to
665 * {@link Insettable} elements, but can differ if the element is using a different profile.
666 */
Sunny Goyal1a52ef52018-01-11 10:15:03 -0800667 public Rect getInsets() {
668 return mInsets;
669 }
670
Sunny Goyal756cd262015-08-20 12:33:21 -0700671 public Point getCellSize() {
Sunny Goyal19ff7282021-04-22 10:12:54 -0700672 return getCellSize(null);
Jon Miranda6f7e9702019-09-16 14:44:14 -0700673 }
674
Sunny Goyal19ff7282021-04-22 10:12:54 -0700675 public Point getCellSize(Point result) {
676 if (result == null) {
677 result = new Point();
678 }
Sunny Goyal756cd262015-08-20 12:33:21 -0700679 // Since we are only concerned with the overall padding, layout direction does
680 // not matter.
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700681 Point padding = getTotalWorkspacePadding();
Jon Miranda18751b62017-07-31 17:25:27 -0700682 result.x = calculateCellWidth(availableWidthPx - padding.x
Sunny Goyal19ff7282021-04-22 10:12:54 -0700683 - cellLayoutPaddingLeftRightPx * 2, cellLayoutBorderSpacingPx, inv.numColumns);
Jon Miranda18751b62017-07-31 17:25:27 -0700684 result.y = calculateCellHeight(availableHeightPx - padding.y
Sunny Goyal19ff7282021-04-22 10:12:54 -0700685 - cellLayoutBottomPaddingPx, cellLayoutBorderSpacingPx, inv.numRows);
Sunny Goyal756cd262015-08-20 12:33:21 -0700686 return result;
687 }
688
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700689 public Point getTotalWorkspacePadding() {
Sunny Goyal07b69292018-01-08 14:19:34 -0800690 updateWorkspacePadding();
691 return new Point(workspacePadding.left + workspacePadding.right,
692 workspacePadding.top + workspacePadding.bottom);
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700693 }
694
695 /**
Sunny Goyal07b69292018-01-08 14:19:34 -0800696 * Updates {@link #workspacePadding} as a result of any internal value change to reflect the
697 * new workspace padding
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700698 */
Sunny Goyal07b69292018-01-08 14:19:34 -0800699 private void updateWorkspacePadding() {
700 Rect padding = workspacePadding;
Tony Wickham3a3517f2015-10-06 11:27:04 -0700701 if (isVerticalBarLayout()) {
Sunny Goyal228153d2018-01-04 15:35:22 -0800702 padding.top = 0;
703 padding.bottom = edgeMarginPx;
Sunny Goyal7e2e67f2018-01-26 13:40:08 -0800704 if (isSeascape()) {
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700705 padding.left = hotseatBarSizePx;
Tony Wickham5edf9e22020-03-27 20:06:52 -0700706 padding.right = hotseatBarSidePaddingStartPx;
Winson1f064272016-07-18 17:18:02 -0700707 } else {
Tony Wickham5edf9e22020-03-27 20:06:52 -0700708 padding.left = hotseatBarSidePaddingStartPx;
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700709 padding.right = hotseatBarSizePx;
Winson1f064272016-07-18 17:18:02 -0700710 }
Winson Chungb3800242013-10-24 11:01:54 -0700711 } else {
Tony Wickhama29a0462021-03-02 12:28:25 -0800712 int hotseatTop = isTaskbarPresent ? taskbarSize : hotseatBarSizePx;
713 int paddingBottom = hotseatTop + workspacePageIndicatorHeight
Jon Miranda228877d2021-02-09 11:05:00 -0500714 + workspaceBottomPadding - mWorkspacePageIndicatorOverlapWorkspace;
Sunny Goyalc6205602015-05-21 20:46:33 -0700715 if (isTablet) {
Winson Chungb3800242013-10-24 11:01:54 -0700716 // Pad the left and right of the workspace to ensure consistent spacing
717 // between all icons
Tony Wickhamd6b40372015-09-23 18:37:57 -0700718 // The amount of screen space available for left/right padding.
Sunny Goyal228153d2018-01-04 15:35:22 -0800719 int availablePaddingX = Math.max(0, widthPx - ((inv.numColumns * cellWidthPx) +
Sunny Goyalf5440cb2016-12-14 15:13:00 -0800720 ((inv.numColumns - 1) * cellWidthPx)));
Tony Wickhamd6b40372015-09-23 18:37:57 -0700721 availablePaddingX = (int) Math.min(availablePaddingX,
Sunny Goyal07b69292018-01-08 14:19:34 -0800722 widthPx * MAX_HORIZONTAL_PADDING_PERCENT);
Tony Wickhama29a0462021-03-02 12:28:25 -0800723 int hotseatVerticalPadding = isTaskbarPresent ? 0
724 : hotseatBarTopPaddingPx + hotseatBarBottomPaddingPx;
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700725 int availablePaddingY = Math.max(0, heightPx - edgeMarginPx - paddingBottom
Tony Wickhama29a0462021-03-02 12:28:25 -0800726 - (2 * inv.numRows * cellHeightPx) - hotseatVerticalPadding);
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700727 padding.set(availablePaddingX / 2, edgeMarginPx + availablePaddingY / 2,
Tony Wickhamd6b40372015-09-23 18:37:57 -0700728 availablePaddingX / 2, paddingBottom + availablePaddingY / 2);
Andras Kloczl8e57cce2021-02-11 23:51:19 +0100729
Sunny Goyal19ff7282021-04-22 10:12:54 -0700730 if (isTwoPanels) {
Andras Kloczl8e57cce2021-02-11 23:51:19 +0100731 padding.set(0, padding.top, 0, padding.bottom);
732 }
Winson Chungb3800242013-10-24 11:01:54 -0700733 } else {
734 // Pad the top and bottom of the workspace with search/hotseat bar sizes
Winson1f064272016-07-18 17:18:02 -0700735 padding.set(desiredWorkspaceLeftRightMarginPx,
Jon Mirandae126d722021-02-25 10:45:20 -0500736 workspaceTopPadding + (isScalableGrid ? 0 : edgeMarginPx),
Winson1f064272016-07-18 17:18:02 -0700737 desiredWorkspaceLeftRightMarginPx,
Winsonfadbe8f2016-07-22 16:35:37 -0700738 paddingBottom);
Winson Chungb3800242013-10-24 11:01:54 -0700739 }
740 }
Winson Chungb3800242013-10-24 11:01:54 -0700741 }
742
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700743 public Rect getHotseatLayoutPadding() {
744 if (isVerticalBarLayout()) {
745 if (isSeascape()) {
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700746 mHotseatPadding.set(mInsets.left + hotseatBarSidePaddingStartPx,
747 mInsets.top, hotseatBarSidePaddingEndPx, mInsets.bottom);
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700748 } else {
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700749 mHotseatPadding.set(hotseatBarSidePaddingEndPx, mInsets.top,
750 mInsets.right + hotseatBarSidePaddingStartPx, mInsets.bottom);
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700751 }
752 } else {
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700753 // We want the edges of the hotseat to line up with the edges of the workspace, but the
754 // icons in the hotseat are a different size, and so don't line up perfectly. To account
755 // for this, we pad the left and right of the hotseat with half of the difference of a
756 // workspace cell vs a hotseat cell.
757 float workspaceCellWidth = (float) widthPx / inv.numColumns;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700758 float hotseatCellWidth = (float) widthPx / numShownHotseatIcons;
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700759 int hotseatAdjustment = Math.round((workspaceCellWidth - hotseatCellWidth) / 2);
760 mHotseatPadding.set(
Sunny Goyal786940a2020-06-02 02:31:31 -0700761 hotseatAdjustment + workspacePadding.left + cellLayoutPaddingLeftRightPx
762 + mInsets.left,
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700763 hotseatBarTopPaddingPx,
Sunny Goyal786940a2020-06-02 02:31:31 -0700764 hotseatAdjustment + workspacePadding.right + cellLayoutPaddingLeftRightPx
765 + mInsets.right,
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700766 hotseatBarBottomPaddingPx + mInsets.bottom + cellLayoutBottomPaddingPx);
767 }
768 return mHotseatPadding;
769 }
770
Winsonfadbe8f2016-07-22 16:35:37 -0700771 /**
772 * @return the bounds for which the open folders should be contained within
773 */
774 public Rect getAbsoluteOpenFolderBounds() {
775 if (isVerticalBarLayout()) {
776 // Folders should only appear right of the drop target bar and left of the hotseat
777 return new Rect(mInsets.left + dropTargetBarSizePx + edgeMarginPx,
778 mInsets.top,
Jon Miranda18751b62017-07-31 17:25:27 -0700779 mInsets.left + availableWidthPx - hotseatBarSizePx - edgeMarginPx,
Winsonfadbe8f2016-07-22 16:35:37 -0700780 mInsets.top + availableHeightPx);
781 } else {
782 // Folders should only appear below the drop target bar and above the hotseat
Tony Wickhamae72b462021-03-10 16:18:40 -0800783 int hotseatTop = isTaskbarPresent ? taskbarSize : hotseatBarSizePx;
Tony Wickhamb4b7e202018-01-12 17:39:24 -0800784 return new Rect(mInsets.left + edgeMarginPx,
Winsonfadbe8f2016-07-22 16:35:37 -0700785 mInsets.top + dropTargetBarSizePx + edgeMarginPx,
Tony Wickhamb4b7e202018-01-12 17:39:24 -0800786 mInsets.left + availableWidthPx - edgeMarginPx,
Tony Wickhamae72b462021-03-10 16:18:40 -0800787 mInsets.top + availableHeightPx - hotseatTop
Tony Wickham5edf9e22020-03-27 20:06:52 -0700788 - workspacePageIndicatorHeight - edgeMarginPx);
Winsonfadbe8f2016-07-22 16:35:37 -0700789 }
790 }
791
Jon Miranda228877d2021-02-09 11:05:00 -0500792 public static int calculateCellWidth(int width, int borderSpacing, int countX) {
793 return (width - ((countX - 1) * borderSpacing)) / countX;
Winson Chungb3800242013-10-24 11:01:54 -0700794 }
Jon Miranda228877d2021-02-09 11:05:00 -0500795 public static int calculateCellHeight(int height, int borderSpacing, int countY) {
796 return (height - ((countY - 1) * borderSpacing)) / countY;
Winson Chungb3800242013-10-24 11:01:54 -0700797 }
798
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -0700799 /**
Tony Wickham55616cd2015-09-23 14:55:17 -0700800 * When {@code true}, the device is in landscape mode and the hotseat is on the right column.
801 * When {@code false}, either device is in portrait mode or the device is in landscape mode and
802 * the hotseat is on the bottom row.
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -0700803 */
Tony Wickhamab946a12015-09-16 15:38:16 -0700804 public boolean isVerticalBarLayout() {
Winson Chungb3800242013-10-24 11:01:54 -0700805 return isLandscape && transposeLayoutWithOrientation;
806 }
807
Sunny Goyal59d086c2018-05-07 17:31:40 -0700808 /**
809 * Updates orientation information and returns true if it has changed from the previous value.
810 */
Winson Chung13c1c2c2019-09-06 11:46:19 -0700811 public boolean updateIsSeascape(Context context) {
Sunny Goyal59d086c2018-05-07 17:31:40 -0700812 if (isVerticalBarLayout()) {
Sunny Goyal35c7b192021-04-20 16:51:10 -0700813 boolean isSeascape = DisplayController.INSTANCE.get(context)
814 .getInfo().rotation == Surface.ROTATION_270;
Sunny Goyal59d086c2018-05-07 17:31:40 -0700815 if (mIsSeascape != isSeascape) {
816 mIsSeascape = isSeascape;
817 return true;
818 }
819 }
820 return false;
821 }
822
Sunny Goyal7e2e67f2018-01-26 13:40:08 -0800823 public boolean isSeascape() {
Sunny Goyal59d086c2018-05-07 17:31:40 -0700824 return isVerticalBarLayout() && mIsSeascape;
Sunny Goyal7e2e67f2018-01-26 13:40:08 -0800825 }
826
Sunny Goyal07b69292018-01-08 14:19:34 -0800827 public boolean shouldFadeAdjacentWorkspaceScreens() {
Sunny Goyal19ff7282021-04-22 10:12:54 -0700828 return isVerticalBarLayout();
Winson Chungb3800242013-10-24 11:01:54 -0700829 }
830
Sunny Goyalc13403c2016-11-18 23:44:48 -0800831 public int getCellHeight(@ContainerType int containerType) {
832 switch (containerType) {
833 case CellLayout.WORKSPACE:
834 return cellHeightPx;
835 case CellLayout.FOLDER:
836 return folderCellHeightPx;
837 case CellLayout.HOTSEAT:
838 return hotseatCellHeightPx;
839 default:
840 // ??
841 return 0;
842 }
843 }
Sunny Goyal13178ac2016-04-04 16:35:22 -0700844
Jon Miranda58561d42021-03-17 10:51:54 -0400845 private String pxToDpStr(String name, float value) {
Sunny Goyal35c7b192021-04-20 16:51:10 -0700846 return "\t" + name + ": " + value + "px (" + dpiFromPx(value, mMetrics.densityDpi) + "dp)";
Jon Miranda58561d42021-03-17 10:51:54 -0400847 }
848
849 public void dump(String prefix, PrintWriter writer) {
850 writer.println(prefix + "DeviceProfile:");
Sunny Goyal35c7b192021-04-20 16:51:10 -0700851 writer.println(prefix + "\t1 dp = " + mMetrics.density + " px");
Jon Miranda58561d42021-03-17 10:51:54 -0400852
Alex Chaua02eddc2021-04-29 00:36:06 +0100853 writer.println(prefix + "\tallowRotation:" + allowRotation);
Jon Miranda58561d42021-03-17 10:51:54 -0400854 writer.println(prefix + "\tisTablet:" + isTablet);
Jon Miranda58561d42021-03-17 10:51:54 -0400855 writer.println(prefix + "\tisPhone:" + isPhone);
856 writer.println(prefix + "\ttransposeLayoutWithOrientation:"
857 + transposeLayoutWithOrientation);
858
859 writer.println(prefix + "\tisLandscape:" + isLandscape);
860 writer.println(prefix + "\tisMultiWindowMode:" + isMultiWindowMode);
Sunny Goyal19ff7282021-04-22 10:12:54 -0700861 writer.println(prefix + "\tisTwoPanels:" + isTwoPanels);
Jon Miranda58561d42021-03-17 10:51:54 -0400862
863 writer.println(prefix + pxToDpStr("windowX", windowX));
864 writer.println(prefix + pxToDpStr("windowY", windowY));
865 writer.println(prefix + pxToDpStr("widthPx", widthPx));
866 writer.println(prefix + pxToDpStr("heightPx", heightPx));
867
868 writer.println(prefix + pxToDpStr("availableWidthPx", availableWidthPx));
869 writer.println(prefix + pxToDpStr("availableHeightPx", availableHeightPx));
870
871 writer.println(prefix + "\taspectRatio:" + aspectRatio);
872
873 writer.println(prefix + "\tisScalableGrid:" + isScalableGrid);
874
875 writer.println(prefix + "\tinv.minCellWidth:" + inv.minCellWidth + "dp");
876 writer.println(prefix + "\tinv.minCellHeight:" + inv.minCellHeight + "dp");
877
878 writer.println(prefix + pxToDpStr("cellWidthPx", cellWidthPx));
879 writer.println(prefix + pxToDpStr("cellHeightPx", cellHeightPx));
880
881 writer.println(prefix + pxToDpStr("getCellSize().x", getCellSize().x));
882 writer.println(prefix + pxToDpStr("getCellSize().y", getCellSize().y));
883
884 writer.println(prefix + "\tinv.iconSize:" + inv.iconSize + "dp");
885 writer.println(prefix + pxToDpStr("iconSizePx", iconSizePx));
886 writer.println(prefix + pxToDpStr("iconTextSizePx", iconTextSizePx));
887 writer.println(prefix + pxToDpStr("iconDrawablePaddingPx", iconDrawablePaddingPx));
888
889 writer.println(prefix + pxToDpStr("folderCellWidthPx", folderCellWidthPx));
890 writer.println(prefix + pxToDpStr("folderCellHeightPx", folderCellHeightPx));
891 writer.println(prefix + pxToDpStr("folderChildIconSizePx", folderChildIconSizePx));
892 writer.println(prefix + pxToDpStr("folderChildTextSizePx", folderChildTextSizePx));
893 writer.println(prefix + pxToDpStr("folderChildDrawablePaddingPx",
894 folderChildDrawablePaddingPx));
Jon Miranda823da222021-03-23 08:08:45 -0400895 writer.println(prefix + pxToDpStr("folderCellLayoutBorderSpacingPx",
896 folderCellLayoutBorderSpacingPx));
Jon Miranda58561d42021-03-17 10:51:54 -0400897
898 writer.println(prefix + pxToDpStr("cellLayoutBorderSpacingPx",
899 cellLayoutBorderSpacingPx));
900 writer.println(prefix + pxToDpStr("desiredWorkspaceLeftRightMarginPx",
901 desiredWorkspaceLeftRightMarginPx));
902
903 writer.println(prefix + pxToDpStr("allAppsIconSizePx", allAppsIconSizePx));
904 writer.println(prefix + pxToDpStr("allAppsIconTextSizePx", allAppsIconTextSizePx));
905 writer.println(prefix + pxToDpStr("allAppsIconDrawablePaddingPx",
906 allAppsIconDrawablePaddingPx));
907 writer.println(prefix + pxToDpStr("allAppsCellHeightPx", allAppsCellHeightPx));
Sunny Goyal19ff7282021-04-22 10:12:54 -0700908 writer.println(prefix + "\tnumShownAllAppsColumns: " + numShownAllAppsColumns);
Jon Miranda58561d42021-03-17 10:51:54 -0400909
910 writer.println(prefix + pxToDpStr("hotseatBarSizePx", hotseatBarSizePx));
911 writer.println(prefix + pxToDpStr("hotseatCellHeightPx", hotseatCellHeightPx));
912 writer.println(prefix + pxToDpStr("hotseatBarTopPaddingPx", hotseatBarTopPaddingPx));
913 writer.println(prefix + pxToDpStr("hotseatBarBottomPaddingPx", hotseatBarBottomPaddingPx));
914 writer.println(prefix + pxToDpStr("hotseatBarSidePaddingStartPx",
915 hotseatBarSidePaddingStartPx));
916 writer.println(prefix + pxToDpStr("hotseatBarSidePaddingEndPx",
917 hotseatBarSidePaddingEndPx));
Sunny Goyal19ff7282021-04-22 10:12:54 -0700918 writer.println(prefix + "\tnumShownHotseatIcons: " + numShownHotseatIcons);
Jon Miranda58561d42021-03-17 10:51:54 -0400919
920 writer.println(prefix + "\tisTaskbarPresent:" + isTaskbarPresent);
921
922 writer.println(prefix + pxToDpStr("taskbarSize", taskbarSize));
923 writer.println(prefix + pxToDpStr("nonOverlappingTaskbarInset",
924 nonOverlappingTaskbarInset));
925
926 writer.println(prefix + pxToDpStr("workspacePadding.left", workspacePadding.left));
927 writer.println(prefix + pxToDpStr("workspacePadding.top", workspacePadding.top));
928 writer.println(prefix + pxToDpStr("workspacePadding.right", workspacePadding.right));
929 writer.println(prefix + pxToDpStr("workspacePadding.bottom", workspacePadding.bottom));
930
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400931 writer.println(prefix + pxToDpStr("scaleToFit", iconScale));
Jon Miranda58561d42021-03-17 10:51:54 -0400932 writer.println(prefix + pxToDpStr("extraSpace", extraSpace));
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400933
934 if (inv.devicePaddings != null) {
935 int unscaledExtraSpace = (int) (extraSpace / iconScale);
936 writer.println(prefix + pxToDpStr("maxEmptySpace",
937 inv.devicePaddings.getDevicePadding(unscaledExtraSpace).getMaxEmptySpacePx()));
938 }
Jon Miranda58561d42021-03-17 10:51:54 -0400939 writer.println(prefix + pxToDpStr("workspaceTopPadding", workspaceTopPadding));
940 writer.println(prefix + pxToDpStr("workspaceBottomPadding", workspaceBottomPadding));
941 writer.println(prefix + pxToDpStr("extraHotseatBottomPadding", extraHotseatBottomPadding));
942 }
943
Sunny Goyalfd58da62020-08-11 12:06:49 -0700944 private static Context getContext(Context c, Info info, int orientation) {
Sunny Goyal1890f672020-04-30 12:28:00 -0700945 Configuration config = new Configuration(c.getResources().getConfiguration());
946 config.orientation = orientation;
Sunny Goyal35c7b192021-04-20 16:51:10 -0700947 config.densityDpi = info.densityDpi;
Sunny Goyal1890f672020-04-30 12:28:00 -0700948 return c.createConfigurationContext(config);
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700949 }
Sunny Goyalfde55052018-02-01 14:46:13 -0800950
951 /**
952 * Callback when a component changes the DeviceProfile associated with it, as a result of
953 * configuration change
954 */
955 public interface OnDeviceProfileChangeListener {
956
957 /**
958 * Called when the device profile is reassigned. Note that for layout and measurements, it
959 * is sufficient to listen for inset changes. Use this callback when you need to perform
960 * a one time operation.
961 */
962 void onDeviceProfileChanged(DeviceProfile dp);
963 }
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700964
965 public static class Builder {
966 private Context mContext;
967 private InvariantDeviceProfile mInv;
Sunny Goyalfd58da62020-08-11 12:06:49 -0700968 private Info mInfo;
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700969
Sunny Goyal19ff7282021-04-22 10:12:54 -0700970 private WindowBounds mWindowBounds;
971 private boolean mUseTwoPanels;
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700972
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700973 private boolean mIsMultiWindowMode = false;
Sunny Goyal19ff7282021-04-22 10:12:54 -0700974 private Boolean mTransposeLayoutWithOrientation;
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700975
Sunny Goyalfd58da62020-08-11 12:06:49 -0700976 public Builder(Context context, InvariantDeviceProfile inv, Info info) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700977 mContext = context;
978 mInv = inv;
979 mInfo = info;
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700980 }
981
982 public Builder setMultiWindowMode(boolean isMultiWindowMode) {
983 mIsMultiWindowMode = isMultiWindowMode;
984 return this;
985 }
986
Sunny Goyal19ff7282021-04-22 10:12:54 -0700987 public Builder setUseTwoPanels(boolean useTwoPanels) {
988 mUseTwoPanels = useTwoPanels;
989 return this;
990 }
991
992
993 public Builder setWindowBounds(WindowBounds bounds) {
994 mWindowBounds = bounds;
Sunny Goyal0addbf02020-04-28 14:17:35 -0700995 return this;
996 }
997
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700998 public Builder setTransposeLayoutWithOrientation(boolean transposeLayoutWithOrientation) {
999 mTransposeLayoutWithOrientation = transposeLayoutWithOrientation;
1000 return this;
1001 }
1002
1003 public DeviceProfile build() {
Sunny Goyal19ff7282021-04-22 10:12:54 -07001004 if (mWindowBounds == null) {
1005 throw new IllegalArgumentException("Window bounds not set");
1006 }
1007 if (mTransposeLayoutWithOrientation == null) {
1008 mTransposeLayoutWithOrientation = !mInfo.isTablet(mWindowBounds);
1009 }
1010 return new DeviceProfile(mContext, mInv, mInfo, mWindowBounds,
1011 mIsMultiWindowMode, mTransposeLayoutWithOrientation, mUseTwoPanels);
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001012 }
1013 }
1014
Winson Chungb3800242013-10-24 11:01:54 -07001015}