blob: 58d612d014510cba880f0d7840cd85bbe5ab39b0 [file] [log] [blame]
Winson Chungb3800242013-10-24 11:01:54 -07001/*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.launcher3;
18
Jon Mirandae126d722021-02-25 10:45:20 -050019import static com.android.launcher3.ResourceUtils.pxFromDp;
Jon Miranda58561d42021-03-17 10:51:54 -040020import static com.android.launcher3.Utilities.dpiFromPx;
Jon Miranda228877d2021-02-09 11:05:00 -050021
Winson Chungb3800242013-10-24 11:01:54 -070022import android.content.Context;
Jon Mirandab28c4fc2017-06-20 10:58:36 -070023import android.content.res.Configuration;
Winson Chungb3800242013-10-24 11:01:54 -070024import android.content.res.Resources;
Winson Chungb3800242013-10-24 11:01:54 -070025import android.graphics.Point;
Jon Miranda7ae64ff2016-11-21 16:18:46 -080026import android.graphics.PointF;
Winson Chungb3800242013-10-24 11:01:54 -070027import android.graphics.Rect;
Sunny Goyal59d086c2018-05-07 17:31:40 -070028import android.view.Surface;
Tony Wickham15883892021-02-12 11:24:40 -080029import android.view.WindowInsets;
30import android.view.WindowManager;
Winson Chungb3800242013-10-24 11:01:54 -070031
Sunny Goyalc13403c2016-11-18 23:44:48 -080032import com.android.launcher3.CellLayout.ContainerType;
Jon Miranda228877d2021-02-09 11:05:00 -050033import com.android.launcher3.DevicePaddings.DevicePadding;
Tony Wickham15883892021-02-12 11:24:40 -080034import com.android.launcher3.config.FeatureFlags;
Tony Wickhame1cb93f2019-05-03 11:27:32 -070035import com.android.launcher3.graphics.IconShape;
Tony Wickham8912b042018-11-29 15:28:53 -080036import com.android.launcher3.icons.DotRenderer;
Hyunyoung Song48cb7bc2018-09-25 17:03:34 -070037import com.android.launcher3.icons.IconNormalizer;
Sunny Goyalfd58da62020-08-11 12:06:49 -070038import com.android.launcher3.util.DisplayController;
39import com.android.launcher3.util.DisplayController.Info;
Sunny Goyalb46703d2020-05-27 17:52:03 -070040import com.android.launcher3.util.WindowBounds;
Winson1f064272016-07-18 17:18:02 -070041
Jon Miranda58561d42021-03-17 10:51:54 -040042import java.io.PrintWriter;
43
Winson Chungb3800242013-10-24 11:01:54 -070044public class DeviceProfile {
Adam Cohen2e6da152015-05-06 11:42:25 -070045
Sunny Goyal1890f672020-04-30 12:28:00 -070046 private static final float TABLET_MIN_DPS = 600;
47 private static final float LARGE_TABLET_MIN_DPS = 720;
48
49
Adam Cohen2e6da152015-05-06 11:42:25 -070050 public final InvariantDeviceProfile inv;
Sunny Goyalfd58da62020-08-11 12:06:49 -070051 private final Info mInfo;
Winson Chungbe876472014-05-14 14:15:20 -070052
Sunny Goyalc6205602015-05-21 20:46:33 -070053 // Device properties
54 public final boolean isTablet;
55 public final boolean isLargeTablet;
56 public final boolean isPhone;
57 public final boolean transposeLayoutWithOrientation;
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -070058
Sunny Goyalc6205602015-05-21 20:46:33 -070059 // Device properties in current orientation
Sunny Goyald792a772018-04-05 13:37:46 -070060 public final boolean isLandscape;
Sunny Goyald70e75a2018-02-22 10:07:32 -080061 public final boolean isMultiWindowMode;
62
Sunny Goyal0addbf02020-04-28 14:17:35 -070063 public final int windowX;
64 public final int windowY;
Sunny Goyalc6205602015-05-21 20:46:33 -070065 public final int widthPx;
66 public final int heightPx;
67 public final int availableWidthPx;
68 public final int availableHeightPx;
Jon Mirandabba64512019-03-27 10:54:17 -070069
70 public final float aspectRatio;
71
Jon Mirandae126d722021-02-25 10:45:20 -050072 public final boolean isScalableGrid;
73
Tony Wickhamd6b40372015-09-23 18:37:57 -070074 /**
75 * The maximum amount of left/right workspace padding as a percentage of the screen width.
76 * To be clear, this means that up to 7% of the screen width can be used as left padding, and
77 * 7% of the screen width can be used as right padding.
78 */
79 private static final float MAX_HORIZONTAL_PADDING_PERCENT = 0.14f;
Winson Chungb3800242013-10-24 11:01:54 -070080
Jon Miranda3f9bab22017-07-28 14:50:17 -070081 private static final float TALL_DEVICE_ASPECT_RATIO_THRESHOLD = 2.0f;
Jon Miranda30d0aa22017-07-25 15:55:29 -070082
Jon Miranda5eacbb72018-07-31 11:14:46 -070083 // To evenly space the icons, increase the left/right margins for tablets in portrait mode.
84 private static final int PORTRAIT_TABLET_LEFT_RIGHT_PADDING_MULTIPLIER = 4;
85
Sunny Goyalc6205602015-05-21 20:46:33 -070086 // Workspace
Jon Mirandae126d722021-02-25 10:45:20 -050087 public final int desiredWorkspaceLeftRightOriginalPx;
88 public int desiredWorkspaceLeftRightMarginPx;
89 public final int cellLayoutBorderSpacingOriginalPx;
90 public int cellLayoutBorderSpacingPx;
Jon Miranda28032002017-07-13 16:18:56 -070091 public final int cellLayoutPaddingLeftRightPx;
Jon Miranda18751b62017-07-31 17:25:27 -070092 public final int cellLayoutBottomPaddingPx;
Sunny Goyalc6205602015-05-21 20:46:33 -070093 public final int edgeMarginPx;
Sunny Goyal47328fd2016-05-25 18:56:41 -070094 public float workspaceSpringLoadShrinkFactor;
95 public final int workspaceSpringLoadedBottomSpace;
Sunny Goyalc6205602015-05-21 20:46:33 -070096
Jon Miranda58561d42021-03-17 10:51:54 -040097 private final int extraSpace;
Jon Miranda228877d2021-02-09 11:05:00 -050098 public int workspaceTopPadding;
99 public int workspaceBottomPadding;
Jon Miranda58561d42021-03-17 10:51:54 -0400100 public int extraHotseatBottomPadding;
Jon Miranda228877d2021-02-09 11:05:00 -0500101
Tony Wickham5edf9e22020-03-27 20:06:52 -0700102 // Workspace page indicator
103 public final int workspacePageIndicatorHeight;
104 private final int mWorkspacePageIndicatorOverlapWorkspace;
Winson1f064272016-07-18 17:18:02 -0700105
Sunny Goyalc6205602015-05-21 20:46:33 -0700106 // Workspace icons
107 public int iconSizePx;
108 public int iconTextSizePx;
109 public int iconDrawablePaddingPx;
Winson Chung5f4e0fd2015-05-22 11:12:27 -0700110 public int iconDrawablePaddingOriginalPx;
Winson Chungb3800242013-10-24 11:01:54 -0700111
Adam Cohen59400422014-03-05 18:07:04 -0800112 public int cellWidthPx;
113 public int cellHeightPx;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700114 public int workspaceCellPaddingXPx;
Adam Cohen59400422014-03-05 18:07:04 -0800115
Jon Mirandae126d722021-02-25 10:45:20 -0500116 public int cellYPaddingPx;
Jon Mirandae126d722021-02-25 10:45:20 -0500117
Sunny Goyalc6205602015-05-21 20:46:33 -0700118 // Folder
Jon Mirandae126d722021-02-25 10:45:20 -0500119 public float folderLabelTextScale;
120 public int folderLabelTextSizePx;
Sunny Goyalc6205602015-05-21 20:46:33 -0700121 public int folderIconSizePx;
Jon Miranda591e3602018-03-28 11:37:00 -0700122 public int folderIconOffsetYPx;
Jon Mirandabf7d8122016-11-03 15:29:29 -0700123
Jon Mirandae126d722021-02-25 10:45:20 -0500124 // Folder content
125 public int folderContentPaddingLeftRight;
126 public int folderContentPaddingTop;
127
Jon Mirandabf7d8122016-11-03 15:29:29 -0700128 // Folder cell
Sunny Goyalc6205602015-05-21 20:46:33 -0700129 public int folderCellWidthPx;
130 public int folderCellHeightPx;
Jon Mirandabf7d8122016-11-03 15:29:29 -0700131
132 // Folder child
133 public int folderChildIconSizePx;
134 public int folderChildTextSizePx;
Sunny Goyalbaec6ff2016-09-14 11:26:21 -0700135 public int folderChildDrawablePaddingPx;
Winson Chungb3800242013-10-24 11:01:54 -0700136
Sunny Goyalc6205602015-05-21 20:46:33 -0700137 // Hotseat
Sunny Goyalc6205602015-05-21 20:46:33 -0700138 public int hotseatCellHeightPx;
Jon Miranda18751b62017-07-31 17:25:27 -0700139 // In portrait: size = height, in landscape: size = width
140 public int hotseatBarSizePx;
Sunny Goyal07b69292018-01-08 14:19:34 -0800141 public final int hotseatBarTopPaddingPx;
Jon Miranda7e183c32018-06-20 11:05:27 -0700142 public int hotseatBarBottomPaddingPx;
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700143 // Start is the side next to the nav bar, end is the side next to the workspace
144 public final int hotseatBarSidePaddingStartPx;
145 public final int hotseatBarSidePaddingEndPx;
Adam Cohen2e6da152015-05-06 11:42:25 -0700146
Sunny Goyalc6205602015-05-21 20:46:33 -0700147 // All apps
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700148 public int allAppsCellHeightPx;
Samuel Fufaf1424a32019-10-04 15:15:19 -0700149 public int allAppsCellWidthPx;
Winson1f064272016-07-18 17:18:02 -0700150 public int allAppsIconSizePx;
151 public int allAppsIconDrawablePaddingPx;
152 public float allAppsIconTextSizePx;
153
Zak Cohen334efeb2021-03-19 16:42:07 -0700154 // Overview
Zak Cohen334efeb2021-03-19 16:42:07 -0700155 public int overviewTaskMarginPx;
Alex Chaudedbc8a2021-03-17 16:53:26 +0000156 public int overviewTaskIconSizePx;
157 public int overviewTaskThumbnailTopMarginPx;
Zak Cohen334efeb2021-03-19 16:42:07 -0700158
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800159 // Widgets
160 public final PointF appWidgetScale = new PointF(1.0f, 1.0f);
161
Sunny Goyal47328fd2016-05-25 18:56:41 -0700162 // Drop Target
163 public int dropTargetBarSizePx;
Adam Cohen4ae96ce2014-08-29 15:05:48 -0700164
Winson1f064272016-07-18 17:18:02 -0700165 // Insets
Sunny Goyal07b69292018-01-08 14:19:34 -0800166 private final Rect mInsets = new Rect();
167 public final Rect workspacePadding = new Rect();
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700168 private final Rect mHotseatPadding = new Rect();
Jon Miranda0bd63d12019-03-06 17:29:29 -0800169 // When true, nav bar is on the left side of the screen.
Sunny Goyal59d086c2018-05-07 17:31:40 -0700170 private boolean mIsSeascape;
Winson1f064272016-07-18 17:18:02 -0700171
Tony Wickhamf34bee82018-12-03 18:11:39 -0800172 // Notification dots
Samuel Fufac96fa242019-09-26 23:06:32 -0700173 public DotRenderer mDotRendererWorkSpace;
174 public DotRenderer mDotRendererAllApps;
Tony Wickham9a8d11f2017-01-11 09:53:12 -0800175
Tony Wickham15883892021-02-12 11:24:40 -0800176 // Taskbar
177 public boolean isTaskbarPresent;
178 public int taskbarSize;
Tony Wickham145b7fd2021-03-11 10:03:12 -0800179 // How much of the bottom inset is due to Taskbar rather than other system elements.
180 public int nonOverlappingTaskbarInset;
Tony Wickham15883892021-02-12 11:24:40 -0800181
Sunny Goyalfd58da62020-08-11 12:06:49 -0700182 DeviceProfile(Context context, InvariantDeviceProfile inv, Info info,
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700183 Point minSize, Point maxSize, int width, int height, boolean isLandscape,
Sunny Goyal0addbf02020-04-28 14:17:35 -0700184 boolean isMultiWindowMode, boolean transposeLayoutWithOrientation,
185 Point windowPosition) {
Sunny Goyalfee35bb2015-05-11 11:38:19 -0700186
Adam Cohen2e6da152015-05-06 11:42:25 -0700187 this.inv = inv;
Sunny Goyalc6205602015-05-21 20:46:33 -0700188 this.isLandscape = isLandscape;
Sunny Goyald70e75a2018-02-22 10:07:32 -0800189 this.isMultiWindowMode = isMultiWindowMode;
Jon Mirandae126d722021-02-25 10:45:20 -0500190 this.transposeLayoutWithOrientation = transposeLayoutWithOrientation;
Sunny Goyal0addbf02020-04-28 14:17:35 -0700191 windowX = windowPosition.x;
192 windowY = windowPosition.y;
Winson Chungb3800242013-10-24 11:01:54 -0700193
Jon Mirandae126d722021-02-25 10:45:20 -0500194 isScalableGrid = inv.isScalable && !isVerticalBarLayout() && !isMultiWindowMode;
195
Jon Miranda7e183c32018-06-20 11:05:27 -0700196 // Determine sizes.
197 widthPx = width;
198 heightPx = height;
Tony Wickham15883892021-02-12 11:24:40 -0800199 int nonFinalAvailableHeightPx;
Jon Miranda7e183c32018-06-20 11:05:27 -0700200 if (isLandscape) {
201 availableWidthPx = maxSize.x;
Tony Wickham15883892021-02-12 11:24:40 -0800202 nonFinalAvailableHeightPx = minSize.y;
Jon Miranda7e183c32018-06-20 11:05:27 -0700203 } else {
204 availableWidthPx = minSize.x;
Tony Wickham15883892021-02-12 11:24:40 -0800205 nonFinalAvailableHeightPx = maxSize.y;
Jon Miranda7e183c32018-06-20 11:05:27 -0700206 }
207
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700208 mInfo = info;
Adam Cohen2e6da152015-05-06 11:42:25 -0700209
Sunny Goyalc6205602015-05-21 20:46:33 -0700210 // Constants from resources
Jon Miranda58561d42021-03-17 10:51:54 -0400211 float swDPs = dpiFromPx(Math.min(info.smallestSize.x, info.smallestSize.y), info.metrics);
Alex Chau4e2c25a2021-02-03 16:20:04 +0000212 boolean allowRotation = context.getResources().getBoolean(R.bool.allow_rotation);
213 // Tablet UI is built with assumption that simulated landscape is disabled.
214 isTablet = allowRotation && swDPs >= TABLET_MIN_DPS;
215 isLargeTablet = isTablet && swDPs >= LARGE_TABLET_MIN_DPS;
Sunny Goyalc6205602015-05-21 20:46:33 -0700216 isPhone = !isTablet && !isLargeTablet;
Jon Mirandabba64512019-03-27 10:54:17 -0700217 aspectRatio = ((float) Math.max(widthPx, heightPx)) / Math.min(widthPx, heightPx);
Jon Miranda7e183c32018-06-20 11:05:27 -0700218 boolean isTallDevice = Float.compare(aspectRatio, TALL_DEVICE_ASPECT_RATIO_THRESHOLD) >= 0;
Sunny Goyalc6205602015-05-21 20:46:33 -0700219
220 // Some more constants
Sunny Goyal1890f672020-04-30 12:28:00 -0700221 context = getContext(context, info, isVerticalBarLayout()
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700222 ? Configuration.ORIENTATION_LANDSCAPE
223 : Configuration.ORIENTATION_PORTRAIT);
Sunny Goyal1890f672020-04-30 12:28:00 -0700224 final Resources res = context.getResources();
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700225
Tony Wickham15883892021-02-12 11:24:40 -0800226 isTaskbarPresent = isTablet && FeatureFlags.ENABLE_TASKBAR.get();
227 if (isTaskbarPresent) {
228 // Taskbar will be added later, but provides bottom insets that we should subtract
229 // from availableHeightPx.
230 taskbarSize = res.getDimensionPixelSize(R.dimen.taskbar_size);
231 WindowInsets windowInsets = DisplayController.INSTANCE.get(context).getHolder(mInfo.id)
232 .getDisplayContext().getSystemService(WindowManager.class)
233 .getCurrentWindowMetrics().getWindowInsets();
Tony Wickham145b7fd2021-03-11 10:03:12 -0800234 nonOverlappingTaskbarInset =
Tony Wickham15883892021-02-12 11:24:40 -0800235 taskbarSize - windowInsets.getSystemWindowInsetBottom();
236 if (nonOverlappingTaskbarInset > 0) {
237 nonFinalAvailableHeightPx -= nonOverlappingTaskbarInset;
238 }
239 }
240 availableHeightPx = nonFinalAvailableHeightPx;
241
Winson Chungb3800242013-10-24 11:01:54 -0700242 edgeMarginPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_edge_margin);
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700243
Jon Mirandae126d722021-02-25 10:45:20 -0500244 desiredWorkspaceLeftRightMarginPx = isVerticalBarLayout() ? 0 : isScalableGrid
245 ? res.getDimensionPixelSize(R.dimen.scalable_grid_left_right_margin)
246 : res.getDimensionPixelSize(R.dimen.dynamic_grid_left_right_margin);
247 desiredWorkspaceLeftRightOriginalPx = desiredWorkspaceLeftRightMarginPx;
248
249 folderLabelTextScale = res.getFloat(R.dimen.folder_label_text_scale);
250 folderContentPaddingLeftRight =
251 res.getDimensionPixelSize(R.dimen.folder_content_padding_left_right);
252 folderContentPaddingTop = res.getDimensionPixelSize(R.dimen.folder_content_padding_top);
253
254 setCellLayoutBorderSpacing(pxFromDp(inv.borderSpacing, mInfo.metrics, 1f));
255 cellLayoutBorderSpacingOriginalPx = cellLayoutBorderSpacingPx;
256
Jon Miranda5eacbb72018-07-31 11:14:46 -0700257 int cellLayoutPaddingLeftRightMultiplier = !isVerticalBarLayout() && isTablet
258 ? PORTRAIT_TABLET_LEFT_RIGHT_PADDING_MULTIPLIER : 1;
Jon Mirandae126d722021-02-25 10:45:20 -0500259 int cellLayoutPadding = isScalableGrid
260 ? 0
261 : res.getDimensionPixelSize(R.dimen.dynamic_grid_cell_layout_padding);
Andras Kloczl8e57cce2021-02-11 23:51:19 +0100262
263 if (FeatureFlags.ENABLE_TWO_PANEL_HOME.get() && isTablet) {
264 cellLayoutPaddingLeftRightPx =
265 res.getDimensionPixelSize(R.dimen.two_panel_home_side_padding);
266 cellLayoutBottomPaddingPx = 0;
267 } else if (isLandscape) {
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700268 cellLayoutPaddingLeftRightPx = 0;
269 cellLayoutBottomPaddingPx = cellLayoutPadding;
270 } else {
271 cellLayoutPaddingLeftRightPx = cellLayoutPaddingLeftRightMultiplier * cellLayoutPadding;
272 cellLayoutBottomPaddingPx = 0;
273 }
274
Tony Wickham5edf9e22020-03-27 20:06:52 -0700275 workspacePageIndicatorHeight = res.getDimensionPixelSize(
276 R.dimen.workspace_page_indicator_height);
277 mWorkspacePageIndicatorOverlapWorkspace =
278 res.getDimensionPixelSize(R.dimen.workspace_page_indicator_overlap_workspace);
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700279
Winson Chungb3800242013-10-24 11:01:54 -0700280 iconDrawablePaddingOriginalPx =
281 res.getDimensionPixelSize(R.dimen.dynamic_grid_icon_drawable_padding);
Sunny Goyal47328fd2016-05-25 18:56:41 -0700282 dropTargetBarSizePx = res.getDimensionPixelSize(R.dimen.dynamic_grid_drop_target_size);
283 workspaceSpringLoadedBottomSpace =
284 res.getDimensionPixelSize(R.dimen.dynamic_grid_min_spring_loaded_space);
Sunny Goyald5190522017-04-24 03:06:54 -0700285
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700286 workspaceCellPaddingXPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_cell_padding_x);
Jon Miranda09660722017-06-14 14:20:14 -0700287
Winson1f064272016-07-18 17:18:02 -0700288 hotseatBarTopPaddingPx =
289 res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_top_padding);
Jon Miranda7e183c32018-06-20 11:05:27 -0700290 hotseatBarBottomPaddingPx = (isTallDevice ? 0
291 : res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_bottom_non_tall_padding))
292 + res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_bottom_padding);
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700293 hotseatBarSidePaddingEndPx =
Sunny Goyal228153d2018-01-04 15:35:22 -0800294 res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_side_padding);
Jon Miranda3f411e72019-05-16 17:15:16 -0700295 // Add a bit of space between nav bar and hotseat in vertical bar layout.
Tony Wickham5edf9e22020-03-27 20:06:52 -0700296 hotseatBarSidePaddingStartPx = isVerticalBarLayout() ? workspacePageIndicatorHeight : 0;
Jon Miranda228877d2021-02-09 11:05:00 -0500297 int hotseatExtraVerticalSize =
298 res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_extra_vertical_size);
Jon Mirandae126d722021-02-25 10:45:20 -0500299 hotseatBarSizePx = pxFromDp(inv.iconSize, mInfo.metrics, 1f)
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700300 + (isVerticalBarLayout()
Sunny Goyal415f1732018-11-29 10:33:47 -0800301 ? (hotseatBarSidePaddingStartPx + hotseatBarSidePaddingEndPx)
Jon Miranda228877d2021-02-09 11:05:00 -0500302 : (hotseatBarTopPaddingPx + hotseatBarBottomPaddingPx
Jon Mirandae126d722021-02-25 10:45:20 -0500303 + (isScalableGrid ? 0 : hotseatExtraVerticalSize)));
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700304
Zak Cohen334efeb2021-03-19 16:42:07 -0700305 overviewTaskMarginPx = res.getDimensionPixelSize(R.dimen.overview_task_margin);
Alex Chaudedbc8a2021-03-17 16:53:26 +0000306 overviewTaskIconSizePx =
307 isTablet && FeatureFlags.ENABLE_OVERVIEW_GRID.get() ? res.getDimensionPixelSize(
308 R.dimen.task_thumbnail_icon_size_grid) : res.getDimensionPixelSize(
309 R.dimen.task_thumbnail_icon_size);
310 overviewTaskThumbnailTopMarginPx = overviewTaskIconSizePx + overviewTaskMarginPx * 2;
Zak Cohen334efeb2021-03-19 16:42:07 -0700311
Jon Miranda2ed276e2017-06-29 11:36:34 -0700312 // Calculate all of the remaining variables.
Jon Miranda58561d42021-03-17 10:51:54 -0400313 extraSpace = updateAvailableDimensions(res);
Jon Miranda2ed276e2017-06-29 11:36:34 -0700314 // Now that we have all of the variables calculated, we can tune certain sizes.
Jon Mirandae126d722021-02-25 10:45:20 -0500315 if (isScalableGrid) {
Jon Miranda228877d2021-02-09 11:05:00 -0500316 DevicePadding padding = inv.devicePaddings.getDevicePadding(extraSpace);
317 workspaceTopPadding = padding.getWorkspaceTopPadding(extraSpace);
318 workspaceBottomPadding = padding.getWorkspaceBottomPadding(extraSpace);
319
Jon Miranda58561d42021-03-17 10:51:54 -0400320 extraHotseatBottomPadding = padding.getHotseatBottomPadding(extraSpace);
321 hotseatBarSizePx += extraHotseatBottomPadding;
322 hotseatBarBottomPaddingPx += extraHotseatBottomPadding;
Jon Miranda228877d2021-02-09 11:05:00 -0500323 } else if (!isVerticalBarLayout() && isPhone && isTallDevice) {
Jon Miranda3f9bab22017-07-28 14:50:17 -0700324 // We increase the hotseat size when there is extra space.
Jon Miranda2ed276e2017-06-29 11:36:34 -0700325 // ie. For a display with a large aspect ratio, we can keep the icons on the workspace
Jon Miranda3f9bab22017-07-28 14:50:17 -0700326 // in portrait mode closer together by adding more height to the hotseat.
Jon Miranda30d0aa22017-07-25 15:55:29 -0700327 // Note: This calculation was created after noticing a pattern in the design spec.
Jon Miranda58561d42021-03-17 10:51:54 -0400328 int extraSpace = getCellSize().y - iconSizePx - iconDrawablePaddingPx * 2
Tony Wickham5edf9e22020-03-27 20:06:52 -0700329 - workspacePageIndicatorHeight;
Jon Miranda7e183c32018-06-20 11:05:27 -0700330 hotseatBarSizePx += extraSpace;
331 hotseatBarBottomPaddingPx += extraSpace;
Jon Miranda30d0aa22017-07-25 15:55:29 -0700332
Jon Miranda3f9bab22017-07-28 14:50:17 -0700333 // Recalculate the available dimensions using the new hotseat size.
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700334 updateAvailableDimensions(res);
Jon Miranda2ed276e2017-06-29 11:36:34 -0700335 }
Sunny Goyal07b69292018-01-08 14:19:34 -0800336 updateWorkspacePadding();
Tony Wickham1237df02017-02-24 08:59:36 -0800337
338 // This is done last, after iconSizePx is calculated above.
Samuel Fufac96fa242019-09-26 23:06:32 -0700339 mDotRendererWorkSpace = new DotRenderer(iconSizePx, IconShape.getShapePath(),
Tony Wickhame1cb93f2019-05-03 11:27:32 -0700340 IconShape.DEFAULT_PATH_SIZE);
Samuel Fufac96fa242019-09-26 23:06:32 -0700341 mDotRendererAllApps = iconSizePx == allAppsIconSizePx ? mDotRendererWorkSpace :
342 new DotRenderer(allAppsIconSizePx, IconShape.getShapePath(),
343 IconShape.DEFAULT_PATH_SIZE);
Adam Cohen63f1ec02014-08-12 09:23:13 -0700344 }
345
Jon Mirandae126d722021-02-25 10:45:20 -0500346 private void setCellLayoutBorderSpacing(int borderSpacing) {
347 if (isScalableGrid) {
348 cellLayoutBorderSpacingPx = borderSpacing;
349 folderContentPaddingLeftRight = borderSpacing;
350 folderContentPaddingTop = borderSpacing;
351 } else {
352 cellLayoutBorderSpacingPx = 0;
353 }
354 }
355
Jon Miranda611dba42021-03-02 14:12:13 -0500356 /**
357 * We inset the widget padding added by the system and instead rely on the border spacing
358 * between cells to create reliable consistency between widgets
359 */
360 public boolean shouldInsetWidgets() {
361 Rect widgetPadding = inv.defaultWidgetPadding;
362
363 // Check all sides to ensure that the widget won't overlap into another cell.
364 return cellLayoutBorderSpacingPx > widgetPadding.left
365 && cellLayoutBorderSpacingPx > widgetPadding.top
366 && cellLayoutBorderSpacingPx > widgetPadding.right
367 && cellLayoutBorderSpacingPx > widgetPadding.bottom;
368 }
Jon Mirandae126d722021-02-25 10:45:20 -0500369
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700370 public Builder toBuilder(Context context) {
Sunny Goyal1a52ef52018-01-11 10:15:03 -0800371 Point size = new Point(availableWidthPx, availableHeightPx);
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700372 return new Builder(context, inv, mInfo)
373 .setSizeRange(size, size)
374 .setSize(widthPx, heightPx)
Sunny Goyal0addbf02020-04-28 14:17:35 -0700375 .setWindowPosition(windowX, windowY)
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700376 .setMultiWindowMode(isMultiWindowMode);
Sunny Goyal1a52ef52018-01-11 10:15:03 -0800377 }
378
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700379 public DeviceProfile copy(Context context) {
380 return toBuilder(context).build();
381 }
382
383 /**
384 * TODO: Move this to the builder as part of setMultiWindowMode
385 */
Sunny Goyalb46703d2020-05-27 17:52:03 -0700386 public DeviceProfile getMultiWindowProfile(Context context, WindowBounds windowBounds) {
Jon Mirandaa11380d2017-08-24 11:30:03 -0700387 // We take the minimum sizes of this profile and it's multi-window variant to ensure that
388 // the system decor is always excluded.
Sunny Goyalb46703d2020-05-27 17:52:03 -0700389 Point mwSize = new Point(Math.min(availableWidthPx, windowBounds.availableSize.x),
390 Math.min(availableHeightPx, windowBounds.availableSize.y));
Jon Mirandaa11380d2017-08-24 11:30:03 -0700391
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700392 DeviceProfile profile = toBuilder(context)
393 .setSizeRange(mwSize, mwSize)
Sunny Goyalb46703d2020-05-27 17:52:03 -0700394 .setSize(windowBounds.bounds.width(), windowBounds.bounds.height())
395 .setWindowPosition(windowBounds.bounds.left, windowBounds.bounds.top)
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700396 .setMultiWindowMode(true)
397 .build();
Jon Miranda93e1f042016-11-11 14:13:04 -0800398
Jon Miranda0cd04572017-09-19 11:31:42 -0700399 // If there isn't enough vertical cell padding with the labels displayed, hide the labels.
400 float workspaceCellPaddingY = profile.getCellSize().y - profile.iconSizePx
401 - iconDrawablePaddingPx - profile.iconTextSizePx;
402 if (workspaceCellPaddingY < profile.iconDrawablePaddingPx * 2) {
403 profile.adjustToHideWorkspaceLabels();
404 }
Jon Miranda93e1f042016-11-11 14:13:04 -0800405
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800406 // We use these scales to measure and layout the widgets using their full invariant profile
407 // sizes and then draw them scaled and centered to fit in their multi-window mode cellspans.
408 float appWidgetScaleX = (float) profile.getCellSize().x / getCellSize().x;
409 float appWidgetScaleY = (float) profile.getCellSize().y / getCellSize().y;
410 profile.appWidgetScale.set(appWidgetScaleX, appWidgetScaleY);
Sunny Goyal07b69292018-01-08 14:19:34 -0800411 profile.updateWorkspacePadding();
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800412
Jon Miranda93e1f042016-11-11 14:13:04 -0800413 return profile;
Jon Mirandacc42c5b2016-10-27 17:15:27 -0700414 }
415
Adam Cohen63f1ec02014-08-12 09:23:13 -0700416 /**
Sunny Goyalb46703d2020-05-27 17:52:03 -0700417 * Inverse of {@link #getMultiWindowProfile(Context, WindowBounds)}
Sunny Goyal2e2e2b42018-02-27 16:52:55 -0800418 * @return device profile corresponding to the current orientation in non multi-window mode.
419 */
420 public DeviceProfile getFullScreenProfile() {
421 return isLandscape ? inv.landscapeProfile : inv.portraitProfile;
422 }
423
424 /**
Jon Miranda1091e532017-07-21 13:31:50 -0700425 * Adjusts the profile so that the labels on the Workspace are hidden.
426 * It is important to call this method after the All Apps variables have been set.
427 */
428 private void adjustToHideWorkspaceLabels() {
429 iconTextSizePx = 0;
430 iconDrawablePaddingPx = 0;
431 cellHeightPx = iconSizePx;
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700432 autoResizeAllAppsCells();
433 }
Jon Miranda1091e532017-07-21 13:31:50 -0700434
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700435 /**
436 * Re-computes the all-apps cell size to be independent of workspace
437 */
438 public void autoResizeAllAppsCells() {
Jon Miranda3f9bab22017-07-28 14:50:17 -0700439 int topBottomPadding = allAppsIconDrawablePaddingPx * (isVerticalBarLayout() ? 2 : 1);
Jon Miranda1091e532017-07-21 13:31:50 -0700440 allAppsCellHeightPx = allAppsIconSizePx + allAppsIconDrawablePaddingPx
441 + Utilities.calculateTextHeight(allAppsIconTextSizePx)
Jon Miranda3f9bab22017-07-28 14:50:17 -0700442 + topBottomPadding * 2;
Jon Miranda1091e532017-07-21 13:31:50 -0700443 }
444
Jon Miranda228877d2021-02-09 11:05:00 -0500445 /**
446 * Returns the amount of extra (or unused) vertical space.
447 */
448 private int updateAvailableDimensions(Resources res) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700449 updateIconSize(1f, res);
Winson Chung59a488a2013-12-10 12:32:14 -0800450
Jon Mirandae126d722021-02-25 10:45:20 -0500451 Point workspacePadding = getTotalWorkspacePadding();
452
453 // Check to see if the icons fit within the available height.
454 float usedHeight = getCellLayoutHeight();
455 final int maxHeight = availableHeightPx - workspacePadding.y;
Jon Miranda228877d2021-02-09 11:05:00 -0500456 float extraHeight = Math.max(0, maxHeight - usedHeight);
Jon Mirandae126d722021-02-25 10:45:20 -0500457 float scaleY = maxHeight / usedHeight;
458 boolean shouldScale = scaleY < 1f;
459
460 float scaleX = 1f;
461 if (isScalableGrid) {
462 // We scale to fit the cellWidth and cellHeight in the available space.
463 // The benefit of scalable grids is that we can get consistent aspect ratios between
464 // devices.
465 float usedWidth = (cellWidthPx * inv.numColumns)
466 + (cellLayoutBorderSpacingPx * (inv.numColumns - 1))
467 + (desiredWorkspaceLeftRightMarginPx * 2);
468 // We do not subtract padding here, as we also scale the workspace padding if needed.
469 scaleX = availableWidthPx / usedWidth;
470 shouldScale = true;
Winson Chungb3800242013-10-24 11:01:54 -0700471 }
Jon Mirandae126d722021-02-25 10:45:20 -0500472
473 if (shouldScale) {
474 float scale = Math.min(scaleX, scaleY);
475 updateIconSize(scale, res);
476 extraHeight = Math.max(0, maxHeight - getCellLayoutHeight());
477 }
478
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700479 updateAvailableFolderCellDimensions(res);
Jon Miranda228877d2021-02-09 11:05:00 -0500480 return Math.round(extraHeight);
Winson Chungb3800242013-10-24 11:01:54 -0700481 }
482
Jon Mirandae126d722021-02-25 10:45:20 -0500483 private int getCellLayoutHeight() {
484 return (cellHeightPx * inv.numRows) + (cellLayoutBorderSpacingPx * (inv.numRows - 1));
485 }
486
Jon Miranda6f7e9702019-09-16 14:44:14 -0700487 /**
488 * Updating the iconSize affects many aspects of the launcher layout, such as: iconSizePx,
489 * iconTextSizePx, iconDrawablePaddingPx, cellWidth/Height, allApps* variants,
490 * hotseat sizes, workspaceSpringLoadedShrinkFactor, folderIconSizePx, and folderIconOffsetYPx.
491 */
Tony Wickham7ba547c2021-02-02 17:12:08 -0800492 public void updateIconSize(float scale, Resources res) {
Jon Miranda18751b62017-07-31 17:25:27 -0700493 // Workspace
Sunny Goyal07b69292018-01-08 14:19:34 -0800494 final boolean isVerticalLayout = isVerticalBarLayout();
Jon Miranda6f7e9702019-09-16 14:44:14 -0700495 float invIconSizeDp = isVerticalLayout ? inv.landscapeIconSize : inv.iconSize;
Jon Mirandae126d722021-02-25 10:45:20 -0500496 iconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mInfo.metrics, scale));
Jon Miranda378c11f2021-03-10 10:28:50 -0500497 iconTextSizePx = (int) (Utilities.pxFromSp(inv.iconTextSize, mInfo.metrics) * scale);
Jon Miranda09660722017-06-14 14:20:14 -0700498 iconDrawablePaddingPx = (int) (iconDrawablePaddingOriginalPx * scale);
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700499
Jon Mirandae126d722021-02-25 10:45:20 -0500500 setCellLayoutBorderSpacing((int) (cellLayoutBorderSpacingOriginalPx * scale));
501
502 if (isScalableGrid) {
503 cellWidthPx = pxFromDp(inv.minCellWidth, mInfo.metrics, scale);
504 cellHeightPx = pxFromDp(inv.minCellHeight, mInfo.metrics, scale);
505 int cellContentHeight = iconSizePx + iconDrawablePaddingPx
506 + Utilities.calculateTextHeight(iconTextSizePx);
507 cellYPaddingPx = Math.max(0, cellHeightPx - cellContentHeight) / 2;
508 desiredWorkspaceLeftRightMarginPx = (int) (desiredWorkspaceLeftRightOriginalPx * scale);
Jon Miranda228877d2021-02-09 11:05:00 -0500509 } else {
Jon Mirandae126d722021-02-25 10:45:20 -0500510 cellWidthPx = iconSizePx + iconDrawablePaddingPx;
Jon Miranda228877d2021-02-09 11:05:00 -0500511 cellHeightPx = iconSizePx + iconDrawablePaddingPx
512 + Utilities.calculateTextHeight(iconTextSizePx);
513 int cellPaddingY = (getCellSize().y - cellHeightPx) / 2;
514 if (iconDrawablePaddingPx > cellPaddingY && !isVerticalLayout
515 && !isMultiWindowMode) {
516 // Ensures that the label is closer to its corresponding icon. This is not an issue
517 // with vertical bar layout or multi-window mode since the issue is handled
518 // separately with their calls to {@link #adjustToHideWorkspaceLabels}.
519 cellHeightPx -= (iconDrawablePaddingPx - cellPaddingY);
520 iconDrawablePaddingPx = cellPaddingY;
521 }
Jon Miranda846455e2017-10-02 14:58:52 -0700522 }
Jon Miranda18751b62017-07-31 17:25:27 -0700523
Sunny Goyalae190ff2020-04-14 00:19:01 +0000524 // All apps
525 if (allAppsHasDifferentNumColumns()) {
Jon Mirandae126d722021-02-25 10:45:20 -0500526 allAppsIconSizePx = pxFromDp(inv.allAppsIconSize, mInfo.metrics);
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700527 allAppsIconTextSizePx = Utilities.pxFromSp(inv.allAppsIconTextSize, mInfo.metrics);
Sunny Goyalae190ff2020-04-14 00:19:01 +0000528 allAppsIconDrawablePaddingPx = iconDrawablePaddingOriginalPx;
Jon Miranda35359442020-07-09 14:54:23 -0700529 // We use 4 below to ensure labels are closer to their corresponding icon.
530 allAppsCellHeightPx = Math.round(allAppsIconSizePx + allAppsIconTextSizePx
531 + (4 * allAppsIconDrawablePaddingPx));
Sunny Goyalae190ff2020-04-14 00:19:01 +0000532 } else {
533 allAppsIconSizePx = iconSizePx;
534 allAppsIconTextSizePx = iconTextSizePx;
535 allAppsIconDrawablePaddingPx = iconDrawablePaddingPx;
536 allAppsCellHeightPx = getCellSize().y;
537 }
538 allAppsCellWidthPx = allAppsIconSizePx + allAppsIconDrawablePaddingPx;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700539
Jon Miranda6f7e9702019-09-16 14:44:14 -0700540 if (isVerticalBarLayout()) {
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700541 // Always hide the Workspace text with vertical bar layout.
Jon Miranda1091e532017-07-21 13:31:50 -0700542 adjustToHideWorkspaceLabels();
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700543 }
Winson Chungb3800242013-10-24 11:01:54 -0700544
Winson Chungb3800242013-10-24 11:01:54 -0700545 // Hotseat
Sunny Goyal07b69292018-01-08 14:19:34 -0800546 if (isVerticalLayout) {
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700547 hotseatBarSizePx = iconSizePx + hotseatBarSidePaddingStartPx
548 + hotseatBarSidePaddingEndPx;
Jon Miranda18751b62017-07-31 17:25:27 -0700549 }
Jon Miranda5044c352017-08-09 11:37:59 -0700550 hotseatCellHeightPx = iconSizePx;
Winson Chungb3800242013-10-24 11:01:54 -0700551
Sunny Goyal07b69292018-01-08 14:19:34 -0800552 if (!isVerticalLayout) {
Jon Miranda18751b62017-07-31 17:25:27 -0700553 int expectedWorkspaceHeight = availableHeightPx - hotseatBarSizePx
Tony Wickham5edf9e22020-03-27 20:06:52 -0700554 - workspacePageIndicatorHeight - edgeMarginPx;
Sunny Goyal47328fd2016-05-25 18:56:41 -0700555 float minRequiredHeight = dropTargetBarSizePx + workspaceSpringLoadedBottomSpace;
556 workspaceSpringLoadShrinkFactor = Math.min(
557 res.getInteger(R.integer.config_workspaceSpringLoadShrinkPercentage) / 100.0f,
558 1 - (minRequiredHeight / expectedWorkspaceHeight));
559 } else {
560 workspaceSpringLoadShrinkFactor =
561 res.getInteger(R.integer.config_workspaceSpringLoadShrinkPercentage) / 100.0f;
562 }
563
Sunny Goyalbaec6ff2016-09-14 11:26:21 -0700564 // Folder icon
Jon Miranda591e3602018-03-28 11:37:00 -0700565 folderIconSizePx = IconNormalizer.getNormalizedCircleSize(iconSizePx);
566 folderIconOffsetYPx = (iconSizePx - folderIconSizePx) / 2;
Winson Chung0f785722015-04-08 10:27:49 -0700567 }
568
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700569 private void updateAvailableFolderCellDimensions(Resources res) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700570 updateFolderCellSize(1f, res);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700571
Jon Mirandae126d722021-02-25 10:45:20 -0500572 final int folderBottomPanelSize = res.getDimensionPixelSize(R.dimen.folder_label_height);
573
Jon Mirandac1b23992016-12-13 08:57:36 -0800574 // Don't let the folder get too close to the edges of the screen.
Jon Miranda1786df32018-09-25 13:05:23 -0700575 int folderMargin = edgeMarginPx * 2;
Sunny Goyal07b69292018-01-08 14:19:34 -0800576 Point totalWorkspacePadding = getTotalWorkspacePadding();
Jon Mirandac1b23992016-12-13 08:57:36 -0800577
578 // Check if the icons fit within the available height.
Jon Miranda228877d2021-02-09 11:05:00 -0500579 float contentUsedHeight = folderCellHeightPx * inv.numFolderRows
580 + ((inv.numFolderRows - 1) * cellLayoutBorderSpacingPx);
Samuel Fufa1c8d90a2019-11-12 17:54:58 -0800581 int contentMaxHeight = availableHeightPx - totalWorkspacePadding.y - folderBottomPanelSize
Jon Mirandae126d722021-02-25 10:45:20 -0500582 - folderMargin - folderContentPaddingTop;
Samuel Fufa1c8d90a2019-11-12 17:54:58 -0800583 float scaleY = contentMaxHeight / contentUsedHeight;
Jon Mirandac1b23992016-12-13 08:57:36 -0800584
585 // Check if the icons fit within the available width.
Jon Miranda228877d2021-02-09 11:05:00 -0500586 float contentUsedWidth = folderCellWidthPx * inv.numFolderColumns
587 + ((inv.numFolderColumns - 1) * cellLayoutBorderSpacingPx);
Jon Mirandae126d722021-02-25 10:45:20 -0500588 int contentMaxWidth = availableWidthPx - totalWorkspacePadding.x - folderMargin
589 - folderContentPaddingLeftRight * 2;
Samuel Fufa1c8d90a2019-11-12 17:54:58 -0800590 float scaleX = contentMaxWidth / contentUsedWidth;
Jon Mirandac1b23992016-12-13 08:57:36 -0800591
592 float scale = Math.min(scaleX, scaleY);
593 if (scale < 1f) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700594 updateFolderCellSize(scale, res);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700595 }
596 }
597
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700598 private void updateFolderCellSize(float scale, Resources res) {
Jon Mirandae126d722021-02-25 10:45:20 -0500599 float invIconSizeDp = isVerticalBarLayout() ? inv.landscapeIconSize : inv.iconSize;
600 folderChildIconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mInfo.metrics, scale));
601 folderChildTextSizePx = pxFromDp(inv.iconTextSize, mInfo.metrics, scale);
602 folderLabelTextSizePx = (int) (folderChildTextSizePx * folderLabelTextScale);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700603
604 int textHeight = Utilities.calculateTextHeight(folderChildTextSizePx);
605 int cellPaddingX = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_x_padding) * scale);
606 int cellPaddingY = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_y_padding) * scale);
607
Jon Mirandac1b23992016-12-13 08:57:36 -0800608 folderCellWidthPx = folderChildIconSizePx + 2 * cellPaddingX;
Jonathan Miranda9ad87462017-07-26 17:41:02 +0000609 folderCellHeightPx = folderChildIconSizePx + 2 * cellPaddingY + textHeight;
610 folderChildDrawablePaddingPx = Math.max(0,
611 (folderCellHeightPx - folderChildIconSizePx - textHeight) / 3);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700612 }
613
Winson1f064272016-07-18 17:18:02 -0700614 public void updateInsets(Rect insets) {
615 mInsets.set(insets);
Sunny Goyal07b69292018-01-08 14:19:34 -0800616 updateWorkspacePadding();
Winson1f064272016-07-18 17:18:02 -0700617 }
618
Sunny Goyalae6e3182019-04-30 12:04:37 -0700619 /**
620 * The current device insets. This is generally same as the insets being dispatched to
621 * {@link Insettable} elements, but can differ if the element is using a different profile.
622 */
Sunny Goyal1a52ef52018-01-11 10:15:03 -0800623 public Rect getInsets() {
624 return mInsets;
625 }
626
Sunny Goyal756cd262015-08-20 12:33:21 -0700627 public Point getCellSize() {
Jon Miranda6f7e9702019-09-16 14:44:14 -0700628 return getCellSize(inv.numColumns, inv.numRows);
629 }
630
631 private Point getCellSize(int numColumns, int numRows) {
Sunny Goyal756cd262015-08-20 12:33:21 -0700632 Point result = new Point();
633 // Since we are only concerned with the overall padding, layout direction does
634 // not matter.
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700635 Point padding = getTotalWorkspacePadding();
Jon Miranda18751b62017-07-31 17:25:27 -0700636 result.x = calculateCellWidth(availableWidthPx - padding.x
Jon Miranda228877d2021-02-09 11:05:00 -0500637 - cellLayoutPaddingLeftRightPx * 2, cellLayoutBorderSpacingPx, numColumns);
Jon Miranda18751b62017-07-31 17:25:27 -0700638 result.y = calculateCellHeight(availableHeightPx - padding.y
Jon Miranda228877d2021-02-09 11:05:00 -0500639 - cellLayoutBottomPaddingPx, cellLayoutBorderSpacingPx, numRows);
Sunny Goyal756cd262015-08-20 12:33:21 -0700640 return result;
641 }
642
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700643 public Point getTotalWorkspacePadding() {
Sunny Goyal07b69292018-01-08 14:19:34 -0800644 updateWorkspacePadding();
645 return new Point(workspacePadding.left + workspacePadding.right,
646 workspacePadding.top + workspacePadding.bottom);
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700647 }
648
649 /**
Sunny Goyal07b69292018-01-08 14:19:34 -0800650 * Updates {@link #workspacePadding} as a result of any internal value change to reflect the
651 * new workspace padding
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700652 */
Sunny Goyal07b69292018-01-08 14:19:34 -0800653 private void updateWorkspacePadding() {
654 Rect padding = workspacePadding;
Tony Wickham3a3517f2015-10-06 11:27:04 -0700655 if (isVerticalBarLayout()) {
Sunny Goyal228153d2018-01-04 15:35:22 -0800656 padding.top = 0;
657 padding.bottom = edgeMarginPx;
Sunny Goyal7e2e67f2018-01-26 13:40:08 -0800658 if (isSeascape()) {
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700659 padding.left = hotseatBarSizePx;
Tony Wickham5edf9e22020-03-27 20:06:52 -0700660 padding.right = hotseatBarSidePaddingStartPx;
Winson1f064272016-07-18 17:18:02 -0700661 } else {
Tony Wickham5edf9e22020-03-27 20:06:52 -0700662 padding.left = hotseatBarSidePaddingStartPx;
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700663 padding.right = hotseatBarSizePx;
Winson1f064272016-07-18 17:18:02 -0700664 }
Winson Chungb3800242013-10-24 11:01:54 -0700665 } else {
Tony Wickhama29a0462021-03-02 12:28:25 -0800666 int hotseatTop = isTaskbarPresent ? taskbarSize : hotseatBarSizePx;
667 int paddingBottom = hotseatTop + workspacePageIndicatorHeight
Jon Miranda228877d2021-02-09 11:05:00 -0500668 + workspaceBottomPadding - mWorkspacePageIndicatorOverlapWorkspace;
Sunny Goyalc6205602015-05-21 20:46:33 -0700669 if (isTablet) {
Winson Chungb3800242013-10-24 11:01:54 -0700670 // Pad the left and right of the workspace to ensure consistent spacing
671 // between all icons
Tony Wickhamd6b40372015-09-23 18:37:57 -0700672 // The amount of screen space available for left/right padding.
Sunny Goyal228153d2018-01-04 15:35:22 -0800673 int availablePaddingX = Math.max(0, widthPx - ((inv.numColumns * cellWidthPx) +
Sunny Goyalf5440cb2016-12-14 15:13:00 -0800674 ((inv.numColumns - 1) * cellWidthPx)));
Tony Wickhamd6b40372015-09-23 18:37:57 -0700675 availablePaddingX = (int) Math.min(availablePaddingX,
Sunny Goyal07b69292018-01-08 14:19:34 -0800676 widthPx * MAX_HORIZONTAL_PADDING_PERCENT);
Tony Wickhama29a0462021-03-02 12:28:25 -0800677 int hotseatVerticalPadding = isTaskbarPresent ? 0
678 : hotseatBarTopPaddingPx + hotseatBarBottomPaddingPx;
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700679 int availablePaddingY = Math.max(0, heightPx - edgeMarginPx - paddingBottom
Tony Wickhama29a0462021-03-02 12:28:25 -0800680 - (2 * inv.numRows * cellHeightPx) - hotseatVerticalPadding);
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700681 padding.set(availablePaddingX / 2, edgeMarginPx + availablePaddingY / 2,
Tony Wickhamd6b40372015-09-23 18:37:57 -0700682 availablePaddingX / 2, paddingBottom + availablePaddingY / 2);
Andras Kloczl8e57cce2021-02-11 23:51:19 +0100683
684 if (FeatureFlags.ENABLE_TWO_PANEL_HOME.get()) {
685 padding.set(0, padding.top, 0, padding.bottom);
686 }
Winson Chungb3800242013-10-24 11:01:54 -0700687 } else {
688 // Pad the top and bottom of the workspace with search/hotseat bar sizes
Winson1f064272016-07-18 17:18:02 -0700689 padding.set(desiredWorkspaceLeftRightMarginPx,
Jon Mirandae126d722021-02-25 10:45:20 -0500690 workspaceTopPadding + (isScalableGrid ? 0 : edgeMarginPx),
Winson1f064272016-07-18 17:18:02 -0700691 desiredWorkspaceLeftRightMarginPx,
Winsonfadbe8f2016-07-22 16:35:37 -0700692 paddingBottom);
Winson Chungb3800242013-10-24 11:01:54 -0700693 }
694 }
Winson Chungb3800242013-10-24 11:01:54 -0700695 }
696
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700697 public Rect getHotseatLayoutPadding() {
698 if (isVerticalBarLayout()) {
699 if (isSeascape()) {
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700700 mHotseatPadding.set(mInsets.left + hotseatBarSidePaddingStartPx,
701 mInsets.top, hotseatBarSidePaddingEndPx, mInsets.bottom);
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700702 } else {
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700703 mHotseatPadding.set(hotseatBarSidePaddingEndPx, mInsets.top,
704 mInsets.right + hotseatBarSidePaddingStartPx, mInsets.bottom);
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700705 }
706 } else {
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700707 // We want the edges of the hotseat to line up with the edges of the workspace, but the
708 // icons in the hotseat are a different size, and so don't line up perfectly. To account
709 // for this, we pad the left and right of the hotseat with half of the difference of a
710 // workspace cell vs a hotseat cell.
711 float workspaceCellWidth = (float) widthPx / inv.numColumns;
712 float hotseatCellWidth = (float) widthPx / inv.numHotseatIcons;
713 int hotseatAdjustment = Math.round((workspaceCellWidth - hotseatCellWidth) / 2);
714 mHotseatPadding.set(
Sunny Goyal786940a2020-06-02 02:31:31 -0700715 hotseatAdjustment + workspacePadding.left + cellLayoutPaddingLeftRightPx
716 + mInsets.left,
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700717 hotseatBarTopPaddingPx,
Sunny Goyal786940a2020-06-02 02:31:31 -0700718 hotseatAdjustment + workspacePadding.right + cellLayoutPaddingLeftRightPx
719 + mInsets.right,
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700720 hotseatBarBottomPaddingPx + mInsets.bottom + cellLayoutBottomPaddingPx);
721 }
722 return mHotseatPadding;
723 }
724
Winsonfadbe8f2016-07-22 16:35:37 -0700725 /**
726 * @return the bounds for which the open folders should be contained within
727 */
728 public Rect getAbsoluteOpenFolderBounds() {
729 if (isVerticalBarLayout()) {
730 // Folders should only appear right of the drop target bar and left of the hotseat
731 return new Rect(mInsets.left + dropTargetBarSizePx + edgeMarginPx,
732 mInsets.top,
Jon Miranda18751b62017-07-31 17:25:27 -0700733 mInsets.left + availableWidthPx - hotseatBarSizePx - edgeMarginPx,
Winsonfadbe8f2016-07-22 16:35:37 -0700734 mInsets.top + availableHeightPx);
735 } else {
736 // Folders should only appear below the drop target bar and above the hotseat
Tony Wickhamae72b462021-03-10 16:18:40 -0800737 int hotseatTop = isTaskbarPresent ? taskbarSize : hotseatBarSizePx;
Tony Wickhamb4b7e202018-01-12 17:39:24 -0800738 return new Rect(mInsets.left + edgeMarginPx,
Winsonfadbe8f2016-07-22 16:35:37 -0700739 mInsets.top + dropTargetBarSizePx + edgeMarginPx,
Tony Wickhamb4b7e202018-01-12 17:39:24 -0800740 mInsets.left + availableWidthPx - edgeMarginPx,
Tony Wickhamae72b462021-03-10 16:18:40 -0800741 mInsets.top + availableHeightPx - hotseatTop
Tony Wickham5edf9e22020-03-27 20:06:52 -0700742 - workspacePageIndicatorHeight - edgeMarginPx);
Winsonfadbe8f2016-07-22 16:35:37 -0700743 }
744 }
745
Jon Miranda228877d2021-02-09 11:05:00 -0500746 public static int calculateCellWidth(int width, int borderSpacing, int countX) {
747 return (width - ((countX - 1) * borderSpacing)) / countX;
Winson Chungb3800242013-10-24 11:01:54 -0700748 }
Jon Miranda228877d2021-02-09 11:05:00 -0500749 public static int calculateCellHeight(int height, int borderSpacing, int countY) {
750 return (height - ((countY - 1) * borderSpacing)) / countY;
Winson Chungb3800242013-10-24 11:01:54 -0700751 }
752
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -0700753 /**
Tony Wickham55616cd2015-09-23 14:55:17 -0700754 * When {@code true}, the device is in landscape mode and the hotseat is on the right column.
755 * When {@code false}, either device is in portrait mode or the device is in landscape mode and
756 * the hotseat is on the bottom row.
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -0700757 */
Tony Wickhamab946a12015-09-16 15:38:16 -0700758 public boolean isVerticalBarLayout() {
Winson Chungb3800242013-10-24 11:01:54 -0700759 return isLandscape && transposeLayoutWithOrientation;
760 }
761
Sunny Goyal59d086c2018-05-07 17:31:40 -0700762 /**
Jon Miranda6f7e9702019-09-16 14:44:14 -0700763 * Returns true when the number of workspace columns and all apps columns differs.
764 */
765 private boolean allAppsHasDifferentNumColumns() {
766 return inv.numAllAppsColumns != inv.numColumns;
767 }
768
769 /**
Sunny Goyal59d086c2018-05-07 17:31:40 -0700770 * Updates orientation information and returns true if it has changed from the previous value.
771 */
Winson Chung13c1c2c2019-09-06 11:46:19 -0700772 public boolean updateIsSeascape(Context context) {
Sunny Goyal59d086c2018-05-07 17:31:40 -0700773 if (isVerticalBarLayout()) {
Schneider Victor-tulias954bb632021-01-27 14:03:51 -0800774 // Check an up-to-date info.
Alex Chaud25e87a2021-02-12 12:12:56 +0000775 DisplayController.Info displayInfo = DisplayController.getDefaultDisplay(context)
776 .createInfoForContext(context);
777 if (displayInfo == null) {
778 return false;
779 }
780
781 boolean isSeascape = displayInfo.rotation == Surface.ROTATION_270;
Sunny Goyal59d086c2018-05-07 17:31:40 -0700782 if (mIsSeascape != isSeascape) {
783 mIsSeascape = isSeascape;
784 return true;
785 }
786 }
787 return false;
788 }
789
Sunny Goyal7e2e67f2018-01-26 13:40:08 -0800790 public boolean isSeascape() {
Sunny Goyal59d086c2018-05-07 17:31:40 -0700791 return isVerticalBarLayout() && mIsSeascape;
Sunny Goyal7e2e67f2018-01-26 13:40:08 -0800792 }
793
Sunny Goyal07b69292018-01-08 14:19:34 -0800794 public boolean shouldFadeAdjacentWorkspaceScreens() {
Sunny Goyalc6205602015-05-21 20:46:33 -0700795 return isVerticalBarLayout() || isLargeTablet;
Winson Chungb3800242013-10-24 11:01:54 -0700796 }
797
Sunny Goyalc13403c2016-11-18 23:44:48 -0800798 public int getCellHeight(@ContainerType int containerType) {
799 switch (containerType) {
800 case CellLayout.WORKSPACE:
801 return cellHeightPx;
802 case CellLayout.FOLDER:
803 return folderCellHeightPx;
804 case CellLayout.HOTSEAT:
805 return hotseatCellHeightPx;
806 default:
807 // ??
808 return 0;
809 }
810 }
Sunny Goyal13178ac2016-04-04 16:35:22 -0700811
Jon Miranda58561d42021-03-17 10:51:54 -0400812 private String pxToDpStr(String name, float value) {
813 return "\t" + name + ": " + value + "px (" + dpiFromPx(value, mInfo.metrics) + "dp)";
814 }
815
816 public void dump(String prefix, PrintWriter writer) {
817 writer.println(prefix + "DeviceProfile:");
818 writer.println(prefix + "\t1 dp = " + mInfo.metrics.density + " px");
819
820 writer.println(prefix + "\tisTablet:" + isTablet);
821 writer.println(prefix + "\tisLargeTablet:" + isLargeTablet);
822 writer.println(prefix + "\tisPhone:" + isPhone);
823 writer.println(prefix + "\ttransposeLayoutWithOrientation:"
824 + transposeLayoutWithOrientation);
825
826 writer.println(prefix + "\tisLandscape:" + isLandscape);
827 writer.println(prefix + "\tisMultiWindowMode:" + isMultiWindowMode);
828
829 writer.println(prefix + pxToDpStr("windowX", windowX));
830 writer.println(prefix + pxToDpStr("windowY", windowY));
831 writer.println(prefix + pxToDpStr("widthPx", widthPx));
832 writer.println(prefix + pxToDpStr("heightPx", heightPx));
833
834 writer.println(prefix + pxToDpStr("availableWidthPx", availableWidthPx));
835 writer.println(prefix + pxToDpStr("availableHeightPx", availableHeightPx));
836
837 writer.println(prefix + "\taspectRatio:" + aspectRatio);
838
839 writer.println(prefix + "\tisScalableGrid:" + isScalableGrid);
840
841 writer.println(prefix + "\tinv.minCellWidth:" + inv.minCellWidth + "dp");
842 writer.println(prefix + "\tinv.minCellHeight:" + inv.minCellHeight + "dp");
843
844 writer.println(prefix + pxToDpStr("cellWidthPx", cellWidthPx));
845 writer.println(prefix + pxToDpStr("cellHeightPx", cellHeightPx));
846
847 writer.println(prefix + pxToDpStr("getCellSize().x", getCellSize().x));
848 writer.println(prefix + pxToDpStr("getCellSize().y", getCellSize().y));
849
850 writer.println(prefix + "\tinv.iconSize:" + inv.iconSize + "dp");
851 writer.println(prefix + pxToDpStr("iconSizePx", iconSizePx));
852 writer.println(prefix + pxToDpStr("iconTextSizePx", iconTextSizePx));
853 writer.println(prefix + pxToDpStr("iconDrawablePaddingPx", iconDrawablePaddingPx));
854
855 writer.println(prefix + pxToDpStr("folderCellWidthPx", folderCellWidthPx));
856 writer.println(prefix + pxToDpStr("folderCellHeightPx", folderCellHeightPx));
857 writer.println(prefix + pxToDpStr("folderChildIconSizePx", folderChildIconSizePx));
858 writer.println(prefix + pxToDpStr("folderChildTextSizePx", folderChildTextSizePx));
859 writer.println(prefix + pxToDpStr("folderChildDrawablePaddingPx",
860 folderChildDrawablePaddingPx));
861
862 writer.println(prefix + pxToDpStr("cellLayoutBorderSpacingPx",
863 cellLayoutBorderSpacingPx));
864 writer.println(prefix + pxToDpStr("desiredWorkspaceLeftRightMarginPx",
865 desiredWorkspaceLeftRightMarginPx));
866
867 writer.println(prefix + pxToDpStr("allAppsIconSizePx", allAppsIconSizePx));
868 writer.println(prefix + pxToDpStr("allAppsIconTextSizePx", allAppsIconTextSizePx));
869 writer.println(prefix + pxToDpStr("allAppsIconDrawablePaddingPx",
870 allAppsIconDrawablePaddingPx));
871 writer.println(prefix + pxToDpStr("allAppsCellHeightPx", allAppsCellHeightPx));
872
873 writer.println(prefix + pxToDpStr("hotseatBarSizePx", hotseatBarSizePx));
874 writer.println(prefix + pxToDpStr("hotseatCellHeightPx", hotseatCellHeightPx));
875 writer.println(prefix + pxToDpStr("hotseatBarTopPaddingPx", hotseatBarTopPaddingPx));
876 writer.println(prefix + pxToDpStr("hotseatBarBottomPaddingPx", hotseatBarBottomPaddingPx));
877 writer.println(prefix + pxToDpStr("hotseatBarSidePaddingStartPx",
878 hotseatBarSidePaddingStartPx));
879 writer.println(prefix + pxToDpStr("hotseatBarSidePaddingEndPx",
880 hotseatBarSidePaddingEndPx));
881
882 writer.println(prefix + "\tisTaskbarPresent:" + isTaskbarPresent);
883
884 writer.println(prefix + pxToDpStr("taskbarSize", taskbarSize));
885 writer.println(prefix + pxToDpStr("nonOverlappingTaskbarInset",
886 nonOverlappingTaskbarInset));
887
888 writer.println(prefix + pxToDpStr("workspacePadding.left", workspacePadding.left));
889 writer.println(prefix + pxToDpStr("workspacePadding.top", workspacePadding.top));
890 writer.println(prefix + pxToDpStr("workspacePadding.right", workspacePadding.right));
891 writer.println(prefix + pxToDpStr("workspacePadding.bottom", workspacePadding.bottom));
892
893 writer.println(prefix + pxToDpStr("extraSpace", extraSpace));
894 writer.println(prefix + pxToDpStr("workspaceTopPadding", workspaceTopPadding));
895 writer.println(prefix + pxToDpStr("workspaceBottomPadding", workspaceBottomPadding));
896 writer.println(prefix + pxToDpStr("extraHotseatBottomPadding", extraHotseatBottomPadding));
897 }
898
Sunny Goyalfd58da62020-08-11 12:06:49 -0700899 private static Context getContext(Context c, Info info, int orientation) {
Sunny Goyal1890f672020-04-30 12:28:00 -0700900 Configuration config = new Configuration(c.getResources().getConfiguration());
901 config.orientation = orientation;
902 config.densityDpi = info.metrics.densityDpi;
903 return c.createConfigurationContext(config);
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700904 }
Sunny Goyalfde55052018-02-01 14:46:13 -0800905
906 /**
907 * Callback when a component changes the DeviceProfile associated with it, as a result of
908 * configuration change
909 */
910 public interface OnDeviceProfileChangeListener {
911
912 /**
913 * Called when the device profile is reassigned. Note that for layout and measurements, it
914 * is sufficient to listen for inset changes. Use this callback when you need to perform
915 * a one time operation.
916 */
917 void onDeviceProfileChanged(DeviceProfile dp);
918 }
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700919
920 public static class Builder {
921 private Context mContext;
922 private InvariantDeviceProfile mInv;
Sunny Goyalfd58da62020-08-11 12:06:49 -0700923 private Info mInfo;
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700924
Sunny Goyal0addbf02020-04-28 14:17:35 -0700925 private final Point mWindowPosition = new Point();
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700926 private Point mMinSize, mMaxSize;
927 private int mWidth, mHeight;
928
929 private boolean mIsLandscape;
930 private boolean mIsMultiWindowMode = false;
931 private boolean mTransposeLayoutWithOrientation;
932
Sunny Goyalfd58da62020-08-11 12:06:49 -0700933 public Builder(Context context, InvariantDeviceProfile inv, Info info) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700934 mContext = context;
935 mInv = inv;
936 mInfo = info;
937 mTransposeLayoutWithOrientation = context.getResources()
938 .getBoolean(R.bool.hotseat_transpose_layout_with_orientation);
939 }
940
941 public Builder setSizeRange(Point minSize, Point maxSize) {
942 mMinSize = minSize;
943 mMaxSize = maxSize;
944 return this;
945 }
946
947 public Builder setSize(int width, int height) {
948 mWidth = width;
949 mHeight = height;
950 mIsLandscape = mWidth > mHeight;
951 return this;
952 }
953
954 public Builder setMultiWindowMode(boolean isMultiWindowMode) {
955 mIsMultiWindowMode = isMultiWindowMode;
956 return this;
957 }
958
Sunny Goyal0addbf02020-04-28 14:17:35 -0700959 /**
960 * Sets the window position if not full-screen
961 */
962 public Builder setWindowPosition(int x, int y) {
963 mWindowPosition.set(x, y);
964 return this;
965 }
966
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700967 public Builder setTransposeLayoutWithOrientation(boolean transposeLayoutWithOrientation) {
968 mTransposeLayoutWithOrientation = transposeLayoutWithOrientation;
969 return this;
970 }
971
972 public DeviceProfile build() {
973 return new DeviceProfile(mContext, mInv, mInfo, mMinSize, mMaxSize,
974 mWidth, mHeight, mIsLandscape, mIsMultiWindowMode,
Sunny Goyal0addbf02020-04-28 14:17:35 -0700975 mTransposeLayoutWithOrientation, mWindowPosition);
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700976 }
977 }
978
Winson Chungb3800242013-10-24 11:01:54 -0700979}