src/com/android/launcher3/DeviceProfile.java

   1 /*
   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
  17 package com.android.launcher3;
  18
  19 import android.appwidget.AppWidgetHostView;
  20 import android.content.ComponentName;
  21 import android.content.Context;
  22 import android.content.res.Resources;
  23 import android.graphics.Point;
  24 import android.graphics.PointF;
  25 import android.graphics.Rect;
  26 import android.util.DisplayMetrics;
  27 import android.view.Gravity;
  28 import android.view.View;
  29 import android.view.ViewGroup;
  30 import android.view.ViewGroup.LayoutParams;
  31 import android.widget.FrameLayout;
  32
  33 import com.android.launcher3.CellLayout.ContainerType;
  34 import com.android.launcher3.badge.BadgeRenderer;
  35 import com.android.launcher3.config.FeatureFlags;
  36
  37 import java.util.ArrayList;
  38
  39 public class DeviceProfile {
  40
  41     public interface LauncherLayoutChangeListener {
  42         void onLauncherLayoutChanged();
  43     }
  44
  45     public final InvariantDeviceProfile inv;
  46
  47     // Device properties
  48     public final boolean isTablet;
  49     public final boolean isLargeTablet;
  50     public final boolean isPhone;
  51     public final boolean transposeLayoutWithOrientation;
  52
  53     // 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;
  59     /**
  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;
  65
  66     // 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;
  72
  73     // Workspace
  74     private int desiredWorkspaceLeftRightMarginPx;
  75     public final int edgeMarginPx;
  76     public final Rect defaultWidgetPadding;
  77     private final int defaultPageSpacingPx;
  78     private final int topWorkspacePadding;
  79     public float workspaceSpringLoadShrinkFactor;
  80     public final int workspaceSpringLoadedBottomSpace;
  81
  82     // Page indicator
  83     private final int pageIndicatorHeightPx;
  84     private final int pageIndicatorLandGutterLeftNavBarPx;
  85     private final int pageIndicatorLandGutterRightNavBarPx;
  86     private final int pageIndicatorLandWorkspaceOffsetPx;
  87
  88     // Workspace icons
  89     public int iconSizePx;
  90     public int iconTextSizePx;
  91     public int iconDrawablePaddingPx;
  92     public int iconDrawablePaddingOriginalPx;
  93
  94     public int cellWidthPx;
  95     public int cellHeightPx;
  96
  97     // Folder
  98     public int folderBackgroundOffset;
  99     public int folderIconSizePx;
 100     public int folderIconPreviewPadding;
 101
 102     // Folder cell
 103     public int folderCellWidthPx;
 104     public int folderCellHeightPx;
 105
 106     // Folder child
 107     public int folderChildIconSizePx;
 108     public int folderChildTextSizePx;
 109     public int folderChildDrawablePaddingPx;
 110
 111     // Hotseat
 112     public int hotseatCellWidthPx;
 113     public int hotseatCellHeightPx;
 114     public int hotseatIconSizePx;
 115     public int hotseatBarHeightPx;
 116     private int hotseatBarTopPaddingPx;
 117     private int hotseatBarBottomPaddingPx;
 118     private int hotseatLandGutterPx;
 119
 120     // All apps
 121     public int allAppsNumCols;
 122     public int allAppsNumPredictiveCols;
 123     public int allAppsButtonVisualSize;
 124     public int allAppsIconSizePx;
 125     public int allAppsIconDrawablePaddingPx;
 126     public float allAppsIconTextSizePx;
 127
 128     // Widgets
 129     public final PointF appWidgetScale = new PointF(1.0f, 1.0f);
 130
 131     // Drop Target
 132     public int dropTargetBarSizePx;
 133
 134     // Insets
 135     private Rect mInsets = new Rect();
 136
 137     // Listeners
 138     private ArrayList<LauncherLayoutChangeListener> mListeners = new ArrayList<>();
 139
 140     // Icon badges
 141     public BadgeRenderer mBadgeRenderer;
 142
 143     public DeviceProfile(Context context, InvariantDeviceProfile inv,
 144             Point minSize, Point maxSize,
 145             int width, int height, boolean isLandscape) {
 146
 147         this.inv = inv;
 148         this.isLandscape = isLandscape;
 149
 150         Resources res = context.getResources();
 151         DisplayMetrics dm = res.getDisplayMetrics();
 152
 153         // Constants from resources
 154         isTablet = res.getBoolean(R.bool.is_tablet);
 155         isLargeTablet = res.getBoolean(R.bool.is_large_tablet);
 156         isPhone = !isTablet && !isLargeTablet;
 157
 158         // Some more constants
 159         transposeLayoutWithOrientation =
 160                 res.getBoolean(R.bool.hotseat_transpose_layout_with_orientation);
 161
 162         ComponentName cn = new ComponentName(context.getPackageName(),
 163                 this.getClass().getName());
 164         defaultWidgetPadding = AppWidgetHostView.getDefaultPaddingForWidget(context, cn, null);
 165         edgeMarginPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_edge_margin);
 166         desiredWorkspaceLeftRightMarginPx = edgeMarginPx;
 167         pageIndicatorHeightPx =
 168                 res.getDimensionPixelSize(R.dimen.dynamic_grid_page_indicator_height);
 169         pageIndicatorLandGutterLeftNavBarPx = res.getDimensionPixelSize(
 170                 R.dimen.dynamic_grid_page_indicator_gutter_width_left_nav_bar);
 171         pageIndicatorLandWorkspaceOffsetPx =
 172                 res.getDimensionPixelSize(R.dimen.all_apps_caret_workspace_offset);
 173         pageIndicatorLandGutterRightNavBarPx = res.getDimensionPixelSize(
 174                 R.dimen.dynamic_grid_page_indicator_gutter_width_right_nav_bar);
 175         defaultPageSpacingPx =
 176                 res.getDimensionPixelSize(R.dimen.dynamic_grid_workspace_page_spacing);
 177         topWorkspacePadding =
 178                 res.getDimensionPixelSize(R.dimen.dynamic_grid_workspace_top_padding);
 179         overviewModeMinIconZoneHeightPx =
 180                 res.getDimensionPixelSize(R.dimen.dynamic_grid_overview_min_icon_zone_height);
 181         overviewModeMaxIconZoneHeightPx =
 182                 res.getDimensionPixelSize(R.dimen.dynamic_grid_overview_max_icon_zone_height);
 183         overviewModeBarItemWidthPx =
 184                 res.getDimensionPixelSize(R.dimen.dynamic_grid_overview_bar_item_width);
 185         overviewModeBarSpacerWidthPx =
 186                 res.getDimensionPixelSize(R.dimen.dynamic_grid_overview_bar_spacer_width);
 187         overviewModeIconZoneRatio =
 188                 res.getInteger(R.integer.config_dynamic_grid_overview_icon_zone_percentage) / 100f;
 189         iconDrawablePaddingOriginalPx =
 190                 res.getDimensionPixelSize(R.dimen.dynamic_grid_icon_drawable_padding);
 191         dropTargetBarSizePx = res.getDimensionPixelSize(R.dimen.dynamic_grid_drop_target_size);
 192         workspaceSpringLoadedBottomSpace =
 193                 res.getDimensionPixelSize(R.dimen.dynamic_grid_min_spring_loaded_space);
 194         hotseatBarHeightPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_height);
 195         hotseatBarTopPaddingPx =
 196                 res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_top_padding);
 197         hotseatBarBottomPaddingPx = 0;
 198         hotseatLandGutterPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_gutter_width);
 199
 200         // Determine sizes.
 201         widthPx = width;
 202         heightPx = height;
 203         if (isLandscape) {
 204             availableWidthPx = maxSize.x;
 205             availableHeightPx = minSize.y;
 206         } else {
 207             availableWidthPx = minSize.x;
 208             availableHeightPx = maxSize.y;
 209         }
 210
 211         // Calculate the remaining vars
 212         updateAvailableDimensions(dm, res);
 213         computeAllAppsButtonSize(context);
 214
 215         // This is done last, after iconSizePx is calculated above.
 216         mBadgeRenderer = new BadgeRenderer(context, iconSizePx);
 217     }
 218
 219     DeviceProfile getMultiWindowProfile(Context context, Point mwSize) {
 220         // In multi-window mode, we can have widthPx = availableWidthPx
 221         // and heightPx = availableHeightPx because Launcher uses the InvariantDeviceProfiles'
 222         // widthPx and heightPx values where it's needed.
 223         DeviceProfile profile = new DeviceProfile(context, inv, mwSize, mwSize, mwSize.x, mwSize.y,
 224                 isLandscape);
 225
 226         // Hide labels on the workspace.
 227         profile.iconTextSizePx = 0;
 228         profile.cellHeightPx = profile.iconSizePx + profile.iconDrawablePaddingPx
 229                 + Utilities.calculateTextHeight(profile.iconTextSizePx);
 230
 231         // The nav bar is black so we add bottom padding to visually center hotseat icons.
 232         profile.hotseatBarBottomPaddingPx = profile.hotseatBarTopPaddingPx;
 233
 234         // We use these scales to measure and layout the widgets using their full invariant profile
 235         // sizes and then draw them scaled and centered to fit in their multi-window mode cellspans.
 236         float appWidgetScaleX = (float) profile.getCellSize().x / getCellSize().x;
 237         float appWidgetScaleY = (float) profile.getCellSize().y / getCellSize().y;
 238         profile.appWidgetScale.set(appWidgetScaleX, appWidgetScaleY);
 239
 240         return profile;
 241     }
 242
 243     public void addLauncherLayoutChangedListener(LauncherLayoutChangeListener listener) {
 244         if (!mListeners.contains(listener)) {
 245             mListeners.add(listener);
 246         }
 247     }
 248
 249     public void removeLauncherLayoutChangedListener(LauncherLayoutChangeListener listener) {
 250         if (mListeners.contains(listener)) {
 251             mListeners.remove(listener);
 252         }
 253     }
 254
 255     /**
 256      * Determine the exact visual footprint of the all apps button, taking into account scaling
 257      * and internal padding of the drawable.
 258      */
 259     private void computeAllAppsButtonSize(Context context) {
 260         Resources res = context.getResources();
 261         float padding = res.getInteger(R.integer.config_allAppsButtonPaddingPercent) / 100f;
 262         allAppsButtonVisualSize = (int) (hotseatIconSizePx * (1 - padding)) - context.getResources()
 263                         .getDimensionPixelSize(R.dimen.all_apps_button_scale_down);
 264     }
 265
 266     private void updateAvailableDimensions(DisplayMetrics dm, Resources res) {
 267         updateIconSize(1f, iconDrawablePaddingOriginalPx, res, dm);
 268
 269         // Check to see if the icons fit within the available height.  If not, then scale down.
 270         float usedHeight = (cellHeightPx * inv.numRows);
 271         int maxHeight = (availableHeightPx - getTotalWorkspacePadding().y);
 272         if (usedHeight > maxHeight) {
 273             float scale = maxHeight / usedHeight;
 274             updateIconSize(scale, 0, res, dm);
 275         }
 276
 277         updateAvailableFolderCellDimensions(dm, res);
 278     }
 279
 280     private void updateIconSize(float scale, int drawablePadding, Resources res,
 281                                 DisplayMetrics dm) {
 282         iconSizePx = (int) (Utilities.pxFromDp(inv.iconSize, dm) * scale);
 283         iconTextSizePx = (int) (Utilities.pxFromSp(inv.iconTextSize, dm) * scale);
 284         iconDrawablePaddingPx = drawablePadding;
 285         hotseatIconSizePx = (int) (Utilities.pxFromDp(inv.hotseatIconSize, dm) * scale);
 286         allAppsIconSizePx = iconSizePx;
 287         allAppsIconDrawablePaddingPx = iconDrawablePaddingPx;
 288         allAppsIconTextSizePx = iconTextSizePx;
 289
 290         cellWidthPx = iconSizePx;
 291         cellHeightPx = iconSizePx + iconDrawablePaddingPx
 292                 + Utilities.calculateTextHeight(iconTextSizePx);
 293
 294         // Hotseat
 295         hotseatCellWidthPx = iconSizePx;
 296         hotseatCellHeightPx = iconSizePx;
 297
 298         if (!isVerticalBarLayout()) {
 299             int expectedWorkspaceHeight = availableHeightPx - hotseatBarHeightPx
 300                     - pageIndicatorHeightPx - topWorkspacePadding;
 301             float minRequiredHeight = dropTargetBarSizePx + workspaceSpringLoadedBottomSpace;
 302             workspaceSpringLoadShrinkFactor = Math.min(
 303                     res.getInteger(R.integer.config_workspaceSpringLoadShrinkPercentage) / 100.0f,
 304                     1 - (minRequiredHeight / expectedWorkspaceHeight));
 305         } else {
 306             workspaceSpringLoadShrinkFactor =
 307                     res.getInteger(R.integer.config_workspaceSpringLoadShrinkPercentage) / 100.0f;
 308         }
 309
 310         // Folder icon
 311         folderBackgroundOffset = -edgeMarginPx;
 312         folderIconSizePx = iconSizePx + 2 * -folderBackgroundOffset;
 313         folderIconPreviewPadding = res.getDimensionPixelSize(R.dimen.folder_preview_padding);
 314     }
 315
 316     private void updateAvailableFolderCellDimensions(DisplayMetrics dm, Resources res) {
 317         int folderBottomPanelSize = res.getDimensionPixelSize(R.dimen.folder_label_padding_top)
 318                 + res.getDimensionPixelSize(R.dimen.folder_label_padding_bottom)
 319                 + Utilities.calculateTextHeight(res.getDimension(R.dimen.folder_label_text_size));
 320
 321         updateFolderCellSize(1f, dm, res);
 322
 323         // Don't let the folder get too close to the edges of the screen.
 324         int folderMargin = 4 * edgeMarginPx;
 325
 326         // Check if the icons fit within the available height.
 327         float usedHeight = folderCellHeightPx * inv.numFolderRows + folderBottomPanelSize;
 328         int maxHeight = availableHeightPx - getTotalWorkspacePadding().y - folderMargin;
 329         float scaleY = maxHeight / usedHeight;
 330
 331         // Check if the icons fit within the available width.
 332         float usedWidth = folderCellWidthPx * inv.numFolderColumns;
 333         int maxWidth = availableWidthPx - getTotalWorkspacePadding().x - folderMargin;
 334         float scaleX = maxWidth / usedWidth;
 335
 336         float scale = Math.min(scaleX, scaleY);
 337         if (scale < 1f) {
 338             updateFolderCellSize(scale, dm, res);
 339         }
 340     }
 341
 342     private void updateFolderCellSize(float scale, DisplayMetrics dm, Resources res) {
 343         folderChildIconSizePx = (int) (Utilities.pxFromDp(inv.iconSize, dm) * scale);
 344         folderChildTextSizePx =
 345                 (int) (res.getDimensionPixelSize(R.dimen.folder_child_text_size) * scale);
 346
 347         int textHeight = Utilities.calculateTextHeight(folderChildTextSizePx);
 348         int cellPaddingX = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_x_padding) * scale);
 349         int cellPaddingY = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_y_padding) * scale);
 350
 351         folderCellWidthPx = folderChildIconSizePx + 2 * cellPaddingX;
 352         folderCellHeightPx = folderChildIconSizePx + 2 * cellPaddingY + textHeight;
 353         folderChildDrawablePaddingPx = Math.max(0,
 354                 (folderCellHeightPx - folderChildIconSizePx - textHeight) / 3);
 355     }
 356
 357     public void updateInsets(Rect insets) {
 358         mInsets.set(insets);
 359     }
 360
 361     public void updateAppsViewNumCols() {
 362         allAppsNumCols = allAppsNumPredictiveCols = inv.numColumns;
 363     }
 364
 365     /** Returns the width and height of the search bar, ignoring any padding. */
 366     public Point getSearchBarDimensForWidgetOpts() {
 367         if (isVerticalBarLayout()) {
 368             return new Point(dropTargetBarSizePx, availableHeightPx - 2 * edgeMarginPx);
 369         } else {
 370             int gap;
 371             if (isTablet) {
 372                 // Pad the left and right of the workspace to ensure consistent spacing
 373                 // between all icons
 374                 int width = getCurrentWidth();
 375                 // XXX: If the icon size changes across orientations, we will have to take
 376                 //      that into account here too.
 377                 gap = ((width - 2 * edgeMarginPx
 378                         - (inv.numColumns * cellWidthPx)) / (2 * (inv.numColumns + 1)))
 379                         + edgeMarginPx;
 380             } else {
 381                 gap = desiredWorkspaceLeftRightMarginPx - defaultWidgetPadding.right;
 382             }
 383             return new Point(availableWidthPx - 2 * gap, dropTargetBarSizePx);
 384         }
 385     }
 386
 387     public Point getCellSize() {
 388         Point result = new Point();
 389         // Since we are only concerned with the overall padding, layout direction does
 390         // not matter.
 391         Point padding = getTotalWorkspacePadding();
 392         result.x = calculateCellWidth(availableWidthPx - padding.x, inv.numColumns);
 393         result.y = calculateCellHeight(availableHeightPx - padding.y, inv.numRows);
 394         return result;
 395     }
 396
 397     public Point getTotalWorkspacePadding() {
 398         Rect padding = getWorkspacePadding(null);
 399         return new Point(padding.left + padding.right, padding.top + padding.bottom);
 400     }
 401
 402     /**
 403      * Returns the workspace padding in the specified orientation.
 404      * Note that it assumes that while in verticalBarLayout, the nav bar is on the right, as such
 405      * this value is not reliable.
 406      * Use {@link #getTotalWorkspacePadding()} instead.
 407      */
 408     public Rect getWorkspacePadding(Rect recycle) {
 409         Rect padding = recycle == null ? new Rect() : recycle;
 410         if (isVerticalBarLayout()) {
 411             if (mInsets.left > 0) {
 412                 padding.set(mInsets.left + pageIndicatorLandGutterLeftNavBarPx, 0,
 413                         hotseatBarHeightPx + hotseatLandGutterPx - mInsets.left, 2 * edgeMarginPx);
 414             } else {
 415                 padding.set(pageIndicatorLandGutterRightNavBarPx, 0,
 416                         hotseatBarHeightPx + hotseatLandGutterPx, 2 * edgeMarginPx);
 417             }
 418         } else {
 419             int paddingBottom = hotseatBarHeightPx + pageIndicatorHeightPx;
 420             if (isTablet) {
 421                 // Pad the left and right of the workspace to ensure consistent spacing
 422                 // between all icons
 423                 int width = getCurrentWidth();
 424                 int height = getCurrentHeight();
 425                 // The amount of screen space available for left/right padding.
 426                 int availablePaddingX = Math.max(0, width - ((inv.numColumns * cellWidthPx) +
 427                         ((inv.numColumns - 1) * cellWidthPx)));
 428                 availablePaddingX = (int) Math.min(availablePaddingX,
 429                             width * MAX_HORIZONTAL_PADDING_PERCENT);
 430                 int availablePaddingY = Math.max(0, height - topWorkspacePadding - paddingBottom
 431                         - (2 * inv.numRows * cellHeightPx) - hotseatBarTopPaddingPx
 432                         - hotseatBarBottomPaddingPx);
 433                 padding.set(availablePaddingX / 2, topWorkspacePadding + availablePaddingY / 2,
 434                         availablePaddingX / 2, paddingBottom + availablePaddingY / 2);
 435             } else {
 436                 // Pad the top and bottom of the workspace with search/hotseat bar sizes
 437                 padding.set(desiredWorkspaceLeftRightMarginPx,
 438                         topWorkspacePadding,
 439                         desiredWorkspaceLeftRightMarginPx,
 440                         paddingBottom);
 441             }
 442         }
 443         return padding;
 444     }
 445
 446     /**
 447      * @return the bounds for which the open folders should be contained within
 448      */
 449     public Rect getAbsoluteOpenFolderBounds() {
 450         if (isVerticalBarLayout()) {
 451             // Folders should only appear right of the drop target bar and left of the hotseat
 452             return new Rect(mInsets.left + dropTargetBarSizePx + edgeMarginPx,
 453                     mInsets.top,
 454                     mInsets.left + availableWidthPx - hotseatBarHeightPx - edgeMarginPx,
 455                     mInsets.top + availableHeightPx);
 456         } else {
 457             // Folders should only appear below the drop target bar and above the hotseat
 458             return new Rect(mInsets.left,
 459                     mInsets.top + dropTargetBarSizePx + edgeMarginPx,
 460                     mInsets.left + availableWidthPx,
 461                     mInsets.top + availableHeightPx - hotseatBarHeightPx - pageIndicatorHeightPx -
 462                             edgeMarginPx);
 463         }
 464     }
 465
 466     private int getWorkspacePageSpacing() {
 467         if (isVerticalBarLayout() || isLargeTablet) {
 468             // In landscape mode the page spacing is set to the default.
 469             return defaultPageSpacingPx;
 470         } else {
 471             // In portrait, we want the pages spaced such that there is no
 472             // overhang of the previous / next page into the current page viewport.
 473             // We assume symmetrical padding in portrait mode.
 474             return Math.max(defaultPageSpacingPx, getWorkspacePadding(null).left + 1);
 475         }
 476     }
 477
 478     int getOverviewModeButtonBarHeight() {
 479         int zoneHeight = (int) (overviewModeIconZoneRatio * availableHeightPx);
 480         zoneHeight = Math.min(overviewModeMaxIconZoneHeightPx,
 481                 Math.max(overviewModeMinIconZoneHeightPx, zoneHeight));
 482         return zoneHeight;
 483     }
 484
 485     public static int calculateCellWidth(int width, int countX) {
 486         return width / countX;
 487     }
 488     public static int calculateCellHeight(int height, int countY) {
 489         return height / countY;
 490     }
 491
 492     /**
 493      * When {@code true}, the device is in landscape mode and the hotseat is on the right column.
 494      * When {@code false}, either device is in portrait mode or the device is in landscape mode and
 495      * the hotseat is on the bottom row.
 496      */
 497     public boolean isVerticalBarLayout() {
 498         return isLandscape && transposeLayoutWithOrientation;
 499     }
 500
 501     boolean shouldFadeAdjacentWorkspaceScreens() {
 502         return isVerticalBarLayout() || isLargeTablet;
 503     }
 504
 505     private int getVisibleChildCount(ViewGroup parent) {
 506         int visibleChildren = 0;
 507         for (int i = 0; i < parent.getChildCount(); i++) {
 508             if (parent.getChildAt(i).getVisibility() != View.GONE) {
 509                 visibleChildren++;
 510             }
 511         }
 512         return visibleChildren;
 513     }
 514
 515     public void layout(Launcher launcher, boolean notifyListeners) {
 516         FrameLayout.LayoutParams lp;
 517         boolean hasVerticalBarLayout = isVerticalBarLayout();
 518
 519         // Layout the search bar space
 520         Point searchBarBounds = getSearchBarDimensForWidgetOpts();
 521         View searchBar = launcher.getDropTargetBar();
 522         lp = (FrameLayout.LayoutParams) searchBar.getLayoutParams();
 523         lp.width = searchBarBounds.x;
 524         lp.height = searchBarBounds.y;
 525         lp.topMargin = mInsets.top + edgeMarginPx;
 526         searchBar.setLayoutParams(lp);
 527
 528         // Layout the workspace
 529         PagedView workspace = (PagedView) launcher.findViewById(R.id.workspace);
 530         Rect workspacePadding = getWorkspacePadding(null);
 531         workspace.setPadding(workspacePadding.left, workspacePadding.top, workspacePadding.right,
 532                 workspacePadding.bottom);
 533         workspace.setPageSpacing(getWorkspacePageSpacing());
 534
 535         // Only display when enabled
 536         if (FeatureFlags.QSB_ON_FIRST_SCREEN) {
 537             View qsbContainer = launcher.getQsbContainer();
 538             lp = (FrameLayout.LayoutParams) qsbContainer.getLayoutParams();
 539             lp.topMargin = mInsets.top + workspacePadding.top;
 540             qsbContainer.setLayoutParams(lp);
 541         }
 542
 543         // Layout the hotseat
 544         Hotseat hotseat = (Hotseat) launcher.findViewById(R.id.hotseat);
 545         lp = (FrameLayout.LayoutParams) hotseat.getLayoutParams();
 546         // We want the edges of the hotseat to line up with the edges of the workspace, but the
 547         // icons in the hotseat are a different size, and so don't line up perfectly. To account for
 548         // this, we pad the left and right of the hotseat with half of the difference of a workspace
 549         // cell vs a hotseat cell.
 550         float workspaceCellWidth = (float) getCurrentWidth() / inv.numColumns;
 551         float hotseatCellWidth = (float) getCurrentWidth() / inv.numHotseatIcons;
 552         int hotseatAdjustment = Math.round((workspaceCellWidth - hotseatCellWidth) / 2);
 553         if (hasVerticalBarLayout) {
 554             // Vertical hotseat -- The hotseat is fixed in the layout to be on the right of the
 555             //                     screen regardless of RTL
 556             lp.gravity = Gravity.RIGHT;
 557             lp.width = hotseatBarHeightPx + mInsets.left + mInsets.right;
 558             lp.height = LayoutParams.MATCH_PARENT;
 559             hotseat.getLayout().setPadding(mInsets.left, mInsets.top, mInsets.right,
 560                     workspacePadding.bottom);
 561         } else if (isTablet) {
 562             // Pad the hotseat with the workspace padding calculated above
 563             lp.gravity = Gravity.BOTTOM;
 564             lp.width = LayoutParams.MATCH_PARENT;
 565             lp.height = hotseatBarHeightPx + mInsets.bottom;
 566             hotseat.getLayout().setPadding(hotseatAdjustment + workspacePadding.left,
 567                     hotseatBarTopPaddingPx, hotseatAdjustment + workspacePadding.right,
 568                     hotseatBarBottomPaddingPx + mInsets.bottom);
 569         } else {
 570             // For phones, layout the hotseat without any bottom margin
 571             // to ensure that we have space for the folders
 572             lp.gravity = Gravity.BOTTOM;
 573             lp.width = LayoutParams.MATCH_PARENT;
 574             lp.height = hotseatBarHeightPx + mInsets.bottom;
 575             hotseat.getLayout().setPadding(hotseatAdjustment + workspacePadding.left,
 576                     hotseatBarTopPaddingPx, hotseatAdjustment + workspacePadding.right,
 577                     hotseatBarBottomPaddingPx + mInsets.bottom);
 578         }
 579         hotseat.setLayoutParams(lp);
 580
 581         // Layout the page indicators
 582         View pageIndicator = launcher.findViewById(R.id.page_indicator);
 583         if (pageIndicator != null) {
 584             lp = (FrameLayout.LayoutParams) pageIndicator.getLayoutParams();
 585             if (isVerticalBarLayout()) {
 586                 if (mInsets.left > 0) {
 587                     lp.leftMargin = mInsets.left + pageIndicatorLandGutterLeftNavBarPx -
 588                             lp.width - pageIndicatorLandWorkspaceOffsetPx;
 589                 } else if (mInsets.right > 0) {
 590                     lp.leftMargin = pageIndicatorLandGutterRightNavBarPx - lp.width -
 591                             pageIndicatorLandWorkspaceOffsetPx;
 592                 }
 593                 lp.bottomMargin = workspacePadding.bottom;
 594             } else {
 595                 // Put the page indicators above the hotseat
 596                 lp.gravity = Gravity.CENTER_HORIZONTAL | Gravity.BOTTOM;
 597                 lp.height = pageIndicatorHeightPx;
 598                 lp.bottomMargin = hotseatBarHeightPx + mInsets.bottom;
 599             }
 600             pageIndicator.setLayoutParams(lp);
 601         }
 602
 603         // Layout the Overview Mode
 604         ViewGroup overviewMode = launcher.getOverviewPanel();
 605         if (overviewMode != null) {
 606             int visibleChildCount = getVisibleChildCount(overviewMode);
 607             int totalItemWidth = visibleChildCount * overviewModeBarItemWidthPx;
 608             int maxWidth = totalItemWidth + (visibleChildCount - 1) * overviewModeBarSpacerWidthPx;
 609
 610             lp = (FrameLayout.LayoutParams) overviewMode.getLayoutParams();
 611             lp.width = Math.min(availableWidthPx, maxWidth);
 612             lp.height = getOverviewModeButtonBarHeight() + mInsets.bottom;
 613             overviewMode.setLayoutParams(lp);
 614         }
 615
 616         if (notifyListeners) {
 617             for (int i = mListeners.size() - 1; i >= 0; i--) {
 618                 mListeners.get(i).onLauncherLayoutChanged();
 619             }
 620         }
 621     }
 622
 623     private int getCurrentWidth() {
 624         return isLandscape
 625                 ? Math.max(widthPx, heightPx)
 626                 : Math.min(widthPx, heightPx);
 627     }
 628
 629     private int getCurrentHeight() {
 630         return isLandscape
 631                 ? Math.min(widthPx, heightPx)
 632                 : Math.max(widthPx, heightPx);
 633     }
 634
 635     public int getCellHeight(@ContainerType int containerType) {
 636         switch (containerType) {
 637             case CellLayout.WORKSPACE:
 638                 return cellHeightPx;
 639             case CellLayout.FOLDER:
 640                 return folderCellHeightPx;
 641             case CellLayout.HOTSEAT:
 642                 return hotseatCellHeightPx;
 643             default:
 644                 // ??
 645                 return 0;
 646         }
 647     }
 648
 649     /**
 650      * @return the left/right paddings for all containers.
 651      */
 652     public final int[] getContainerPadding() {
 653         // No paddings for portrait phone
 654         if (isPhone && !isVerticalBarLayout()) {
 655             return new int[] {0, 0};
 656         }
 657
 658         // In landscape, we match the width of the workspace
 659         int padding = (pageIndicatorLandGutterRightNavBarPx +
 660                 hotseatBarHeightPx + hotseatLandGutterPx + mInsets.left) / 2;
 661         return new int[]{ padding, padding };
 662     }
 663
 664     public boolean shouldIgnoreLongPressToOverview(float touchX) {
 665         boolean inMultiWindowMode = this != inv.landscapeProfile && this != inv.portraitProfile;
 666         boolean touchedLhsEdge = mInsets.left == 0 && touchX < edgeMarginPx;
 667         boolean touchedRhsEdge = mInsets.right == 0 && touchX > (widthPx - edgeMarginPx);
 668         return !inMultiWindowMode && (touchedLhsEdge || touchedRhsEdge);
 669     }
 670 }