blob: c9e3d4f109bac144ae930027da78705094b46d33 [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
19import android.appwidget.AppWidgetHostView;
20import android.content.ComponentName;
21import android.content.Context;
Winson Chungb3800242013-10-24 11:01:54 -070022import android.content.res.Resources;
Winson Chungb3800242013-10-24 11:01:54 -070023import android.graphics.Point;
Jon Miranda7ae64ff2016-11-21 16:18:46 -080024import android.graphics.PointF;
Winson Chungb3800242013-10-24 11:01:54 -070025import android.graphics.Rect;
26import android.util.DisplayMetrics;
Winson Chungb3800242013-10-24 11:01:54 -070027import android.view.Gravity;
Winson Chungb3800242013-10-24 11:01:54 -070028import android.view.View;
Jorim Jaggid017f882014-01-14 17:08:48 -080029import android.view.ViewGroup;
Winson Chungb3800242013-10-24 11:01:54 -070030import android.view.ViewGroup.LayoutParams;
Winson Chungb3800242013-10-24 11:01:54 -070031import android.widget.FrameLayout;
32
Sunny Goyalc13403c2016-11-18 23:44:48 -080033import com.android.launcher3.CellLayout.ContainerType;
Tony Wickham9a8d11f2017-01-11 09:53:12 -080034import com.android.launcher3.badge.BadgeRenderer;
Tony Wickhame0c33232016-02-08 11:37:04 -080035
Winson1f064272016-07-18 17:18:02 -070036import java.util.ArrayList;
37
Winson Chungb3800242013-10-24 11:01:54 -070038public class DeviceProfile {
Adam Cohen2e6da152015-05-06 11:42:25 -070039
Winson1f064272016-07-18 17:18:02 -070040 public interface LauncherLayoutChangeListener {
41 void onLauncherLayoutChanged();
42 }
43
Adam Cohen2e6da152015-05-06 11:42:25 -070044 public final InvariantDeviceProfile inv;
Winson Chungbe876472014-05-14 14:15:20 -070045
Sunny Goyalc6205602015-05-21 20:46:33 -070046 // Device properties
47 public final boolean isTablet;
48 public final boolean isLargeTablet;
49 public final boolean isPhone;
50 public final boolean transposeLayoutWithOrientation;
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -070051
Sunny Goyalc6205602015-05-21 20:46:33 -070052 // Device properties in current orientation
53 public final boolean isLandscape;
54 public final int widthPx;
55 public final int heightPx;
56 public final int availableWidthPx;
57 public final int availableHeightPx;
Tony Wickhamd6b40372015-09-23 18:37:57 -070058 /**
59 * The maximum amount of left/right workspace padding as a percentage of the screen width.
60 * To be clear, this means that up to 7% of the screen width can be used as left padding, and
61 * 7% of the screen width can be used as right padding.
62 */
63 private static final float MAX_HORIZONTAL_PADDING_PERCENT = 0.14f;
Winson Chungb3800242013-10-24 11:01:54 -070064
Sunny Goyalc6205602015-05-21 20:46:33 -070065 // Overview mode
66 private final int overviewModeMinIconZoneHeightPx;
67 private final int overviewModeMaxIconZoneHeightPx;
68 private final int overviewModeBarItemWidthPx;
69 private final int overviewModeBarSpacerWidthPx;
70 private final float overviewModeIconZoneRatio;
Winson Chungb3800242013-10-24 11:01:54 -070071
Sunny Goyalc6205602015-05-21 20:46:33 -070072 // Workspace
73 private int desiredWorkspaceLeftRightMarginPx;
74 public final int edgeMarginPx;
75 public final Rect defaultWidgetPadding;
Sunny Goyalc6205602015-05-21 20:46:33 -070076 private final int defaultPageSpacingPx;
Sunny Goyal47328fd2016-05-25 18:56:41 -070077 private final int topWorkspacePadding;
Sunny Goyal47328fd2016-05-25 18:56:41 -070078 public float workspaceSpringLoadShrinkFactor;
79 public final int workspaceSpringLoadedBottomSpace;
Sunny Goyalc6205602015-05-21 20:46:33 -070080
Winson1f064272016-07-18 17:18:02 -070081 // Page indicator
82 private final int pageIndicatorHeightPx;
83 private final int pageIndicatorLandGutterLeftNavBarPx;
84 private final int pageIndicatorLandGutterRightNavBarPx;
85 private final int pageIndicatorLandWorkspaceOffsetPx;
86
Sunny Goyalc6205602015-05-21 20:46:33 -070087 // Workspace icons
88 public int iconSizePx;
89 public int iconTextSizePx;
90 public int iconDrawablePaddingPx;
Winson Chung5f4e0fd2015-05-22 11:12:27 -070091 public int iconDrawablePaddingOriginalPx;
Winson Chungb3800242013-10-24 11:01:54 -070092
Adam Cohen59400422014-03-05 18:07:04 -080093 public int cellWidthPx;
94 public int cellHeightPx;
95
Sunny Goyalc6205602015-05-21 20:46:33 -070096 // Folder
97 public int folderBackgroundOffset;
98 public int folderIconSizePx;
Adam Cohenefca0272016-02-24 19:19:06 -080099 public int folderIconPreviewPadding;
Jon Mirandabf7d8122016-11-03 15:29:29 -0700100
101 // Folder cell
Sunny Goyalc6205602015-05-21 20:46:33 -0700102 public int folderCellWidthPx;
103 public int folderCellHeightPx;
Jon Mirandabf7d8122016-11-03 15:29:29 -0700104
105 // Folder child
106 public int folderChildIconSizePx;
107 public int folderChildTextSizePx;
Sunny Goyalbaec6ff2016-09-14 11:26:21 -0700108 public int folderChildDrawablePaddingPx;
Winson Chungb3800242013-10-24 11:01:54 -0700109
Sunny Goyalc6205602015-05-21 20:46:33 -0700110 // Hotseat
111 public int hotseatCellWidthPx;
112 public int hotseatCellHeightPx;
113 public int hotseatIconSizePx;
Jon Mirandaaca21452016-09-26 14:01:56 -0700114 public int hotseatBarHeightPx;
Winson1f064272016-07-18 17:18:02 -0700115 private int hotseatBarTopPaddingPx;
Jon Mirandac1b08c52016-11-15 14:37:56 -0800116 private int hotseatBarBottomPaddingPx;
Winson1f064272016-07-18 17:18:02 -0700117 private int hotseatLandGutterPx;
Adam Cohen2e6da152015-05-06 11:42:25 -0700118
Sunny Goyalc6205602015-05-21 20:46:33 -0700119 // All apps
Winson Chung5f4e0fd2015-05-22 11:12:27 -0700120 public int allAppsNumCols;
121 public int allAppsNumPredictiveCols;
Sunny Goyalc6205602015-05-21 20:46:33 -0700122 public int allAppsButtonVisualSize;
Winson1f064272016-07-18 17:18:02 -0700123 public int allAppsIconSizePx;
124 public int allAppsIconDrawablePaddingPx;
125 public float allAppsIconTextSizePx;
126
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800127 // Widgets
128 public final PointF appWidgetScale = new PointF(1.0f, 1.0f);
129
Sunny Goyal47328fd2016-05-25 18:56:41 -0700130 // Drop Target
131 public int dropTargetBarSizePx;
Adam Cohen4ae96ce2014-08-29 15:05:48 -0700132
Winson1f064272016-07-18 17:18:02 -0700133 // Insets
134 private Rect mInsets = new Rect();
135
136 // Listeners
137 private ArrayList<LauncherLayoutChangeListener> mListeners = new ArrayList<>();
138
Tony Wickham9a8d11f2017-01-11 09:53:12 -0800139 // Icon badges
140 public BadgeRenderer mBadgeRenderer;
141
Sunny Goyalc6205602015-05-21 20:46:33 -0700142 public DeviceProfile(Context context, InvariantDeviceProfile inv,
143 Point minSize, Point maxSize,
144 int width, int height, boolean isLandscape) {
Sunny Goyalfee35bb2015-05-11 11:38:19 -0700145
Adam Cohen2e6da152015-05-06 11:42:25 -0700146 this.inv = inv;
Sunny Goyalc6205602015-05-21 20:46:33 -0700147 this.isLandscape = isLandscape;
Winson Chungb3800242013-10-24 11:01:54 -0700148
Adam Cohen2e6da152015-05-06 11:42:25 -0700149 Resources res = context.getResources();
Winson Chungb3800242013-10-24 11:01:54 -0700150 DisplayMetrics dm = res.getDisplayMetrics();
Adam Cohen2e6da152015-05-06 11:42:25 -0700151
Sunny Goyalc6205602015-05-21 20:46:33 -0700152 // Constants from resources
153 isTablet = res.getBoolean(R.bool.is_tablet);
154 isLargeTablet = res.getBoolean(R.bool.is_large_tablet);
155 isPhone = !isTablet && !isLargeTablet;
156
157 // Some more constants
Winson Chungb3800242013-10-24 11:01:54 -0700158 transposeLayoutWithOrientation =
159 res.getBoolean(R.bool.hotseat_transpose_layout_with_orientation);
Winson Chungb3800242013-10-24 11:01:54 -0700160
161 ComponentName cn = new ComponentName(context.getPackageName(),
162 this.getClass().getName());
163 defaultWidgetPadding = AppWidgetHostView.getDefaultPaddingForWidget(context, cn, null);
164 edgeMarginPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_edge_margin);
Winson1f064272016-07-18 17:18:02 -0700165 desiredWorkspaceLeftRightMarginPx = edgeMarginPx;
Winson Chungb3800242013-10-24 11:01:54 -0700166 pageIndicatorHeightPx =
167 res.getDimensionPixelSize(R.dimen.dynamic_grid_page_indicator_height);
Winson1f064272016-07-18 17:18:02 -0700168 pageIndicatorLandGutterLeftNavBarPx = res.getDimensionPixelSize(
169 R.dimen.dynamic_grid_page_indicator_gutter_width_left_nav_bar);
170 pageIndicatorLandWorkspaceOffsetPx =
171 res.getDimensionPixelSize(R.dimen.all_apps_caret_workspace_offset);
172 pageIndicatorLandGutterRightNavBarPx = res.getDimensionPixelSize(
173 R.dimen.dynamic_grid_page_indicator_gutter_width_right_nav_bar);
Winson Chungb3800242013-10-24 11:01:54 -0700174 defaultPageSpacingPx =
175 res.getDimensionPixelSize(R.dimen.dynamic_grid_workspace_page_spacing);
Sunny Goyal47328fd2016-05-25 18:56:41 -0700176 topWorkspacePadding =
177 res.getDimensionPixelSize(R.dimen.dynamic_grid_workspace_top_padding);
Winson Chungb3800242013-10-24 11:01:54 -0700178 overviewModeMinIconZoneHeightPx =
179 res.getDimensionPixelSize(R.dimen.dynamic_grid_overview_min_icon_zone_height);
180 overviewModeMaxIconZoneHeightPx =
181 res.getDimensionPixelSize(R.dimen.dynamic_grid_overview_max_icon_zone_height);
Jorim Jaggid017f882014-01-14 17:08:48 -0800182 overviewModeBarItemWidthPx =
183 res.getDimensionPixelSize(R.dimen.dynamic_grid_overview_bar_item_width);
184 overviewModeBarSpacerWidthPx =
185 res.getDimensionPixelSize(R.dimen.dynamic_grid_overview_bar_spacer_width);
Winson Chungb3800242013-10-24 11:01:54 -0700186 overviewModeIconZoneRatio =
187 res.getInteger(R.integer.config_dynamic_grid_overview_icon_zone_percentage) / 100f;
Winson Chungb3800242013-10-24 11:01:54 -0700188 iconDrawablePaddingOriginalPx =
189 res.getDimensionPixelSize(R.dimen.dynamic_grid_icon_drawable_padding);
Sunny Goyal47328fd2016-05-25 18:56:41 -0700190 dropTargetBarSizePx = res.getDimensionPixelSize(R.dimen.dynamic_grid_drop_target_size);
191 workspaceSpringLoadedBottomSpace =
192 res.getDimensionPixelSize(R.dimen.dynamic_grid_min_spring_loaded_space);
Winson1f064272016-07-18 17:18:02 -0700193 hotseatBarHeightPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_height);
194 hotseatBarTopPaddingPx =
195 res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_top_padding);
Jon Mirandac1b08c52016-11-15 14:37:56 -0800196 hotseatBarBottomPaddingPx = 0;
Winson1f064272016-07-18 17:18:02 -0700197 hotseatLandGutterPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_gutter_width);
Winson Chungb3800242013-10-24 11:01:54 -0700198
Tony Wickhama799bed2017-01-31 10:49:18 -0800199 mBadgeRenderer = new BadgeRenderer(context);
Tony Wickham9a8d11f2017-01-11 09:53:12 -0800200
Sunny Goyalc6205602015-05-21 20:46:33 -0700201 // Determine sizes.
202 widthPx = width;
203 heightPx = height;
204 if (isLandscape) {
205 availableWidthPx = maxSize.x;
206 availableHeightPx = minSize.y;
207 } else {
208 availableWidthPx = minSize.x;
209 availableHeightPx = maxSize.y;
210 }
Adam Cohen4ae96ce2014-08-29 15:05:48 -0700211
Winson Chungb3800242013-10-24 11:01:54 -0700212 // Calculate the remaining vars
Sunny Goyalc6205602015-05-21 20:46:33 -0700213 updateAvailableDimensions(dm, res);
Adam Cohen63f1ec02014-08-12 09:23:13 -0700214 computeAllAppsButtonSize(context);
215 }
216
Jon Mirandacc42c5b2016-10-27 17:15:27 -0700217 DeviceProfile getMultiWindowProfile(Context context, Point mwSize) {
218 // In multi-window mode, we can have widthPx = availableWidthPx
219 // and heightPx = availableHeightPx because Launcher uses the InvariantDeviceProfiles'
220 // widthPx and heightPx values where it's needed.
Jon Miranda93e1f042016-11-11 14:13:04 -0800221 DeviceProfile profile = new DeviceProfile(context, inv, mwSize, mwSize, mwSize.x, mwSize.y,
222 isLandscape);
223
224 // Hide labels on the workspace.
225 profile.iconTextSizePx = 0;
226 profile.cellHeightPx = profile.iconSizePx + profile.iconDrawablePaddingPx
227 + Utilities.calculateTextHeight(profile.iconTextSizePx);
228
Jon Mirandac1b08c52016-11-15 14:37:56 -0800229 // The nav bar is black so we add bottom padding to visually center hotseat icons.
230 profile.hotseatBarBottomPaddingPx = profile.hotseatBarTopPaddingPx;
231
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800232 // We use these scales to measure and layout the widgets using their full invariant profile
233 // sizes and then draw them scaled and centered to fit in their multi-window mode cellspans.
234 float appWidgetScaleX = (float) profile.getCellSize().x / getCellSize().x;
235 float appWidgetScaleY = (float) profile.getCellSize().y / getCellSize().y;
236 profile.appWidgetScale.set(appWidgetScaleX, appWidgetScaleY);
237
Jon Miranda93e1f042016-11-11 14:13:04 -0800238 return profile;
Jon Mirandacc42c5b2016-10-27 17:15:27 -0700239 }
240
Winson1f064272016-07-18 17:18:02 -0700241 public void addLauncherLayoutChangedListener(LauncherLayoutChangeListener listener) {
242 if (!mListeners.contains(listener)) {
243 mListeners.add(listener);
244 }
245 }
246
247 public void removeLauncherLayoutChangedListener(LauncherLayoutChangeListener listener) {
248 if (mListeners.contains(listener)) {
249 mListeners.remove(listener);
250 }
251 }
252
Adam Cohen63f1ec02014-08-12 09:23:13 -0700253 /**
254 * Determine the exact visual footprint of the all apps button, taking into account scaling
255 * and internal padding of the drawable.
256 */
257 private void computeAllAppsButtonSize(Context context) {
258 Resources res = context.getResources();
259 float padding = res.getInteger(R.integer.config_allAppsButtonPaddingPercent) / 100f;
Tony Wickhamd6b40372015-09-23 18:37:57 -0700260 allAppsButtonVisualSize = (int) (hotseatIconSizePx * (1 - padding)) - context.getResources()
261 .getDimensionPixelSize(R.dimen.all_apps_button_scale_down);
Winson Chungb3800242013-10-24 11:01:54 -0700262 }
263
Sunny Goyalc6205602015-05-21 20:46:33 -0700264 private void updateAvailableDimensions(DisplayMetrics dm, Resources res) {
Jon Mirandabf7d8122016-11-03 15:29:29 -0700265 updateIconSize(1f, iconDrawablePaddingOriginalPx, res, dm);
Winson Chung59a488a2013-12-10 12:32:14 -0800266
Jon Mirandabf7d8122016-11-03 15:29:29 -0700267 // Check to see if the icons fit within the available height. If not, then scale down.
268 float usedHeight = (cellHeightPx * inv.numRows);
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700269 int maxHeight = (availableHeightPx - getTotalWorkspacePadding().y);
Winson Chungb3800242013-10-24 11:01:54 -0700270 if (usedHeight > maxHeight) {
Jon Mirandabf7d8122016-11-03 15:29:29 -0700271 float scale = maxHeight / usedHeight;
272 updateIconSize(scale, 0, res, dm);
Winson Chungb3800242013-10-24 11:01:54 -0700273 }
Jon Mirandabf7d8122016-11-03 15:29:29 -0700274
275 updateAvailableFolderCellDimensions(dm, res);
Winson Chungb3800242013-10-24 11:01:54 -0700276 }
277
Winson Chung93f98ea2015-03-10 16:28:47 -0700278 private void updateIconSize(float scale, int drawablePadding, Resources res,
Winson Chungb3800242013-10-24 11:01:54 -0700279 DisplayMetrics dm) {
Adam Cohen2e6da152015-05-06 11:42:25 -0700280 iconSizePx = (int) (Utilities.pxFromDp(inv.iconSize, dm) * scale);
Sunny Goyala50a4192015-12-11 09:50:49 -0800281 iconTextSizePx = (int) (Utilities.pxFromSp(inv.iconTextSize, dm) * scale);
Winson Chungb3800242013-10-24 11:01:54 -0700282 iconDrawablePaddingPx = drawablePadding;
Adam Cohen2e6da152015-05-06 11:42:25 -0700283 hotseatIconSizePx = (int) (Utilities.pxFromDp(inv.hotseatIconSize, dm) * scale);
Winson1f064272016-07-18 17:18:02 -0700284 allAppsIconSizePx = iconSizePx;
285 allAppsIconDrawablePaddingPx = iconDrawablePaddingPx;
286 allAppsIconTextSizePx = iconTextSizePx;
Winson Chungb3800242013-10-24 11:01:54 -0700287
Winson Chungb3800242013-10-24 11:01:54 -0700288 cellWidthPx = iconSizePx;
Sunny Goyalbaec6ff2016-09-14 11:26:21 -0700289 cellHeightPx = iconSizePx + iconDrawablePaddingPx
290 + Utilities.calculateTextHeight(iconTextSizePx);
Winson Chungb3800242013-10-24 11:01:54 -0700291
292 // Hotseat
Winson Chungb3800242013-10-24 11:01:54 -0700293 hotseatCellWidthPx = iconSizePx;
294 hotseatCellHeightPx = iconSizePx;
295
Sunny Goyal47328fd2016-05-25 18:56:41 -0700296 if (!isVerticalBarLayout()) {
297 int expectedWorkspaceHeight = availableHeightPx - hotseatBarHeightPx
298 - pageIndicatorHeightPx - topWorkspacePadding;
299 float minRequiredHeight = dropTargetBarSizePx + workspaceSpringLoadedBottomSpace;
300 workspaceSpringLoadShrinkFactor = Math.min(
301 res.getInteger(R.integer.config_workspaceSpringLoadShrinkPercentage) / 100.0f,
302 1 - (minRequiredHeight / expectedWorkspaceHeight));
303 } else {
304 workspaceSpringLoadShrinkFactor =
305 res.getInteger(R.integer.config_workspaceSpringLoadShrinkPercentage) / 100.0f;
306 }
307
Sunny Goyalbaec6ff2016-09-14 11:26:21 -0700308 // Folder icon
Winson Chungb3800242013-10-24 11:01:54 -0700309 folderBackgroundOffset = -edgeMarginPx;
310 folderIconSizePx = iconSizePx + 2 * -folderBackgroundOffset;
Adam Cohenefca0272016-02-24 19:19:06 -0800311 folderIconPreviewPadding = res.getDimensionPixelSize(R.dimen.folder_preview_padding);
Winson Chung0f785722015-04-08 10:27:49 -0700312 }
313
Jon Mirandabf7d8122016-11-03 15:29:29 -0700314 private void updateAvailableFolderCellDimensions(DisplayMetrics dm, Resources res) {
315 int folderBottomPanelSize = res.getDimensionPixelSize(R.dimen.folder_label_padding_top)
316 + res.getDimensionPixelSize(R.dimen.folder_label_padding_bottom)
317 + Utilities.calculateTextHeight(res.getDimension(R.dimen.folder_label_text_size));
318
Jon Mirandac1b23992016-12-13 08:57:36 -0800319 updateFolderCellSize(1f, dm, res);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700320
Jon Mirandac1b23992016-12-13 08:57:36 -0800321 // Don't let the folder get too close to the edges of the screen.
322 int folderMargin = 4 * edgeMarginPx;
323
324 // Check if the icons fit within the available height.
325 float usedHeight = folderCellHeightPx * inv.numFolderRows + folderBottomPanelSize;
326 int maxHeight = availableHeightPx - getTotalWorkspacePadding().y - folderMargin;
327 float scaleY = maxHeight / usedHeight;
328
329 // Check if the icons fit within the available width.
330 float usedWidth = folderCellWidthPx * inv.numFolderColumns;
331 int maxWidth = availableWidthPx - getTotalWorkspacePadding().x - folderMargin;
332 float scaleX = maxWidth / usedWidth;
333
334 float scale = Math.min(scaleX, scaleY);
335 if (scale < 1f) {
336 updateFolderCellSize(scale, dm, res);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700337 }
338 }
339
Jon Mirandac1b23992016-12-13 08:57:36 -0800340 private void updateFolderCellSize(float scale, DisplayMetrics dm, Resources res) {
Jon Mirandabf7d8122016-11-03 15:29:29 -0700341 folderChildIconSizePx = (int) (Utilities.pxFromDp(inv.iconSize, dm) * scale);
342 folderChildTextSizePx =
343 (int) (res.getDimensionPixelSize(R.dimen.folder_child_text_size) * scale);
344
345 int textHeight = Utilities.calculateTextHeight(folderChildTextSizePx);
346 int cellPaddingX = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_x_padding) * scale);
347 int cellPaddingY = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_y_padding) * scale);
348
Jon Mirandac1b23992016-12-13 08:57:36 -0800349 folderCellWidthPx = folderChildIconSizePx + 2 * cellPaddingX;
350 folderCellHeightPx = folderChildIconSizePx + 2 * cellPaddingY + textHeight;
Jon Mirandabf7d8122016-11-03 15:29:29 -0700351 folderChildDrawablePaddingPx = Math.max(0,
352 (folderCellHeightPx - folderChildIconSizePx - textHeight) / 3);
353 }
354
Winson1f064272016-07-18 17:18:02 -0700355 public void updateInsets(Rect insets) {
356 mInsets.set(insets);
357 }
358
Winson1f064272016-07-18 17:18:02 -0700359 public void updateAppsViewNumCols() {
360 allAppsNumCols = allAppsNumPredictiveCols = inv.numColumns;
Winson Chungb3800242013-10-24 11:01:54 -0700361 }
362
Tony Wickhama3c74d12015-10-23 11:43:47 -0700363 /** Returns the width and height of the search bar, ignoring any padding. */
Sunny Goyal47328fd2016-05-25 18:56:41 -0700364 public Point getSearchBarDimensForWidgetOpts() {
Tony Wickhama3c74d12015-10-23 11:43:47 -0700365 if (isVerticalBarLayout()) {
Sunny Goyal47328fd2016-05-25 18:56:41 -0700366 return new Point(dropTargetBarSizePx, availableHeightPx - 2 * edgeMarginPx);
Winson Chungb3800242013-10-24 11:01:54 -0700367 } else {
Sunny Goyal47328fd2016-05-25 18:56:41 -0700368 int gap;
Sunny Goyalc6205602015-05-21 20:46:33 -0700369 if (isTablet) {
Winson Chungb3800242013-10-24 11:01:54 -0700370 // Pad the left and right of the workspace to ensure consistent spacing
371 // between all icons
Winson Chung4f3bfad2015-07-13 11:14:30 -0700372 int width = getCurrentWidth();
Winson Chungb3800242013-10-24 11:01:54 -0700373 // XXX: If the icon size changes across orientations, we will have to take
374 // that into account here too.
Sunny Goyal47328fd2016-05-25 18:56:41 -0700375 gap = ((width - 2 * edgeMarginPx
376 - (inv.numColumns * cellWidthPx)) / (2 * (inv.numColumns + 1)))
377 + edgeMarginPx;
Winson Chungb3800242013-10-24 11:01:54 -0700378 } else {
Sunny Goyal47328fd2016-05-25 18:56:41 -0700379 gap = desiredWorkspaceLeftRightMarginPx - defaultWidgetPadding.right;
Winson Chungb3800242013-10-24 11:01:54 -0700380 }
Sunny Goyal47328fd2016-05-25 18:56:41 -0700381 return new Point(availableWidthPx - 2 * gap, dropTargetBarSizePx);
Winson Chungb3800242013-10-24 11:01:54 -0700382 }
Winson Chungb3800242013-10-24 11:01:54 -0700383 }
384
Sunny Goyal756cd262015-08-20 12:33:21 -0700385 public Point getCellSize() {
386 Point result = new Point();
387 // Since we are only concerned with the overall padding, layout direction does
388 // not matter.
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700389 Point padding = getTotalWorkspacePadding();
390 result.x = calculateCellWidth(availableWidthPx - padding.x, inv.numColumns);
391 result.y = calculateCellHeight(availableHeightPx - padding.y, inv.numRows);
Sunny Goyal756cd262015-08-20 12:33:21 -0700392 return result;
393 }
394
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700395 public Point getTotalWorkspacePadding() {
Sunny Goyal6178f132016-07-11 17:30:03 -0700396 Rect padding = getWorkspacePadding(null);
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700397 return new Point(padding.left + padding.right, padding.top + padding.bottom);
398 }
399
400 /**
401 * Returns the workspace padding in the specified orientation.
402 * Note that it assumes that while in verticalBarLayout, the nav bar is on the right, as such
403 * this value is not reliable.
404 * Use {@link #getTotalWorkspacePadding()} instead.
405 */
Sunny Goyal6178f132016-07-11 17:30:03 -0700406 public Rect getWorkspacePadding(Rect recycle) {
407 Rect padding = recycle == null ? new Rect() : recycle;
Tony Wickham3a3517f2015-10-06 11:27:04 -0700408 if (isVerticalBarLayout()) {
Winson1f064272016-07-18 17:18:02 -0700409 if (mInsets.left > 0) {
410 padding.set(mInsets.left + pageIndicatorLandGutterLeftNavBarPx, 0,
411 hotseatBarHeightPx + hotseatLandGutterPx - mInsets.left, 2 * edgeMarginPx);
412 } else {
413 padding.set(pageIndicatorLandGutterRightNavBarPx, 0,
414 hotseatBarHeightPx + hotseatLandGutterPx, 2 * edgeMarginPx);
415 }
Winson Chungb3800242013-10-24 11:01:54 -0700416 } else {
Tony Wickhama3c74d12015-10-23 11:43:47 -0700417 int paddingBottom = hotseatBarHeightPx + pageIndicatorHeightPx;
Sunny Goyalc6205602015-05-21 20:46:33 -0700418 if (isTablet) {
Winson Chungb3800242013-10-24 11:01:54 -0700419 // Pad the left and right of the workspace to ensure consistent spacing
420 // between all icons
Winson Chung4f3bfad2015-07-13 11:14:30 -0700421 int width = getCurrentWidth();
422 int height = getCurrentHeight();
Tony Wickhamd6b40372015-09-23 18:37:57 -0700423 // The amount of screen space available for left/right padding.
Sunny Goyalf5440cb2016-12-14 15:13:00 -0800424 int availablePaddingX = Math.max(0, width - ((inv.numColumns * cellWidthPx) +
425 ((inv.numColumns - 1) * cellWidthPx)));
Tony Wickhamd6b40372015-09-23 18:37:57 -0700426 availablePaddingX = (int) Math.min(availablePaddingX,
427 width * MAX_HORIZONTAL_PADDING_PERCENT);
Sunny Goyal47328fd2016-05-25 18:56:41 -0700428 int availablePaddingY = Math.max(0, height - topWorkspacePadding - paddingBottom
Jon Mirandac1b08c52016-11-15 14:37:56 -0800429 - (2 * inv.numRows * cellHeightPx) - hotseatBarTopPaddingPx
430 - hotseatBarBottomPaddingPx);
Sunny Goyal47328fd2016-05-25 18:56:41 -0700431 padding.set(availablePaddingX / 2, topWorkspacePadding + availablePaddingY / 2,
Tony Wickhamd6b40372015-09-23 18:37:57 -0700432 availablePaddingX / 2, paddingBottom + availablePaddingY / 2);
Winson Chungb3800242013-10-24 11:01:54 -0700433 } else {
434 // Pad the top and bottom of the workspace with search/hotseat bar sizes
Winson1f064272016-07-18 17:18:02 -0700435 padding.set(desiredWorkspaceLeftRightMarginPx,
Sunny Goyal47328fd2016-05-25 18:56:41 -0700436 topWorkspacePadding,
Winson1f064272016-07-18 17:18:02 -0700437 desiredWorkspaceLeftRightMarginPx,
Winsonfadbe8f2016-07-22 16:35:37 -0700438 paddingBottom);
Winson Chungb3800242013-10-24 11:01:54 -0700439 }
440 }
441 return padding;
442 }
443
Winsonfadbe8f2016-07-22 16:35:37 -0700444 /**
445 * @return the bounds for which the open folders should be contained within
446 */
447 public Rect getAbsoluteOpenFolderBounds() {
448 if (isVerticalBarLayout()) {
449 // Folders should only appear right of the drop target bar and left of the hotseat
450 return new Rect(mInsets.left + dropTargetBarSizePx + edgeMarginPx,
451 mInsets.top,
452 mInsets.left + availableWidthPx - hotseatBarHeightPx - edgeMarginPx,
453 mInsets.top + availableHeightPx);
454 } else {
455 // Folders should only appear below the drop target bar and above the hotseat
456 return new Rect(mInsets.left,
457 mInsets.top + dropTargetBarSizePx + edgeMarginPx,
458 mInsets.left + availableWidthPx,
459 mInsets.top + availableHeightPx - hotseatBarHeightPx - pageIndicatorHeightPx -
460 edgeMarginPx);
461 }
462 }
463
Sunny Goyal47328fd2016-05-25 18:56:41 -0700464 private int getWorkspacePageSpacing() {
Tony Wickham3a3517f2015-10-06 11:27:04 -0700465 if (isVerticalBarLayout() || isLargeTablet) {
Winson Chungb3800242013-10-24 11:01:54 -0700466 // In landscape mode the page spacing is set to the default.
467 return defaultPageSpacingPx;
468 } else {
469 // In portrait, we want the pages spaced such that there is no
470 // overhang of the previous / next page into the current page viewport.
471 // We assume symmetrical padding in portrait mode.
Winson11439c52016-07-20 14:25:07 -0700472 return Math.max(defaultPageSpacingPx, getWorkspacePadding(null).left + 1);
Winson Chungb3800242013-10-24 11:01:54 -0700473 }
474 }
475
Winson Chung4f7eb402015-07-10 18:00:48 -0700476 int getOverviewModeButtonBarHeight() {
Winson Chungb3800242013-10-24 11:01:54 -0700477 int zoneHeight = (int) (overviewModeIconZoneRatio * availableHeightPx);
478 zoneHeight = Math.min(overviewModeMaxIconZoneHeightPx,
479 Math.max(overviewModeMinIconZoneHeightPx, zoneHeight));
Winson Chung4f7eb402015-07-10 18:00:48 -0700480 return zoneHeight;
Winson Chungb3800242013-10-24 11:01:54 -0700481 }
482
Adam Cohen2e6da152015-05-06 11:42:25 -0700483 public static int calculateCellWidth(int width, int countX) {
Winson Chungb3800242013-10-24 11:01:54 -0700484 return width / countX;
485 }
Adam Cohen2e6da152015-05-06 11:42:25 -0700486 public static int calculateCellHeight(int height, int countY) {
Winson Chungb3800242013-10-24 11:01:54 -0700487 return height / countY;
488 }
489
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -0700490 /**
Tony Wickham55616cd2015-09-23 14:55:17 -0700491 * When {@code true}, the device is in landscape mode and the hotseat is on the right column.
492 * When {@code false}, either device is in portrait mode or the device is in landscape mode and
493 * the hotseat is on the bottom row.
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -0700494 */
Tony Wickhamab946a12015-09-16 15:38:16 -0700495 public boolean isVerticalBarLayout() {
Winson Chungb3800242013-10-24 11:01:54 -0700496 return isLandscape && transposeLayoutWithOrientation;
497 }
498
499 boolean shouldFadeAdjacentWorkspaceScreens() {
Sunny Goyalc6205602015-05-21 20:46:33 -0700500 return isVerticalBarLayout() || isLargeTablet;
Winson Chungb3800242013-10-24 11:01:54 -0700501 }
502
Sunny Goyalc6205602015-05-21 20:46:33 -0700503 private int getVisibleChildCount(ViewGroup parent) {
Jorim Jaggid017f882014-01-14 17:08:48 -0800504 int visibleChildren = 0;
505 for (int i = 0; i < parent.getChildCount(); i++) {
506 if (parent.getChildAt(i).getVisibility() != View.GONE) {
507 visibleChildren++;
508 }
509 }
510 return visibleChildren;
511 }
512
Winson1f064272016-07-18 17:18:02 -0700513 public void layout(Launcher launcher, boolean notifyListeners) {
Winson Chungb3800242013-10-24 11:01:54 -0700514 FrameLayout.LayoutParams lp;
Winson Chungb3800242013-10-24 11:01:54 -0700515 boolean hasVerticalBarLayout = isVerticalBarLayout();
516
517 // Layout the search bar space
Sunny Goyal47328fd2016-05-25 18:56:41 -0700518 Point searchBarBounds = getSearchBarDimensForWidgetOpts();
519 View searchBar = launcher.getDropTargetBar();
Sunny Goyalf37a2142016-03-24 17:28:25 -0700520 lp = (FrameLayout.LayoutParams) searchBar.getLayoutParams();
Sunny Goyal47328fd2016-05-25 18:56:41 -0700521 lp.width = searchBarBounds.x;
522 lp.height = searchBarBounds.y;
Winson1f064272016-07-18 17:18:02 -0700523 lp.topMargin = mInsets.top + edgeMarginPx;
Winson Chungb3800242013-10-24 11:01:54 -0700524 searchBar.setLayoutParams(lp);
525
Winson Chungb3800242013-10-24 11:01:54 -0700526 // Layout the workspace
527 PagedView workspace = (PagedView) launcher.findViewById(R.id.workspace);
Winson1f064272016-07-18 17:18:02 -0700528 Rect workspacePadding = getWorkspacePadding(null);
529 workspace.setPadding(workspacePadding.left, workspacePadding.top, workspacePadding.right,
530 workspacePadding.bottom);
Sunny Goyal47328fd2016-05-25 18:56:41 -0700531 workspace.setPageSpacing(getWorkspacePageSpacing());
Winson Chungb3800242013-10-24 11:01:54 -0700532
Sunny Goyal6178f132016-07-11 17:30:03 -0700533 View qsbContainer = launcher.getQsbContainer();
534 lp = (FrameLayout.LayoutParams) qsbContainer.getLayoutParams();
Winson1f064272016-07-18 17:18:02 -0700535 lp.topMargin = mInsets.top + workspacePadding.top;
Sunny Goyal6178f132016-07-11 17:30:03 -0700536 qsbContainer.setLayoutParams(lp);
537
Winson Chungb3800242013-10-24 11:01:54 -0700538 // Layout the hotseat
Winson6231ede2016-07-20 17:21:55 -0700539 Hotseat hotseat = (Hotseat) launcher.findViewById(R.id.hotseat);
Winson Chungb3800242013-10-24 11:01:54 -0700540 lp = (FrameLayout.LayoutParams) hotseat.getLayoutParams();
Tony Wickhamd6b40372015-09-23 18:37:57 -0700541 // We want the edges of the hotseat to line up with the edges of the workspace, but the
542 // icons in the hotseat are a different size, and so don't line up perfectly. To account for
543 // this, we pad the left and right of the hotseat with half of the difference of a workspace
544 // cell vs a hotseat cell.
545 float workspaceCellWidth = (float) getCurrentWidth() / inv.numColumns;
546 float hotseatCellWidth = (float) getCurrentWidth() / inv.numHotseatIcons;
547 int hotseatAdjustment = Math.round((workspaceCellWidth - hotseatCellWidth) / 2);
Winson Chungb3800242013-10-24 11:01:54 -0700548 if (hasVerticalBarLayout) {
Winson Chungf8c6f882015-06-03 11:27:26 -0700549 // Vertical hotseat -- The hotseat is fixed in the layout to be on the right of the
550 // screen regardless of RTL
551 lp.gravity = Gravity.RIGHT;
Winson1f064272016-07-18 17:18:02 -0700552 lp.width = hotseatBarHeightPx + mInsets.left + mInsets.right;
Winson Chungb3800242013-10-24 11:01:54 -0700553 lp.height = LayoutParams.MATCH_PARENT;
Winson6231ede2016-07-20 17:21:55 -0700554 hotseat.getLayout().setPadding(mInsets.left, mInsets.top, mInsets.right,
555 workspacePadding.bottom);
Sunny Goyalc6205602015-05-21 20:46:33 -0700556 } else if (isTablet) {
Winson Chung59a488a2013-12-10 12:32:14 -0800557 // Pad the hotseat with the workspace padding calculated above
Winson Chungb3800242013-10-24 11:01:54 -0700558 lp.gravity = Gravity.BOTTOM;
559 lp.width = LayoutParams.MATCH_PARENT;
Winson1f064272016-07-18 17:18:02 -0700560 lp.height = hotseatBarHeightPx + mInsets.bottom;
Winson6231ede2016-07-20 17:21:55 -0700561 hotseat.getLayout().setPadding(hotseatAdjustment + workspacePadding.left,
562 hotseatBarTopPaddingPx, hotseatAdjustment + workspacePadding.right,
Jon Mirandac1b08c52016-11-15 14:37:56 -0800563 hotseatBarBottomPaddingPx + mInsets.bottom);
Winson Chungb3800242013-10-24 11:01:54 -0700564 } else {
565 // For phones, layout the hotseat without any bottom margin
566 // to ensure that we have space for the folders
567 lp.gravity = Gravity.BOTTOM;
568 lp.width = LayoutParams.MATCH_PARENT;
Winson1f064272016-07-18 17:18:02 -0700569 lp.height = hotseatBarHeightPx + mInsets.bottom;
Winson6231ede2016-07-20 17:21:55 -0700570 hotseat.getLayout().setPadding(hotseatAdjustment + workspacePadding.left,
571 hotseatBarTopPaddingPx, hotseatAdjustment + workspacePadding.right,
Jon Mirandac1b08c52016-11-15 14:37:56 -0800572 hotseatBarBottomPaddingPx + mInsets.bottom);
Winson Chungb3800242013-10-24 11:01:54 -0700573 }
574 hotseat.setLayoutParams(lp);
575
576 // Layout the page indicators
577 View pageIndicator = launcher.findViewById(R.id.page_indicator);
578 if (pageIndicator != null) {
Hyunyoung Song7d2fc812016-06-15 12:51:30 -0700579 lp = (FrameLayout.LayoutParams) pageIndicator.getLayoutParams();
Winson1f064272016-07-18 17:18:02 -0700580 if (isVerticalBarLayout()) {
581 if (mInsets.left > 0) {
582 lp.leftMargin = mInsets.left + pageIndicatorLandGutterLeftNavBarPx -
583 lp.width - pageIndicatorLandWorkspaceOffsetPx;
584 } else if (mInsets.right > 0) {
585 lp.leftMargin = pageIndicatorLandGutterRightNavBarPx - lp.width -
586 pageIndicatorLandWorkspaceOffsetPx;
587 }
588 lp.bottomMargin = workspacePadding.bottom;
589 } else {
Winson Chungb3800242013-10-24 11:01:54 -0700590 // Put the page indicators above the hotseat
Winson Chungb3800242013-10-24 11:01:54 -0700591 lp.gravity = Gravity.CENTER_HORIZONTAL | Gravity.BOTTOM;
Winson1f064272016-07-18 17:18:02 -0700592 lp.height = pageIndicatorHeightPx;
593 lp.bottomMargin = hotseatBarHeightPx + mInsets.bottom;
Winson Chungb3800242013-10-24 11:01:54 -0700594 }
Hyunyoung Song7d2fc812016-06-15 12:51:30 -0700595 pageIndicator.setLayoutParams(lp);
Winson Chungb3800242013-10-24 11:01:54 -0700596 }
597
Winson Chungb3800242013-10-24 11:01:54 -0700598 // Layout the Overview Mode
Jorim Jaggid017f882014-01-14 17:08:48 -0800599 ViewGroup overviewMode = launcher.getOverviewPanel();
Winson Chungb3800242013-10-24 11:01:54 -0700600 if (overviewMode != null) {
Sunny Goyal8dfe2da2014-10-24 16:26:52 -0700601 int visibleChildCount = getVisibleChildCount(overviewMode);
602 int totalItemWidth = visibleChildCount * overviewModeBarItemWidthPx;
Jon Mirandadf3bc522016-11-01 16:55:56 -0700603 int maxWidth = totalItemWidth + (visibleChildCount - 1) * overviewModeBarSpacerWidthPx;
Sunny Goyal8dfe2da2014-10-24 16:26:52 -0700604
Jon Mirandadf3bc522016-11-01 16:55:56 -0700605 lp = (FrameLayout.LayoutParams) overviewMode.getLayoutParams();
Sunny Goyal8dfe2da2014-10-24 16:26:52 -0700606 lp.width = Math.min(availableWidthPx, maxWidth);
Jon Mirandadf3bc522016-11-01 16:55:56 -0700607 lp.height = getOverviewModeButtonBarHeight() + mInsets.bottom;
Winson Chungb3800242013-10-24 11:01:54 -0700608 overviewMode.setLayoutParams(lp);
Winson1f064272016-07-18 17:18:02 -0700609 }
Sunny Goyal8dfe2da2014-10-24 16:26:52 -0700610
Winson1f064272016-07-18 17:18:02 -0700611 if (notifyListeners) {
612 for (int i = mListeners.size() - 1; i >= 0; i--) {
613 mListeners.get(i).onLauncherLayoutChanged();
Sunny Goyal8dfe2da2014-10-24 16:26:52 -0700614 }
Winson Chungb3800242013-10-24 11:01:54 -0700615 }
616 }
Winson Chung4f3bfad2015-07-13 11:14:30 -0700617
618 private int getCurrentWidth() {
619 return isLandscape
620 ? Math.max(widthPx, heightPx)
621 : Math.min(widthPx, heightPx);
622 }
623
624 private int getCurrentHeight() {
625 return isLandscape
626 ? Math.min(widthPx, heightPx)
627 : Math.max(widthPx, heightPx);
628 }
Sunny Goyal13178ac2016-04-04 16:35:22 -0700629
Sunny Goyalc13403c2016-11-18 23:44:48 -0800630 public int getCellHeight(@ContainerType int containerType) {
631 switch (containerType) {
632 case CellLayout.WORKSPACE:
633 return cellHeightPx;
634 case CellLayout.FOLDER:
635 return folderCellHeightPx;
636 case CellLayout.HOTSEAT:
637 return hotseatCellHeightPx;
638 default:
639 // ??
640 return 0;
641 }
642 }
Sunny Goyal13178ac2016-04-04 16:35:22 -0700643
Winson1f064272016-07-18 17:18:02 -0700644 /**
645 * @return the left/right paddings for all containers.
646 */
Jon Mirandac3e4e222016-11-02 16:56:52 -0700647 public final int[] getContainerPadding() {
Winson1f064272016-07-18 17:18:02 -0700648 // No paddings for portrait phone
649 if (isPhone && !isVerticalBarLayout()) {
650 return new int[] {0, 0};
Sunny Goyal13178ac2016-04-04 16:35:22 -0700651 }
Winson1f064272016-07-18 17:18:02 -0700652
Hyunyoung Song9d96fd52016-08-23 11:06:24 -0700653 // In landscape, we match the width of the workspace
654 int padding = (pageIndicatorLandGutterRightNavBarPx +
655 hotseatBarHeightPx + hotseatLandGutterPx + mInsets.left) / 2;
Winson1f064272016-07-18 17:18:02 -0700656 return new int[]{ padding, padding };
Sunny Goyal13178ac2016-04-04 16:35:22 -0700657 }
Jon Mirandacc42c5b2016-10-27 17:15:27 -0700658
Jon Miranda51f037d2016-11-07 08:37:20 -0800659 public boolean shouldIgnoreLongPressToOverview(float touchX) {
Jon Mirandacc42c5b2016-10-27 17:15:27 -0700660 boolean inMultiWindowMode = this != inv.landscapeProfile && this != inv.portraitProfile;
Jon Miranda51f037d2016-11-07 08:37:20 -0800661 boolean touchedLhsEdge = mInsets.left == 0 && touchX < edgeMarginPx;
662 boolean touchedRhsEdge = mInsets.right == 0 && touchX > (widthPx - edgeMarginPx);
Jon Mirandacc42c5b2016-10-27 17:15:27 -0700663 return !inMultiWindowMode && (touchedLhsEdge || touchedRhsEdge);
664 }
Winson Chungb3800242013-10-24 11:01:54 -0700665}