blob: aea38a054b4e197d254745558e02de521a1a7b60 [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
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400107 public float iconScale;
Sunny Goyalc6205602015-05-21 20:46:33 -0700108 public int iconSizePx;
109 public int iconTextSizePx;
110 public int iconDrawablePaddingPx;
Winson Chung5f4e0fd2015-05-22 11:12:27 -0700111 public int iconDrawablePaddingOriginalPx;
Winson Chungb3800242013-10-24 11:01:54 -0700112
Adam Cohen59400422014-03-05 18:07:04 -0800113 public int cellWidthPx;
114 public int cellHeightPx;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700115 public int workspaceCellPaddingXPx;
Adam Cohen59400422014-03-05 18:07:04 -0800116
Jon Mirandae126d722021-02-25 10:45:20 -0500117 public int cellYPaddingPx;
Jon Mirandae126d722021-02-25 10:45:20 -0500118
Sunny Goyalc6205602015-05-21 20:46:33 -0700119 // Folder
Jon Mirandae126d722021-02-25 10:45:20 -0500120 public float folderLabelTextScale;
121 public int folderLabelTextSizePx;
Sunny Goyalc6205602015-05-21 20:46:33 -0700122 public int folderIconSizePx;
Jon Miranda591e3602018-03-28 11:37:00 -0700123 public int folderIconOffsetYPx;
Jon Mirandabf7d8122016-11-03 15:29:29 -0700124
Jon Mirandae126d722021-02-25 10:45:20 -0500125 // Folder content
Jon Miranda823da222021-03-23 08:08:45 -0400126 public int folderCellLayoutBorderSpacingPx;
Jon Mirandae126d722021-02-25 10:45:20 -0500127 public int folderContentPaddingLeftRight;
128 public int folderContentPaddingTop;
129
Jon Mirandabf7d8122016-11-03 15:29:29 -0700130 // Folder cell
Sunny Goyalc6205602015-05-21 20:46:33 -0700131 public int folderCellWidthPx;
132 public int folderCellHeightPx;
Jon Mirandabf7d8122016-11-03 15:29:29 -0700133
134 // Folder child
135 public int folderChildIconSizePx;
136 public int folderChildTextSizePx;
Sunny Goyalbaec6ff2016-09-14 11:26:21 -0700137 public int folderChildDrawablePaddingPx;
Winson Chungb3800242013-10-24 11:01:54 -0700138
Sunny Goyalc6205602015-05-21 20:46:33 -0700139 // Hotseat
Sunny Goyalc6205602015-05-21 20:46:33 -0700140 public int hotseatCellHeightPx;
Jon Miranda18751b62017-07-31 17:25:27 -0700141 // In portrait: size = height, in landscape: size = width
142 public int hotseatBarSizePx;
Sunny Goyal07b69292018-01-08 14:19:34 -0800143 public final int hotseatBarTopPaddingPx;
Jon Miranda7e183c32018-06-20 11:05:27 -0700144 public int hotseatBarBottomPaddingPx;
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700145 // Start is the side next to the nav bar, end is the side next to the workspace
146 public final int hotseatBarSidePaddingStartPx;
147 public final int hotseatBarSidePaddingEndPx;
Adam Cohen2e6da152015-05-06 11:42:25 -0700148
Sunny Goyalc6205602015-05-21 20:46:33 -0700149 // All apps
Samuel Fufaee9aff92021-04-05 13:30:40 -0500150 public int allAppsOpenVerticalTranslate;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700151 public int allAppsCellHeightPx;
Samuel Fufaf1424a32019-10-04 15:15:19 -0700152 public int allAppsCellWidthPx;
Winson1f064272016-07-18 17:18:02 -0700153 public int allAppsIconSizePx;
154 public int allAppsIconDrawablePaddingPx;
155 public float allAppsIconTextSizePx;
156
Zak Cohen334efeb2021-03-19 16:42:07 -0700157 // Overview
Zak Cohen334efeb2021-03-19 16:42:07 -0700158 public int overviewTaskMarginPx;
Alex Chaudedbc8a2021-03-17 16:53:26 +0000159 public int overviewTaskIconSizePx;
160 public int overviewTaskThumbnailTopMarginPx;
Zak Cohen334efeb2021-03-19 16:42:07 -0700161
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800162 // Widgets
163 public final PointF appWidgetScale = new PointF(1.0f, 1.0f);
164
Sunny Goyal47328fd2016-05-25 18:56:41 -0700165 // Drop Target
166 public int dropTargetBarSizePx;
Adam Cohen4ae96ce2014-08-29 15:05:48 -0700167
Winson1f064272016-07-18 17:18:02 -0700168 // Insets
Sunny Goyal07b69292018-01-08 14:19:34 -0800169 private final Rect mInsets = new Rect();
170 public final Rect workspacePadding = new Rect();
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700171 private final Rect mHotseatPadding = new Rect();
Jon Miranda0bd63d12019-03-06 17:29:29 -0800172 // When true, nav bar is on the left side of the screen.
Sunny Goyal59d086c2018-05-07 17:31:40 -0700173 private boolean mIsSeascape;
Winson1f064272016-07-18 17:18:02 -0700174
Tony Wickhamf34bee82018-12-03 18:11:39 -0800175 // Notification dots
Samuel Fufac96fa242019-09-26 23:06:32 -0700176 public DotRenderer mDotRendererWorkSpace;
177 public DotRenderer mDotRendererAllApps;
Tony Wickham9a8d11f2017-01-11 09:53:12 -0800178
Tony Wickham15883892021-02-12 11:24:40 -0800179 // Taskbar
180 public boolean isTaskbarPresent;
181 public int taskbarSize;
Tony Wickham145b7fd2021-03-11 10:03:12 -0800182 // How much of the bottom inset is due to Taskbar rather than other system elements.
183 public int nonOverlappingTaskbarInset;
Tony Wickham15883892021-02-12 11:24:40 -0800184
Sunny Goyalfd58da62020-08-11 12:06:49 -0700185 DeviceProfile(Context context, InvariantDeviceProfile inv, Info info,
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700186 Point minSize, Point maxSize, int width, int height, boolean isLandscape,
Sunny Goyal0addbf02020-04-28 14:17:35 -0700187 boolean isMultiWindowMode, boolean transposeLayoutWithOrientation,
188 Point windowPosition) {
Sunny Goyalfee35bb2015-05-11 11:38:19 -0700189
Adam Cohen2e6da152015-05-06 11:42:25 -0700190 this.inv = inv;
Sunny Goyalc6205602015-05-21 20:46:33 -0700191 this.isLandscape = isLandscape;
Sunny Goyald70e75a2018-02-22 10:07:32 -0800192 this.isMultiWindowMode = isMultiWindowMode;
Jon Mirandae126d722021-02-25 10:45:20 -0500193 this.transposeLayoutWithOrientation = transposeLayoutWithOrientation;
Sunny Goyal0addbf02020-04-28 14:17:35 -0700194 windowX = windowPosition.x;
195 windowY = windowPosition.y;
Winson Chungb3800242013-10-24 11:01:54 -0700196
Jon Mirandae126d722021-02-25 10:45:20 -0500197 isScalableGrid = inv.isScalable && !isVerticalBarLayout() && !isMultiWindowMode;
198
Jon Miranda7e183c32018-06-20 11:05:27 -0700199 // Determine sizes.
200 widthPx = width;
201 heightPx = height;
Tony Wickham15883892021-02-12 11:24:40 -0800202 int nonFinalAvailableHeightPx;
Jon Miranda7e183c32018-06-20 11:05:27 -0700203 if (isLandscape) {
204 availableWidthPx = maxSize.x;
Tony Wickham15883892021-02-12 11:24:40 -0800205 nonFinalAvailableHeightPx = minSize.y;
Jon Miranda7e183c32018-06-20 11:05:27 -0700206 } else {
207 availableWidthPx = minSize.x;
Tony Wickham15883892021-02-12 11:24:40 -0800208 nonFinalAvailableHeightPx = maxSize.y;
Jon Miranda7e183c32018-06-20 11:05:27 -0700209 }
210
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700211 mInfo = info;
Adam Cohen2e6da152015-05-06 11:42:25 -0700212
Sunny Goyalc6205602015-05-21 20:46:33 -0700213 // Constants from resources
Jon Miranda58561d42021-03-17 10:51:54 -0400214 float swDPs = dpiFromPx(Math.min(info.smallestSize.x, info.smallestSize.y), info.metrics);
Alex Chau4e2c25a2021-02-03 16:20:04 +0000215 boolean allowRotation = context.getResources().getBoolean(R.bool.allow_rotation);
216 // Tablet UI is built with assumption that simulated landscape is disabled.
217 isTablet = allowRotation && swDPs >= TABLET_MIN_DPS;
218 isLargeTablet = isTablet && swDPs >= LARGE_TABLET_MIN_DPS;
Sunny Goyalc6205602015-05-21 20:46:33 -0700219 isPhone = !isTablet && !isLargeTablet;
Jon Mirandabba64512019-03-27 10:54:17 -0700220 aspectRatio = ((float) Math.max(widthPx, heightPx)) / Math.min(widthPx, heightPx);
Jon Miranda7e183c32018-06-20 11:05:27 -0700221 boolean isTallDevice = Float.compare(aspectRatio, TALL_DEVICE_ASPECT_RATIO_THRESHOLD) >= 0;
Sunny Goyalc6205602015-05-21 20:46:33 -0700222
223 // Some more constants
Sunny Goyal1890f672020-04-30 12:28:00 -0700224 context = getContext(context, info, isVerticalBarLayout()
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700225 ? Configuration.ORIENTATION_LANDSCAPE
226 : Configuration.ORIENTATION_PORTRAIT);
Sunny Goyal1890f672020-04-30 12:28:00 -0700227 final Resources res = context.getResources();
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700228
Tony Wickham15883892021-02-12 11:24:40 -0800229 isTaskbarPresent = isTablet && FeatureFlags.ENABLE_TASKBAR.get();
230 if (isTaskbarPresent) {
231 // Taskbar will be added later, but provides bottom insets that we should subtract
232 // from availableHeightPx.
233 taskbarSize = res.getDimensionPixelSize(R.dimen.taskbar_size);
234 WindowInsets windowInsets = DisplayController.INSTANCE.get(context).getHolder(mInfo.id)
235 .getDisplayContext().getSystemService(WindowManager.class)
236 .getCurrentWindowMetrics().getWindowInsets();
Tony Wickham145b7fd2021-03-11 10:03:12 -0800237 nonOverlappingTaskbarInset =
Tony Wickham15883892021-02-12 11:24:40 -0800238 taskbarSize - windowInsets.getSystemWindowInsetBottom();
239 if (nonOverlappingTaskbarInset > 0) {
240 nonFinalAvailableHeightPx -= nonOverlappingTaskbarInset;
241 }
242 }
243 availableHeightPx = nonFinalAvailableHeightPx;
244
Winson Chungb3800242013-10-24 11:01:54 -0700245 edgeMarginPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_edge_margin);
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700246
Jon Mirandae126d722021-02-25 10:45:20 -0500247 desiredWorkspaceLeftRightMarginPx = isVerticalBarLayout() ? 0 : isScalableGrid
248 ? res.getDimensionPixelSize(R.dimen.scalable_grid_left_right_margin)
249 : res.getDimensionPixelSize(R.dimen.dynamic_grid_left_right_margin);
250 desiredWorkspaceLeftRightOriginalPx = desiredWorkspaceLeftRightMarginPx;
251
Samuel Fufaee9aff92021-04-05 13:30:40 -0500252
253 allAppsOpenVerticalTranslate = res.getDimensionPixelSize(
254 R.dimen.all_apps_open_vertical_translate);
255
Jon Mirandae126d722021-02-25 10:45:20 -0500256 folderLabelTextScale = res.getFloat(R.dimen.folder_label_text_scale);
257 folderContentPaddingLeftRight =
258 res.getDimensionPixelSize(R.dimen.folder_content_padding_left_right);
259 folderContentPaddingTop = res.getDimensionPixelSize(R.dimen.folder_content_padding_top);
260
261 setCellLayoutBorderSpacing(pxFromDp(inv.borderSpacing, mInfo.metrics, 1f));
262 cellLayoutBorderSpacingOriginalPx = cellLayoutBorderSpacingPx;
Jon Miranda823da222021-03-23 08:08:45 -0400263 folderCellLayoutBorderSpacingPx = cellLayoutBorderSpacingPx;
Jon Mirandae126d722021-02-25 10:45:20 -0500264
Jon Miranda5eacbb72018-07-31 11:14:46 -0700265 int cellLayoutPaddingLeftRightMultiplier = !isVerticalBarLayout() && isTablet
266 ? PORTRAIT_TABLET_LEFT_RIGHT_PADDING_MULTIPLIER : 1;
Jon Mirandae126d722021-02-25 10:45:20 -0500267 int cellLayoutPadding = isScalableGrid
268 ? 0
269 : res.getDimensionPixelSize(R.dimen.dynamic_grid_cell_layout_padding);
Andras Kloczl8e57cce2021-02-11 23:51:19 +0100270
271 if (FeatureFlags.ENABLE_TWO_PANEL_HOME.get() && isTablet) {
272 cellLayoutPaddingLeftRightPx =
273 res.getDimensionPixelSize(R.dimen.two_panel_home_side_padding);
274 cellLayoutBottomPaddingPx = 0;
275 } else if (isLandscape) {
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700276 cellLayoutPaddingLeftRightPx = 0;
277 cellLayoutBottomPaddingPx = cellLayoutPadding;
278 } else {
279 cellLayoutPaddingLeftRightPx = cellLayoutPaddingLeftRightMultiplier * cellLayoutPadding;
280 cellLayoutBottomPaddingPx = 0;
281 }
282
Tony Wickham5edf9e22020-03-27 20:06:52 -0700283 workspacePageIndicatorHeight = res.getDimensionPixelSize(
284 R.dimen.workspace_page_indicator_height);
285 mWorkspacePageIndicatorOverlapWorkspace =
286 res.getDimensionPixelSize(R.dimen.workspace_page_indicator_overlap_workspace);
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700287
Winson Chungb3800242013-10-24 11:01:54 -0700288 iconDrawablePaddingOriginalPx =
289 res.getDimensionPixelSize(R.dimen.dynamic_grid_icon_drawable_padding);
Sunny Goyal47328fd2016-05-25 18:56:41 -0700290 dropTargetBarSizePx = res.getDimensionPixelSize(R.dimen.dynamic_grid_drop_target_size);
291 workspaceSpringLoadedBottomSpace =
292 res.getDimensionPixelSize(R.dimen.dynamic_grid_min_spring_loaded_space);
Sunny Goyald5190522017-04-24 03:06:54 -0700293
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700294 workspaceCellPaddingXPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_cell_padding_x);
Jon Miranda09660722017-06-14 14:20:14 -0700295
Winson1f064272016-07-18 17:18:02 -0700296 hotseatBarTopPaddingPx =
297 res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_top_padding);
Jon Miranda7e183c32018-06-20 11:05:27 -0700298 hotseatBarBottomPaddingPx = (isTallDevice ? 0
299 : res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_bottom_non_tall_padding))
300 + res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_bottom_padding);
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700301 hotseatBarSidePaddingEndPx =
Sunny Goyal228153d2018-01-04 15:35:22 -0800302 res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_side_padding);
Jon Miranda3f411e72019-05-16 17:15:16 -0700303 // Add a bit of space between nav bar and hotseat in vertical bar layout.
Tony Wickham5edf9e22020-03-27 20:06:52 -0700304 hotseatBarSidePaddingStartPx = isVerticalBarLayout() ? workspacePageIndicatorHeight : 0;
Jon Miranda228877d2021-02-09 11:05:00 -0500305 int hotseatExtraVerticalSize =
306 res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_extra_vertical_size);
Jon Mirandae126d722021-02-25 10:45:20 -0500307 hotseatBarSizePx = pxFromDp(inv.iconSize, mInfo.metrics, 1f)
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700308 + (isVerticalBarLayout()
Sunny Goyal415f1732018-11-29 10:33:47 -0800309 ? (hotseatBarSidePaddingStartPx + hotseatBarSidePaddingEndPx)
Jon Miranda228877d2021-02-09 11:05:00 -0500310 : (hotseatBarTopPaddingPx + hotseatBarBottomPaddingPx
Jon Mirandae126d722021-02-25 10:45:20 -0500311 + (isScalableGrid ? 0 : hotseatExtraVerticalSize)));
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700312
Zak Cohen334efeb2021-03-19 16:42:07 -0700313 overviewTaskMarginPx = res.getDimensionPixelSize(R.dimen.overview_task_margin);
Alex Chaudedbc8a2021-03-17 16:53:26 +0000314 overviewTaskIconSizePx =
315 isTablet && FeatureFlags.ENABLE_OVERVIEW_GRID.get() ? res.getDimensionPixelSize(
316 R.dimen.task_thumbnail_icon_size_grid) : res.getDimensionPixelSize(
317 R.dimen.task_thumbnail_icon_size);
318 overviewTaskThumbnailTopMarginPx = overviewTaskIconSizePx + overviewTaskMarginPx * 2;
Zak Cohen334efeb2021-03-19 16:42:07 -0700319
Jon Miranda2ed276e2017-06-29 11:36:34 -0700320 // Calculate all of the remaining variables.
Jon Miranda58561d42021-03-17 10:51:54 -0400321 extraSpace = updateAvailableDimensions(res);
Jon Miranda2ed276e2017-06-29 11:36:34 -0700322 // Now that we have all of the variables calculated, we can tune certain sizes.
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400323 if (isScalableGrid && inv.devicePaddings != null) {
324 // Paddings were created assuming no scaling, so we first unscale the extra space.
325 int unscaledExtraSpace = (int) (extraSpace / iconScale);
326 DevicePadding padding = inv.devicePaddings.getDevicePadding(unscaledExtraSpace);
Jon Miranda228877d2021-02-09 11:05:00 -0500327
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400328 int paddingWorkspaceTop = padding.getWorkspaceTopPadding(unscaledExtraSpace);
329 int paddingWorkspaceBottom = padding.getWorkspaceBottomPadding(unscaledExtraSpace);
330 int paddingHotseatBottom = padding.getHotseatBottomPadding(unscaledExtraSpace);
331
332 workspaceTopPadding = Math.round(paddingWorkspaceTop * iconScale);
333 workspaceBottomPadding = Math.round(paddingWorkspaceBottom * iconScale);
334 extraHotseatBottomPadding = Math.round(paddingHotseatBottom * iconScale);
335
Jon Miranda58561d42021-03-17 10:51:54 -0400336 hotseatBarSizePx += extraHotseatBottomPadding;
337 hotseatBarBottomPaddingPx += extraHotseatBottomPadding;
Jon Miranda228877d2021-02-09 11:05:00 -0500338 } else if (!isVerticalBarLayout() && isPhone && isTallDevice) {
Jon Miranda3f9bab22017-07-28 14:50:17 -0700339 // We increase the hotseat size when there is extra space.
Jon Miranda2ed276e2017-06-29 11:36:34 -0700340 // ie. For a display with a large aspect ratio, we can keep the icons on the workspace
Jon Miranda3f9bab22017-07-28 14:50:17 -0700341 // in portrait mode closer together by adding more height to the hotseat.
Jon Miranda30d0aa22017-07-25 15:55:29 -0700342 // Note: This calculation was created after noticing a pattern in the design spec.
Jon Miranda58561d42021-03-17 10:51:54 -0400343 int extraSpace = getCellSize().y - iconSizePx - iconDrawablePaddingPx * 2
Tony Wickham5edf9e22020-03-27 20:06:52 -0700344 - workspacePageIndicatorHeight;
Jon Miranda7e183c32018-06-20 11:05:27 -0700345 hotseatBarSizePx += extraSpace;
346 hotseatBarBottomPaddingPx += extraSpace;
Jon Miranda30d0aa22017-07-25 15:55:29 -0700347
Jon Miranda3f9bab22017-07-28 14:50:17 -0700348 // Recalculate the available dimensions using the new hotseat size.
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700349 updateAvailableDimensions(res);
Jon Miranda2ed276e2017-06-29 11:36:34 -0700350 }
Sunny Goyal07b69292018-01-08 14:19:34 -0800351 updateWorkspacePadding();
Tony Wickham1237df02017-02-24 08:59:36 -0800352
353 // This is done last, after iconSizePx is calculated above.
Samuel Fufac96fa242019-09-26 23:06:32 -0700354 mDotRendererWorkSpace = new DotRenderer(iconSizePx, IconShape.getShapePath(),
Tony Wickhame1cb93f2019-05-03 11:27:32 -0700355 IconShape.DEFAULT_PATH_SIZE);
Samuel Fufac96fa242019-09-26 23:06:32 -0700356 mDotRendererAllApps = iconSizePx == allAppsIconSizePx ? mDotRendererWorkSpace :
357 new DotRenderer(allAppsIconSizePx, IconShape.getShapePath(),
358 IconShape.DEFAULT_PATH_SIZE);
Adam Cohen63f1ec02014-08-12 09:23:13 -0700359 }
360
Jon Mirandae126d722021-02-25 10:45:20 -0500361 private void setCellLayoutBorderSpacing(int borderSpacing) {
Jon Miranda823da222021-03-23 08:08:45 -0400362 cellLayoutBorderSpacingPx = isScalableGrid ? borderSpacing : 0;
Jon Mirandae126d722021-02-25 10:45:20 -0500363 }
364
Jon Miranda611dba42021-03-02 14:12:13 -0500365 /**
366 * We inset the widget padding added by the system and instead rely on the border spacing
367 * between cells to create reliable consistency between widgets
368 */
369 public boolean shouldInsetWidgets() {
370 Rect widgetPadding = inv.defaultWidgetPadding;
371
372 // Check all sides to ensure that the widget won't overlap into another cell.
373 return cellLayoutBorderSpacingPx > widgetPadding.left
374 && cellLayoutBorderSpacingPx > widgetPadding.top
375 && cellLayoutBorderSpacingPx > widgetPadding.right
376 && cellLayoutBorderSpacingPx > widgetPadding.bottom;
377 }
Jon Mirandae126d722021-02-25 10:45:20 -0500378
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700379 public Builder toBuilder(Context context) {
Sunny Goyal1a52ef52018-01-11 10:15:03 -0800380 Point size = new Point(availableWidthPx, availableHeightPx);
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700381 return new Builder(context, inv, mInfo)
382 .setSizeRange(size, size)
383 .setSize(widthPx, heightPx)
Sunny Goyal0addbf02020-04-28 14:17:35 -0700384 .setWindowPosition(windowX, windowY)
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700385 .setMultiWindowMode(isMultiWindowMode);
Sunny Goyal1a52ef52018-01-11 10:15:03 -0800386 }
387
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700388 public DeviceProfile copy(Context context) {
389 return toBuilder(context).build();
390 }
391
392 /**
393 * TODO: Move this to the builder as part of setMultiWindowMode
394 */
Sunny Goyalb46703d2020-05-27 17:52:03 -0700395 public DeviceProfile getMultiWindowProfile(Context context, WindowBounds windowBounds) {
Jon Mirandaa11380d2017-08-24 11:30:03 -0700396 // We take the minimum sizes of this profile and it's multi-window variant to ensure that
397 // the system decor is always excluded.
Sunny Goyalb46703d2020-05-27 17:52:03 -0700398 Point mwSize = new Point(Math.min(availableWidthPx, windowBounds.availableSize.x),
399 Math.min(availableHeightPx, windowBounds.availableSize.y));
Jon Mirandaa11380d2017-08-24 11:30:03 -0700400
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700401 DeviceProfile profile = toBuilder(context)
402 .setSizeRange(mwSize, mwSize)
Sunny Goyalb46703d2020-05-27 17:52:03 -0700403 .setSize(windowBounds.bounds.width(), windowBounds.bounds.height())
404 .setWindowPosition(windowBounds.bounds.left, windowBounds.bounds.top)
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700405 .setMultiWindowMode(true)
406 .build();
Jon Miranda93e1f042016-11-11 14:13:04 -0800407
Jon Miranda941375e2021-03-31 13:10:45 -0400408 profile.hideWorkspaceLabelsIfNotEnoughSpace();
Jon Miranda93e1f042016-11-11 14:13:04 -0800409
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800410 // We use these scales to measure and layout the widgets using their full invariant profile
411 // sizes and then draw them scaled and centered to fit in their multi-window mode cellspans.
412 float appWidgetScaleX = (float) profile.getCellSize().x / getCellSize().x;
413 float appWidgetScaleY = (float) profile.getCellSize().y / getCellSize().y;
414 profile.appWidgetScale.set(appWidgetScaleX, appWidgetScaleY);
Sunny Goyal07b69292018-01-08 14:19:34 -0800415 profile.updateWorkspacePadding();
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800416
Jon Miranda93e1f042016-11-11 14:13:04 -0800417 return profile;
Jon Mirandacc42c5b2016-10-27 17:15:27 -0700418 }
419
Adam Cohen63f1ec02014-08-12 09:23:13 -0700420 /**
Sunny Goyalb46703d2020-05-27 17:52:03 -0700421 * Inverse of {@link #getMultiWindowProfile(Context, WindowBounds)}
Sunny Goyal2e2e2b42018-02-27 16:52:55 -0800422 * @return device profile corresponding to the current orientation in non multi-window mode.
423 */
424 public DeviceProfile getFullScreenProfile() {
425 return isLandscape ? inv.landscapeProfile : inv.portraitProfile;
426 }
427
428 /**
Jon Miranda941375e2021-03-31 13:10:45 -0400429 * Checks if there is enough space for labels on the workspace.
430 * If there is not, labels on the Workspace are hidden.
Jon Miranda1091e532017-07-21 13:31:50 -0700431 * It is important to call this method after the All Apps variables have been set.
432 */
Jon Miranda941375e2021-03-31 13:10:45 -0400433 private void hideWorkspaceLabelsIfNotEnoughSpace() {
434 float iconTextHeight = Utilities.calculateTextHeight(iconTextSizePx);
435 float workspaceCellPaddingY = getCellSize().y - iconSizePx - iconDrawablePaddingPx
436 - iconTextHeight;
437
438 // We want enough space so that the text is closer to its corresponding icon.
439 if (workspaceCellPaddingY < iconTextHeight) {
440 iconTextSizePx = 0;
441 iconDrawablePaddingPx = 0;
442 cellHeightPx = iconSizePx;
443 autoResizeAllAppsCells();
444 }
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700445 }
Jon Miranda1091e532017-07-21 13:31:50 -0700446
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700447 /**
448 * Re-computes the all-apps cell size to be independent of workspace
449 */
450 public void autoResizeAllAppsCells() {
Jon Miranda941375e2021-03-31 13:10:45 -0400451 int textHeight = Utilities.calculateTextHeight(allAppsIconTextSizePx);
452 int topBottomPadding = textHeight;
Jon Miranda1091e532017-07-21 13:31:50 -0700453 allAppsCellHeightPx = allAppsIconSizePx + allAppsIconDrawablePaddingPx
Jon Miranda941375e2021-03-31 13:10:45 -0400454 + textHeight + (topBottomPadding * 2);
Jon Miranda1091e532017-07-21 13:31:50 -0700455 }
456
Jon Miranda228877d2021-02-09 11:05:00 -0500457 /**
458 * Returns the amount of extra (or unused) vertical space.
459 */
460 private int updateAvailableDimensions(Resources res) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700461 updateIconSize(1f, res);
Winson Chung59a488a2013-12-10 12:32:14 -0800462
Jon Mirandae126d722021-02-25 10:45:20 -0500463 Point workspacePadding = getTotalWorkspacePadding();
464
465 // Check to see if the icons fit within the available height.
466 float usedHeight = getCellLayoutHeight();
467 final int maxHeight = availableHeightPx - workspacePadding.y;
Jon Miranda228877d2021-02-09 11:05:00 -0500468 float extraHeight = Math.max(0, maxHeight - usedHeight);
Jon Mirandae126d722021-02-25 10:45:20 -0500469 float scaleY = maxHeight / usedHeight;
470 boolean shouldScale = scaleY < 1f;
471
472 float scaleX = 1f;
473 if (isScalableGrid) {
474 // We scale to fit the cellWidth and cellHeight in the available space.
475 // The benefit of scalable grids is that we can get consistent aspect ratios between
476 // devices.
477 float usedWidth = (cellWidthPx * inv.numColumns)
478 + (cellLayoutBorderSpacingPx * (inv.numColumns - 1))
479 + (desiredWorkspaceLeftRightMarginPx * 2);
480 // We do not subtract padding here, as we also scale the workspace padding if needed.
481 scaleX = availableWidthPx / usedWidth;
482 shouldScale = true;
Winson Chungb3800242013-10-24 11:01:54 -0700483 }
Jon Mirandae126d722021-02-25 10:45:20 -0500484
485 if (shouldScale) {
486 float scale = Math.min(scaleX, scaleY);
487 updateIconSize(scale, res);
488 extraHeight = Math.max(0, maxHeight - getCellLayoutHeight());
489 }
490
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700491 updateAvailableFolderCellDimensions(res);
Jon Miranda228877d2021-02-09 11:05:00 -0500492 return Math.round(extraHeight);
Winson Chungb3800242013-10-24 11:01:54 -0700493 }
494
Jon Mirandae126d722021-02-25 10:45:20 -0500495 private int getCellLayoutHeight() {
496 return (cellHeightPx * inv.numRows) + (cellLayoutBorderSpacingPx * (inv.numRows - 1));
497 }
498
Jon Miranda6f7e9702019-09-16 14:44:14 -0700499 /**
500 * Updating the iconSize affects many aspects of the launcher layout, such as: iconSizePx,
501 * iconTextSizePx, iconDrawablePaddingPx, cellWidth/Height, allApps* variants,
502 * hotseat sizes, workspaceSpringLoadedShrinkFactor, folderIconSizePx, and folderIconOffsetYPx.
503 */
Tony Wickham7ba547c2021-02-02 17:12:08 -0800504 public void updateIconSize(float scale, Resources res) {
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400505 iconScale = scale;
506
Jon Miranda18751b62017-07-31 17:25:27 -0700507 // Workspace
Sunny Goyal07b69292018-01-08 14:19:34 -0800508 final boolean isVerticalLayout = isVerticalBarLayout();
Jon Miranda6f7e9702019-09-16 14:44:14 -0700509 float invIconSizeDp = isVerticalLayout ? inv.landscapeIconSize : inv.iconSize;
Jon Mirandae126d722021-02-25 10:45:20 -0500510 iconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mInfo.metrics, scale));
Jon Miranda378c11f2021-03-10 10:28:50 -0500511 iconTextSizePx = (int) (Utilities.pxFromSp(inv.iconTextSize, mInfo.metrics) * scale);
Jon Miranda09660722017-06-14 14:20:14 -0700512 iconDrawablePaddingPx = (int) (iconDrawablePaddingOriginalPx * scale);
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700513
Jon Mirandae126d722021-02-25 10:45:20 -0500514 setCellLayoutBorderSpacing((int) (cellLayoutBorderSpacingOriginalPx * scale));
515
516 if (isScalableGrid) {
517 cellWidthPx = pxFromDp(inv.minCellWidth, mInfo.metrics, scale);
518 cellHeightPx = pxFromDp(inv.minCellHeight, mInfo.metrics, scale);
519 int cellContentHeight = iconSizePx + iconDrawablePaddingPx
520 + Utilities.calculateTextHeight(iconTextSizePx);
521 cellYPaddingPx = Math.max(0, cellHeightPx - cellContentHeight) / 2;
522 desiredWorkspaceLeftRightMarginPx = (int) (desiredWorkspaceLeftRightOriginalPx * scale);
Jon Miranda228877d2021-02-09 11:05:00 -0500523 } else {
Jon Mirandae126d722021-02-25 10:45:20 -0500524 cellWidthPx = iconSizePx + iconDrawablePaddingPx;
Jon Miranda228877d2021-02-09 11:05:00 -0500525 cellHeightPx = iconSizePx + iconDrawablePaddingPx
526 + Utilities.calculateTextHeight(iconTextSizePx);
527 int cellPaddingY = (getCellSize().y - cellHeightPx) / 2;
528 if (iconDrawablePaddingPx > cellPaddingY && !isVerticalLayout
529 && !isMultiWindowMode) {
530 // Ensures that the label is closer to its corresponding icon. This is not an issue
531 // with vertical bar layout or multi-window mode since the issue is handled
532 // separately with their calls to {@link #adjustToHideWorkspaceLabels}.
533 cellHeightPx -= (iconDrawablePaddingPx - cellPaddingY);
534 iconDrawablePaddingPx = cellPaddingY;
535 }
Jon Miranda846455e2017-10-02 14:58:52 -0700536 }
Jon Miranda18751b62017-07-31 17:25:27 -0700537
Sunny Goyalae190ff2020-04-14 00:19:01 +0000538 // All apps
539 if (allAppsHasDifferentNumColumns()) {
Jon Mirandae126d722021-02-25 10:45:20 -0500540 allAppsIconSizePx = pxFromDp(inv.allAppsIconSize, mInfo.metrics);
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700541 allAppsIconTextSizePx = Utilities.pxFromSp(inv.allAppsIconTextSize, mInfo.metrics);
Sunny Goyalae190ff2020-04-14 00:19:01 +0000542 allAppsIconDrawablePaddingPx = iconDrawablePaddingOriginalPx;
Jon Miranda941375e2021-03-31 13:10:45 -0400543 autoResizeAllAppsCells();
Sunny Goyalae190ff2020-04-14 00:19:01 +0000544 } else {
545 allAppsIconSizePx = iconSizePx;
546 allAppsIconTextSizePx = iconTextSizePx;
547 allAppsIconDrawablePaddingPx = iconDrawablePaddingPx;
548 allAppsCellHeightPx = getCellSize().y;
549 }
550 allAppsCellWidthPx = allAppsIconSizePx + allAppsIconDrawablePaddingPx;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700551
Jon Miranda941375e2021-03-31 13:10:45 -0400552 if (isVerticalLayout) {
553 hideWorkspaceLabelsIfNotEnoughSpace();
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700554 }
Winson Chungb3800242013-10-24 11:01:54 -0700555
Winson Chungb3800242013-10-24 11:01:54 -0700556 // Hotseat
Sunny Goyal07b69292018-01-08 14:19:34 -0800557 if (isVerticalLayout) {
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700558 hotseatBarSizePx = iconSizePx + hotseatBarSidePaddingStartPx
559 + hotseatBarSidePaddingEndPx;
Jon Miranda18751b62017-07-31 17:25:27 -0700560 }
Jon Miranda5044c352017-08-09 11:37:59 -0700561 hotseatCellHeightPx = iconSizePx;
Winson Chungb3800242013-10-24 11:01:54 -0700562
Sunny Goyal07b69292018-01-08 14:19:34 -0800563 if (!isVerticalLayout) {
Jon Miranda18751b62017-07-31 17:25:27 -0700564 int expectedWorkspaceHeight = availableHeightPx - hotseatBarSizePx
Tony Wickham5edf9e22020-03-27 20:06:52 -0700565 - workspacePageIndicatorHeight - edgeMarginPx;
Sunny Goyal47328fd2016-05-25 18:56:41 -0700566 float minRequiredHeight = dropTargetBarSizePx + workspaceSpringLoadedBottomSpace;
567 workspaceSpringLoadShrinkFactor = Math.min(
568 res.getInteger(R.integer.config_workspaceSpringLoadShrinkPercentage) / 100.0f,
569 1 - (minRequiredHeight / expectedWorkspaceHeight));
570 } else {
571 workspaceSpringLoadShrinkFactor =
572 res.getInteger(R.integer.config_workspaceSpringLoadShrinkPercentage) / 100.0f;
573 }
574
Sunny Goyalbaec6ff2016-09-14 11:26:21 -0700575 // Folder icon
Jon Miranda591e3602018-03-28 11:37:00 -0700576 folderIconSizePx = IconNormalizer.getNormalizedCircleSize(iconSizePx);
577 folderIconOffsetYPx = (iconSizePx - folderIconSizePx) / 2;
Winson Chung0f785722015-04-08 10:27:49 -0700578 }
579
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700580 private void updateAvailableFolderCellDimensions(Resources res) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700581 updateFolderCellSize(1f, res);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700582
Jon Mirandae126d722021-02-25 10:45:20 -0500583 final int folderBottomPanelSize = res.getDimensionPixelSize(R.dimen.folder_label_height);
584
Jon Mirandac1b23992016-12-13 08:57:36 -0800585 // Don't let the folder get too close to the edges of the screen.
Jon Miranda1786df32018-09-25 13:05:23 -0700586 int folderMargin = edgeMarginPx * 2;
Sunny Goyal07b69292018-01-08 14:19:34 -0800587 Point totalWorkspacePadding = getTotalWorkspacePadding();
Jon Mirandac1b23992016-12-13 08:57:36 -0800588
589 // Check if the icons fit within the available height.
Jon Miranda228877d2021-02-09 11:05:00 -0500590 float contentUsedHeight = folderCellHeightPx * inv.numFolderRows
Jon Miranda823da222021-03-23 08:08:45 -0400591 + ((inv.numFolderRows - 1) * folderCellLayoutBorderSpacingPx);
Samuel Fufa1c8d90a2019-11-12 17:54:58 -0800592 int contentMaxHeight = availableHeightPx - totalWorkspacePadding.y - folderBottomPanelSize
Jon Mirandae126d722021-02-25 10:45:20 -0500593 - folderMargin - folderContentPaddingTop;
Samuel Fufa1c8d90a2019-11-12 17:54:58 -0800594 float scaleY = contentMaxHeight / contentUsedHeight;
Jon Mirandac1b23992016-12-13 08:57:36 -0800595
596 // Check if the icons fit within the available width.
Jon Miranda228877d2021-02-09 11:05:00 -0500597 float contentUsedWidth = folderCellWidthPx * inv.numFolderColumns
Jon Miranda823da222021-03-23 08:08:45 -0400598 + ((inv.numFolderColumns - 1) * folderCellLayoutBorderSpacingPx);
Jon Mirandae126d722021-02-25 10:45:20 -0500599 int contentMaxWidth = availableWidthPx - totalWorkspacePadding.x - folderMargin
600 - folderContentPaddingLeftRight * 2;
Samuel Fufa1c8d90a2019-11-12 17:54:58 -0800601 float scaleX = contentMaxWidth / contentUsedWidth;
Jon Mirandac1b23992016-12-13 08:57:36 -0800602
603 float scale = Math.min(scaleX, scaleY);
604 if (scale < 1f) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700605 updateFolderCellSize(scale, res);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700606 }
607 }
608
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700609 private void updateFolderCellSize(float scale, Resources res) {
Jon Mirandae126d722021-02-25 10:45:20 -0500610 float invIconSizeDp = isVerticalBarLayout() ? inv.landscapeIconSize : inv.iconSize;
611 folderChildIconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mInfo.metrics, scale));
612 folderChildTextSizePx = pxFromDp(inv.iconTextSize, mInfo.metrics, scale);
613 folderLabelTextSizePx = (int) (folderChildTextSizePx * folderLabelTextScale);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700614
615 int textHeight = Utilities.calculateTextHeight(folderChildTextSizePx);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700616
Jon Miranda823da222021-03-23 08:08:45 -0400617 if (isScalableGrid) {
618 folderCellWidthPx = (int) (cellWidthPx * scale);
619 folderCellHeightPx = (int) (cellHeightPx * scale);
620
621 int borderSpacing = (int) (cellLayoutBorderSpacingOriginalPx * scale);
622 folderCellLayoutBorderSpacingPx = borderSpacing;
623 folderContentPaddingLeftRight = borderSpacing;
624 folderContentPaddingTop = borderSpacing;
625 } else {
626 int cellPaddingX = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_x_padding)
627 * scale);
628 int cellPaddingY = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_y_padding)
629 * scale);
630
631 folderCellWidthPx = folderChildIconSizePx + 2 * cellPaddingX;
632 folderCellHeightPx = folderChildIconSizePx + 2 * cellPaddingY + textHeight;
633 }
634
Jonathan Miranda9ad87462017-07-26 17:41:02 +0000635 folderChildDrawablePaddingPx = Math.max(0,
636 (folderCellHeightPx - folderChildIconSizePx - textHeight) / 3);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700637 }
638
Winson1f064272016-07-18 17:18:02 -0700639 public void updateInsets(Rect insets) {
640 mInsets.set(insets);
Sunny Goyal07b69292018-01-08 14:19:34 -0800641 updateWorkspacePadding();
Winson1f064272016-07-18 17:18:02 -0700642 }
643
Sunny Goyalae6e3182019-04-30 12:04:37 -0700644 /**
645 * The current device insets. This is generally same as the insets being dispatched to
646 * {@link Insettable} elements, but can differ if the element is using a different profile.
647 */
Sunny Goyal1a52ef52018-01-11 10:15:03 -0800648 public Rect getInsets() {
649 return mInsets;
650 }
651
Sunny Goyal756cd262015-08-20 12:33:21 -0700652 public Point getCellSize() {
Jon Miranda6f7e9702019-09-16 14:44:14 -0700653 return getCellSize(inv.numColumns, inv.numRows);
654 }
655
656 private Point getCellSize(int numColumns, int numRows) {
Sunny Goyal756cd262015-08-20 12:33:21 -0700657 Point result = new Point();
658 // Since we are only concerned with the overall padding, layout direction does
659 // not matter.
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700660 Point padding = getTotalWorkspacePadding();
Jon Miranda18751b62017-07-31 17:25:27 -0700661 result.x = calculateCellWidth(availableWidthPx - padding.x
Jon Miranda228877d2021-02-09 11:05:00 -0500662 - cellLayoutPaddingLeftRightPx * 2, cellLayoutBorderSpacingPx, numColumns);
Jon Miranda18751b62017-07-31 17:25:27 -0700663 result.y = calculateCellHeight(availableHeightPx - padding.y
Jon Miranda228877d2021-02-09 11:05:00 -0500664 - cellLayoutBottomPaddingPx, cellLayoutBorderSpacingPx, numRows);
Sunny Goyal756cd262015-08-20 12:33:21 -0700665 return result;
666 }
667
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700668 public Point getTotalWorkspacePadding() {
Sunny Goyal07b69292018-01-08 14:19:34 -0800669 updateWorkspacePadding();
670 return new Point(workspacePadding.left + workspacePadding.right,
671 workspacePadding.top + workspacePadding.bottom);
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700672 }
673
674 /**
Sunny Goyal07b69292018-01-08 14:19:34 -0800675 * Updates {@link #workspacePadding} as a result of any internal value change to reflect the
676 * new workspace padding
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700677 */
Sunny Goyal07b69292018-01-08 14:19:34 -0800678 private void updateWorkspacePadding() {
679 Rect padding = workspacePadding;
Tony Wickham3a3517f2015-10-06 11:27:04 -0700680 if (isVerticalBarLayout()) {
Sunny Goyal228153d2018-01-04 15:35:22 -0800681 padding.top = 0;
682 padding.bottom = edgeMarginPx;
Sunny Goyal7e2e67f2018-01-26 13:40:08 -0800683 if (isSeascape()) {
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700684 padding.left = hotseatBarSizePx;
Tony Wickham5edf9e22020-03-27 20:06:52 -0700685 padding.right = hotseatBarSidePaddingStartPx;
Winson1f064272016-07-18 17:18:02 -0700686 } else {
Tony Wickham5edf9e22020-03-27 20:06:52 -0700687 padding.left = hotseatBarSidePaddingStartPx;
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700688 padding.right = hotseatBarSizePx;
Winson1f064272016-07-18 17:18:02 -0700689 }
Winson Chungb3800242013-10-24 11:01:54 -0700690 } else {
Tony Wickhama29a0462021-03-02 12:28:25 -0800691 int hotseatTop = isTaskbarPresent ? taskbarSize : hotseatBarSizePx;
692 int paddingBottom = hotseatTop + workspacePageIndicatorHeight
Jon Miranda228877d2021-02-09 11:05:00 -0500693 + workspaceBottomPadding - mWorkspacePageIndicatorOverlapWorkspace;
Sunny Goyalc6205602015-05-21 20:46:33 -0700694 if (isTablet) {
Winson Chungb3800242013-10-24 11:01:54 -0700695 // Pad the left and right of the workspace to ensure consistent spacing
696 // between all icons
Tony Wickhamd6b40372015-09-23 18:37:57 -0700697 // The amount of screen space available for left/right padding.
Sunny Goyal228153d2018-01-04 15:35:22 -0800698 int availablePaddingX = Math.max(0, widthPx - ((inv.numColumns * cellWidthPx) +
Sunny Goyalf5440cb2016-12-14 15:13:00 -0800699 ((inv.numColumns - 1) * cellWidthPx)));
Tony Wickhamd6b40372015-09-23 18:37:57 -0700700 availablePaddingX = (int) Math.min(availablePaddingX,
Sunny Goyal07b69292018-01-08 14:19:34 -0800701 widthPx * MAX_HORIZONTAL_PADDING_PERCENT);
Tony Wickhama29a0462021-03-02 12:28:25 -0800702 int hotseatVerticalPadding = isTaskbarPresent ? 0
703 : hotseatBarTopPaddingPx + hotseatBarBottomPaddingPx;
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700704 int availablePaddingY = Math.max(0, heightPx - edgeMarginPx - paddingBottom
Tony Wickhama29a0462021-03-02 12:28:25 -0800705 - (2 * inv.numRows * cellHeightPx) - hotseatVerticalPadding);
Sunny Goyal58fa4b62019-03-22 16:23:25 -0700706 padding.set(availablePaddingX / 2, edgeMarginPx + availablePaddingY / 2,
Tony Wickhamd6b40372015-09-23 18:37:57 -0700707 availablePaddingX / 2, paddingBottom + availablePaddingY / 2);
Andras Kloczl8e57cce2021-02-11 23:51:19 +0100708
709 if (FeatureFlags.ENABLE_TWO_PANEL_HOME.get()) {
710 padding.set(0, padding.top, 0, padding.bottom);
711 }
Winson Chungb3800242013-10-24 11:01:54 -0700712 } else {
713 // Pad the top and bottom of the workspace with search/hotseat bar sizes
Winson1f064272016-07-18 17:18:02 -0700714 padding.set(desiredWorkspaceLeftRightMarginPx,
Jon Mirandae126d722021-02-25 10:45:20 -0500715 workspaceTopPadding + (isScalableGrid ? 0 : edgeMarginPx),
Winson1f064272016-07-18 17:18:02 -0700716 desiredWorkspaceLeftRightMarginPx,
Winsonfadbe8f2016-07-22 16:35:37 -0700717 paddingBottom);
Winson Chungb3800242013-10-24 11:01:54 -0700718 }
719 }
Winson Chungb3800242013-10-24 11:01:54 -0700720 }
721
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700722 public Rect getHotseatLayoutPadding() {
723 if (isVerticalBarLayout()) {
724 if (isSeascape()) {
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700725 mHotseatPadding.set(mInsets.left + hotseatBarSidePaddingStartPx,
726 mInsets.top, hotseatBarSidePaddingEndPx, mInsets.bottom);
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700727 } else {
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700728 mHotseatPadding.set(hotseatBarSidePaddingEndPx, mInsets.top,
729 mInsets.right + hotseatBarSidePaddingStartPx, mInsets.bottom);
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700730 }
731 } else {
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700732 // We want the edges of the hotseat to line up with the edges of the workspace, but the
733 // icons in the hotseat are a different size, and so don't line up perfectly. To account
734 // for this, we pad the left and right of the hotseat with half of the difference of a
735 // workspace cell vs a hotseat cell.
736 float workspaceCellWidth = (float) widthPx / inv.numColumns;
737 float hotseatCellWidth = (float) widthPx / inv.numHotseatIcons;
738 int hotseatAdjustment = Math.round((workspaceCellWidth - hotseatCellWidth) / 2);
739 mHotseatPadding.set(
Sunny Goyal786940a2020-06-02 02:31:31 -0700740 hotseatAdjustment + workspacePadding.left + cellLayoutPaddingLeftRightPx
741 + mInsets.left,
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700742 hotseatBarTopPaddingPx,
Sunny Goyal786940a2020-06-02 02:31:31 -0700743 hotseatAdjustment + workspacePadding.right + cellLayoutPaddingLeftRightPx
744 + mInsets.right,
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700745 hotseatBarBottomPaddingPx + mInsets.bottom + cellLayoutBottomPaddingPx);
746 }
747 return mHotseatPadding;
748 }
749
Winsonfadbe8f2016-07-22 16:35:37 -0700750 /**
751 * @return the bounds for which the open folders should be contained within
752 */
753 public Rect getAbsoluteOpenFolderBounds() {
754 if (isVerticalBarLayout()) {
755 // Folders should only appear right of the drop target bar and left of the hotseat
756 return new Rect(mInsets.left + dropTargetBarSizePx + edgeMarginPx,
757 mInsets.top,
Jon Miranda18751b62017-07-31 17:25:27 -0700758 mInsets.left + availableWidthPx - hotseatBarSizePx - edgeMarginPx,
Winsonfadbe8f2016-07-22 16:35:37 -0700759 mInsets.top + availableHeightPx);
760 } else {
761 // Folders should only appear below the drop target bar and above the hotseat
Tony Wickhamae72b462021-03-10 16:18:40 -0800762 int hotseatTop = isTaskbarPresent ? taskbarSize : hotseatBarSizePx;
Tony Wickhamb4b7e202018-01-12 17:39:24 -0800763 return new Rect(mInsets.left + edgeMarginPx,
Winsonfadbe8f2016-07-22 16:35:37 -0700764 mInsets.top + dropTargetBarSizePx + edgeMarginPx,
Tony Wickhamb4b7e202018-01-12 17:39:24 -0800765 mInsets.left + availableWidthPx - edgeMarginPx,
Tony Wickhamae72b462021-03-10 16:18:40 -0800766 mInsets.top + availableHeightPx - hotseatTop
Tony Wickham5edf9e22020-03-27 20:06:52 -0700767 - workspacePageIndicatorHeight - edgeMarginPx);
Winsonfadbe8f2016-07-22 16:35:37 -0700768 }
769 }
770
Jon Miranda228877d2021-02-09 11:05:00 -0500771 public static int calculateCellWidth(int width, int borderSpacing, int countX) {
772 return (width - ((countX - 1) * borderSpacing)) / countX;
Winson Chungb3800242013-10-24 11:01:54 -0700773 }
Jon Miranda228877d2021-02-09 11:05:00 -0500774 public static int calculateCellHeight(int height, int borderSpacing, int countY) {
775 return (height - ((countY - 1) * borderSpacing)) / countY;
Winson Chungb3800242013-10-24 11:01:54 -0700776 }
777
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -0700778 /**
Tony Wickham55616cd2015-09-23 14:55:17 -0700779 * When {@code true}, the device is in landscape mode and the hotseat is on the right column.
780 * When {@code false}, either device is in portrait mode or the device is in landscape mode and
781 * the hotseat is on the bottom row.
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -0700782 */
Tony Wickhamab946a12015-09-16 15:38:16 -0700783 public boolean isVerticalBarLayout() {
Winson Chungb3800242013-10-24 11:01:54 -0700784 return isLandscape && transposeLayoutWithOrientation;
785 }
786
Sunny Goyal59d086c2018-05-07 17:31:40 -0700787 /**
Jon Miranda6f7e9702019-09-16 14:44:14 -0700788 * Returns true when the number of workspace columns and all apps columns differs.
789 */
790 private boolean allAppsHasDifferentNumColumns() {
791 return inv.numAllAppsColumns != inv.numColumns;
792 }
793
794 /**
Sunny Goyal59d086c2018-05-07 17:31:40 -0700795 * Updates orientation information and returns true if it has changed from the previous value.
796 */
Winson Chung13c1c2c2019-09-06 11:46:19 -0700797 public boolean updateIsSeascape(Context context) {
Sunny Goyal59d086c2018-05-07 17:31:40 -0700798 if (isVerticalBarLayout()) {
Schneider Victor-tulias954bb632021-01-27 14:03:51 -0800799 // Check an up-to-date info.
Alex Chaud25e87a2021-02-12 12:12:56 +0000800 DisplayController.Info displayInfo = DisplayController.getDefaultDisplay(context)
801 .createInfoForContext(context);
802 if (displayInfo == null) {
803 return false;
804 }
805
806 boolean isSeascape = displayInfo.rotation == Surface.ROTATION_270;
Sunny Goyal59d086c2018-05-07 17:31:40 -0700807 if (mIsSeascape != isSeascape) {
808 mIsSeascape = isSeascape;
809 return true;
810 }
811 }
812 return false;
813 }
814
Sunny Goyal7e2e67f2018-01-26 13:40:08 -0800815 public boolean isSeascape() {
Sunny Goyal59d086c2018-05-07 17:31:40 -0700816 return isVerticalBarLayout() && mIsSeascape;
Sunny Goyal7e2e67f2018-01-26 13:40:08 -0800817 }
818
Sunny Goyal07b69292018-01-08 14:19:34 -0800819 public boolean shouldFadeAdjacentWorkspaceScreens() {
Sunny Goyalc6205602015-05-21 20:46:33 -0700820 return isVerticalBarLayout() || isLargeTablet;
Winson Chungb3800242013-10-24 11:01:54 -0700821 }
822
Sunny Goyalc13403c2016-11-18 23:44:48 -0800823 public int getCellHeight(@ContainerType int containerType) {
824 switch (containerType) {
825 case CellLayout.WORKSPACE:
826 return cellHeightPx;
827 case CellLayout.FOLDER:
828 return folderCellHeightPx;
829 case CellLayout.HOTSEAT:
830 return hotseatCellHeightPx;
831 default:
832 // ??
833 return 0;
834 }
835 }
Sunny Goyal13178ac2016-04-04 16:35:22 -0700836
Jon Miranda58561d42021-03-17 10:51:54 -0400837 private String pxToDpStr(String name, float value) {
838 return "\t" + name + ": " + value + "px (" + dpiFromPx(value, mInfo.metrics) + "dp)";
839 }
840
841 public void dump(String prefix, PrintWriter writer) {
842 writer.println(prefix + "DeviceProfile:");
843 writer.println(prefix + "\t1 dp = " + mInfo.metrics.density + " px");
844
845 writer.println(prefix + "\tisTablet:" + isTablet);
846 writer.println(prefix + "\tisLargeTablet:" + isLargeTablet);
847 writer.println(prefix + "\tisPhone:" + isPhone);
848 writer.println(prefix + "\ttransposeLayoutWithOrientation:"
849 + transposeLayoutWithOrientation);
850
851 writer.println(prefix + "\tisLandscape:" + isLandscape);
852 writer.println(prefix + "\tisMultiWindowMode:" + isMultiWindowMode);
853
854 writer.println(prefix + pxToDpStr("windowX", windowX));
855 writer.println(prefix + pxToDpStr("windowY", windowY));
856 writer.println(prefix + pxToDpStr("widthPx", widthPx));
857 writer.println(prefix + pxToDpStr("heightPx", heightPx));
858
859 writer.println(prefix + pxToDpStr("availableWidthPx", availableWidthPx));
860 writer.println(prefix + pxToDpStr("availableHeightPx", availableHeightPx));
861
862 writer.println(prefix + "\taspectRatio:" + aspectRatio);
863
864 writer.println(prefix + "\tisScalableGrid:" + isScalableGrid);
865
866 writer.println(prefix + "\tinv.minCellWidth:" + inv.minCellWidth + "dp");
867 writer.println(prefix + "\tinv.minCellHeight:" + inv.minCellHeight + "dp");
868
869 writer.println(prefix + pxToDpStr("cellWidthPx", cellWidthPx));
870 writer.println(prefix + pxToDpStr("cellHeightPx", cellHeightPx));
871
872 writer.println(prefix + pxToDpStr("getCellSize().x", getCellSize().x));
873 writer.println(prefix + pxToDpStr("getCellSize().y", getCellSize().y));
874
875 writer.println(prefix + "\tinv.iconSize:" + inv.iconSize + "dp");
876 writer.println(prefix + pxToDpStr("iconSizePx", iconSizePx));
877 writer.println(prefix + pxToDpStr("iconTextSizePx", iconTextSizePx));
878 writer.println(prefix + pxToDpStr("iconDrawablePaddingPx", iconDrawablePaddingPx));
879
880 writer.println(prefix + pxToDpStr("folderCellWidthPx", folderCellWidthPx));
881 writer.println(prefix + pxToDpStr("folderCellHeightPx", folderCellHeightPx));
882 writer.println(prefix + pxToDpStr("folderChildIconSizePx", folderChildIconSizePx));
883 writer.println(prefix + pxToDpStr("folderChildTextSizePx", folderChildTextSizePx));
884 writer.println(prefix + pxToDpStr("folderChildDrawablePaddingPx",
885 folderChildDrawablePaddingPx));
Jon Miranda823da222021-03-23 08:08:45 -0400886 writer.println(prefix + pxToDpStr("folderCellLayoutBorderSpacingPx",
887 folderCellLayoutBorderSpacingPx));
Jon Miranda58561d42021-03-17 10:51:54 -0400888
889 writer.println(prefix + pxToDpStr("cellLayoutBorderSpacingPx",
890 cellLayoutBorderSpacingPx));
891 writer.println(prefix + pxToDpStr("desiredWorkspaceLeftRightMarginPx",
892 desiredWorkspaceLeftRightMarginPx));
893
894 writer.println(prefix + pxToDpStr("allAppsIconSizePx", allAppsIconSizePx));
895 writer.println(prefix + pxToDpStr("allAppsIconTextSizePx", allAppsIconTextSizePx));
896 writer.println(prefix + pxToDpStr("allAppsIconDrawablePaddingPx",
897 allAppsIconDrawablePaddingPx));
898 writer.println(prefix + pxToDpStr("allAppsCellHeightPx", allAppsCellHeightPx));
899
900 writer.println(prefix + pxToDpStr("hotseatBarSizePx", hotseatBarSizePx));
901 writer.println(prefix + pxToDpStr("hotseatCellHeightPx", hotseatCellHeightPx));
902 writer.println(prefix + pxToDpStr("hotseatBarTopPaddingPx", hotseatBarTopPaddingPx));
903 writer.println(prefix + pxToDpStr("hotseatBarBottomPaddingPx", hotseatBarBottomPaddingPx));
904 writer.println(prefix + pxToDpStr("hotseatBarSidePaddingStartPx",
905 hotseatBarSidePaddingStartPx));
906 writer.println(prefix + pxToDpStr("hotseatBarSidePaddingEndPx",
907 hotseatBarSidePaddingEndPx));
908
909 writer.println(prefix + "\tisTaskbarPresent:" + isTaskbarPresent);
910
911 writer.println(prefix + pxToDpStr("taskbarSize", taskbarSize));
912 writer.println(prefix + pxToDpStr("nonOverlappingTaskbarInset",
913 nonOverlappingTaskbarInset));
914
915 writer.println(prefix + pxToDpStr("workspacePadding.left", workspacePadding.left));
916 writer.println(prefix + pxToDpStr("workspacePadding.top", workspacePadding.top));
917 writer.println(prefix + pxToDpStr("workspacePadding.right", workspacePadding.right));
918 writer.println(prefix + pxToDpStr("workspacePadding.bottom", workspacePadding.bottom));
919
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400920 writer.println(prefix + pxToDpStr("scaleToFit", iconScale));
Jon Miranda58561d42021-03-17 10:51:54 -0400921 writer.println(prefix + pxToDpStr("extraSpace", extraSpace));
Jon Mirandac9e69fa2021-03-22 17:13:34 -0400922
923 if (inv.devicePaddings != null) {
924 int unscaledExtraSpace = (int) (extraSpace / iconScale);
925 writer.println(prefix + pxToDpStr("maxEmptySpace",
926 inv.devicePaddings.getDevicePadding(unscaledExtraSpace).getMaxEmptySpacePx()));
927 }
Jon Miranda58561d42021-03-17 10:51:54 -0400928 writer.println(prefix + pxToDpStr("workspaceTopPadding", workspaceTopPadding));
929 writer.println(prefix + pxToDpStr("workspaceBottomPadding", workspaceBottomPadding));
930 writer.println(prefix + pxToDpStr("extraHotseatBottomPadding", extraHotseatBottomPadding));
931 }
932
Sunny Goyalfd58da62020-08-11 12:06:49 -0700933 private static Context getContext(Context c, Info info, int orientation) {
Sunny Goyal1890f672020-04-30 12:28:00 -0700934 Configuration config = new Configuration(c.getResources().getConfiguration());
935 config.orientation = orientation;
936 config.densityDpi = info.metrics.densityDpi;
937 return c.createConfigurationContext(config);
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700938 }
Sunny Goyalfde55052018-02-01 14:46:13 -0800939
940 /**
941 * Callback when a component changes the DeviceProfile associated with it, as a result of
942 * configuration change
943 */
944 public interface OnDeviceProfileChangeListener {
945
946 /**
947 * Called when the device profile is reassigned. Note that for layout and measurements, it
948 * is sufficient to listen for inset changes. Use this callback when you need to perform
949 * a one time operation.
950 */
951 void onDeviceProfileChanged(DeviceProfile dp);
952 }
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700953
954 public static class Builder {
955 private Context mContext;
956 private InvariantDeviceProfile mInv;
Sunny Goyalfd58da62020-08-11 12:06:49 -0700957 private Info mInfo;
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700958
Sunny Goyal0addbf02020-04-28 14:17:35 -0700959 private final Point mWindowPosition = new Point();
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700960 private Point mMinSize, mMaxSize;
961 private int mWidth, mHeight;
962
963 private boolean mIsLandscape;
964 private boolean mIsMultiWindowMode = false;
965 private boolean mTransposeLayoutWithOrientation;
966
Sunny Goyalfd58da62020-08-11 12:06:49 -0700967 public Builder(Context context, InvariantDeviceProfile inv, Info info) {
Sunny Goyal0e7a3382020-04-13 17:15:05 -0700968 mContext = context;
969 mInv = inv;
970 mInfo = info;
971 mTransposeLayoutWithOrientation = context.getResources()
972 .getBoolean(R.bool.hotseat_transpose_layout_with_orientation);
973 }
974
975 public Builder setSizeRange(Point minSize, Point maxSize) {
976 mMinSize = minSize;
977 mMaxSize = maxSize;
978 return this;
979 }
980
981 public Builder setSize(int width, int height) {
982 mWidth = width;
983 mHeight = height;
984 mIsLandscape = mWidth > mHeight;
985 return this;
986 }
987
988 public Builder setMultiWindowMode(boolean isMultiWindowMode) {
989 mIsMultiWindowMode = isMultiWindowMode;
990 return this;
991 }
992
Sunny Goyal0addbf02020-04-28 14:17:35 -0700993 /**
994 * Sets the window position if not full-screen
995 */
996 public Builder setWindowPosition(int x, int y) {
997 mWindowPosition.set(x, y);
998 return this;
999 }
1000
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001001 public Builder setTransposeLayoutWithOrientation(boolean transposeLayoutWithOrientation) {
1002 mTransposeLayoutWithOrientation = transposeLayoutWithOrientation;
1003 return this;
1004 }
1005
1006 public DeviceProfile build() {
1007 return new DeviceProfile(mContext, mInv, mInfo, mMinSize, mMaxSize,
1008 mWidth, mHeight, mIsLandscape, mIsMultiWindowMode,
Sunny Goyal0addbf02020-04-28 14:17:35 -07001009 mTransposeLayoutWithOrientation, mWindowPosition);
Sunny Goyal0e7a3382020-04-13 17:15:05 -07001010 }
1011 }
1012
Winson Chungb3800242013-10-24 11:01:54 -07001013}