blob: bd239690f67d714904e4ace1a4d4c820b5da76fd [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;
Jon Mirandab28c4fc2017-06-20 10:58:36 -070022import android.content.res.Configuration;
Winson Chungb3800242013-10-24 11:01:54 -070023import android.content.res.Resources;
Winson Chungb3800242013-10-24 11:01:54 -070024import android.graphics.Point;
Jon Miranda7ae64ff2016-11-21 16:18:46 -080025import android.graphics.PointF;
Winson Chungb3800242013-10-24 11:01:54 -070026import android.graphics.Rect;
27import android.util.DisplayMetrics;
Winson Chungb3800242013-10-24 11:01:54 -070028import android.view.Gravity;
Winson Chungb3800242013-10-24 11:01:54 -070029import android.view.View;
Jorim Jaggid017f882014-01-14 17:08:48 -080030import android.view.ViewGroup;
Winson Chungb3800242013-10-24 11:01:54 -070031import android.view.ViewGroup.LayoutParams;
Winson Chungb3800242013-10-24 11:01:54 -070032import android.widget.FrameLayout;
33
Sunny Goyalc13403c2016-11-18 23:44:48 -080034import com.android.launcher3.CellLayout.ContainerType;
Tony Wickham9a8d11f2017-01-11 09:53:12 -080035import com.android.launcher3.badge.BadgeRenderer;
Tony Wickhame0c33232016-02-08 11:37:04 -080036
Winson1f064272016-07-18 17:18:02 -070037import java.util.ArrayList;
38
Winson Chungb3800242013-10-24 11:01:54 -070039public class DeviceProfile {
Adam Cohen2e6da152015-05-06 11:42:25 -070040
Winson1f064272016-07-18 17:18:02 -070041 public interface LauncherLayoutChangeListener {
42 void onLauncherLayoutChanged();
43 }
44
Adam Cohen2e6da152015-05-06 11:42:25 -070045 public final InvariantDeviceProfile inv;
Winson Chungbe876472014-05-14 14:15:20 -070046
Sunny Goyalc6205602015-05-21 20:46:33 -070047 // Device properties
48 public final boolean isTablet;
49 public final boolean isLargeTablet;
50 public final boolean isPhone;
51 public final boolean transposeLayoutWithOrientation;
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -070052
Sunny Goyalc6205602015-05-21 20:46:33 -070053 // Device properties in current orientation
54 public final boolean isLandscape;
55 public final int widthPx;
56 public final int heightPx;
57 public final int availableWidthPx;
58 public final int availableHeightPx;
Tony Wickhamd6b40372015-09-23 18:37:57 -070059 /**
60 * The maximum amount of left/right workspace padding as a percentage of the screen width.
61 * To be clear, this means that up to 7% of the screen width can be used as left padding, and
62 * 7% of the screen width can be used as right padding.
63 */
64 private static final float MAX_HORIZONTAL_PADDING_PERCENT = 0.14f;
Winson Chungb3800242013-10-24 11:01:54 -070065
Sunny Goyalc6205602015-05-21 20:46:33 -070066 // Overview mode
67 private final int overviewModeMinIconZoneHeightPx;
68 private final int overviewModeMaxIconZoneHeightPx;
69 private final int overviewModeBarItemWidthPx;
70 private final int overviewModeBarSpacerWidthPx;
71 private final float overviewModeIconZoneRatio;
Winson Chungb3800242013-10-24 11:01:54 -070072
Sunny Goyalc6205602015-05-21 20:46:33 -070073 // Workspace
Jon Miranda28032002017-07-13 16:18:56 -070074 private final int desiredWorkspaceLeftRightMarginPx;
75 public final int cellLayoutPaddingLeftRightPx;
Sunny Goyalc6205602015-05-21 20:46:33 -070076 public final int edgeMarginPx;
77 public final Rect defaultWidgetPadding;
Sunny Goyalc6205602015-05-21 20:46:33 -070078 private final int defaultPageSpacingPx;
Sunny Goyal47328fd2016-05-25 18:56:41 -070079 private final int topWorkspacePadding;
Sunny Goyal47328fd2016-05-25 18:56:41 -070080 public float workspaceSpringLoadShrinkFactor;
81 public final int workspaceSpringLoadedBottomSpace;
Sunny Goyalc6205602015-05-21 20:46:33 -070082
Winson1f064272016-07-18 17:18:02 -070083 // Page indicator
Jon Miranda2ed276e2017-06-29 11:36:34 -070084 private int pageIndicatorSizePx;
Jon Mirandab28c4fc2017-06-20 10:58:36 -070085 private final int pageIndicatorLandGutterPx;
Winson1f064272016-07-18 17:18:02 -070086 private final int pageIndicatorLandWorkspaceOffsetPx;
87
Sunny Goyalc6205602015-05-21 20:46:33 -070088 // Workspace icons
89 public int iconSizePx;
90 public int iconTextSizePx;
91 public int iconDrawablePaddingPx;
Winson Chung5f4e0fd2015-05-22 11:12:27 -070092 public int iconDrawablePaddingOriginalPx;
Winson Chungb3800242013-10-24 11:01:54 -070093
Adam Cohen59400422014-03-05 18:07:04 -080094 public int cellWidthPx;
95 public int cellHeightPx;
Jon Mirandab28c4fc2017-06-20 10:58:36 -070096 public int workspaceCellPaddingXPx;
Adam Cohen59400422014-03-05 18:07:04 -080097
Sunny Goyalc6205602015-05-21 20:46:33 -070098 // Folder
99 public int folderBackgroundOffset;
100 public int folderIconSizePx;
Adam Cohenefca0272016-02-24 19:19:06 -0800101 public int folderIconPreviewPadding;
Jon Mirandabf7d8122016-11-03 15:29:29 -0700102
103 // Folder cell
Sunny Goyalc6205602015-05-21 20:46:33 -0700104 public int folderCellWidthPx;
105 public int folderCellHeightPx;
Jon Mirandabf7d8122016-11-03 15:29:29 -0700106
107 // Folder child
108 public int folderChildIconSizePx;
109 public int folderChildTextSizePx;
Sunny Goyalbaec6ff2016-09-14 11:26:21 -0700110 public int folderChildDrawablePaddingPx;
Winson Chungb3800242013-10-24 11:01:54 -0700111
Sunny Goyalc6205602015-05-21 20:46:33 -0700112 // Hotseat
Sunny Goyalc6205602015-05-21 20:46:33 -0700113 public int hotseatCellHeightPx;
Jon Mirandaaca21452016-09-26 14:01:56 -0700114 public int hotseatBarHeightPx;
Sunny Goyal0dc1db42017-05-17 11:34:33 -0700115 public int hotseatBarTopPaddingPx;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700116 public int hotseatBarLeftNavBarRightPaddingPx;
117 public int hotseatBarRightNavBarRightPaddingPx;
Sunny Goyal0dc1db42017-05-17 11:34:33 -0700118 public int hotseatBarBottomPaddingPx;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700119 public int hotseatLandLeftNavBarGutterPx;
120 public int hotseatLandRightNavBarGutterPx;
Adam Cohen2e6da152015-05-06 11:42:25 -0700121
Sunny Goyalc6205602015-05-21 20:46:33 -0700122 // All apps
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700123 public int allAppsCellHeightPx;
Winson Chung5f4e0fd2015-05-22 11:12:27 -0700124 public int allAppsNumCols;
125 public int allAppsNumPredictiveCols;
Sunny Goyalc6205602015-05-21 20:46:33 -0700126 public int allAppsButtonVisualSize;
Winson1f064272016-07-18 17:18:02 -0700127 public int allAppsIconSizePx;
128 public int allAppsIconDrawablePaddingPx;
129 public float allAppsIconTextSizePx;
130
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800131 // Widgets
132 public final PointF appWidgetScale = new PointF(1.0f, 1.0f);
133
Sunny Goyal47328fd2016-05-25 18:56:41 -0700134 // Drop Target
135 public int dropTargetBarSizePx;
Adam Cohen4ae96ce2014-08-29 15:05:48 -0700136
Winson1f064272016-07-18 17:18:02 -0700137 // Insets
138 private Rect mInsets = new Rect();
139
140 // Listeners
141 private ArrayList<LauncherLayoutChangeListener> mListeners = new ArrayList<>();
142
Tony Wickham9a8d11f2017-01-11 09:53:12 -0800143 // Icon badges
144 public BadgeRenderer mBadgeRenderer;
145
Sunny Goyalc6205602015-05-21 20:46:33 -0700146 public DeviceProfile(Context context, InvariantDeviceProfile inv,
147 Point minSize, Point maxSize,
148 int width, int height, boolean isLandscape) {
Sunny Goyalfee35bb2015-05-11 11:38:19 -0700149
Adam Cohen2e6da152015-05-06 11:42:25 -0700150 this.inv = inv;
Sunny Goyalc6205602015-05-21 20:46:33 -0700151 this.isLandscape = isLandscape;
Winson Chungb3800242013-10-24 11:01:54 -0700152
Adam Cohen2e6da152015-05-06 11:42:25 -0700153 Resources res = context.getResources();
Winson Chungb3800242013-10-24 11:01:54 -0700154 DisplayMetrics dm = res.getDisplayMetrics();
Adam Cohen2e6da152015-05-06 11:42:25 -0700155
Sunny Goyalc6205602015-05-21 20:46:33 -0700156 // Constants from resources
157 isTablet = res.getBoolean(R.bool.is_tablet);
158 isLargeTablet = res.getBoolean(R.bool.is_large_tablet);
159 isPhone = !isTablet && !isLargeTablet;
160
161 // Some more constants
Winson Chungb3800242013-10-24 11:01:54 -0700162 transposeLayoutWithOrientation =
163 res.getBoolean(R.bool.hotseat_transpose_layout_with_orientation);
Winson Chungb3800242013-10-24 11:01:54 -0700164
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700165 context = getContext(context, isVerticalBarLayout()
166 ? Configuration.ORIENTATION_LANDSCAPE
167 : Configuration.ORIENTATION_PORTRAIT);
168 res = context.getResources();
169
170
Winson Chungb3800242013-10-24 11:01:54 -0700171 ComponentName cn = new ComponentName(context.getPackageName(),
172 this.getClass().getName());
173 defaultWidgetPadding = AppWidgetHostView.getDefaultPaddingForWidget(context, cn, null);
174 edgeMarginPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_edge_margin);
Jon Miranda28032002017-07-13 16:18:56 -0700175 desiredWorkspaceLeftRightMarginPx = isVerticalBarLayout() ? 0 : edgeMarginPx;
176 cellLayoutPaddingLeftRightPx = isVerticalBarLayout() ? 0 : edgeMarginPx;
Jon Miranda2ed276e2017-06-29 11:36:34 -0700177 pageIndicatorSizePx = res.getDimensionPixelSize(
178 R.dimen.dynamic_grid_min_page_indicator_size);
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700179 pageIndicatorLandGutterPx = res.getDimensionPixelSize(
180 R.dimen.dynamic_grid_page_indicator_gutter_width);
Winson1f064272016-07-18 17:18:02 -0700181 pageIndicatorLandWorkspaceOffsetPx =
182 res.getDimensionPixelSize(R.dimen.all_apps_caret_workspace_offset);
Winson Chungb3800242013-10-24 11:01:54 -0700183 defaultPageSpacingPx =
184 res.getDimensionPixelSize(R.dimen.dynamic_grid_workspace_page_spacing);
Sunny Goyal47328fd2016-05-25 18:56:41 -0700185 topWorkspacePadding =
186 res.getDimensionPixelSize(R.dimen.dynamic_grid_workspace_top_padding);
Winson Chungb3800242013-10-24 11:01:54 -0700187 overviewModeMinIconZoneHeightPx =
188 res.getDimensionPixelSize(R.dimen.dynamic_grid_overview_min_icon_zone_height);
189 overviewModeMaxIconZoneHeightPx =
190 res.getDimensionPixelSize(R.dimen.dynamic_grid_overview_max_icon_zone_height);
Jorim Jaggid017f882014-01-14 17:08:48 -0800191 overviewModeBarItemWidthPx =
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700192 res.getDimensionPixelSize(R.dimen.dynamic_grid_overview_bar_item_width);
Jorim Jaggid017f882014-01-14 17:08:48 -0800193 overviewModeBarSpacerWidthPx =
194 res.getDimensionPixelSize(R.dimen.dynamic_grid_overview_bar_spacer_width);
Winson Chungb3800242013-10-24 11:01:54 -0700195 overviewModeIconZoneRatio =
196 res.getInteger(R.integer.config_dynamic_grid_overview_icon_zone_percentage) / 100f;
Winson Chungb3800242013-10-24 11:01:54 -0700197 iconDrawablePaddingOriginalPx =
198 res.getDimensionPixelSize(R.dimen.dynamic_grid_icon_drawable_padding);
Sunny Goyal47328fd2016-05-25 18:56:41 -0700199 dropTargetBarSizePx = res.getDimensionPixelSize(R.dimen.dynamic_grid_drop_target_size);
200 workspaceSpringLoadedBottomSpace =
201 res.getDimensionPixelSize(R.dimen.dynamic_grid_min_spring_loaded_space);
Sunny Goyald5190522017-04-24 03:06:54 -0700202
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700203 workspaceCellPaddingXPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_cell_padding_x);
Jon Miranda09660722017-06-14 14:20:14 -0700204
Winson1f064272016-07-18 17:18:02 -0700205 hotseatBarTopPaddingPx =
206 res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_top_padding);
Sunny Goyald5190522017-04-24 03:06:54 -0700207 hotseatBarBottomPaddingPx =
208 res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_bottom_padding);
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700209 hotseatBarLeftNavBarRightPaddingPx = res.getDimensionPixelSize(
210 R.dimen.dynamic_grid_hotseat_land_left_nav_bar_right_padding);
211 hotseatBarRightNavBarRightPaddingPx = res.getDimensionPixelSize(
212 R.dimen.dynamic_grid_hotseat_land_right_nav_bar_right_padding);
213 hotseatBarHeightPx = isVerticalBarLayout()
214 ? res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_height)
215 : res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_height)
216 + hotseatBarTopPaddingPx + hotseatBarBottomPaddingPx;
217
218 hotseatLandLeftNavBarGutterPx = res.getDimensionPixelSize(
219 R.dimen.dynamic_grid_hotseat_land_left_nav_bar_gutter_width);
220 hotseatLandRightNavBarGutterPx = res.getDimensionPixelSize(
221 R.dimen.dynamic_grid_hotseat_land_right_nav_bar_gutter_width);
Winson Chungb3800242013-10-24 11:01:54 -0700222
Sunny Goyalc6205602015-05-21 20:46:33 -0700223 // Determine sizes.
224 widthPx = width;
225 heightPx = height;
226 if (isLandscape) {
227 availableWidthPx = maxSize.x;
228 availableHeightPx = minSize.y;
229 } else {
230 availableWidthPx = minSize.x;
231 availableHeightPx = maxSize.y;
232 }
Adam Cohen4ae96ce2014-08-29 15:05:48 -0700233
Jon Miranda2ed276e2017-06-29 11:36:34 -0700234 // Calculate all of the remaining variables.
Sunny Goyalc6205602015-05-21 20:46:33 -0700235 updateAvailableDimensions(dm, res);
Jon Miranda2ed276e2017-06-29 11:36:34 -0700236
237 // Now that we have all of the variables calculated, we can tune certain sizes.
238 if (!isVerticalBarLayout()) {
239 // We increase the page indicator size when there is extra space.
240 // ie. For a display with a large aspect ratio, we can keep the icons on the workspace
241 // in portrait mode closer together by increasing the page indicator size.
242 int newPageIndicatorSizePx = getCellSize().y - iconSizePx - iconTextSizePx
243 - iconDrawablePaddingOriginalPx;
244 if (newPageIndicatorSizePx > pageIndicatorSizePx) {
245 pageIndicatorSizePx = newPageIndicatorSizePx;
246 // Recalculate the available dimensions using the new page indicator size.
247 updateAvailableDimensions(dm, res);
248 }
249 }
250
Adam Cohen63f1ec02014-08-12 09:23:13 -0700251 computeAllAppsButtonSize(context);
Tony Wickham1237df02017-02-24 08:59:36 -0800252
253 // This is done last, after iconSizePx is calculated above.
254 mBadgeRenderer = new BadgeRenderer(context, iconSizePx);
Adam Cohen63f1ec02014-08-12 09:23:13 -0700255 }
256
Jon Mirandacc42c5b2016-10-27 17:15:27 -0700257 DeviceProfile getMultiWindowProfile(Context context, Point mwSize) {
258 // In multi-window mode, we can have widthPx = availableWidthPx
259 // and heightPx = availableHeightPx because Launcher uses the InvariantDeviceProfiles'
260 // widthPx and heightPx values where it's needed.
Jon Miranda93e1f042016-11-11 14:13:04 -0800261 DeviceProfile profile = new DeviceProfile(context, inv, mwSize, mwSize, mwSize.x, mwSize.y,
262 isLandscape);
263
264 // Hide labels on the workspace.
Jon Miranda1091e532017-07-21 13:31:50 -0700265 profile.adjustToHideWorkspaceLabels();
Jon Miranda93e1f042016-11-11 14:13:04 -0800266
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800267 // We use these scales to measure and layout the widgets using their full invariant profile
268 // sizes and then draw them scaled and centered to fit in their multi-window mode cellspans.
269 float appWidgetScaleX = (float) profile.getCellSize().x / getCellSize().x;
270 float appWidgetScaleY = (float) profile.getCellSize().y / getCellSize().y;
271 profile.appWidgetScale.set(appWidgetScaleX, appWidgetScaleY);
272
Jon Miranda93e1f042016-11-11 14:13:04 -0800273 return profile;
Jon Mirandacc42c5b2016-10-27 17:15:27 -0700274 }
275
Winson1f064272016-07-18 17:18:02 -0700276 public void addLauncherLayoutChangedListener(LauncherLayoutChangeListener listener) {
277 if (!mListeners.contains(listener)) {
278 mListeners.add(listener);
279 }
280 }
281
282 public void removeLauncherLayoutChangedListener(LauncherLayoutChangeListener listener) {
283 if (mListeners.contains(listener)) {
284 mListeners.remove(listener);
285 }
286 }
287
Adam Cohen63f1ec02014-08-12 09:23:13 -0700288 /**
Jon Miranda1091e532017-07-21 13:31:50 -0700289 * Adjusts the profile so that the labels on the Workspace are hidden.
290 * It is important to call this method after the All Apps variables have been set.
291 */
292 private void adjustToHideWorkspaceLabels() {
293 iconTextSizePx = 0;
294 iconDrawablePaddingPx = 0;
295 cellHeightPx = iconSizePx;
296
297 // In normal cases, All Apps cell height should equal the Workspace cell height.
298 // Since we are removing labels from the Workspace, we need to manually compute the
299 // All Apps cell height.
300 allAppsCellHeightPx = allAppsIconSizePx + allAppsIconDrawablePaddingPx
301 + Utilities.calculateTextHeight(allAppsIconTextSizePx)
302 // Top and bottom padding is equal to the drawable padding
303 + allAppsIconDrawablePaddingPx * 2;
304 }
305
306 /**
Adam Cohen63f1ec02014-08-12 09:23:13 -0700307 * Determine the exact visual footprint of the all apps button, taking into account scaling
308 * and internal padding of the drawable.
309 */
310 private void computeAllAppsButtonSize(Context context) {
311 Resources res = context.getResources();
312 float padding = res.getInteger(R.integer.config_allAppsButtonPaddingPercent) / 100f;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700313 allAppsButtonVisualSize = (int) (iconSizePx * (1 - padding)) - context.getResources()
Tony Wickhamd6b40372015-09-23 18:37:57 -0700314 .getDimensionPixelSize(R.dimen.all_apps_button_scale_down);
Winson Chungb3800242013-10-24 11:01:54 -0700315 }
316
Sunny Goyalc6205602015-05-21 20:46:33 -0700317 private void updateAvailableDimensions(DisplayMetrics dm, Resources res) {
Jon Miranda09660722017-06-14 14:20:14 -0700318 updateIconSize(1f, res, dm);
Winson Chung59a488a2013-12-10 12:32:14 -0800319
Jon Mirandabf7d8122016-11-03 15:29:29 -0700320 // Check to see if the icons fit within the available height. If not, then scale down.
321 float usedHeight = (cellHeightPx * inv.numRows);
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700322 int maxHeight = (availableHeightPx - getTotalWorkspacePadding().y);
Winson Chungb3800242013-10-24 11:01:54 -0700323 if (usedHeight > maxHeight) {
Jon Mirandabf7d8122016-11-03 15:29:29 -0700324 float scale = maxHeight / usedHeight;
Jon Miranda09660722017-06-14 14:20:14 -0700325 updateIconSize(scale, res, dm);
Winson Chungb3800242013-10-24 11:01:54 -0700326 }
Jon Mirandabf7d8122016-11-03 15:29:29 -0700327 updateAvailableFolderCellDimensions(dm, res);
Winson Chungb3800242013-10-24 11:01:54 -0700328 }
329
Jon Miranda09660722017-06-14 14:20:14 -0700330 private void updateIconSize(float scale, Resources res, DisplayMetrics dm) {
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700331 float invIconSizePx = isVerticalBarLayout() ? inv.landscapeIconSize : inv.iconSize;
332 iconSizePx = (int) (Utilities.pxFromDp(invIconSizePx, dm) * scale);
Sunny Goyala50a4192015-12-11 09:50:49 -0800333 iconTextSizePx = (int) (Utilities.pxFromSp(inv.iconTextSize, dm) * scale);
Jon Miranda09660722017-06-14 14:20:14 -0700334 iconDrawablePaddingPx = (int) (iconDrawablePaddingOriginalPx * scale);
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700335
336 // All apps
337 allAppsIconTextSizePx = iconTextSizePx;
Winson1f064272016-07-18 17:18:02 -0700338 allAppsIconSizePx = iconSizePx;
339 allAppsIconDrawablePaddingPx = iconDrawablePaddingPx;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700340 allAppsCellHeightPx = getCellSize().y;
341
342 if (isVerticalBarLayout()) {
343 // Always hide the Workspace text with vertical bar layout.
Jon Miranda1091e532017-07-21 13:31:50 -0700344 adjustToHideWorkspaceLabels();
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700345 }
Winson Chungb3800242013-10-24 11:01:54 -0700346
Jon Miranda09660722017-06-14 14:20:14 -0700347 cellWidthPx = iconSizePx + iconDrawablePaddingPx;
Sunny Goyalbaec6ff2016-09-14 11:26:21 -0700348 cellHeightPx = iconSizePx + iconDrawablePaddingPx
349 + Utilities.calculateTextHeight(iconTextSizePx);
Winson Chungb3800242013-10-24 11:01:54 -0700350
351 // Hotseat
Jon Miranda09660722017-06-14 14:20:14 -0700352 hotseatCellHeightPx = iconSizePx + iconDrawablePaddingPx;
Winson Chungb3800242013-10-24 11:01:54 -0700353
Sunny Goyal47328fd2016-05-25 18:56:41 -0700354 if (!isVerticalBarLayout()) {
355 int expectedWorkspaceHeight = availableHeightPx - hotseatBarHeightPx
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700356 - pageIndicatorSizePx - topWorkspacePadding;
Sunny Goyal47328fd2016-05-25 18:56:41 -0700357 float minRequiredHeight = dropTargetBarSizePx + workspaceSpringLoadedBottomSpace;
358 workspaceSpringLoadShrinkFactor = Math.min(
359 res.getInteger(R.integer.config_workspaceSpringLoadShrinkPercentage) / 100.0f,
360 1 - (minRequiredHeight / expectedWorkspaceHeight));
361 } else {
362 workspaceSpringLoadShrinkFactor =
363 res.getInteger(R.integer.config_workspaceSpringLoadShrinkPercentage) / 100.0f;
364 }
365
Sunny Goyalbaec6ff2016-09-14 11:26:21 -0700366 // Folder icon
Jon Miranda09660722017-06-14 14:20:14 -0700367 folderBackgroundOffset = -iconDrawablePaddingPx;
Winson Chungb3800242013-10-24 11:01:54 -0700368 folderIconSizePx = iconSizePx + 2 * -folderBackgroundOffset;
Adam Cohenefca0272016-02-24 19:19:06 -0800369 folderIconPreviewPadding = res.getDimensionPixelSize(R.dimen.folder_preview_padding);
Winson Chung0f785722015-04-08 10:27:49 -0700370 }
371
Jon Mirandabf7d8122016-11-03 15:29:29 -0700372 private void updateAvailableFolderCellDimensions(DisplayMetrics dm, Resources res) {
373 int folderBottomPanelSize = res.getDimensionPixelSize(R.dimen.folder_label_padding_top)
374 + res.getDimensionPixelSize(R.dimen.folder_label_padding_bottom)
375 + Utilities.calculateTextHeight(res.getDimension(R.dimen.folder_label_text_size));
376
Jon Mirandac1b23992016-12-13 08:57:36 -0800377 updateFolderCellSize(1f, dm, res);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700378
Jon Mirandac1b23992016-12-13 08:57:36 -0800379 // Don't let the folder get too close to the edges of the screen.
Jon Miranda72b5fd12017-06-25 18:06:23 -0700380 int folderMargin = edgeMarginPx;
Jon Mirandac1b23992016-12-13 08:57:36 -0800381
382 // Check if the icons fit within the available height.
383 float usedHeight = folderCellHeightPx * inv.numFolderRows + folderBottomPanelSize;
384 int maxHeight = availableHeightPx - getTotalWorkspacePadding().y - folderMargin;
385 float scaleY = maxHeight / usedHeight;
386
387 // Check if the icons fit within the available width.
388 float usedWidth = folderCellWidthPx * inv.numFolderColumns;
389 int maxWidth = availableWidthPx - getTotalWorkspacePadding().x - folderMargin;
390 float scaleX = maxWidth / usedWidth;
391
392 float scale = Math.min(scaleX, scaleY);
393 if (scale < 1f) {
394 updateFolderCellSize(scale, dm, res);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700395 }
396 }
397
Jon Mirandac1b23992016-12-13 08:57:36 -0800398 private void updateFolderCellSize(float scale, DisplayMetrics dm, Resources res) {
Jon Mirandabf7d8122016-11-03 15:29:29 -0700399 folderChildIconSizePx = (int) (Utilities.pxFromDp(inv.iconSize, dm) * scale);
400 folderChildTextSizePx =
401 (int) (res.getDimensionPixelSize(R.dimen.folder_child_text_size) * scale);
402
403 int textHeight = Utilities.calculateTextHeight(folderChildTextSizePx);
404 int cellPaddingX = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_x_padding) * scale);
405 int cellPaddingY = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_y_padding) * scale);
406
Jon Mirandac1b23992016-12-13 08:57:36 -0800407 folderCellWidthPx = folderChildIconSizePx + 2 * cellPaddingX;
Jonathan Miranda9ad87462017-07-26 17:41:02 +0000408 folderCellHeightPx = folderChildIconSizePx + 2 * cellPaddingY + textHeight;
409 folderChildDrawablePaddingPx = Math.max(0,
410 (folderCellHeightPx - folderChildIconSizePx - textHeight) / 3);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700411 }
412
Winson1f064272016-07-18 17:18:02 -0700413 public void updateInsets(Rect insets) {
414 mInsets.set(insets);
415 }
416
Winson1f064272016-07-18 17:18:02 -0700417 public void updateAppsViewNumCols() {
418 allAppsNumCols = allAppsNumPredictiveCols = inv.numColumns;
Winson Chungb3800242013-10-24 11:01:54 -0700419 }
420
Tony Wickhama3c74d12015-10-23 11:43:47 -0700421 /** Returns the width and height of the search bar, ignoring any padding. */
Sunny Goyal47328fd2016-05-25 18:56:41 -0700422 public Point getSearchBarDimensForWidgetOpts() {
Tony Wickhama3c74d12015-10-23 11:43:47 -0700423 if (isVerticalBarLayout()) {
Sunny Goyal47328fd2016-05-25 18:56:41 -0700424 return new Point(dropTargetBarSizePx, availableHeightPx - 2 * edgeMarginPx);
Winson Chungb3800242013-10-24 11:01:54 -0700425 } else {
Sunny Goyal47328fd2016-05-25 18:56:41 -0700426 int gap;
Sunny Goyalc6205602015-05-21 20:46:33 -0700427 if (isTablet) {
Winson Chungb3800242013-10-24 11:01:54 -0700428 // Pad the left and right of the workspace to ensure consistent spacing
429 // between all icons
Winson Chung4f3bfad2015-07-13 11:14:30 -0700430 int width = getCurrentWidth();
Winson Chungb3800242013-10-24 11:01:54 -0700431 // XXX: If the icon size changes across orientations, we will have to take
432 // that into account here too.
Sunny Goyal47328fd2016-05-25 18:56:41 -0700433 gap = ((width - 2 * edgeMarginPx
434 - (inv.numColumns * cellWidthPx)) / (2 * (inv.numColumns + 1)))
435 + edgeMarginPx;
Winson Chungb3800242013-10-24 11:01:54 -0700436 } else {
Sunny Goyal47328fd2016-05-25 18:56:41 -0700437 gap = desiredWorkspaceLeftRightMarginPx - defaultWidgetPadding.right;
Winson Chungb3800242013-10-24 11:01:54 -0700438 }
Sunny Goyal47328fd2016-05-25 18:56:41 -0700439 return new Point(availableWidthPx - 2 * gap, dropTargetBarSizePx);
Winson Chungb3800242013-10-24 11:01:54 -0700440 }
Winson Chungb3800242013-10-24 11:01:54 -0700441 }
442
Sunny Goyal756cd262015-08-20 12:33:21 -0700443 public Point getCellSize() {
444 Point result = new Point();
445 // Since we are only concerned with the overall padding, layout direction does
446 // not matter.
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700447 Point padding = getTotalWorkspacePadding();
Jon Miranda8632d9d2017-07-18 12:42:15 -0700448 int cellPadding = cellLayoutPaddingLeftRightPx * 2;
449 result.x = calculateCellWidth(availableWidthPx - padding.x - cellPadding, inv.numColumns);
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700450 result.y = calculateCellHeight(availableHeightPx - padding.y, inv.numRows);
Sunny Goyal756cd262015-08-20 12:33:21 -0700451 return result;
452 }
453
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700454 public Point getTotalWorkspacePadding() {
Sunny Goyal6178f132016-07-11 17:30:03 -0700455 Rect padding = getWorkspacePadding(null);
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700456 return new Point(padding.left + padding.right, padding.top + padding.bottom);
457 }
458
459 /**
460 * Returns the workspace padding in the specified orientation.
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700461 */
Sunny Goyal6178f132016-07-11 17:30:03 -0700462 public Rect getWorkspacePadding(Rect recycle) {
463 Rect padding = recycle == null ? new Rect() : recycle;
Tony Wickham3a3517f2015-10-06 11:27:04 -0700464 if (isVerticalBarLayout()) {
Winson1f064272016-07-18 17:18:02 -0700465 if (mInsets.left > 0) {
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700466 padding.set(mInsets.left + pageIndicatorLandGutterPx,
467 0,
468 hotseatBarHeightPx + hotseatLandLeftNavBarGutterPx
469 + hotseatBarLeftNavBarRightPaddingPx - mInsets.left,
470 edgeMarginPx);
Winson1f064272016-07-18 17:18:02 -0700471 } else {
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700472 padding.set(pageIndicatorLandGutterPx,
473 0,
474 hotseatBarHeightPx + hotseatLandRightNavBarGutterPx
475 + hotseatBarRightNavBarRightPaddingPx,
476 edgeMarginPx);
Winson1f064272016-07-18 17:18:02 -0700477 }
Winson Chungb3800242013-10-24 11:01:54 -0700478 } else {
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700479 int paddingBottom = hotseatBarHeightPx + pageIndicatorSizePx;
Sunny Goyalc6205602015-05-21 20:46:33 -0700480 if (isTablet) {
Winson Chungb3800242013-10-24 11:01:54 -0700481 // Pad the left and right of the workspace to ensure consistent spacing
482 // between all icons
Winson Chung4f3bfad2015-07-13 11:14:30 -0700483 int width = getCurrentWidth();
484 int height = getCurrentHeight();
Tony Wickhamd6b40372015-09-23 18:37:57 -0700485 // The amount of screen space available for left/right padding.
Sunny Goyalf5440cb2016-12-14 15:13:00 -0800486 int availablePaddingX = Math.max(0, width - ((inv.numColumns * cellWidthPx) +
487 ((inv.numColumns - 1) * cellWidthPx)));
Tony Wickhamd6b40372015-09-23 18:37:57 -0700488 availablePaddingX = (int) Math.min(availablePaddingX,
489 width * MAX_HORIZONTAL_PADDING_PERCENT);
Sunny Goyal47328fd2016-05-25 18:56:41 -0700490 int availablePaddingY = Math.max(0, height - topWorkspacePadding - paddingBottom
Jon Mirandac1b08c52016-11-15 14:37:56 -0800491 - (2 * inv.numRows * cellHeightPx) - hotseatBarTopPaddingPx
492 - hotseatBarBottomPaddingPx);
Sunny Goyal47328fd2016-05-25 18:56:41 -0700493 padding.set(availablePaddingX / 2, topWorkspacePadding + availablePaddingY / 2,
Tony Wickhamd6b40372015-09-23 18:37:57 -0700494 availablePaddingX / 2, paddingBottom + availablePaddingY / 2);
Winson Chungb3800242013-10-24 11:01:54 -0700495 } else {
496 // Pad the top and bottom of the workspace with search/hotseat bar sizes
Winson1f064272016-07-18 17:18:02 -0700497 padding.set(desiredWorkspaceLeftRightMarginPx,
Sunny Goyal47328fd2016-05-25 18:56:41 -0700498 topWorkspacePadding,
Winson1f064272016-07-18 17:18:02 -0700499 desiredWorkspaceLeftRightMarginPx,
Winsonfadbe8f2016-07-22 16:35:37 -0700500 paddingBottom);
Winson Chungb3800242013-10-24 11:01:54 -0700501 }
502 }
503 return padding;
504 }
505
Winsonfadbe8f2016-07-22 16:35:37 -0700506 /**
507 * @return the bounds for which the open folders should be contained within
508 */
509 public Rect getAbsoluteOpenFolderBounds() {
510 if (isVerticalBarLayout()) {
511 // Folders should only appear right of the drop target bar and left of the hotseat
512 return new Rect(mInsets.left + dropTargetBarSizePx + edgeMarginPx,
513 mInsets.top,
514 mInsets.left + availableWidthPx - hotseatBarHeightPx - edgeMarginPx,
515 mInsets.top + availableHeightPx);
516 } else {
517 // Folders should only appear below the drop target bar and above the hotseat
518 return new Rect(mInsets.left,
519 mInsets.top + dropTargetBarSizePx + edgeMarginPx,
520 mInsets.left + availableWidthPx,
Jon Miranda2ed276e2017-06-29 11:36:34 -0700521 mInsets.top + availableHeightPx - hotseatBarHeightPx
522 - pageIndicatorSizePx - edgeMarginPx);
Winsonfadbe8f2016-07-22 16:35:37 -0700523 }
524 }
525
Sunny Goyal47328fd2016-05-25 18:56:41 -0700526 private int getWorkspacePageSpacing() {
Tony Wickham3a3517f2015-10-06 11:27:04 -0700527 if (isVerticalBarLayout() || isLargeTablet) {
Winson Chungb3800242013-10-24 11:01:54 -0700528 // In landscape mode the page spacing is set to the default.
529 return defaultPageSpacingPx;
530 } else {
531 // In portrait, we want the pages spaced such that there is no
532 // overhang of the previous / next page into the current page viewport.
533 // We assume symmetrical padding in portrait mode.
Jon Miranda28032002017-07-13 16:18:56 -0700534 return Math.max(defaultPageSpacingPx, getWorkspacePadding(null).left + 1);
Winson Chungb3800242013-10-24 11:01:54 -0700535 }
536 }
537
Winson Chung4f7eb402015-07-10 18:00:48 -0700538 int getOverviewModeButtonBarHeight() {
Winson Chungb3800242013-10-24 11:01:54 -0700539 int zoneHeight = (int) (overviewModeIconZoneRatio * availableHeightPx);
540 zoneHeight = Math.min(overviewModeMaxIconZoneHeightPx,
541 Math.max(overviewModeMinIconZoneHeightPx, zoneHeight));
Winson Chung4f7eb402015-07-10 18:00:48 -0700542 return zoneHeight;
Winson Chungb3800242013-10-24 11:01:54 -0700543 }
544
Adam Cohen2e6da152015-05-06 11:42:25 -0700545 public static int calculateCellWidth(int width, int countX) {
Winson Chungb3800242013-10-24 11:01:54 -0700546 return width / countX;
547 }
Adam Cohen2e6da152015-05-06 11:42:25 -0700548 public static int calculateCellHeight(int height, int countY) {
Winson Chungb3800242013-10-24 11:01:54 -0700549 return height / countY;
550 }
551
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -0700552 /**
Tony Wickham55616cd2015-09-23 14:55:17 -0700553 * When {@code true}, the device is in landscape mode and the hotseat is on the right column.
554 * When {@code false}, either device is in portrait mode or the device is in landscape mode and
555 * the hotseat is on the bottom row.
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -0700556 */
Tony Wickhamab946a12015-09-16 15:38:16 -0700557 public boolean isVerticalBarLayout() {
Winson Chungb3800242013-10-24 11:01:54 -0700558 return isLandscape && transposeLayoutWithOrientation;
559 }
560
561 boolean shouldFadeAdjacentWorkspaceScreens() {
Sunny Goyalc6205602015-05-21 20:46:33 -0700562 return isVerticalBarLayout() || isLargeTablet;
Winson Chungb3800242013-10-24 11:01:54 -0700563 }
564
Sunny Goyalc6205602015-05-21 20:46:33 -0700565 private int getVisibleChildCount(ViewGroup parent) {
Jorim Jaggid017f882014-01-14 17:08:48 -0800566 int visibleChildren = 0;
567 for (int i = 0; i < parent.getChildCount(); i++) {
568 if (parent.getChildAt(i).getVisibility() != View.GONE) {
569 visibleChildren++;
570 }
571 }
572 return visibleChildren;
573 }
574
Winson1f064272016-07-18 17:18:02 -0700575 public void layout(Launcher launcher, boolean notifyListeners) {
Winson Chungb3800242013-10-24 11:01:54 -0700576 FrameLayout.LayoutParams lp;
Winson Chungb3800242013-10-24 11:01:54 -0700577 boolean hasVerticalBarLayout = isVerticalBarLayout();
578
579 // Layout the search bar space
Sunny Goyal47328fd2016-05-25 18:56:41 -0700580 Point searchBarBounds = getSearchBarDimensForWidgetOpts();
581 View searchBar = launcher.getDropTargetBar();
Sunny Goyalf37a2142016-03-24 17:28:25 -0700582 lp = (FrameLayout.LayoutParams) searchBar.getLayoutParams();
Sunny Goyal47328fd2016-05-25 18:56:41 -0700583 lp.width = searchBarBounds.x;
584 lp.height = searchBarBounds.y;
Jon Miranda28032002017-07-13 16:18:56 -0700585 lp.topMargin = mInsets.top + edgeMarginPx;
Winson Chungb3800242013-10-24 11:01:54 -0700586 searchBar.setLayoutParams(lp);
587
Winson Chungb3800242013-10-24 11:01:54 -0700588 // Layout the workspace
589 PagedView workspace = (PagedView) launcher.findViewById(R.id.workspace);
Winson1f064272016-07-18 17:18:02 -0700590 Rect workspacePadding = getWorkspacePadding(null);
591 workspace.setPadding(workspacePadding.left, workspacePadding.top, workspacePadding.right,
592 workspacePadding.bottom);
Sunny Goyal47328fd2016-05-25 18:56:41 -0700593 workspace.setPageSpacing(getWorkspacePageSpacing());
Winson Chungb3800242013-10-24 11:01:54 -0700594
595 // Layout the hotseat
Winson6231ede2016-07-20 17:21:55 -0700596 Hotseat hotseat = (Hotseat) launcher.findViewById(R.id.hotseat);
Winson Chungb3800242013-10-24 11:01:54 -0700597 lp = (FrameLayout.LayoutParams) hotseat.getLayoutParams();
Tony Wickhamd6b40372015-09-23 18:37:57 -0700598 // We want the edges of the hotseat to line up with the edges of the workspace, but the
599 // icons in the hotseat are a different size, and so don't line up perfectly. To account for
600 // this, we pad the left and right of the hotseat with half of the difference of a workspace
601 // cell vs a hotseat cell.
602 float workspaceCellWidth = (float) getCurrentWidth() / inv.numColumns;
603 float hotseatCellWidth = (float) getCurrentWidth() / inv.numHotseatIcons;
604 int hotseatAdjustment = Math.round((workspaceCellWidth - hotseatCellWidth) / 2);
Winson Chungb3800242013-10-24 11:01:54 -0700605 if (hasVerticalBarLayout) {
Winson Chungf8c6f882015-06-03 11:27:26 -0700606 // Vertical hotseat -- The hotseat is fixed in the layout to be on the right of the
607 // screen regardless of RTL
608 lp.gravity = Gravity.RIGHT;
Winson1f064272016-07-18 17:18:02 -0700609 lp.width = hotseatBarHeightPx + mInsets.left + mInsets.right;
Winson Chungb3800242013-10-24 11:01:54 -0700610 lp.height = LayoutParams.MATCH_PARENT;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700611
612 int paddingRight = mInsets.left > 0
613 ? hotseatBarLeftNavBarRightPaddingPx
614 : hotseatBarRightNavBarRightPaddingPx;
615
Jon Miranda52ff3252017-07-14 11:39:16 -0700616 hotseat.getLayout().setPadding(mInsets.left + cellLayoutPaddingLeftRightPx,
617 mInsets.top, mInsets.right + paddingRight + cellLayoutPaddingLeftRightPx,
Winson6231ede2016-07-20 17:21:55 -0700618 workspacePadding.bottom);
Sunny Goyalc6205602015-05-21 20:46:33 -0700619 } else if (isTablet) {
Winson Chung59a488a2013-12-10 12:32:14 -0800620 // Pad the hotseat with the workspace padding calculated above
Winson Chungb3800242013-10-24 11:01:54 -0700621 lp.gravity = Gravity.BOTTOM;
622 lp.width = LayoutParams.MATCH_PARENT;
Winson1f064272016-07-18 17:18:02 -0700623 lp.height = hotseatBarHeightPx + mInsets.bottom;
Jon Miranda52ff3252017-07-14 11:39:16 -0700624 hotseat.getLayout().setPadding(hotseatAdjustment + workspacePadding.left
625 + cellLayoutPaddingLeftRightPx,
626 hotseatBarTopPaddingPx,
627 hotseatAdjustment + workspacePadding.right + cellLayoutPaddingLeftRightPx,
Jon Mirandac1b08c52016-11-15 14:37:56 -0800628 hotseatBarBottomPaddingPx + mInsets.bottom);
Winson Chungb3800242013-10-24 11:01:54 -0700629 } else {
630 // For phones, layout the hotseat without any bottom margin
631 // to ensure that we have space for the folders
632 lp.gravity = Gravity.BOTTOM;
633 lp.width = LayoutParams.MATCH_PARENT;
Winson1f064272016-07-18 17:18:02 -0700634 lp.height = hotseatBarHeightPx + mInsets.bottom;
Jon Miranda52ff3252017-07-14 11:39:16 -0700635 hotseat.getLayout().setPadding(hotseatAdjustment + workspacePadding.left
636 + cellLayoutPaddingLeftRightPx,
637 hotseatBarTopPaddingPx,
638 hotseatAdjustment + workspacePadding.right + cellLayoutPaddingLeftRightPx,
Jon Mirandac1b08c52016-11-15 14:37:56 -0800639 hotseatBarBottomPaddingPx + mInsets.bottom);
Winson Chungb3800242013-10-24 11:01:54 -0700640 }
641 hotseat.setLayoutParams(lp);
642
643 // Layout the page indicators
644 View pageIndicator = launcher.findViewById(R.id.page_indicator);
645 if (pageIndicator != null) {
Hyunyoung Song7d2fc812016-06-15 12:51:30 -0700646 lp = (FrameLayout.LayoutParams) pageIndicator.getLayoutParams();
Winson1f064272016-07-18 17:18:02 -0700647 if (isVerticalBarLayout()) {
648 if (mInsets.left > 0) {
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700649 lp.leftMargin = mInsets.left;
650 } else {
651 lp.leftMargin = pageIndicatorLandWorkspaceOffsetPx;
Winson1f064272016-07-18 17:18:02 -0700652 }
653 lp.bottomMargin = workspacePadding.bottom;
654 } else {
Winson Chungb3800242013-10-24 11:01:54 -0700655 // Put the page indicators above the hotseat
Winson Chungb3800242013-10-24 11:01:54 -0700656 lp.gravity = Gravity.CENTER_HORIZONTAL | Gravity.BOTTOM;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700657 lp.height = pageIndicatorSizePx;
Winson1f064272016-07-18 17:18:02 -0700658 lp.bottomMargin = hotseatBarHeightPx + mInsets.bottom;
Winson Chungb3800242013-10-24 11:01:54 -0700659 }
Hyunyoung Song7d2fc812016-06-15 12:51:30 -0700660 pageIndicator.setLayoutParams(lp);
Winson Chungb3800242013-10-24 11:01:54 -0700661 }
662
Winson Chungb3800242013-10-24 11:01:54 -0700663 // Layout the Overview Mode
Jorim Jaggid017f882014-01-14 17:08:48 -0800664 ViewGroup overviewMode = launcher.getOverviewPanel();
Winson Chungb3800242013-10-24 11:01:54 -0700665 if (overviewMode != null) {
Sunny Goyal8dfe2da2014-10-24 16:26:52 -0700666 int visibleChildCount = getVisibleChildCount(overviewMode);
667 int totalItemWidth = visibleChildCount * overviewModeBarItemWidthPx;
Jon Mirandadf3bc522016-11-01 16:55:56 -0700668 int maxWidth = totalItemWidth + (visibleChildCount - 1) * overviewModeBarSpacerWidthPx;
Sunny Goyal8dfe2da2014-10-24 16:26:52 -0700669
Jon Mirandadf3bc522016-11-01 16:55:56 -0700670 lp = (FrameLayout.LayoutParams) overviewMode.getLayoutParams();
Sunny Goyal8dfe2da2014-10-24 16:26:52 -0700671 lp.width = Math.min(availableWidthPx, maxWidth);
Jon Mirandadf3bc522016-11-01 16:55:56 -0700672 lp.height = getOverviewModeButtonBarHeight() + mInsets.bottom;
Winson Chungb3800242013-10-24 11:01:54 -0700673 overviewMode.setLayoutParams(lp);
Winson1f064272016-07-18 17:18:02 -0700674 }
Sunny Goyal8dfe2da2014-10-24 16:26:52 -0700675
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700676 // Layout the AllAppsRecyclerView
677 View view = launcher.findViewById(R.id.apps_list_view);
Jon Miranda28032002017-07-13 16:18:56 -0700678 int paddingLeftRight = desiredWorkspaceLeftRightMarginPx + cellLayoutPaddingLeftRightPx;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700679 view.setPadding(paddingLeftRight, view.getPaddingTop(), paddingLeftRight,
680 view.getPaddingBottom());
681
Winson1f064272016-07-18 17:18:02 -0700682 if (notifyListeners) {
683 for (int i = mListeners.size() - 1; i >= 0; i--) {
684 mListeners.get(i).onLauncherLayoutChanged();
Sunny Goyal8dfe2da2014-10-24 16:26:52 -0700685 }
Winson Chungb3800242013-10-24 11:01:54 -0700686 }
687 }
Winson Chung4f3bfad2015-07-13 11:14:30 -0700688
689 private int getCurrentWidth() {
690 return isLandscape
691 ? Math.max(widthPx, heightPx)
692 : Math.min(widthPx, heightPx);
693 }
694
695 private int getCurrentHeight() {
696 return isLandscape
697 ? Math.min(widthPx, heightPx)
698 : Math.max(widthPx, heightPx);
699 }
Sunny Goyal13178ac2016-04-04 16:35:22 -0700700
Sunny Goyalc13403c2016-11-18 23:44:48 -0800701 public int getCellHeight(@ContainerType int containerType) {
702 switch (containerType) {
703 case CellLayout.WORKSPACE:
704 return cellHeightPx;
705 case CellLayout.FOLDER:
706 return folderCellHeightPx;
707 case CellLayout.HOTSEAT:
708 return hotseatCellHeightPx;
709 default:
710 // ??
711 return 0;
712 }
713 }
Sunny Goyal13178ac2016-04-04 16:35:22 -0700714
Winson1f064272016-07-18 17:18:02 -0700715 /**
716 * @return the left/right paddings for all containers.
717 */
Jon Mirandac3e4e222016-11-02 16:56:52 -0700718 public final int[] getContainerPadding() {
Winson1f064272016-07-18 17:18:02 -0700719 // No paddings for portrait phone
720 if (isPhone && !isVerticalBarLayout()) {
721 return new int[] {0, 0};
Sunny Goyal13178ac2016-04-04 16:35:22 -0700722 }
Winson1f064272016-07-18 17:18:02 -0700723
Hyunyoung Song9d96fd52016-08-23 11:06:24 -0700724 // In landscape, we match the width of the workspace
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700725 Rect padding = getWorkspacePadding(null);
726 return new int[] { padding.left - mInsets.left, padding.right + mInsets.left};
Sunny Goyal13178ac2016-04-04 16:35:22 -0700727 }
Jon Mirandacc42c5b2016-10-27 17:15:27 -0700728
Jon Miranda51f037d2016-11-07 08:37:20 -0800729 public boolean shouldIgnoreLongPressToOverview(float touchX) {
Jon Mirandacc42c5b2016-10-27 17:15:27 -0700730 boolean inMultiWindowMode = this != inv.landscapeProfile && this != inv.portraitProfile;
Jon Miranda51f037d2016-11-07 08:37:20 -0800731 boolean touchedLhsEdge = mInsets.left == 0 && touchX < edgeMarginPx;
732 boolean touchedRhsEdge = mInsets.right == 0 && touchX > (widthPx - edgeMarginPx);
Jon Mirandacc42c5b2016-10-27 17:15:27 -0700733 return !inMultiWindowMode && (touchedLhsEdge || touchedRhsEdge);
734 }
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700735
736 private static Context getContext(Context c, int orientation) {
737 Configuration context = new Configuration(c.getResources().getConfiguration());
738 context.orientation = orientation;
739 return c.createConfigurationContext(context);
740
741 }
Winson Chungb3800242013-10-24 11:01:54 -0700742}