/* * Copyright (C) 2008 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.android.launcher3; import android.appwidget.AppWidgetHostView; import android.content.ComponentName; import android.content.Context; import android.content.res.Resources; import android.graphics.Paint; import android.graphics.Paint.FontMetrics; import android.graphics.Point; import android.graphics.Rect; import android.util.DisplayMetrics; import android.view.Gravity; import android.view.View; import android.view.ViewGroup; import android.view.ViewGroup.LayoutParams; import android.view.ViewGroup.MarginLayoutParams; import android.widget.FrameLayout; import android.widget.LinearLayout; import com.android.launcher3.settings.SettingsProvider; import com.android.launcher3.allapps.AllAppsContainerView; public class DeviceProfile { public final InvariantDeviceProfile inv; // Device properties public final boolean isTablet; public final boolean isLargeTablet; public final boolean isPhone; public final boolean transposeLayoutWithOrientation; // Device properties in current orientation public final boolean isLandscape; public final int widthPx; public final int heightPx; public final int availableWidthPx; public final int availableHeightPx; // Overview mode private final int overviewModeMinIconZoneHeightPx; private final int overviewModeMaxIconZoneHeightPx; private final int overviewModeBarItemWidthPx; private final int overviewModeBarSpacerWidthPx; private final float overviewModeIconZoneRatio; // Workspace private int desiredWorkspaceLeftRightMarginPx; public final int edgeMarginPx; public final Rect defaultWidgetPadding; private final int pageIndicatorHeightPx; private final int defaultPageSpacingPx; private float dragViewScale; // Workspace icons public int iconSizePx; public int iconTextSizePx; public int iconDrawablePaddingPx; public int iconDrawablePaddingOriginalPx; public int cellWidthPx; public int cellHeightPx; // Folder public int folderBackgroundOffset; public int folderIconSizePx; public int folderCellWidthPx; public int folderCellHeightPx; // Hotseat public int hotseatCellWidthPx; public int hotseatCellHeightPx; public int hotseatIconSizePx; private int hotseatBarHeightPx; // All apps public int allAppsNumCols; public int allAppsNumPredictiveCols; public int allAppsButtonVisualSize; public final int allAppsIconSizePx; public final int allAppsIconTextSizePx; // QSB public boolean searchBarVisible; private int searchBarSpaceWidthPx; private int searchBarSpaceHeightPx; private int defaultSearchBarSpaceHeightPx; public DeviceProfile(Context context, InvariantDeviceProfile inv, Point minSize, Point maxSize, int width, int height, boolean isLandscape) { this.inv = inv; this.isLandscape = isLandscape; Resources res = context.getResources(); DisplayMetrics dm = res.getDisplayMetrics(); // Constants from resources isTablet = res.getBoolean(R.bool.is_tablet); isLargeTablet = res.getBoolean(R.bool.is_large_tablet); isPhone = !isTablet && !isLargeTablet; // Some more constants transposeLayoutWithOrientation = res.getBoolean(R.bool.hotseat_transpose_layout_with_orientation); ComponentName cn = new ComponentName(context.getPackageName(), this.getClass().getName()); defaultWidgetPadding = AppWidgetHostView.getDefaultPaddingForWidget(context, cn, null); edgeMarginPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_edge_margin); desiredWorkspaceLeftRightMarginPx = 2 * edgeMarginPx; pageIndicatorHeightPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_page_indicator_height); defaultPageSpacingPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_workspace_page_spacing); overviewModeMinIconZoneHeightPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_overview_min_icon_zone_height); overviewModeMaxIconZoneHeightPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_overview_max_icon_zone_height); overviewModeBarItemWidthPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_overview_bar_item_width); overviewModeBarSpacerWidthPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_overview_bar_spacer_width); overviewModeIconZoneRatio = res.getInteger(R.integer.config_dynamic_grid_overview_icon_zone_percentage) / 100f; iconDrawablePaddingOriginalPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_icon_drawable_padding); // AllApps uses the original non-scaled icon text size allAppsIconTextSizePx = Utilities.pxFromDp(inv.iconTextSize, dm); // AllApps uses the original non-scaled icon size allAppsIconSizePx = Utilities.pxFromDp(inv.iconSize, dm); // Determine sizes. widthPx = width; heightPx = height; if (isLandscape) { availableWidthPx = maxSize.x; availableHeightPx = minSize.y; } else { availableWidthPx = minSize.x; availableHeightPx = maxSize.y; } // Calculate the remaining vars updateAvailableDimensions(dm, res); computeAllAppsButtonSize(context); // Search Bar searchBarVisible = isSearchBarEnabled(context); searchBarSpaceWidthPx = Math.min(searchBarSpaceWidthPx, widthPx); defaultSearchBarSpaceHeightPx = getSearchBarTopOffset() + res.getDimensionPixelSize(R.dimen.dynamic_grid_search_bar_height); searchBarSpaceHeightPx = 2 * edgeMarginPx + (searchBarVisible ? defaultSearchBarSpaceHeightPx - getSearchBarTopOffset() : 3 * edgeMarginPx); } /** * Determine the exact visual footprint of the all apps button, taking into account scaling * and internal padding of the drawable. */ private void computeAllAppsButtonSize(Context context) { Resources res = context.getResources(); float padding = res.getInteger(R.integer.config_allAppsButtonPaddingPercent) / 100f; allAppsButtonVisualSize = (int) (hotseatIconSizePx * (1 - padding)); } private void updateAvailableDimensions(DisplayMetrics dm, Resources res) { // Check to see if the icons fit in the new available height. If not, then we need to // shrink the icon size. float scale = 1f; int drawablePadding = iconDrawablePaddingOriginalPx; updateIconSize(1f, drawablePadding, res, dm); float usedHeight = (cellHeightPx * inv.numRows); // We only care about the top and bottom workspace padding, which is not affected by RTL. Rect workspacePadding = getWorkspacePadding(false /* isLayoutRtl */); int maxHeight = (availableHeightPx - workspacePadding.top - workspacePadding.bottom); if (usedHeight > maxHeight) { scale = maxHeight / usedHeight; drawablePadding = 0; } updateIconSize(scale, drawablePadding, res, dm); } private void updateIconSize(float scale, int drawablePadding, Resources res, DisplayMetrics dm) { iconSizePx = (int) (Utilities.pxFromDp(inv.iconSize, dm) * scale); iconTextSizePx = (int) (Utilities.pxFromSp(inv.iconTextSize, dm) * scale); iconDrawablePaddingPx = drawablePadding; hotseatIconSizePx = (int) (Utilities.pxFromDp(inv.hotseatIconSize, dm) * scale); // Search Bar searchBarSpaceWidthPx = Math.min(widthPx, res.getDimensionPixelSize(R.dimen.dynamic_grid_search_bar_max_width)); defaultSearchBarSpaceHeightPx = getSearchBarTopOffset() + res.getDimensionPixelSize(R.dimen.dynamic_grid_search_bar_height); searchBarSpaceHeightPx = defaultSearchBarSpaceHeightPx; // Calculate the actual text height Paint textPaint = new Paint(); textPaint.setTextSize(iconTextSizePx); FontMetrics fm = textPaint.getFontMetrics(); cellWidthPx = iconSizePx; cellHeightPx = iconSizePx + iconDrawablePaddingPx + (int) Math.ceil(fm.bottom - fm.top); final float scaleDps = res.getDimensionPixelSize(R.dimen.dragViewScale); dragViewScale = (iconSizePx + scaleDps) / iconSizePx; // Hotseat hotseatBarHeightPx = iconSizePx + 4 * edgeMarginPx; hotseatCellWidthPx = iconSizePx; hotseatCellHeightPx = iconSizePx; // Folder folderCellWidthPx = cellWidthPx + 3 * edgeMarginPx; folderCellHeightPx = cellHeightPx + edgeMarginPx; folderBackgroundOffset = -edgeMarginPx; folderIconSizePx = iconSizePx + 2 * -folderBackgroundOffset; } /** * @param recyclerViewWidth the available width of the AllAppsRecyclerView */ public void updateAppsViewNumCols(Resources res, int recyclerViewWidth, int gridStrategy) { int appsViewLeftMarginPx = gridStrategy == AllAppsContainerView.SECTION_STRATEGY_GRID ? res.getDimensionPixelSize(R.dimen.all_apps_grid_view_start_margin) : res.getDimensionPixelSize(R.dimen.all_apps_grid_view_start_margin_with_sections); int allAppsCellWidthGap = gridStrategy == AllAppsContainerView.SECTION_STRATEGY_GRID ? res.getDimensionPixelSize(R.dimen.all_apps_icon_width_gap) : res.getDimensionPixelSize(R.dimen.all_apps_icon_width_gap_with_sections); int availableAppsWidthPx = (recyclerViewWidth > 0) ? recyclerViewWidth : availableWidthPx; int numAppsCols = (availableAppsWidthPx - appsViewLeftMarginPx) / (allAppsIconSizePx + allAppsCellWidthGap); int numPredictiveAppCols = Math.max(inv.minAllAppsPredictionColumns, numAppsCols); allAppsNumCols = numAppsCols; allAppsNumPredictiveCols = numPredictiveAppCols; } /** Returns the search bar top offset */ private int getSearchBarTopOffset() { if (isTablet && !isVerticalBarLayout()) { return searchBarVisible ? 4 * edgeMarginPx : 0; } else { return searchBarVisible ? 2 * edgeMarginPx : 0; } } /** Returns the search bar bounds in the current orientation */ public Rect getSearchBarBounds(boolean isLayoutRtl) { Rect bounds = new Rect(); if (isLandscape && transposeLayoutWithOrientation) { if (isLayoutRtl) { bounds.set(availableWidthPx - searchBarSpaceHeightPx, edgeMarginPx, availableWidthPx, availableHeightPx - edgeMarginPx); } else { bounds.set(0, edgeMarginPx, searchBarSpaceHeightPx, availableHeightPx - edgeMarginPx); } } else { if (isTablet) { // Pad the left and right of the workspace to ensure consistent spacing // between all icons int width = getCurrentWidth(); // XXX: If the icon size changes across orientations, we will have to take // that into account here too. int gap = (int) ((width - 2 * edgeMarginPx - (inv.numColumns * cellWidthPx)) / (2 * (inv.numColumns + 1))); bounds.set(edgeMarginPx + gap, getSearchBarTopOffset(), availableWidthPx - (edgeMarginPx + gap), searchBarVisible ? searchBarSpaceHeightPx : edgeMarginPx); } else { bounds.set(desiredWorkspaceLeftRightMarginPx - defaultWidgetPadding.left, getSearchBarTopOffset(), availableWidthPx - (desiredWorkspaceLeftRightMarginPx - defaultWidgetPadding.right), searchBarVisible ? searchBarSpaceHeightPx : edgeMarginPx); } } return bounds; } /** Returns the workspace padding in the specified orientation */ Rect getWorkspacePadding(boolean isLayoutRtl) { Rect searchBarBounds = getSearchBarBounds(isLayoutRtl); Rect padding = new Rect(); if (isLandscape && transposeLayoutWithOrientation) { // Pad the left and right of the workspace with search/hotseat bar sizes if (isLayoutRtl) { padding.set(hotseatBarHeightPx, edgeMarginPx, searchBarBounds.width(), edgeMarginPx); } else { padding.set(searchBarBounds.width(), edgeMarginPx, hotseatBarHeightPx, edgeMarginPx); } } else { if (isTablet) { // Pad the left and right of the workspace to ensure consistent spacing // between all icons float gapScale = 1f + (dragViewScale - 1f) / 2f; int width = getCurrentWidth(); int height = getCurrentHeight(); int paddingTop = searchBarBounds.bottom; int paddingBottom = hotseatBarHeightPx + pageIndicatorHeightPx; int availableWidth = Math.max(0, width - (int) ((inv.numColumns * cellWidthPx) + (inv.numColumns * gapScale * cellWidthPx))); int availableHeight = Math.max(0, height - paddingTop - paddingBottom - (int) (2 * inv.numRows * cellHeightPx)); padding.set(availableWidth / 2, paddingTop + availableHeight / 2, availableWidth / 2, paddingBottom + availableHeight / 2); } else { // Pad the top and bottom of the workspace with search/hotseat bar sizes padding.set(desiredWorkspaceLeftRightMarginPx - defaultWidgetPadding.left, searchBarBounds.bottom, desiredWorkspaceLeftRightMarginPx - defaultWidgetPadding.right, hotseatBarHeightPx + pageIndicatorHeightPx); } } return padding; } private int getWorkspacePageSpacing(boolean isLayoutRtl) { if ((isLandscape && transposeLayoutWithOrientation) || isLargeTablet) { // In landscape mode the page spacing is set to the default. return defaultPageSpacingPx; } else { // In portrait, we want the pages spaced such that there is no // overhang of the previous / next page into the current page viewport. // We assume symmetrical padding in portrait mode. return Math.max(defaultPageSpacingPx, 2 * getWorkspacePadding(isLayoutRtl).left); } } int getOverviewModeButtonBarHeight() { int zoneHeight = (int) (overviewModeIconZoneRatio * availableHeightPx); zoneHeight = Math.min(overviewModeMaxIconZoneHeightPx, Math.max(overviewModeMinIconZoneHeightPx, zoneHeight)); return zoneHeight; } // The rect returned will be extended to below the system ui that covers the workspace Rect getHotseatRect() { if (isVerticalBarLayout()) { return new Rect(availableWidthPx - hotseatBarHeightPx, 0, Integer.MAX_VALUE, availableHeightPx); } else { return new Rect(0, availableHeightPx - hotseatBarHeightPx, availableWidthPx, Integer.MAX_VALUE); } } public static int calculateCellWidth(int width, int countX) { return width / countX; } public static int calculateCellHeight(int height, int countY) { return height / countY; } /** * When {@code true}, hotseat is on the bottom row when in landscape mode. * If {@code false}, hotseat is on the right column when in landscape mode. */ boolean isVerticalBarLayout() { return isLandscape && transposeLayoutWithOrientation; } boolean shouldFadeAdjacentWorkspaceScreens() { return isVerticalBarLayout() || isLargeTablet; } private int getVisibleChildCount(ViewGroup parent) { int visibleChildren = 0; for (int i = 0; i < parent.getChildCount(); i++) { if (parent.getChildAt(i).getVisibility() != View.GONE) { visibleChildren++; } } return visibleChildren; } public void layoutSearchBar(Launcher launcher, boolean hasVerticalBarLayout) { // Update search bar for live settings searchBarVisible = isSearchBarEnabled(launcher); // Layout the search bar space View searchBar = launcher.getSearchDropTargetBar(); FrameLayout.LayoutParams lp = (FrameLayout.LayoutParams) searchBar.getLayoutParams(); if (hasVerticalBarLayout) { // If search bar is invisible add some extra padding for the drop targets searchBarSpaceHeightPx = searchBarVisible ? searchBarSpaceHeightPx : defaultSearchBarSpaceHeightPx + 5 * edgeMarginPx; // Vertical search bar space -- The search bar is fixed in the layout to be on the left // of the screen regardless of RTL lp.gravity = Gravity.LEFT; lp.width = searchBarSpaceHeightPx; LinearLayout targets = (LinearLayout) searchBar.findViewById(R.id.drag_target_bar); targets.setOrientation(LinearLayout.VERTICAL); FrameLayout.LayoutParams targetsLp = (FrameLayout.LayoutParams) targets.getLayoutParams(); targetsLp.gravity = Gravity.TOP; targetsLp.height = LayoutParams.WRAP_CONTENT; } else { // Horizontal search bar space lp.gravity = Gravity.TOP; lp.height = searchBarSpaceHeightPx; LinearLayout targets = (LinearLayout) searchBar.findViewById(R.id.drag_target_bar); targets.getLayoutParams().width = searchBarSpaceWidthPx; } searchBar.setLayoutParams(lp); View qsbBar = launcher.getOrCreateQsbBar(); if (qsbBar != null) { qsbBar.setVisibility(searchBarVisible ? View.VISIBLE : View.GONE); LayoutParams vglp = qsbBar.getLayoutParams(); vglp.width = LayoutParams.MATCH_PARENT; vglp.height = LayoutParams.MATCH_PARENT; qsbBar.setLayoutParams(vglp); } } public void layout(Launcher launcher) { FrameLayout.LayoutParams lp; boolean hasVerticalBarLayout = isVerticalBarLayout(); final boolean isLayoutRtl = Utilities.isRtl(launcher.getResources()); layoutSearchBar(launcher, hasVerticalBarLayout); // Layout the workspace PagedView workspace = (PagedView) launcher.findViewById(R.id.workspace); lp = (FrameLayout.LayoutParams) workspace.getLayoutParams(); lp.gravity = Gravity.CENTER; Rect padding = getWorkspacePadding(isLayoutRtl); workspace.setLayoutParams(lp); workspace.setPadding(padding.left, padding.top, padding.right, padding.bottom); workspace.setPageSpacing(getWorkspacePageSpacing(isLayoutRtl)); // Layout the hotseat View hotseat = launcher.findViewById(R.id.hotseat); lp = (FrameLayout.LayoutParams) hotseat.getLayoutParams(); if (hasVerticalBarLayout) { // Vertical hotseat -- The hotseat is fixed in the layout to be on the right of the // screen regardless of RTL lp.gravity = Gravity.RIGHT; lp.width = hotseatBarHeightPx; lp.height = LayoutParams.MATCH_PARENT; hotseat.findViewById(R.id.layout).setPadding(0, 2 * edgeMarginPx, 0, 2 * edgeMarginPx); } else if (isTablet) { // Pad the hotseat with the workspace padding calculated above lp.gravity = Gravity.BOTTOM; lp.width = LayoutParams.MATCH_PARENT; lp.height = hotseatBarHeightPx; hotseat.setPadding(edgeMarginPx + padding.left, 0, edgeMarginPx + padding.right, 2 * edgeMarginPx); } else { // For phones, layout the hotseat without any bottom margin // to ensure that we have space for the folders lp.gravity = Gravity.BOTTOM; lp.width = LayoutParams.MATCH_PARENT; lp.height = hotseatBarHeightPx; hotseat.findViewById(R.id.layout).setPadding(2 * edgeMarginPx, 0, 2 * edgeMarginPx, 0); } hotseat.setLayoutParams(lp); // Layout the page indicators View pageIndicator = launcher.findViewById(R.id.page_indicator); if (pageIndicator != null) { if (hasVerticalBarLayout) { // Hide the page indicators when we have vertical search/hotseat pageIndicator.setVisibility(View.GONE); } else { // Put the page indicators above the hotseat lp = (FrameLayout.LayoutParams) pageIndicator.getLayoutParams(); lp.gravity = Gravity.CENTER_HORIZONTAL | Gravity.BOTTOM; lp.width = LayoutParams.WRAP_CONTENT; lp.height = LayoutParams.WRAP_CONTENT; lp.bottomMargin = Math.max(hotseatBarHeightPx , lp.bottomMargin); pageIndicator.setLayoutParams(lp); } } // Layout the Overview Mode /*ViewGroup overviewMode = launcher.getOverviewPanel(); if (overviewMode != null) { int overviewButtonBarHeight = getOverviewModeButtonBarHeight(); lp = (FrameLayout.LayoutParams) overviewMode.getLayoutParams(); lp.gravity = Gravity.CENTER_HORIZONTAL | Gravity.BOTTOM; int visibleChildCount = getVisibleChildCount(overviewMode); int totalItemWidth = visibleChildCount * overviewModeBarItemWidthPx; int maxWidth = totalItemWidth + (visibleChildCount-1) * overviewModeBarSpacerWidthPx; lp.width = Math.min(availableWidthPx, maxWidth); lp.height = overviewButtonBarHeight; overviewMode.setLayoutParams(lp); if (lp.width > totalItemWidth && visibleChildCount > 1) { // We have enough space. Lets add some margin too. int margin = (lp.width - totalItemWidth) / (visibleChildCount-1); View lastChild = null; // Set margin of all visible children except the last visible child for (int i = 0; i < visibleChildCount; i++) { if (lastChild != null) { MarginLayoutParams clp = (MarginLayoutParams) lastChild.getLayoutParams(); if (isLayoutRtl) { clp.leftMargin = margin; } else { clp.rightMargin = margin; } lastChild.setLayoutParams(clp); lastChild = null; } View thisChild = overviewMode.getChildAt(i); if (thisChild.getVisibility() != View.GONE) { lastChild = thisChild; } } } }*/ } private int getCurrentWidth() { return isLandscape ? Math.max(widthPx, heightPx) : Math.min(widthPx, heightPx); } private int getCurrentHeight() { return isLandscape ? Math.min(widthPx, heightPx) : Math.max(widthPx, heightPx); } private boolean isSearchBarEnabled(Context context) { boolean searchActivityExists = Utilities.searchActivityExists(context); boolean isSearchEnabled = SettingsProvider.getBoolean(context, SettingsProvider.SETTINGS_UI_HOMESCREEN_SEARCH, R.bool.preferences_interface_homescreen_search_default); if (searchActivityExists) { return isSearchEnabled; } else { if (isSearchEnabled) { // Disable search bar SettingsProvider.putBoolean(context, SettingsProvider.SETTINGS_UI_HOMESCREEN_SEARCH, false); } return false; } } }