Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 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 | |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 19 | import static com.android.launcher3.ResourceUtils.pxFromDp; |
Jon Miranda | 58561d4 | 2021-03-17 10:51:54 -0400 | [diff] [blame] | 20 | import static com.android.launcher3.Utilities.dpiFromPx; |
Jon Miranda | af3aed0 | 2021-05-06 18:28:45 -0700 | [diff] [blame] | 21 | import static com.android.launcher3.Utilities.pxFromSp; |
Jon Miranda | 92c1b5d | 2021-07-20 13:57:16 -0700 | [diff] [blame] | 22 | import static com.android.launcher3.folder.ClippedFolderIconLayoutRule.ICON_OVERLAP_FACTOR; |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 23 | |
Sunny Goyal | 35c7b19 | 2021-04-20 16:51:10 -0700 | [diff] [blame] | 24 | import android.annotation.SuppressLint; |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 25 | import android.content.Context; |
Jon Miranda | b28c4fc | 2017-06-20 10:58:36 -0700 | [diff] [blame] | 26 | import android.content.res.Configuration; |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 27 | import android.content.res.Resources; |
Sunny Goyal | 8b9919d | 2021-04-07 14:45:17 -0700 | [diff] [blame] | 28 | import android.graphics.Path; |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 29 | import android.graphics.Point; |
Jon Miranda | 7ae64ff | 2016-11-21 16:18:46 -0800 | [diff] [blame] | 30 | import android.graphics.PointF; |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 31 | import android.graphics.Rect; |
Sunny Goyal | 35c7b19 | 2021-04-20 16:51:10 -0700 | [diff] [blame] | 32 | import android.util.DisplayMetrics; |
Sunny Goyal | 59d086c | 2018-05-07 17:31:40 -0700 | [diff] [blame] | 33 | import android.view.Surface; |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 34 | |
Sunny Goyal | c13403c | 2016-11-18 23:44:48 -0800 | [diff] [blame] | 35 | import com.android.launcher3.CellLayout.ContainerType; |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 36 | import com.android.launcher3.DevicePaddings.DevicePadding; |
Tony Wickham | 8912b04 | 2018-11-29 15:28:53 -0800 | [diff] [blame] | 37 | import com.android.launcher3.icons.DotRenderer; |
Sunny Goyal | 8b9919d | 2021-04-07 14:45:17 -0700 | [diff] [blame] | 38 | import com.android.launcher3.icons.GraphicsUtils; |
Hyunyoung Song | 48cb7bc | 2018-09-25 17:03:34 -0700 | [diff] [blame] | 39 | import com.android.launcher3.icons.IconNormalizer; |
Sunny Goyal | 57b2279 | 2021-05-25 14:35:01 -0700 | [diff] [blame] | 40 | import com.android.launcher3.uioverrides.ApiWrapper; |
Sunny Goyal | fd58da6 | 2020-08-11 12:06:49 -0700 | [diff] [blame] | 41 | import com.android.launcher3.util.DisplayController; |
| 42 | import com.android.launcher3.util.DisplayController.Info; |
Sunny Goyal | b46703d | 2020-05-27 17:52:03 -0700 | [diff] [blame] | 43 | import com.android.launcher3.util.WindowBounds; |
Winson | 1f06427 | 2016-07-18 17:18:02 -0700 | [diff] [blame] | 44 | |
Jon Miranda | 58561d4 | 2021-03-17 10:51:54 -0400 | [diff] [blame] | 45 | import java.io.PrintWriter; |
Brian Isganitis | 099945b | 2022-01-31 18:15:00 -0500 | [diff] [blame] | 46 | import java.util.List; |
Jon Miranda | 58561d4 | 2021-03-17 10:51:54 -0400 | [diff] [blame] | 47 | |
Sunny Goyal | 35c7b19 | 2021-04-20 16:51:10 -0700 | [diff] [blame] | 48 | @SuppressLint("NewApi") |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 49 | public class DeviceProfile { |
Adam Cohen | 2e6da15 | 2015-05-06 11:42:25 -0700 | [diff] [blame] | 50 | |
Sunny Goyal | 8b9919d | 2021-04-07 14:45:17 -0700 | [diff] [blame] | 51 | private static final int DEFAULT_DOT_SIZE = 100; |
Sunny Goyal | 57b2279 | 2021-05-25 14:35:01 -0700 | [diff] [blame] | 52 | // Ratio of empty space, qsb should take up to appear visually centered. |
Pratyush | 9afe1ea | 2021-10-13 11:13:27 +0000 | [diff] [blame] | 53 | private final float mQsbCenterFactor; |
Sunny Goyal | 1890f67 | 2020-04-30 12:28:00 -0700 | [diff] [blame] | 54 | |
Adam Cohen | 2e6da15 | 2015-05-06 11:42:25 -0700 | [diff] [blame] | 55 | public final InvariantDeviceProfile inv; |
Sunny Goyal | fd58da6 | 2020-08-11 12:06:49 -0700 | [diff] [blame] | 56 | private final Info mInfo; |
Sunny Goyal | 35c7b19 | 2021-04-20 16:51:10 -0700 | [diff] [blame] | 57 | private final DisplayMetrics mMetrics; |
Winson Chung | be87647 | 2014-05-14 14:15:20 -0700 | [diff] [blame] | 58 | |
Sunny Goyal | c620560 | 2015-05-21 20:46:33 -0700 | [diff] [blame] | 59 | // Device properties |
| 60 | public final boolean isTablet; |
Alex Chau | 6ed408f | 2022-03-04 12:58:05 +0000 | [diff] [blame] | 61 | public final boolean isLargeTablet; |
Sunny Goyal | c620560 | 2015-05-21 20:46:33 -0700 | [diff] [blame] | 62 | public final boolean isPhone; |
| 63 | public final boolean transposeLayoutWithOrientation; |
Sunny Goyal | 19ff728 | 2021-04-22 10:12:54 -0700 | [diff] [blame] | 64 | public final boolean isTwoPanels; |
Thales Lima | a101290 | 2022-01-13 17:58:42 +0000 | [diff] [blame] | 65 | public final boolean isQsbInline; |
Hyunyoung Song | 18bfaaf | 2015-03-17 11:32:21 -0700 | [diff] [blame] | 66 | |
Sunny Goyal | c620560 | 2015-05-21 20:46:33 -0700 | [diff] [blame] | 67 | // Device properties in current orientation |
Sunny Goyal | d792a77 | 2018-04-05 13:37:46 -0700 | [diff] [blame] | 68 | public final boolean isLandscape; |
Sunny Goyal | d70e75a | 2018-02-22 10:07:32 -0800 | [diff] [blame] | 69 | public final boolean isMultiWindowMode; |
Alex Chau | 6ed408f | 2022-03-04 12:58:05 +0000 | [diff] [blame] | 70 | public final boolean isGestureMode; |
Sunny Goyal | d70e75a | 2018-02-22 10:07:32 -0800 | [diff] [blame] | 71 | |
Sunny Goyal | 0addbf0 | 2020-04-28 14:17:35 -0700 | [diff] [blame] | 72 | public final int windowX; |
| 73 | public final int windowY; |
Sunny Goyal | c620560 | 2015-05-21 20:46:33 -0700 | [diff] [blame] | 74 | public final int widthPx; |
| 75 | public final int heightPx; |
| 76 | public final int availableWidthPx; |
| 77 | public final int availableHeightPx; |
Sunny Goyal | 187b16c | 2022-03-01 16:53:23 -0800 | [diff] [blame] | 78 | public final int rotationHint; |
Jon Miranda | bba6451 | 2019-03-27 10:54:17 -0700 | [diff] [blame] | 79 | |
| 80 | public final float aspectRatio; |
| 81 | |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 82 | public final boolean isScalableGrid; |
Thales Lima | 83bedbf | 2021-10-05 17:47:39 +0100 | [diff] [blame] | 83 | private final int mTypeIndex; |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 84 | |
Tony Wickham | d6b4037 | 2015-09-23 18:37:57 -0700 | [diff] [blame] | 85 | /** |
| 86 | * The maximum amount of left/right workspace padding as a percentage of the screen width. |
| 87 | * To be clear, this means that up to 7% of the screen width can be used as left padding, and |
| 88 | * 7% of the screen width can be used as right padding. |
| 89 | */ |
| 90 | private static final float MAX_HORIZONTAL_PADDING_PERCENT = 0.14f; |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 91 | |
Jon Miranda | 3f9bab2 | 2017-07-28 14:50:17 -0700 | [diff] [blame] | 92 | private static final float TALL_DEVICE_ASPECT_RATIO_THRESHOLD = 2.0f; |
Jon Miranda | 80cddbc | 2021-07-22 13:51:16 -0700 | [diff] [blame] | 93 | private static final float TALLER_DEVICE_ASPECT_RATIO_THRESHOLD = 2.15f; |
Jon Miranda | 80dda30 | 2021-07-28 14:14:59 -0700 | [diff] [blame] | 94 | private static final float TALL_DEVICE_EXTRA_SPACE_THRESHOLD_DP = 252; |
| 95 | private static final float TALL_DEVICE_MORE_EXTRA_SPACE_THRESHOLD_DP = 268; |
Jon Miranda | 30d0aa2 | 2017-07-25 15:55:29 -0700 | [diff] [blame] | 96 | |
Jon Miranda | 5eacbb7 | 2018-07-31 11:14:46 -0700 | [diff] [blame] | 97 | // To evenly space the icons, increase the left/right margins for tablets in portrait mode. |
| 98 | private static final int PORTRAIT_TABLET_LEFT_RIGHT_PADDING_MULTIPLIER = 4; |
| 99 | |
Sunny Goyal | c620560 | 2015-05-21 20:46:33 -0700 | [diff] [blame] | 100 | // Workspace |
Thales Lima | d90faab | 2021-09-21 17:18:47 +0100 | [diff] [blame] | 101 | public final int desiredWorkspaceHorizontalMarginOriginalPx; |
| 102 | public int desiredWorkspaceHorizontalMarginPx; |
Thales Lima | 78d00ad | 2021-09-30 11:29:06 +0100 | [diff] [blame] | 103 | public Point cellLayoutBorderSpaceOriginalPx; |
| 104 | public Point cellLayoutBorderSpacePx; |
Jon Miranda | 2803200 | 2017-07-13 16:18:56 -0700 | [diff] [blame] | 105 | public final int cellLayoutPaddingLeftRightPx; |
Jon Miranda | 18751b6 | 2017-07-31 17:25:27 -0700 | [diff] [blame] | 106 | public final int cellLayoutBottomPaddingPx; |
Sunny Goyal | c620560 | 2015-05-21 20:46:33 -0700 | [diff] [blame] | 107 | public final int edgeMarginPx; |
Sunny Goyal | 47328fd | 2016-05-25 18:56:41 -0700 | [diff] [blame] | 108 | public float workspaceSpringLoadShrinkFactor; |
| 109 | public final int workspaceSpringLoadedBottomSpace; |
Sunny Goyal | c620560 | 2015-05-21 20:46:33 -0700 | [diff] [blame] | 110 | |
Jon Miranda | 58561d4 | 2021-03-17 10:51:54 -0400 | [diff] [blame] | 111 | private final int extraSpace; |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 112 | public int workspaceTopPadding; |
| 113 | public int workspaceBottomPadding; |
Jon Miranda | 58561d4 | 2021-03-17 10:51:54 -0400 | [diff] [blame] | 114 | public int extraHotseatBottomPadding; |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 115 | |
Tony Wickham | 5edf9e2 | 2020-03-27 20:06:52 -0700 | [diff] [blame] | 116 | // Workspace page indicator |
| 117 | public final int workspacePageIndicatorHeight; |
| 118 | private final int mWorkspacePageIndicatorOverlapWorkspace; |
Winson | 1f06427 | 2016-07-18 17:18:02 -0700 | [diff] [blame] | 119 | |
Sunny Goyal | c620560 | 2015-05-21 20:46:33 -0700 | [diff] [blame] | 120 | // Workspace icons |
Jon Miranda | c9e69fa | 2021-03-22 17:13:34 -0400 | [diff] [blame] | 121 | public float iconScale; |
Sunny Goyal | c620560 | 2015-05-21 20:46:33 -0700 | [diff] [blame] | 122 | public int iconSizePx; |
| 123 | public int iconTextSizePx; |
| 124 | public int iconDrawablePaddingPx; |
Winson Chung | 5f4e0fd | 2015-05-22 11:12:27 -0700 | [diff] [blame] | 125 | public int iconDrawablePaddingOriginalPx; |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 126 | |
Jon Miranda | ab3c681 | 2021-06-28 15:42:28 -0700 | [diff] [blame] | 127 | public float cellScaleToFit; |
Adam Cohen | 5940042 | 2014-03-05 18:07:04 -0800 | [diff] [blame] | 128 | public int cellWidthPx; |
| 129 | public int cellHeightPx; |
Jon Miranda | b28c4fc | 2017-06-20 10:58:36 -0700 | [diff] [blame] | 130 | public int workspaceCellPaddingXPx; |
Adam Cohen | 5940042 | 2014-03-05 18:07:04 -0800 | [diff] [blame] | 131 | |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 132 | public int cellYPaddingPx; |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 133 | |
Sunny Goyal | c620560 | 2015-05-21 20:46:33 -0700 | [diff] [blame] | 134 | // Folder |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 135 | public float folderLabelTextScale; |
| 136 | public int folderLabelTextSizePx; |
Sunny Goyal | c620560 | 2015-05-21 20:46:33 -0700 | [diff] [blame] | 137 | public int folderIconSizePx; |
Jon Miranda | 591e360 | 2018-03-28 11:37:00 -0700 | [diff] [blame] | 138 | public int folderIconOffsetYPx; |
Jon Miranda | bf7d812 | 2016-11-03 15:29:29 -0700 | [diff] [blame] | 139 | |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 140 | // Folder content |
Thales Lima | 78d00ad | 2021-09-30 11:29:06 +0100 | [diff] [blame] | 141 | public Point folderCellLayoutBorderSpacePx; |
| 142 | public int folderCellLayoutBorderSpaceOriginalPx; |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 143 | public int folderContentPaddingLeftRight; |
| 144 | public int folderContentPaddingTop; |
| 145 | |
Jon Miranda | bf7d812 | 2016-11-03 15:29:29 -0700 | [diff] [blame] | 146 | // Folder cell |
Sunny Goyal | c620560 | 2015-05-21 20:46:33 -0700 | [diff] [blame] | 147 | public int folderCellWidthPx; |
| 148 | public int folderCellHeightPx; |
Jon Miranda | bf7d812 | 2016-11-03 15:29:29 -0700 | [diff] [blame] | 149 | |
| 150 | // Folder child |
| 151 | public int folderChildIconSizePx; |
| 152 | public int folderChildTextSizePx; |
Sunny Goyal | baec6ff | 2016-09-14 11:26:21 -0700 | [diff] [blame] | 153 | public int folderChildDrawablePaddingPx; |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 154 | |
Sunny Goyal | c620560 | 2015-05-21 20:46:33 -0700 | [diff] [blame] | 155 | // Hotseat |
Jon Miranda | 80cddbc | 2021-07-22 13:51:16 -0700 | [diff] [blame] | 156 | public int hotseatBarSizeExtraSpacePx; |
Tony Wickham | b87f3cd | 2021-04-07 15:02:37 -0700 | [diff] [blame] | 157 | public final int numShownHotseatIcons; |
Sunny Goyal | c620560 | 2015-05-21 20:46:33 -0700 | [diff] [blame] | 158 | public int hotseatCellHeightPx; |
Jon Miranda | 0d28485 | 2021-06-22 14:50:55 -0700 | [diff] [blame] | 159 | private final int hotseatExtraVerticalSize; |
Jon Miranda | 18751b6 | 2017-07-31 17:25:27 -0700 | [diff] [blame] | 160 | // In portrait: size = height, in landscape: size = width |
| 161 | public int hotseatBarSizePx; |
Jon Miranda | 80cddbc | 2021-07-22 13:51:16 -0700 | [diff] [blame] | 162 | public int hotseatBarTopPaddingPx; |
Jon Miranda | 0d28485 | 2021-06-22 14:50:55 -0700 | [diff] [blame] | 163 | public final int hotseatBarBottomPaddingPx; |
Tony Wickham | 1eeffbe | 2018-06-12 15:01:15 -0700 | [diff] [blame] | 164 | // Start is the side next to the nav bar, end is the side next to the workspace |
| 165 | public final int hotseatBarSidePaddingStartPx; |
| 166 | public final int hotseatBarSidePaddingEndPx; |
Sunny Goyal | 57b2279 | 2021-05-25 14:35:01 -0700 | [diff] [blame] | 167 | public final int hotseatQsbHeight; |
Thales Lima | dd02734 | 2022-01-07 12:54:37 +0000 | [diff] [blame] | 168 | public int hotseatBorderSpace; |
Adam Cohen | 2e6da15 | 2015-05-06 11:42:25 -0700 | [diff] [blame] | 169 | |
Jon Miranda | 8bdb222 | 2021-06-23 18:10:10 -0700 | [diff] [blame] | 170 | public final float qsbBottomMarginOriginalPx; |
| 171 | public int qsbBottomMarginPx; |
Thales Lima | a101290 | 2022-01-13 17:58:42 +0000 | [diff] [blame] | 172 | public int qsbWidth; // only used when isQsbInline |
Jon Miranda | 8bdb222 | 2021-06-23 18:10:10 -0700 | [diff] [blame] | 173 | |
Sunny Goyal | c620560 | 2015-05-21 20:46:33 -0700 | [diff] [blame] | 174 | // All apps |
Thales Lima | 85c942f | 2021-12-31 13:04:20 +0000 | [diff] [blame] | 175 | public Point allAppsBorderSpacePx; |
Alex Chau | b8c22e1 | 2022-02-14 18:35:58 +0000 | [diff] [blame] | 176 | public int allAppsShiftRange; |
| 177 | public int allAppsTopPadding; |
Jon Miranda | b28c4fc | 2017-06-20 10:58:36 -0700 | [diff] [blame] | 178 | public int allAppsCellHeightPx; |
Samuel Fufa | f1424a3 | 2019-10-04 15:15:19 -0700 | [diff] [blame] | 179 | public int allAppsCellWidthPx; |
Winson | 1f06427 | 2016-07-18 17:18:02 -0700 | [diff] [blame] | 180 | public int allAppsIconSizePx; |
| 181 | public int allAppsIconDrawablePaddingPx; |
sfufa@google.com | de01329 | 2021-09-21 18:22:44 -0700 | [diff] [blame] | 182 | public int allAppsLeftRightPadding; |
Alex Chau | 27b39b9 | 2022-01-14 18:02:18 +0000 | [diff] [blame] | 183 | public int allAppsLeftRightMargin; |
Sunny Goyal | 19ff728 | 2021-04-22 10:12:54 -0700 | [diff] [blame] | 184 | public final int numShownAllAppsColumns; |
Winson | 1f06427 | 2016-07-18 17:18:02 -0700 | [diff] [blame] | 185 | public float allAppsIconTextSizePx; |
| 186 | |
Zak Cohen | 334efeb | 2021-03-19 16:42:07 -0700 | [diff] [blame] | 187 | // Overview |
Zak Cohen | 334efeb | 2021-03-19 16:42:07 -0700 | [diff] [blame] | 188 | public int overviewTaskMarginPx; |
Alex Chau | eaa6d68 | 2021-08-17 12:56:15 +0100 | [diff] [blame] | 189 | public int overviewTaskMarginGridPx; |
Alex Chau | dedbc8a | 2021-03-17 16:53:26 +0000 | [diff] [blame] | 190 | public int overviewTaskIconSizePx; |
Alex Chau | ac9df38 | 2021-08-02 19:08:41 +0100 | [diff] [blame] | 191 | public int overviewTaskIconDrawableSizePx; |
| 192 | public int overviewTaskIconDrawableSizeGridPx; |
Alex Chau | dedbc8a | 2021-03-17 16:53:26 +0000 | [diff] [blame] | 193 | public int overviewTaskThumbnailTopMarginPx; |
zakcohen | dad8a80 | 2021-05-20 09:52:26 -0700 | [diff] [blame] | 194 | public final int overviewActionsMarginThreeButtonPx; |
Alex Chau | 5fd9d49 | 2021-07-22 17:27:11 +0100 | [diff] [blame] | 195 | public final int overviewActionsTopMarginGesturePx; |
| 196 | public final int overviewActionsBottomMarginGesturePx; |
Alex Chau | 1bf0fe1 | 2021-11-30 15:32:45 +0000 | [diff] [blame] | 197 | public final int overviewActionsButtonSpacing; |
Alex Chau | 5fd9d49 | 2021-07-22 17:27:11 +0100 | [diff] [blame] | 198 | public int overviewPageSpacing; |
| 199 | public int overviewRowSpacing; |
Alex Chau | 56bd257 | 2021-11-03 18:48:18 +0000 | [diff] [blame] | 200 | public int overviewGridSideMargin; |
Zak Cohen | 334efeb | 2021-03-19 16:42:07 -0700 | [diff] [blame] | 201 | |
Jon Miranda | 7ae64ff | 2016-11-21 16:18:46 -0800 | [diff] [blame] | 202 | // Widgets |
| 203 | public final PointF appWidgetScale = new PointF(1.0f, 1.0f); |
| 204 | |
Sunny Goyal | 47328fd | 2016-05-25 18:56:41 -0700 | [diff] [blame] | 205 | // Drop Target |
| 206 | public int dropTargetBarSizePx; |
Alex Chau | a02eddc | 2021-04-29 00:36:06 +0100 | [diff] [blame] | 207 | public int dropTargetDragPaddingPx; |
| 208 | public int dropTargetTextSizePx; |
Adam Cohen | 4ae96ce | 2014-08-29 15:05:48 -0700 | [diff] [blame] | 209 | |
Winson | 1f06427 | 2016-07-18 17:18:02 -0700 | [diff] [blame] | 210 | // Insets |
Sunny Goyal | 07b6929 | 2018-01-08 14:19:34 -0800 | [diff] [blame] | 211 | private final Rect mInsets = new Rect(); |
| 212 | public final Rect workspacePadding = new Rect(); |
Sunny Goyal | 81b4c7b | 2018-03-26 12:10:31 -0700 | [diff] [blame] | 213 | private final Rect mHotseatPadding = new Rect(); |
Jon Miranda | 0bd63d1 | 2019-03-06 17:29:29 -0800 | [diff] [blame] | 214 | // When true, nav bar is on the left side of the screen. |
Sunny Goyal | 59d086c | 2018-05-07 17:31:40 -0700 | [diff] [blame] | 215 | private boolean mIsSeascape; |
Winson | 1f06427 | 2016-07-18 17:18:02 -0700 | [diff] [blame] | 216 | |
Tony Wickham | f34bee8 | 2018-12-03 18:11:39 -0800 | [diff] [blame] | 217 | // Notification dots |
Samuel Fufa | c96fa24 | 2019-09-26 23:06:32 -0700 | [diff] [blame] | 218 | public DotRenderer mDotRendererWorkSpace; |
| 219 | public DotRenderer mDotRendererAllApps; |
Tony Wickham | 9a8d11f | 2017-01-11 09:53:12 -0800 | [diff] [blame] | 220 | |
Pierre Barbier de Reuille | 578deba | 2021-09-24 13:47:44 +0100 | [diff] [blame] | 221 | // Taskbar |
Tony Wickham | 1588389 | 2021-02-12 11:24:40 -0800 | [diff] [blame] | 222 | public boolean isTaskbarPresent; |
Tony Wickham | 635e180 | 2021-07-22 14:28:04 -1000 | [diff] [blame] | 223 | // Whether Taskbar will inset the bottom of apps by taskbarSize. |
| 224 | public boolean isTaskbarPresentInApps; |
Tony Wickham | 1588389 | 2021-02-12 11:24:40 -0800 | [diff] [blame] | 225 | public int taskbarSize; |
Alex Chau | 6a7d1e2 | 2022-01-20 19:54:17 +0000 | [diff] [blame] | 226 | public int stashedTaskbarSize; |
Tony Wickham | 1588389 | 2021-02-12 11:24:40 -0800 | [diff] [blame] | 227 | |
Alex Chau | a02eddc | 2021-04-29 00:36:06 +0100 | [diff] [blame] | 228 | // DragController |
| 229 | public int flingToDeleteThresholdVelocity; |
| 230 | |
Vinit Nayak | 17c4b33 | 2021-08-05 12:54:58 -0700 | [diff] [blame] | 231 | /** TODO: Once we fully migrate to staged split, remove "isMultiWindowMode" */ |
Sunny Goyal | 19ff728 | 2021-04-22 10:12:54 -0700 | [diff] [blame] | 232 | DeviceProfile(Context context, InvariantDeviceProfile inv, Info info, WindowBounds windowBounds, |
Sunny Goyal | 0addbf0 | 2020-04-28 14:17:35 -0700 | [diff] [blame] | 233 | boolean isMultiWindowMode, boolean transposeLayoutWithOrientation, |
Alex Chau | 6ed408f | 2022-03-04 12:58:05 +0000 | [diff] [blame] | 234 | boolean useTwoPanels, boolean isGestureMode) { |
Sunny Goyal | fee35bb | 2015-05-11 11:38:19 -0700 | [diff] [blame] | 235 | |
Adam Cohen | 2e6da15 | 2015-05-06 11:42:25 -0700 | [diff] [blame] | 236 | this.inv = inv; |
Sunny Goyal | 19ff728 | 2021-04-22 10:12:54 -0700 | [diff] [blame] | 237 | this.isLandscape = windowBounds.isLandscape(); |
Sunny Goyal | d70e75a | 2018-02-22 10:07:32 -0800 | [diff] [blame] | 238 | this.isMultiWindowMode = isMultiWindowMode; |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 239 | this.transposeLayoutWithOrientation = transposeLayoutWithOrientation; |
Alex Chau | 6ed408f | 2022-03-04 12:58:05 +0000 | [diff] [blame] | 240 | this.isGestureMode = isGestureMode; |
Sunny Goyal | 19ff728 | 2021-04-22 10:12:54 -0700 | [diff] [blame] | 241 | windowX = windowBounds.bounds.left; |
| 242 | windowY = windowBounds.bounds.top; |
Sunny Goyal | 187b16c | 2022-03-01 16:53:23 -0800 | [diff] [blame] | 243 | this.rotationHint = windowBounds.rotationHint; |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 244 | |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 245 | isScalableGrid = inv.isScalable && !isVerticalBarLayout() && !isMultiWindowMode; |
| 246 | |
Alex Chau | dfc8ddf | 2022-01-25 11:26:25 +0000 | [diff] [blame] | 247 | // Determine device posture. |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 248 | mInfo = info; |
Alex Chau | 2998307 | 2021-11-19 15:14:20 +0000 | [diff] [blame] | 249 | isTablet = info.isTablet(windowBounds); |
Alex Chau | 6ed408f | 2022-03-04 12:58:05 +0000 | [diff] [blame] | 250 | isLargeTablet = info.isLargeTablet(windowBounds); |
Sunny Goyal | 19ff728 | 2021-04-22 10:12:54 -0700 | [diff] [blame] | 251 | isPhone = !isTablet; |
Alex Chau | 9012582 | 2021-11-17 14:16:58 +0000 | [diff] [blame] | 252 | isTwoPanels = isTablet && useTwoPanels; |
Vinit Nayak | 58c27cc | 2022-02-16 17:42:21 -0800 | [diff] [blame] | 253 | isTaskbarPresent = isTablet && ApiWrapper.TASKBAR_DRAWN_IN_PROCESS; |
Adam Cohen | 2e6da15 | 2015-05-06 11:42:25 -0700 | [diff] [blame] | 254 | |
Alex Chau | dfc8ddf | 2022-01-25 11:26:25 +0000 | [diff] [blame] | 255 | // Some more constants. |
Alex Chau | 635b3ab | 2022-01-26 16:49:10 +0000 | [diff] [blame] | 256 | context = getContext(context, info, isVerticalBarLayout() || (isTablet && isLandscape) |
Jon Miranda | b28c4fc | 2017-06-20 10:58:36 -0700 | [diff] [blame] | 257 | ? Configuration.ORIENTATION_LANDSCAPE |
| 258 | : Configuration.ORIENTATION_PORTRAIT); |
Sunny Goyal | 1890f67 | 2020-04-30 12:28:00 -0700 | [diff] [blame] | 259 | final Resources res = context.getResources(); |
Alex Chau | dfc8ddf | 2022-01-25 11:26:25 +0000 | [diff] [blame] | 260 | mMetrics = res.getDisplayMetrics(); |
| 261 | |
| 262 | // Determine sizes. |
| 263 | widthPx = windowBounds.bounds.width(); |
| 264 | heightPx = windowBounds.bounds.height(); |
| 265 | availableWidthPx = windowBounds.availableSize.x; |
Alex Chau | 6a7d1e2 | 2022-01-20 19:54:17 +0000 | [diff] [blame] | 266 | availableHeightPx = windowBounds.availableSize.y; |
Alex Chau | dfc8ddf | 2022-01-25 11:26:25 +0000 | [diff] [blame] | 267 | |
| 268 | aspectRatio = ((float) Math.max(widthPx, heightPx)) / Math.min(widthPx, heightPx); |
| 269 | boolean isTallDevice = Float.compare(aspectRatio, TALL_DEVICE_ASPECT_RATIO_THRESHOLD) >= 0; |
| 270 | mQsbCenterFactor = res.getFloat(R.dimen.qsb_center_factor); |
Jon Miranda | b28c4fc | 2017-06-20 10:58:36 -0700 | [diff] [blame] | 271 | |
Thales Lima | 83bedbf | 2021-10-05 17:47:39 +0100 | [diff] [blame] | 272 | if (isTwoPanels) { |
| 273 | if (isLandscape) { |
| 274 | mTypeIndex = InvariantDeviceProfile.INDEX_TWO_PANEL_LANDSCAPE; |
| 275 | } else { |
| 276 | mTypeIndex = InvariantDeviceProfile.INDEX_TWO_PANEL_PORTRAIT; |
| 277 | } |
| 278 | } else { |
| 279 | if (isLandscape) { |
| 280 | mTypeIndex = InvariantDeviceProfile.INDEX_LANDSCAPE; |
| 281 | } else { |
| 282 | mTypeIndex = InvariantDeviceProfile.INDEX_DEFAULT; |
| 283 | } |
| 284 | } |
| 285 | |
Tony Wickham | 1588389 | 2021-02-12 11:24:40 -0800 | [diff] [blame] | 286 | if (isTaskbarPresent) { |
Tony Wickham | 1588389 | 2021-02-12 11:24:40 -0800 | [diff] [blame] | 287 | taskbarSize = res.getDimensionPixelSize(R.dimen.taskbar_size); |
Alex Chau | 6a7d1e2 | 2022-01-20 19:54:17 +0000 | [diff] [blame] | 288 | stashedTaskbarSize = res.getDimensionPixelSize(R.dimen.taskbar_stashed_size); |
Tony Wickham | 1588389 | 2021-02-12 11:24:40 -0800 | [diff] [blame] | 289 | } |
Tony Wickham | 1588389 | 2021-02-12 11:24:40 -0800 | [diff] [blame] | 290 | |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 291 | edgeMarginPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_edge_margin); |
Sunny Goyal | 58fa4b6 | 2019-03-22 16:23:25 -0700 | [diff] [blame] | 292 | |
Thales Lima | d90faab | 2021-09-21 17:18:47 +0100 | [diff] [blame] | 293 | desiredWorkspaceHorizontalMarginPx = getHorizontalMarginPx(inv, res); |
| 294 | desiredWorkspaceHorizontalMarginOriginalPx = desiredWorkspaceHorizontalMarginPx; |
Samuel Fufa | ee9aff9 | 2021-04-05 13:30:40 -0500 | [diff] [blame] | 295 | |
Alex Chau | b8c22e1 | 2022-02-14 18:35:58 +0000 | [diff] [blame] | 296 | allAppsTopPadding = res.getDimensionPixelSize(R.dimen.all_apps_top_padding) |
| 297 | + (isTablet ? heightPx - availableHeightPx : 0); |
| 298 | allAppsShiftRange = isTablet |
| 299 | ? heightPx - allAppsTopPadding |
| 300 | : res.getDimensionPixelSize(R.dimen.all_apps_starting_vertical_translate); |
Samuel Fufa | ee9aff9 | 2021-04-05 13:30:40 -0500 | [diff] [blame] | 301 | |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 302 | folderLabelTextScale = res.getFloat(R.dimen.folder_label_text_scale); |
| 303 | folderContentPaddingLeftRight = |
| 304 | res.getDimensionPixelSize(R.dimen.folder_content_padding_left_right); |
| 305 | folderContentPaddingTop = res.getDimensionPixelSize(R.dimen.folder_content_padding_top); |
| 306 | |
Thales Lima | 78d00ad | 2021-09-30 11:29:06 +0100 | [diff] [blame] | 307 | cellLayoutBorderSpacePx = getCellLayoutBorderSpace(inv); |
Thales Lima | 85c942f | 2021-12-31 13:04:20 +0000 | [diff] [blame] | 308 | allAppsBorderSpacePx = new Point( |
Thales Lima | bb7d388 | 2021-12-22 12:56:29 +0000 | [diff] [blame] | 309 | pxFromDp(inv.allAppsBorderSpaces[mTypeIndex].x, mMetrics), |
| 310 | pxFromDp(inv.allAppsBorderSpaces[mTypeIndex].y, mMetrics)); |
Thales Lima | 78d00ad | 2021-09-30 11:29:06 +0100 | [diff] [blame] | 311 | cellLayoutBorderSpaceOriginalPx = new Point(cellLayoutBorderSpacePx); |
| 312 | folderCellLayoutBorderSpaceOriginalPx = pxFromDp(inv.folderBorderSpace, mMetrics, 1f); |
| 313 | folderCellLayoutBorderSpacePx = new Point(folderCellLayoutBorderSpaceOriginalPx, |
| 314 | folderCellLayoutBorderSpaceOriginalPx); |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 315 | |
Jon Miranda | 5eacbb7 | 2018-07-31 11:14:46 -0700 | [diff] [blame] | 316 | int cellLayoutPaddingLeftRightMultiplier = !isVerticalBarLayout() && isTablet |
| 317 | ? PORTRAIT_TABLET_LEFT_RIGHT_PADDING_MULTIPLIER : 1; |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 318 | int cellLayoutPadding = isScalableGrid |
| 319 | ? 0 |
| 320 | : res.getDimensionPixelSize(R.dimen.dynamic_grid_cell_layout_padding); |
Andras Kloczl | 8e57cce | 2021-02-11 23:51:19 +0100 | [diff] [blame] | 321 | |
Sunny Goyal | 19ff728 | 2021-04-22 10:12:54 -0700 | [diff] [blame] | 322 | if (isTwoPanels) { |
Thales Lima | 7a6752d | 2021-09-23 14:31:00 +0100 | [diff] [blame] | 323 | cellLayoutPaddingLeftRightPx = 0; |
Andras Kloczl | 8e57cce | 2021-02-11 23:51:19 +0100 | [diff] [blame] | 324 | cellLayoutBottomPaddingPx = 0; |
| 325 | } else if (isLandscape) { |
Sunny Goyal | 58fa4b6 | 2019-03-22 16:23:25 -0700 | [diff] [blame] | 326 | cellLayoutPaddingLeftRightPx = 0; |
| 327 | cellLayoutBottomPaddingPx = cellLayoutPadding; |
| 328 | } else { |
| 329 | cellLayoutPaddingLeftRightPx = cellLayoutPaddingLeftRightMultiplier * cellLayoutPadding; |
| 330 | cellLayoutBottomPaddingPx = 0; |
| 331 | } |
| 332 | |
Tony Wickham | 5edf9e2 | 2020-03-27 20:06:52 -0700 | [diff] [blame] | 333 | workspacePageIndicatorHeight = res.getDimensionPixelSize( |
| 334 | R.dimen.workspace_page_indicator_height); |
| 335 | mWorkspacePageIndicatorOverlapWorkspace = |
| 336 | res.getDimensionPixelSize(R.dimen.workspace_page_indicator_overlap_workspace); |
Sunny Goyal | 58fa4b6 | 2019-03-22 16:23:25 -0700 | [diff] [blame] | 337 | |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 338 | iconDrawablePaddingOriginalPx = |
| 339 | res.getDimensionPixelSize(R.dimen.dynamic_grid_icon_drawable_padding); |
Alex Chau | a02eddc | 2021-04-29 00:36:06 +0100 | [diff] [blame] | 340 | |
Sunny Goyal | 47328fd | 2016-05-25 18:56:41 -0700 | [diff] [blame] | 341 | dropTargetBarSizePx = res.getDimensionPixelSize(R.dimen.dynamic_grid_drop_target_size); |
Alex Chau | a02eddc | 2021-04-29 00:36:06 +0100 | [diff] [blame] | 342 | dropTargetDragPaddingPx = res.getDimensionPixelSize(R.dimen.drop_target_drag_padding); |
| 343 | dropTargetTextSizePx = res.getDimensionPixelSize(R.dimen.drop_target_text_size); |
| 344 | |
Sunny Goyal | 47328fd | 2016-05-25 18:56:41 -0700 | [diff] [blame] | 345 | workspaceSpringLoadedBottomSpace = |
| 346 | res.getDimensionPixelSize(R.dimen.dynamic_grid_min_spring_loaded_space); |
Sunny Goyal | d519052 | 2017-04-24 03:06:54 -0700 | [diff] [blame] | 347 | |
Jon Miranda | b28c4fc | 2017-06-20 10:58:36 -0700 | [diff] [blame] | 348 | workspaceCellPaddingXPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_cell_padding_x); |
Jon Miranda | 0966072 | 2017-06-14 14:20:14 -0700 | [diff] [blame] | 349 | |
Thales Lima | a101290 | 2022-01-13 17:58:42 +0000 | [diff] [blame] | 350 | hotseatQsbHeight = res.getDimensionPixelSize(R.dimen.qsb_widget_height); |
Alex Chau | 8175da9 | 2022-03-09 11:19:47 +0000 | [diff] [blame] | 351 | // Whether QSB might be inline in appropriate orientation (landscape). |
| 352 | boolean canQsbInline = isLargeTablet && hotseatQsbHeight > 0; |
| 353 | isQsbInline = canQsbInline && isLandscape; |
Alex Chau | 6ed408f | 2022-03-04 12:58:05 +0000 | [diff] [blame] | 354 | |
Alex Chau | 8175da9 | 2022-03-09 11:19:47 +0000 | [diff] [blame] | 355 | // We shrink hotseat sizes regardless of orientation, if nav buttons are inline and QSB |
| 356 | // might be inline in either orientations, to keep hotseat size consistent across rotation. |
| 357 | boolean areNavButtonsInline = isTaskbarPresent && !isGestureMode; |
| 358 | if (areNavButtonsInline && canQsbInline) { |
Alex Chau | 6ed408f | 2022-03-04 12:58:05 +0000 | [diff] [blame] | 359 | numShownHotseatIcons = inv.numShrunkenHotseatIcons; |
| 360 | } else { |
| 361 | numShownHotseatIcons = |
| 362 | isTwoPanels ? inv.numDatabaseHotseatIcons : inv.numShownHotseatIcons; |
| 363 | } |
| 364 | |
Sunny Goyal | 19ff728 | 2021-04-22 10:12:54 -0700 | [diff] [blame] | 365 | numShownAllAppsColumns = |
| 366 | isTwoPanels ? inv.numDatabaseAllAppsColumns : inv.numAllAppsColumns; |
Jon Miranda | 80cddbc | 2021-07-22 13:51:16 -0700 | [diff] [blame] | 367 | hotseatBarSizeExtraSpacePx = 0; |
Winson | 1f06427 | 2016-07-18 17:18:02 -0700 | [diff] [blame] | 368 | hotseatBarTopPaddingPx = |
| 369 | res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_top_padding); |
Thales Lima | a101290 | 2022-01-13 17:58:42 +0000 | [diff] [blame] | 370 | if (isQsbInline) { |
| 371 | hotseatBarBottomPaddingPx = res.getDimensionPixelSize(R.dimen.inline_qsb_bottom_margin); |
| 372 | qsbWidth = calculateQsbWidth(); |
| 373 | } else { |
| 374 | hotseatBarBottomPaddingPx = (isTallDevice ? res.getDimensionPixelSize( |
| 375 | R.dimen.dynamic_grid_hotseat_bottom_tall_padding) |
| 376 | : res.getDimensionPixelSize( |
| 377 | R.dimen.dynamic_grid_hotseat_bottom_non_tall_padding)) |
| 378 | + res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_bottom_padding); |
| 379 | qsbWidth = 0; |
| 380 | } |
Tony Wickham | 1eeffbe | 2018-06-12 15:01:15 -0700 | [diff] [blame] | 381 | hotseatBarSidePaddingEndPx = |
Sunny Goyal | 228153d | 2018-01-04 15:35:22 -0800 | [diff] [blame] | 382 | res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_side_padding); |
Jon Miranda | 3f411e7 | 2019-05-16 17:15:16 -0700 | [diff] [blame] | 383 | // Add a bit of space between nav bar and hotseat in vertical bar layout. |
Tony Wickham | 5edf9e2 | 2020-03-27 20:06:52 -0700 | [diff] [blame] | 384 | hotseatBarSidePaddingStartPx = isVerticalBarLayout() ? workspacePageIndicatorHeight : 0; |
Jon Miranda | 0d28485 | 2021-06-22 14:50:55 -0700 | [diff] [blame] | 385 | hotseatExtraVerticalSize = |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 386 | res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_extra_vertical_size); |
Thales Lima | 6e7f36c | 2022-01-04 12:14:11 +0000 | [diff] [blame] | 387 | hotseatBorderSpace = pxFromDp(inv.hotseatBorderSpaces[mTypeIndex], mMetrics); |
Thales Lima | 83bedbf | 2021-10-05 17:47:39 +0100 | [diff] [blame] | 388 | updateHotseatIconSize( |
Thales Lima | 6e7f36c | 2022-01-04 12:14:11 +0000 | [diff] [blame] | 389 | pxFromDp(inv.iconSize[InvariantDeviceProfile.INDEX_DEFAULT], mMetrics)); |
Jon Miranda | b28c4fc | 2017-06-20 10:58:36 -0700 | [diff] [blame] | 390 | |
Jon Miranda | 8bdb222 | 2021-06-23 18:10:10 -0700 | [diff] [blame] | 391 | qsbBottomMarginOriginalPx = isScalableGrid |
| 392 | ? res.getDimensionPixelSize(R.dimen.scalable_grid_qsb_bottom_margin) |
| 393 | : 0; |
| 394 | |
Alex Chau | 635b3ab | 2022-01-26 16:49:10 +0000 | [diff] [blame] | 395 | overviewTaskMarginPx = res.getDimensionPixelSize(R.dimen.overview_task_margin); |
Alex Chau | eaa6d68 | 2021-08-17 12:56:15 +0100 | [diff] [blame] | 396 | overviewTaskMarginGridPx = res.getDimensionPixelSize(R.dimen.overview_task_margin_grid); |
Alex Chau | 5fd9d49 | 2021-07-22 17:27:11 +0100 | [diff] [blame] | 397 | overviewTaskIconSizePx = res.getDimensionPixelSize(R.dimen.task_thumbnail_icon_size); |
Alex Chau | ac9df38 | 2021-08-02 19:08:41 +0100 | [diff] [blame] | 398 | overviewTaskIconDrawableSizePx = |
| 399 | res.getDimensionPixelSize(R.dimen.task_thumbnail_icon_drawable_size); |
| 400 | overviewTaskIconDrawableSizeGridPx = |
| 401 | res.getDimensionPixelSize(R.dimen.task_thumbnail_icon_drawable_size_grid); |
Alex Chau | dedbc8a | 2021-03-17 16:53:26 +0000 | [diff] [blame] | 402 | overviewTaskThumbnailTopMarginPx = overviewTaskIconSizePx + overviewTaskMarginPx * 2; |
Alex Chau | 635b3ab | 2022-01-26 16:49:10 +0000 | [diff] [blame] | 403 | overviewActionsTopMarginGesturePx = res.getDimensionPixelSize( |
| 404 | R.dimen.overview_actions_top_margin_gesture); |
| 405 | overviewActionsBottomMarginGesturePx = res.getDimensionPixelSize( |
| 406 | R.dimen.overview_actions_bottom_margin_gesture); |
| 407 | overviewPageSpacing = res.getDimensionPixelSize(R.dimen.overview_page_spacing); |
| 408 | overviewActionsButtonSpacing = res.getDimensionPixelSize( |
| 409 | R.dimen.overview_actions_button_spacing); |
zakcohen | dad8a80 | 2021-05-20 09:52:26 -0700 | [diff] [blame] | 410 | overviewActionsMarginThreeButtonPx = res.getDimensionPixelSize( |
Alex Chau | 5fd9d49 | 2021-07-22 17:27:11 +0100 | [diff] [blame] | 411 | R.dimen.overview_actions_margin_three_button); |
Alex Chau | 4c98374 | 2021-12-10 13:09:53 +0000 | [diff] [blame] | 412 | // Grid task's top margin is only overviewTaskIconSizePx + overviewTaskMarginGridPx, but |
| 413 | // overviewTaskThumbnailTopMarginPx is applied to all TaskThumbnailView, so exclude the |
| 414 | // extra margin when calculating row spacing. |
| 415 | int extraTopMargin = overviewTaskThumbnailTopMarginPx - overviewTaskIconSizePx |
| 416 | - overviewTaskMarginGridPx; |
| 417 | overviewRowSpacing = res.getDimensionPixelSize(R.dimen.overview_grid_row_spacing) |
| 418 | - extraTopMargin; |
Alex Chau | 635b3ab | 2022-01-26 16:49:10 +0000 | [diff] [blame] | 419 | overviewGridSideMargin = res.getDimensionPixelSize(R.dimen.overview_grid_side_margin); |
Zak Cohen | 334efeb | 2021-03-19 16:42:07 -0700 | [diff] [blame] | 420 | |
Jon Miranda | 2ed276e | 2017-06-29 11:36:34 -0700 | [diff] [blame] | 421 | // Calculate all of the remaining variables. |
Jon Miranda | 58561d4 | 2021-03-17 10:51:54 -0400 | [diff] [blame] | 422 | extraSpace = updateAvailableDimensions(res); |
Jon Miranda | 80cddbc | 2021-07-22 13:51:16 -0700 | [diff] [blame] | 423 | |
Jon Miranda | 2ed276e | 2017-06-29 11:36:34 -0700 | [diff] [blame] | 424 | // Now that we have all of the variables calculated, we can tune certain sizes. |
Jon Miranda | c9e69fa | 2021-03-22 17:13:34 -0400 | [diff] [blame] | 425 | if (isScalableGrid && inv.devicePaddings != null) { |
| 426 | // Paddings were created assuming no scaling, so we first unscale the extra space. |
Jon Miranda | ab3c681 | 2021-06-28 15:42:28 -0700 | [diff] [blame] | 427 | int unscaledExtraSpace = (int) (extraSpace / cellScaleToFit); |
Jon Miranda | c9e69fa | 2021-03-22 17:13:34 -0400 | [diff] [blame] | 428 | DevicePadding padding = inv.devicePaddings.getDevicePadding(unscaledExtraSpace); |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 429 | |
Jon Miranda | c9e69fa | 2021-03-22 17:13:34 -0400 | [diff] [blame] | 430 | int paddingWorkspaceTop = padding.getWorkspaceTopPadding(unscaledExtraSpace); |
| 431 | int paddingWorkspaceBottom = padding.getWorkspaceBottomPadding(unscaledExtraSpace); |
| 432 | int paddingHotseatBottom = padding.getHotseatBottomPadding(unscaledExtraSpace); |
| 433 | |
Jon Miranda | ab3c681 | 2021-06-28 15:42:28 -0700 | [diff] [blame] | 434 | workspaceTopPadding = Math.round(paddingWorkspaceTop * cellScaleToFit); |
| 435 | workspaceBottomPadding = Math.round(paddingWorkspaceBottom * cellScaleToFit); |
| 436 | extraHotseatBottomPadding = Math.round(paddingHotseatBottom * cellScaleToFit); |
Jon Miranda | c9e69fa | 2021-03-22 17:13:34 -0400 | [diff] [blame] | 437 | |
Jon Miranda | 58561d4 | 2021-03-17 10:51:54 -0400 | [diff] [blame] | 438 | hotseatBarSizePx += extraHotseatBottomPadding; |
Jon Miranda | 8bdb222 | 2021-06-23 18:10:10 -0700 | [diff] [blame] | 439 | |
Jon Miranda | ab3c681 | 2021-06-28 15:42:28 -0700 | [diff] [blame] | 440 | qsbBottomMarginPx = Math.round(qsbBottomMarginOriginalPx * cellScaleToFit); |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 441 | } else if (!isVerticalBarLayout() && isPhone && isTallDevice) { |
Jon Miranda | 3f9bab2 | 2017-07-28 14:50:17 -0700 | [diff] [blame] | 442 | // We increase the hotseat size when there is extra space. |
Jon Miranda | 80cddbc | 2021-07-22 13:51:16 -0700 | [diff] [blame] | 443 | |
Jon Miranda | 80dda30 | 2021-07-28 14:14:59 -0700 | [diff] [blame] | 444 | if (Float.compare(aspectRatio, TALLER_DEVICE_ASPECT_RATIO_THRESHOLD) >= 0 |
| 445 | && extraSpace >= Utilities.dpToPx(TALL_DEVICE_EXTRA_SPACE_THRESHOLD_DP)) { |
| 446 | // For taller devices, we will take a piece of the extra space from each row, |
Jon Miranda | 80cddbc | 2021-07-22 13:51:16 -0700 | [diff] [blame] | 447 | // and add it to the space above and below the hotseat. |
Jon Miranda | 80dda30 | 2021-07-28 14:14:59 -0700 | [diff] [blame] | 448 | |
| 449 | // For devices with more extra space, we take a larger piece from each cell. |
| 450 | int piece = extraSpace < Utilities.dpToPx(TALL_DEVICE_MORE_EXTRA_SPACE_THRESHOLD_DP) |
Jon Miranda | a56cb84 | 2021-08-03 17:26:44 -0700 | [diff] [blame] | 451 | ? 7 : 5; |
Jon Miranda | 80dda30 | 2021-07-28 14:14:59 -0700 | [diff] [blame] | 452 | |
Jon Miranda | 80cddbc | 2021-07-22 13:51:16 -0700 | [diff] [blame] | 453 | int extraSpace = ((getCellSize().y - iconSizePx - iconDrawablePaddingPx * 2) |
Jon Miranda | 80dda30 | 2021-07-28 14:14:59 -0700 | [diff] [blame] | 454 | * inv.numRows) / piece; |
Jon Miranda | 80cddbc | 2021-07-22 13:51:16 -0700 | [diff] [blame] | 455 | |
Jon Miranda | a56cb84 | 2021-08-03 17:26:44 -0700 | [diff] [blame] | 456 | workspaceTopPadding = extraSpace / 8; |
| 457 | int halfLeftOver = (extraSpace - workspaceTopPadding) / 2; |
| 458 | hotseatBarTopPaddingPx += halfLeftOver; |
| 459 | hotseatBarSizeExtraSpacePx = halfLeftOver; |
Jon Miranda | 80cddbc | 2021-07-22 13:51:16 -0700 | [diff] [blame] | 460 | } else { |
| 461 | // ie. For a display with a large aspect ratio, we can keep the icons on the |
| 462 | // workspace in portrait mode closer together by adding more height to the hotseat. |
| 463 | // Note: This calculation was created after noticing a pattern in the design spec. |
| 464 | hotseatBarSizeExtraSpacePx = getCellSize().y - iconSizePx |
| 465 | - iconDrawablePaddingPx * 2 - workspacePageIndicatorHeight; |
| 466 | } |
| 467 | |
| 468 | updateHotseatIconSize(iconSizePx); |
Jon Miranda | 30d0aa2 | 2017-07-25 15:55:29 -0700 | [diff] [blame] | 469 | |
Jon Miranda | 3f9bab2 | 2017-07-28 14:50:17 -0700 | [diff] [blame] | 470 | // Recalculate the available dimensions using the new hotseat size. |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 471 | updateAvailableDimensions(res); |
Jon Miranda | 2ed276e | 2017-06-29 11:36:34 -0700 | [diff] [blame] | 472 | } |
Sunny Goyal | 07b6929 | 2018-01-08 14:19:34 -0800 | [diff] [blame] | 473 | updateWorkspacePadding(); |
Tony Wickham | 1237df0 | 2017-02-24 08:59:36 -0800 | [diff] [blame] | 474 | |
Alex Chau | a02eddc | 2021-04-29 00:36:06 +0100 | [diff] [blame] | 475 | flingToDeleteThresholdVelocity = res.getDimensionPixelSize( |
| 476 | R.dimen.drag_flingToDeleteMinVelocity); |
| 477 | |
Tony Wickham | 1237df0 | 2017-02-24 08:59:36 -0800 | [diff] [blame] | 478 | // This is done last, after iconSizePx is calculated above. |
Sunny Goyal | 8b9919d | 2021-04-07 14:45:17 -0700 | [diff] [blame] | 479 | Path dotPath = GraphicsUtils.getShapePath(DEFAULT_DOT_SIZE); |
| 480 | mDotRendererWorkSpace = new DotRenderer(iconSizePx, dotPath, DEFAULT_DOT_SIZE); |
Samuel Fufa | c96fa24 | 2019-09-26 23:06:32 -0700 | [diff] [blame] | 481 | mDotRendererAllApps = iconSizePx == allAppsIconSizePx ? mDotRendererWorkSpace : |
Sunny Goyal | 8b9919d | 2021-04-07 14:45:17 -0700 | [diff] [blame] | 482 | new DotRenderer(allAppsIconSizePx, dotPath, DEFAULT_DOT_SIZE); |
Adam Cohen | 63f1ec0 | 2014-08-12 09:23:13 -0700 | [diff] [blame] | 483 | } |
| 484 | |
Thales Lima | a101290 | 2022-01-13 17:58:42 +0000 | [diff] [blame] | 485 | private int calculateQsbWidth() { |
| 486 | return cellWidthPx * inv.numColumns |
| 487 | + cellLayoutBorderSpacePx.x * (inv.numColumns - 1) |
| 488 | - (cellWidthPx - iconSizePx) // left and right cell space |
| 489 | - iconSizePx * numShownHotseatIcons |
| 490 | - hotseatBorderSpace * numShownHotseatIcons; |
| 491 | } |
| 492 | |
Thales Lima | d90faab | 2021-09-21 17:18:47 +0100 | [diff] [blame] | 493 | private int getHorizontalMarginPx(InvariantDeviceProfile idp, Resources res) { |
| 494 | if (isVerticalBarLayout()) { |
| 495 | return 0; |
| 496 | } |
| 497 | |
Thales Lima | 83bedbf | 2021-10-05 17:47:39 +0100 | [diff] [blame] | 498 | return isScalableGrid |
| 499 | ? pxFromDp(idp.horizontalMargin[mTypeIndex], mMetrics) |
| 500 | : res.getDimensionPixelSize(R.dimen.dynamic_grid_left_right_margin); |
Thales Lima | d90faab | 2021-09-21 17:18:47 +0100 | [diff] [blame] | 501 | } |
| 502 | |
Jon Miranda | 0d28485 | 2021-06-22 14:50:55 -0700 | [diff] [blame] | 503 | private void updateHotseatIconSize(int hotseatIconSizePx) { |
Jon Miranda | 92c1b5d | 2021-07-20 13:57:16 -0700 | [diff] [blame] | 504 | // Ensure there is enough space for folder icons, which have a slightly larger radius. |
| 505 | hotseatCellHeightPx = (int) Math.ceil(hotseatIconSizePx * ICON_OVERLAP_FACTOR); |
Jon Miranda | 0d28485 | 2021-06-22 14:50:55 -0700 | [diff] [blame] | 506 | if (isVerticalBarLayout()) { |
| 507 | hotseatBarSizePx = hotseatIconSizePx + hotseatBarSidePaddingStartPx |
| 508 | + hotseatBarSidePaddingEndPx; |
| 509 | } else { |
| 510 | hotseatBarSizePx = hotseatIconSizePx + hotseatBarTopPaddingPx |
Jon Miranda | 80cddbc | 2021-07-22 13:51:16 -0700 | [diff] [blame] | 511 | + hotseatBarBottomPaddingPx + (isScalableGrid ? 0 : hotseatExtraVerticalSize) |
| 512 | + hotseatBarSizeExtraSpacePx; |
Jon Miranda | 0d28485 | 2021-06-22 14:50:55 -0700 | [diff] [blame] | 513 | } |
| 514 | } |
| 515 | |
Thales Lima | 78d00ad | 2021-09-30 11:29:06 +0100 | [diff] [blame] | 516 | private Point getCellLayoutBorderSpace(InvariantDeviceProfile idp) { |
| 517 | if (!isScalableGrid) { |
| 518 | return new Point(0, 0); |
| 519 | } |
| 520 | |
Thales Lima | 83bedbf | 2021-10-05 17:47:39 +0100 | [diff] [blame] | 521 | int horizontalSpacePx = pxFromDp(idp.borderSpaces[mTypeIndex].x, mMetrics); |
| 522 | int verticalSpacePx = pxFromDp(idp.borderSpaces[mTypeIndex].y, mMetrics); |
Thales Lima | 78d00ad | 2021-09-30 11:29:06 +0100 | [diff] [blame] | 523 | |
| 524 | return new Point(horizontalSpacePx, verticalSpacePx); |
| 525 | } |
| 526 | |
| 527 | private Point getCellLayoutBorderSpaceScaled(InvariantDeviceProfile idp, float scale) { |
| 528 | Point original = getCellLayoutBorderSpace(idp); |
| 529 | return new Point((int) (original.x * scale), (int) (original.y * scale)); |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 530 | } |
| 531 | |
Sunny Goyal | 69a8eec | 2021-07-22 10:02:50 -0700 | [diff] [blame] | 532 | public Info getDisplayInfo() { |
| 533 | return mInfo; |
| 534 | } |
| 535 | |
Jon Miranda | 611dba4 | 2021-03-02 14:12:13 -0500 | [diff] [blame] | 536 | /** |
| 537 | * We inset the widget padding added by the system and instead rely on the border spacing |
| 538 | * between cells to create reliable consistency between widgets |
| 539 | */ |
| 540 | public boolean shouldInsetWidgets() { |
| 541 | Rect widgetPadding = inv.defaultWidgetPadding; |
| 542 | |
Jon Miranda | 4981118 | 2021-06-03 09:52:40 -0700 | [diff] [blame] | 543 | // Check all sides to ensure that the widget won't overlap into another cell, or into |
| 544 | // status bar. |
| 545 | return workspaceTopPadding > widgetPadding.top |
Thales Lima | 78d00ad | 2021-09-30 11:29:06 +0100 | [diff] [blame] | 546 | && cellLayoutBorderSpacePx.x > widgetPadding.left |
| 547 | && cellLayoutBorderSpacePx.y > widgetPadding.top |
| 548 | && cellLayoutBorderSpacePx.x > widgetPadding.right |
| 549 | && cellLayoutBorderSpacePx.y > widgetPadding.bottom; |
Jon Miranda | 611dba4 | 2021-03-02 14:12:13 -0500 | [diff] [blame] | 550 | } |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 551 | |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 552 | public Builder toBuilder(Context context) { |
Sunny Goyal | 187b16c | 2022-03-01 16:53:23 -0800 | [diff] [blame] | 553 | WindowBounds bounds = new WindowBounds( |
| 554 | widthPx, heightPx, availableWidthPx, availableHeightPx, rotationHint); |
Sunny Goyal | 19ff728 | 2021-04-22 10:12:54 -0700 | [diff] [blame] | 555 | bounds.bounds.offsetTo(windowX, windowY); |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 556 | return new Builder(context, inv, mInfo) |
Sunny Goyal | 19ff728 | 2021-04-22 10:12:54 -0700 | [diff] [blame] | 557 | .setWindowBounds(bounds) |
| 558 | .setUseTwoPanels(isTwoPanels) |
Alex Chau | 6ed408f | 2022-03-04 12:58:05 +0000 | [diff] [blame] | 559 | .setMultiWindowMode(isMultiWindowMode) |
| 560 | .setGestureMode(isGestureMode); |
Sunny Goyal | 1a52ef5 | 2018-01-11 10:15:03 -0800 | [diff] [blame] | 561 | } |
| 562 | |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 563 | public DeviceProfile copy(Context context) { |
| 564 | return toBuilder(context).build(); |
| 565 | } |
| 566 | |
| 567 | /** |
| 568 | * TODO: Move this to the builder as part of setMultiWindowMode |
| 569 | */ |
Sunny Goyal | b46703d | 2020-05-27 17:52:03 -0700 | [diff] [blame] | 570 | public DeviceProfile getMultiWindowProfile(Context context, WindowBounds windowBounds) { |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 571 | DeviceProfile profile = toBuilder(context) |
Sunny Goyal | 19ff728 | 2021-04-22 10:12:54 -0700 | [diff] [blame] | 572 | .setWindowBounds(windowBounds) |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 573 | .setMultiWindowMode(true) |
| 574 | .build(); |
Jon Miranda | 93e1f04 | 2016-11-11 14:13:04 -0800 | [diff] [blame] | 575 | |
Jon Miranda | 941375e | 2021-03-31 13:10:45 -0400 | [diff] [blame] | 576 | profile.hideWorkspaceLabelsIfNotEnoughSpace(); |
Jon Miranda | 93e1f04 | 2016-11-11 14:13:04 -0800 | [diff] [blame] | 577 | |
Jon Miranda | 7ae64ff | 2016-11-21 16:18:46 -0800 | [diff] [blame] | 578 | // We use these scales to measure and layout the widgets using their full invariant profile |
| 579 | // sizes and then draw them scaled and centered to fit in their multi-window mode cellspans. |
| 580 | float appWidgetScaleX = (float) profile.getCellSize().x / getCellSize().x; |
| 581 | float appWidgetScaleY = (float) profile.getCellSize().y / getCellSize().y; |
| 582 | profile.appWidgetScale.set(appWidgetScaleX, appWidgetScaleY); |
Sunny Goyal | 07b6929 | 2018-01-08 14:19:34 -0800 | [diff] [blame] | 583 | profile.updateWorkspacePadding(); |
Jon Miranda | 7ae64ff | 2016-11-21 16:18:46 -0800 | [diff] [blame] | 584 | |
Jon Miranda | 93e1f04 | 2016-11-11 14:13:04 -0800 | [diff] [blame] | 585 | return profile; |
Jon Miranda | cc42c5b | 2016-10-27 17:15:27 -0700 | [diff] [blame] | 586 | } |
| 587 | |
Adam Cohen | 63f1ec0 | 2014-08-12 09:23:13 -0700 | [diff] [blame] | 588 | /** |
Jon Miranda | 941375e | 2021-03-31 13:10:45 -0400 | [diff] [blame] | 589 | * Checks if there is enough space for labels on the workspace. |
| 590 | * If there is not, labels on the Workspace are hidden. |
Jon Miranda | 1091e53 | 2017-07-21 13:31:50 -0700 | [diff] [blame] | 591 | * It is important to call this method after the All Apps variables have been set. |
| 592 | */ |
Jon Miranda | 941375e | 2021-03-31 13:10:45 -0400 | [diff] [blame] | 593 | private void hideWorkspaceLabelsIfNotEnoughSpace() { |
| 594 | float iconTextHeight = Utilities.calculateTextHeight(iconTextSizePx); |
| 595 | float workspaceCellPaddingY = getCellSize().y - iconSizePx - iconDrawablePaddingPx |
| 596 | - iconTextHeight; |
| 597 | |
| 598 | // We want enough space so that the text is closer to its corresponding icon. |
| 599 | if (workspaceCellPaddingY < iconTextHeight) { |
| 600 | iconTextSizePx = 0; |
| 601 | iconDrawablePaddingPx = 0; |
Jon Miranda | 92c1b5d | 2021-07-20 13:57:16 -0700 | [diff] [blame] | 602 | cellHeightPx = (int) Math.ceil(iconSizePx * ICON_OVERLAP_FACTOR); |
Jon Miranda | 941375e | 2021-03-31 13:10:45 -0400 | [diff] [blame] | 603 | autoResizeAllAppsCells(); |
| 604 | } |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 605 | } |
Jon Miranda | 1091e53 | 2017-07-21 13:31:50 -0700 | [diff] [blame] | 606 | |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 607 | /** |
| 608 | * Re-computes the all-apps cell size to be independent of workspace |
| 609 | */ |
| 610 | public void autoResizeAllAppsCells() { |
Jon Miranda | 941375e | 2021-03-31 13:10:45 -0400 | [diff] [blame] | 611 | int textHeight = Utilities.calculateTextHeight(allAppsIconTextSizePx); |
| 612 | int topBottomPadding = textHeight; |
Jon Miranda | 1091e53 | 2017-07-21 13:31:50 -0700 | [diff] [blame] | 613 | allAppsCellHeightPx = allAppsIconSizePx + allAppsIconDrawablePaddingPx |
Jon Miranda | 941375e | 2021-03-31 13:10:45 -0400 | [diff] [blame] | 614 | + textHeight + (topBottomPadding * 2); |
Jon Miranda | 1091e53 | 2017-07-21 13:31:50 -0700 | [diff] [blame] | 615 | } |
| 616 | |
Alex Chau | 27b39b9 | 2022-01-14 18:02:18 +0000 | [diff] [blame] | 617 | private void updateAllAppsWidth(Resources res) { |
| 618 | |
| 619 | if (isTablet) { |
| 620 | allAppsLeftRightPadding = |
| 621 | res.getDimensionPixelSize(R.dimen.all_apps_bottom_sheet_horizontal_padding) |
| 622 | + cellLayoutPaddingLeftRightPx; |
sfufa@google.com | de01329 | 2021-09-21 18:22:44 -0700 | [diff] [blame] | 623 | int usedWidth = (allAppsCellWidthPx * numShownAllAppsColumns) |
Alex Chau | 27b39b9 | 2022-01-14 18:02:18 +0000 | [diff] [blame] | 624 | + (allAppsBorderSpacePx.x * (numShownAllAppsColumns + 1)) |
| 625 | + allAppsLeftRightPadding * 2; |
| 626 | allAppsLeftRightMargin = Math.max(1, (availableWidthPx - usedWidth) / 2); |
sfufa@google.com | de01329 | 2021-09-21 18:22:44 -0700 | [diff] [blame] | 627 | } else { |
| 628 | allAppsLeftRightPadding = |
Thales Lima | d90faab | 2021-09-21 17:18:47 +0100 | [diff] [blame] | 629 | desiredWorkspaceHorizontalMarginPx + cellLayoutPaddingLeftRightPx; |
sfufa@google.com | de01329 | 2021-09-21 18:22:44 -0700 | [diff] [blame] | 630 | } |
| 631 | } |
| 632 | |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 633 | /** |
| 634 | * Returns the amount of extra (or unused) vertical space. |
| 635 | */ |
| 636 | private int updateAvailableDimensions(Resources res) { |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 637 | updateIconSize(1f, res); |
Winson Chung | 59a488a | 2013-12-10 12:32:14 -0800 | [diff] [blame] | 638 | |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 639 | Point workspacePadding = getTotalWorkspacePadding(); |
| 640 | |
| 641 | // Check to see if the icons fit within the available height. |
| 642 | float usedHeight = getCellLayoutHeight(); |
| 643 | final int maxHeight = availableHeightPx - workspacePadding.y; |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 644 | float extraHeight = Math.max(0, maxHeight - usedHeight); |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 645 | float scaleY = maxHeight / usedHeight; |
| 646 | boolean shouldScale = scaleY < 1f; |
| 647 | |
| 648 | float scaleX = 1f; |
| 649 | if (isScalableGrid) { |
| 650 | // We scale to fit the cellWidth and cellHeight in the available space. |
| 651 | // The benefit of scalable grids is that we can get consistent aspect ratios between |
| 652 | // devices. |
Thales Lima | d1df5fc | 2021-09-03 18:37:19 +0100 | [diff] [blame] | 653 | int numColumns = isTwoPanels ? inv.numColumns * 2 : inv.numColumns; |
| 654 | float usedWidth = (cellWidthPx * numColumns) |
Thales Lima | 78d00ad | 2021-09-30 11:29:06 +0100 | [diff] [blame] | 655 | + (cellLayoutBorderSpacePx.x * (numColumns - 1)) |
Thales Lima | d90faab | 2021-09-21 17:18:47 +0100 | [diff] [blame] | 656 | + (desiredWorkspaceHorizontalMarginPx * 2); |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 657 | // We do not subtract padding here, as we also scale the workspace padding if needed. |
| 658 | scaleX = availableWidthPx / usedWidth; |
| 659 | shouldScale = true; |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 660 | } |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 661 | |
| 662 | if (shouldScale) { |
| 663 | float scale = Math.min(scaleX, scaleY); |
| 664 | updateIconSize(scale, res); |
| 665 | extraHeight = Math.max(0, maxHeight - getCellLayoutHeight()); |
| 666 | } |
| 667 | |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 668 | updateAvailableFolderCellDimensions(res); |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 669 | return Math.round(extraHeight); |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 670 | } |
| 671 | |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 672 | private int getCellLayoutHeight() { |
Thales Lima | 78d00ad | 2021-09-30 11:29:06 +0100 | [diff] [blame] | 673 | return (cellHeightPx * inv.numRows) + (cellLayoutBorderSpacePx.y * (inv.numRows - 1)); |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 674 | } |
| 675 | |
Jon Miranda | 6f7e970 | 2019-09-16 14:44:14 -0700 | [diff] [blame] | 676 | /** |
| 677 | * Updating the iconSize affects many aspects of the launcher layout, such as: iconSizePx, |
| 678 | * iconTextSizePx, iconDrawablePaddingPx, cellWidth/Height, allApps* variants, |
| 679 | * hotseat sizes, workspaceSpringLoadedShrinkFactor, folderIconSizePx, and folderIconOffsetYPx. |
| 680 | */ |
Tony Wickham | 7ba547c | 2021-02-02 17:12:08 -0800 | [diff] [blame] | 681 | public void updateIconSize(float scale, Resources res) { |
Jon Miranda | ab3c681 | 2021-06-28 15:42:28 -0700 | [diff] [blame] | 682 | // Icon scale should never exceed 1, otherwise pixellation may occur. |
| 683 | iconScale = Math.min(1f, scale); |
| 684 | cellScaleToFit = scale; |
| 685 | |
Jon Miranda | 18751b6 | 2017-07-31 17:25:27 -0700 | [diff] [blame] | 686 | // Workspace |
Sunny Goyal | 07b6929 | 2018-01-08 14:19:34 -0800 | [diff] [blame] | 687 | final boolean isVerticalLayout = isVerticalBarLayout(); |
Thales Lima | 83bedbf | 2021-10-05 17:47:39 +0100 | [diff] [blame] | 688 | float invIconSizeDp = inv.iconSize[mTypeIndex]; |
| 689 | float invIconTextSizeSp = inv.iconTextSize[mTypeIndex]; |
Andras Kloczl | 30fe915 | 2021-08-05 18:02:29 +0200 | [diff] [blame] | 690 | |
Jon Miranda | ab3c681 | 2021-06-28 15:42:28 -0700 | [diff] [blame] | 691 | iconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mMetrics, iconScale)); |
Jon Miranda | ab3c681 | 2021-06-28 15:42:28 -0700 | [diff] [blame] | 692 | iconTextSizePx = (int) (pxFromSp(invIconTextSizeSp, mMetrics) * iconScale); |
| 693 | iconDrawablePaddingPx = (int) (iconDrawablePaddingOriginalPx * iconScale); |
Jon Miranda | b28c4fc | 2017-06-20 10:58:36 -0700 | [diff] [blame] | 694 | |
Thales Lima | 78d00ad | 2021-09-30 11:29:06 +0100 | [diff] [blame] | 695 | cellLayoutBorderSpacePx = getCellLayoutBorderSpaceScaled(inv, scale); |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 696 | |
| 697 | if (isScalableGrid) { |
Thales Lima | 83bedbf | 2021-10-05 17:47:39 +0100 | [diff] [blame] | 698 | cellWidthPx = pxFromDp(inv.minCellSize[mTypeIndex].x, mMetrics, scale); |
| 699 | cellHeightPx = pxFromDp(inv.minCellSize[mTypeIndex].y, mMetrics, scale); |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 700 | int cellContentHeight = iconSizePx + iconDrawablePaddingPx |
| 701 | + Utilities.calculateTextHeight(iconTextSizePx); |
| 702 | cellYPaddingPx = Math.max(0, cellHeightPx - cellContentHeight) / 2; |
Thales Lima | d90faab | 2021-09-21 17:18:47 +0100 | [diff] [blame] | 703 | desiredWorkspaceHorizontalMarginPx = |
| 704 | (int) (desiredWorkspaceHorizontalMarginOriginalPx * scale); |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 705 | } else { |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 706 | cellWidthPx = iconSizePx + iconDrawablePaddingPx; |
Jon Miranda | 92c1b5d | 2021-07-20 13:57:16 -0700 | [diff] [blame] | 707 | cellHeightPx = (int) Math.ceil(iconSizePx * ICON_OVERLAP_FACTOR) |
| 708 | + iconDrawablePaddingPx |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 709 | + Utilities.calculateTextHeight(iconTextSizePx); |
| 710 | int cellPaddingY = (getCellSize().y - cellHeightPx) / 2; |
| 711 | if (iconDrawablePaddingPx > cellPaddingY && !isVerticalLayout |
| 712 | && !isMultiWindowMode) { |
| 713 | // Ensures that the label is closer to its corresponding icon. This is not an issue |
| 714 | // with vertical bar layout or multi-window mode since the issue is handled |
| 715 | // separately with their calls to {@link #adjustToHideWorkspaceLabels}. |
| 716 | cellHeightPx -= (iconDrawablePaddingPx - cellPaddingY); |
| 717 | iconDrawablePaddingPx = cellPaddingY; |
| 718 | } |
Jon Miranda | 846455e | 2017-10-02 14:58:52 -0700 | [diff] [blame] | 719 | } |
Jon Miranda | 18751b6 | 2017-07-31 17:25:27 -0700 | [diff] [blame] | 720 | |
Sunny Goyal | ae190ff | 2020-04-14 00:19:01 +0000 | [diff] [blame] | 721 | // All apps |
Brian Isganitis | 25b2ac8 | 2022-01-28 16:25:13 -0500 | [diff] [blame] | 722 | updateAllAppsIconSize(scale, res); |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 723 | |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 724 | // Hotseat |
Thales Lima | dd02734 | 2022-01-07 12:54:37 +0000 | [diff] [blame] | 725 | hotseatBorderSpace = pxFromDp(inv.hotseatBorderSpaces[mTypeIndex], mMetrics, scale); |
Thales Lima | a101290 | 2022-01-13 17:58:42 +0000 | [diff] [blame] | 726 | if (isQsbInline) { |
| 727 | qsbWidth = calculateQsbWidth(); |
| 728 | } else { |
| 729 | qsbWidth = 0; |
| 730 | } |
Jon Miranda | 0d28485 | 2021-06-22 14:50:55 -0700 | [diff] [blame] | 731 | updateHotseatIconSize(iconSizePx); |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 732 | |
Sunny Goyal | 07b6929 | 2018-01-08 14:19:34 -0800 | [diff] [blame] | 733 | if (!isVerticalLayout) { |
Jon Miranda | 18751b6 | 2017-07-31 17:25:27 -0700 | [diff] [blame] | 734 | int expectedWorkspaceHeight = availableHeightPx - hotseatBarSizePx |
Tony Wickham | 5edf9e2 | 2020-03-27 20:06:52 -0700 | [diff] [blame] | 735 | - workspacePageIndicatorHeight - edgeMarginPx; |
Sunny Goyal | 47328fd | 2016-05-25 18:56:41 -0700 | [diff] [blame] | 736 | float minRequiredHeight = dropTargetBarSizePx + workspaceSpringLoadedBottomSpace; |
| 737 | workspaceSpringLoadShrinkFactor = Math.min( |
| 738 | res.getInteger(R.integer.config_workspaceSpringLoadShrinkPercentage) / 100.0f, |
| 739 | 1 - (minRequiredHeight / expectedWorkspaceHeight)); |
| 740 | } else { |
| 741 | workspaceSpringLoadShrinkFactor = |
| 742 | res.getInteger(R.integer.config_workspaceSpringLoadShrinkPercentage) / 100.0f; |
| 743 | } |
| 744 | |
Sunny Goyal | baec6ff | 2016-09-14 11:26:21 -0700 | [diff] [blame] | 745 | // Folder icon |
Jon Miranda | 591e360 | 2018-03-28 11:37:00 -0700 | [diff] [blame] | 746 | folderIconSizePx = IconNormalizer.getNormalizedCircleSize(iconSizePx); |
| 747 | folderIconOffsetYPx = (iconSizePx - folderIconSizePx) / 2; |
Winson Chung | 0f78572 | 2015-04-08 10:27:49 -0700 | [diff] [blame] | 748 | } |
| 749 | |
Brian Isganitis | 25b2ac8 | 2022-01-28 16:25:13 -0500 | [diff] [blame] | 750 | |
| 751 | /** |
| 752 | * Updates the iconSize for allApps* variants. |
| 753 | */ |
| 754 | public void updateAllAppsIconSize(float scale, Resources res) { |
| 755 | if (numShownAllAppsColumns != inv.numColumns) { |
| 756 | allAppsIconSizePx = |
| 757 | pxFromDp(inv.allAppsIconSize[mTypeIndex], mMetrics); |
| 758 | allAppsIconTextSizePx = |
| 759 | pxFromSp(inv.allAppsIconTextSize[mTypeIndex], mMetrics); |
| 760 | allAppsIconDrawablePaddingPx = iconDrawablePaddingOriginalPx; |
| 761 | autoResizeAllAppsCells(); |
| 762 | } else { |
| 763 | float invIconSizeDp = inv.iconSize[mTypeIndex]; |
| 764 | float invIconTextSizeSp = inv.iconTextSize[mTypeIndex]; |
| 765 | allAppsIconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mMetrics, scale)); |
| 766 | allAppsIconTextSizePx = (int) (pxFromSp(invIconTextSizeSp, mMetrics) * scale); |
| 767 | allAppsIconDrawablePaddingPx = (int) (iconDrawablePaddingOriginalPx * scale); |
| 768 | allAppsCellHeightPx = getCellSize().y; |
| 769 | } |
| 770 | |
| 771 | allAppsCellWidthPx = allAppsIconSizePx + (2 * allAppsIconDrawablePaddingPx); |
| 772 | updateAllAppsWidth(res); |
| 773 | if (isVerticalBarLayout()) { |
| 774 | hideWorkspaceLabelsIfNotEnoughSpace(); |
| 775 | } |
| 776 | } |
| 777 | |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 778 | private void updateAvailableFolderCellDimensions(Resources res) { |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 779 | updateFolderCellSize(1f, res); |
Jon Miranda | bf7d812 | 2016-11-03 15:29:29 -0700 | [diff] [blame] | 780 | |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 781 | final int folderBottomPanelSize = res.getDimensionPixelSize(R.dimen.folder_label_height); |
| 782 | |
Jon Miranda | c1b2399 | 2016-12-13 08:57:36 -0800 | [diff] [blame] | 783 | // Don't let the folder get too close to the edges of the screen. |
Jon Miranda | 1786df3 | 2018-09-25 13:05:23 -0700 | [diff] [blame] | 784 | int folderMargin = edgeMarginPx * 2; |
Sunny Goyal | 07b6929 | 2018-01-08 14:19:34 -0800 | [diff] [blame] | 785 | Point totalWorkspacePadding = getTotalWorkspacePadding(); |
Jon Miranda | c1b2399 | 2016-12-13 08:57:36 -0800 | [diff] [blame] | 786 | |
| 787 | // Check if the icons fit within the available height. |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 788 | float contentUsedHeight = folderCellHeightPx * inv.numFolderRows |
Thales Lima | 78d00ad | 2021-09-30 11:29:06 +0100 | [diff] [blame] | 789 | + ((inv.numFolderRows - 1) * folderCellLayoutBorderSpacePx.y); |
Samuel Fufa | 1c8d90a | 2019-11-12 17:54:58 -0800 | [diff] [blame] | 790 | int contentMaxHeight = availableHeightPx - totalWorkspacePadding.y - folderBottomPanelSize |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 791 | - folderMargin - folderContentPaddingTop; |
Samuel Fufa | 1c8d90a | 2019-11-12 17:54:58 -0800 | [diff] [blame] | 792 | float scaleY = contentMaxHeight / contentUsedHeight; |
Jon Miranda | c1b2399 | 2016-12-13 08:57:36 -0800 | [diff] [blame] | 793 | |
| 794 | // Check if the icons fit within the available width. |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 795 | float contentUsedWidth = folderCellWidthPx * inv.numFolderColumns |
Thales Lima | 78d00ad | 2021-09-30 11:29:06 +0100 | [diff] [blame] | 796 | + ((inv.numFolderColumns - 1) * folderCellLayoutBorderSpacePx.x); |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 797 | int contentMaxWidth = availableWidthPx - totalWorkspacePadding.x - folderMargin |
| 798 | - folderContentPaddingLeftRight * 2; |
Samuel Fufa | 1c8d90a | 2019-11-12 17:54:58 -0800 | [diff] [blame] | 799 | float scaleX = contentMaxWidth / contentUsedWidth; |
Jon Miranda | c1b2399 | 2016-12-13 08:57:36 -0800 | [diff] [blame] | 800 | |
| 801 | float scale = Math.min(scaleX, scaleY); |
| 802 | if (scale < 1f) { |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 803 | updateFolderCellSize(scale, res); |
Jon Miranda | bf7d812 | 2016-11-03 15:29:29 -0700 | [diff] [blame] | 804 | } |
| 805 | } |
| 806 | |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 807 | private void updateFolderCellSize(float scale, Resources res) { |
Thales Lima | 83bedbf | 2021-10-05 17:47:39 +0100 | [diff] [blame] | 808 | float invIconSizeDp = isVerticalBarLayout() |
| 809 | ? inv.iconSize[InvariantDeviceProfile.INDEX_LANDSCAPE] |
| 810 | : inv.iconSize[InvariantDeviceProfile.INDEX_DEFAULT]; |
Sunny Goyal | 35c7b19 | 2021-04-20 16:51:10 -0700 | [diff] [blame] | 811 | folderChildIconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mMetrics, scale)); |
Thales Lima | 83bedbf | 2021-10-05 17:47:39 +0100 | [diff] [blame] | 812 | folderChildTextSizePx = |
| 813 | pxFromSp(inv.iconTextSize[InvariantDeviceProfile.INDEX_DEFAULT], mMetrics, scale); |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 814 | folderLabelTextSizePx = (int) (folderChildTextSizePx * folderLabelTextScale); |
Jon Miranda | bf7d812 | 2016-11-03 15:29:29 -0700 | [diff] [blame] | 815 | |
| 816 | int textHeight = Utilities.calculateTextHeight(folderChildTextSizePx); |
Jon Miranda | bf7d812 | 2016-11-03 15:29:29 -0700 | [diff] [blame] | 817 | |
Jon Miranda | 823da22 | 2021-03-23 08:08:45 -0400 | [diff] [blame] | 818 | if (isScalableGrid) { |
Jon Miranda | f33f5b3 | 2021-07-22 17:15:31 -0700 | [diff] [blame] | 819 | int minWidth = folderChildIconSizePx + iconDrawablePaddingPx * 2; |
| 820 | int minHeight = folderChildIconSizePx + iconDrawablePaddingPx * 2 + textHeight; |
| 821 | |
| 822 | folderCellWidthPx = (int) Math.max(minWidth, cellWidthPx * scale); |
| 823 | folderCellHeightPx = (int) Math.max(minHeight, cellHeightPx * scale); |
Jon Miranda | 823da22 | 2021-03-23 08:08:45 -0400 | [diff] [blame] | 824 | |
Thales Lima | 78d00ad | 2021-09-30 11:29:06 +0100 | [diff] [blame] | 825 | int scaledSpace = (int) (folderCellLayoutBorderSpaceOriginalPx * scale); |
| 826 | folderCellLayoutBorderSpacePx = new Point(scaledSpace, scaledSpace); |
| 827 | folderContentPaddingLeftRight = scaledSpace; |
| 828 | folderContentPaddingTop = scaledSpace; |
Jon Miranda | 823da22 | 2021-03-23 08:08:45 -0400 | [diff] [blame] | 829 | } else { |
| 830 | int cellPaddingX = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_x_padding) |
| 831 | * scale); |
| 832 | int cellPaddingY = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_y_padding) |
| 833 | * scale); |
| 834 | |
| 835 | folderCellWidthPx = folderChildIconSizePx + 2 * cellPaddingX; |
| 836 | folderCellHeightPx = folderChildIconSizePx + 2 * cellPaddingY + textHeight; |
| 837 | } |
| 838 | |
Jonathan Miranda | 9ad8746 | 2017-07-26 17:41:02 +0000 | [diff] [blame] | 839 | folderChildDrawablePaddingPx = Math.max(0, |
| 840 | (folderCellHeightPx - folderChildIconSizePx - textHeight) / 3); |
Jon Miranda | bf7d812 | 2016-11-03 15:29:29 -0700 | [diff] [blame] | 841 | } |
| 842 | |
Winson | 1f06427 | 2016-07-18 17:18:02 -0700 | [diff] [blame] | 843 | public void updateInsets(Rect insets) { |
| 844 | mInsets.set(insets); |
Sunny Goyal | 07b6929 | 2018-01-08 14:19:34 -0800 | [diff] [blame] | 845 | updateWorkspacePadding(); |
Winson | 1f06427 | 2016-07-18 17:18:02 -0700 | [diff] [blame] | 846 | } |
| 847 | |
Sunny Goyal | ae6e318 | 2019-04-30 12:04:37 -0700 | [diff] [blame] | 848 | /** |
| 849 | * The current device insets. This is generally same as the insets being dispatched to |
| 850 | * {@link Insettable} elements, but can differ if the element is using a different profile. |
| 851 | */ |
Sunny Goyal | 1a52ef5 | 2018-01-11 10:15:03 -0800 | [diff] [blame] | 852 | public Rect getInsets() { |
| 853 | return mInsets; |
| 854 | } |
| 855 | |
Sunny Goyal | 756cd26 | 2015-08-20 12:33:21 -0700 | [diff] [blame] | 856 | public Point getCellSize() { |
Sunny Goyal | 19ff728 | 2021-04-22 10:12:54 -0700 | [diff] [blame] | 857 | return getCellSize(null); |
Jon Miranda | 6f7e970 | 2019-09-16 14:44:14 -0700 | [diff] [blame] | 858 | } |
| 859 | |
Sunny Goyal | 19ff728 | 2021-04-22 10:12:54 -0700 | [diff] [blame] | 860 | public Point getCellSize(Point result) { |
| 861 | if (result == null) { |
| 862 | result = new Point(); |
| 863 | } |
Thales Lima | d1df5fc | 2021-09-03 18:37:19 +0100 | [diff] [blame] | 864 | |
Sunny Goyal | 756cd26 | 2015-08-20 12:33:21 -0700 | [diff] [blame] | 865 | // Since we are only concerned with the overall padding, layout direction does |
| 866 | // not matter. |
Sunny Goyal | 6c2975e | 2016-07-06 09:47:56 -0700 | [diff] [blame] | 867 | Point padding = getTotalWorkspacePadding(); |
Thales Lima | d1df5fc | 2021-09-03 18:37:19 +0100 | [diff] [blame] | 868 | |
| 869 | int numColumns = isTwoPanels ? inv.numColumns * 2 : inv.numColumns; |
Alex Chau | 6095333 | 2021-11-24 12:41:07 +0000 | [diff] [blame] | 870 | int screenWidthPx = getWorkspaceWidth(padding); |
Thales Lima | 78d00ad | 2021-09-30 11:29:06 +0100 | [diff] [blame] | 871 | result.x = calculateCellWidth(screenWidthPx, cellLayoutBorderSpacePx.x, numColumns); |
Jon Miranda | 18751b6 | 2017-07-31 17:25:27 -0700 | [diff] [blame] | 872 | result.y = calculateCellHeight(availableHeightPx - padding.y |
Thales Lima | 78d00ad | 2021-09-30 11:29:06 +0100 | [diff] [blame] | 873 | - cellLayoutBottomPaddingPx, cellLayoutBorderSpacePx.y, inv.numRows); |
Sunny Goyal | 756cd26 | 2015-08-20 12:33:21 -0700 | [diff] [blame] | 874 | return result; |
| 875 | } |
| 876 | |
Alex Chau | 6095333 | 2021-11-24 12:41:07 +0000 | [diff] [blame] | 877 | public int getWorkspaceWidth() { |
| 878 | return getWorkspaceWidth(getTotalWorkspacePadding()); |
| 879 | } |
| 880 | |
| 881 | public int getWorkspaceWidth(Point workspacePadding) { |
| 882 | int cellLayoutTotalPadding = |
| 883 | isTwoPanels ? 4 * cellLayoutPaddingLeftRightPx : 2 * cellLayoutPaddingLeftRightPx; |
| 884 | return availableWidthPx - workspacePadding.x - cellLayoutTotalPadding; |
| 885 | } |
| 886 | |
Sunny Goyal | 6c2975e | 2016-07-06 09:47:56 -0700 | [diff] [blame] | 887 | public Point getTotalWorkspacePadding() { |
Sunny Goyal | 07b6929 | 2018-01-08 14:19:34 -0800 | [diff] [blame] | 888 | updateWorkspacePadding(); |
| 889 | return new Point(workspacePadding.left + workspacePadding.right, |
| 890 | workspacePadding.top + workspacePadding.bottom); |
Sunny Goyal | 6c2975e | 2016-07-06 09:47:56 -0700 | [diff] [blame] | 891 | } |
| 892 | |
| 893 | /** |
Sunny Goyal | 07b6929 | 2018-01-08 14:19:34 -0800 | [diff] [blame] | 894 | * Updates {@link #workspacePadding} as a result of any internal value change to reflect the |
| 895 | * new workspace padding |
Sunny Goyal | 6c2975e | 2016-07-06 09:47:56 -0700 | [diff] [blame] | 896 | */ |
Sunny Goyal | 07b6929 | 2018-01-08 14:19:34 -0800 | [diff] [blame] | 897 | private void updateWorkspacePadding() { |
| 898 | Rect padding = workspacePadding; |
Tony Wickham | 3a3517f | 2015-10-06 11:27:04 -0700 | [diff] [blame] | 899 | if (isVerticalBarLayout()) { |
Sunny Goyal | 228153d | 2018-01-04 15:35:22 -0800 | [diff] [blame] | 900 | padding.top = 0; |
| 901 | padding.bottom = edgeMarginPx; |
Sunny Goyal | 7e2e67f | 2018-01-26 13:40:08 -0800 | [diff] [blame] | 902 | if (isSeascape()) { |
Tony Wickham | 1eeffbe | 2018-06-12 15:01:15 -0700 | [diff] [blame] | 903 | padding.left = hotseatBarSizePx; |
Tony Wickham | 5edf9e2 | 2020-03-27 20:06:52 -0700 | [diff] [blame] | 904 | padding.right = hotseatBarSidePaddingStartPx; |
Winson | 1f06427 | 2016-07-18 17:18:02 -0700 | [diff] [blame] | 905 | } else { |
Tony Wickham | 5edf9e2 | 2020-03-27 20:06:52 -0700 | [diff] [blame] | 906 | padding.left = hotseatBarSidePaddingStartPx; |
Tony Wickham | 1eeffbe | 2018-06-12 15:01:15 -0700 | [diff] [blame] | 907 | padding.right = hotseatBarSizePx; |
Winson | 1f06427 | 2016-07-18 17:18:02 -0700 | [diff] [blame] | 908 | } |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 909 | } else { |
Thales Lima | 7a6752d | 2021-09-23 14:31:00 +0100 | [diff] [blame] | 910 | // Pad the bottom of the workspace with search/hotseat bar sizes |
Tony Wickham | 21970cc | 2021-09-15 15:44:05 -0700 | [diff] [blame] | 911 | int hotseatTop = hotseatBarSizePx; |
Tony Wickham | a29a046 | 2021-03-02 12:28:25 -0800 | [diff] [blame] | 912 | int paddingBottom = hotseatTop + workspacePageIndicatorHeight |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 913 | + workspaceBottomPadding - mWorkspacePageIndicatorOverlapWorkspace; |
Andras Kloczl | 8e57cce | 2021-02-11 23:51:19 +0100 | [diff] [blame] | 914 | |
Thales Lima | d90faab | 2021-09-21 17:18:47 +0100 | [diff] [blame] | 915 | padding.set(desiredWorkspaceHorizontalMarginPx, |
Thales Lima | 83bedbf | 2021-10-05 17:47:39 +0100 | [diff] [blame] | 916 | workspaceTopPadding + (isScalableGrid ? 0 : edgeMarginPx), |
Thales Lima | d90faab | 2021-09-21 17:18:47 +0100 | [diff] [blame] | 917 | desiredWorkspaceHorizontalMarginPx, |
Thales Lima | 7a6752d | 2021-09-23 14:31:00 +0100 | [diff] [blame] | 918 | paddingBottom); |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 919 | } |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 920 | } |
| 921 | |
Sunny Goyal | 57b2279 | 2021-05-25 14:35:01 -0700 | [diff] [blame] | 922 | /** |
| 923 | * Returns the padding for hotseat view |
| 924 | */ |
| 925 | public Rect getHotseatLayoutPadding(Context context) { |
Sunny Goyal | 81b4c7b | 2018-03-26 12:10:31 -0700 | [diff] [blame] | 926 | if (isVerticalBarLayout()) { |
| 927 | if (isSeascape()) { |
Tony Wickham | 1eeffbe | 2018-06-12 15:01:15 -0700 | [diff] [blame] | 928 | mHotseatPadding.set(mInsets.left + hotseatBarSidePaddingStartPx, |
| 929 | mInsets.top, hotseatBarSidePaddingEndPx, mInsets.bottom); |
Sunny Goyal | 81b4c7b | 2018-03-26 12:10:31 -0700 | [diff] [blame] | 930 | } else { |
Tony Wickham | 1eeffbe | 2018-06-12 15:01:15 -0700 | [diff] [blame] | 931 | mHotseatPadding.set(hotseatBarSidePaddingEndPx, mInsets.top, |
| 932 | mInsets.right + hotseatBarSidePaddingStartPx, mInsets.bottom); |
Sunny Goyal | 81b4c7b | 2018-03-26 12:10:31 -0700 | [diff] [blame] | 933 | } |
Sunny Goyal | 57b2279 | 2021-05-25 14:35:01 -0700 | [diff] [blame] | 934 | } else if (isTaskbarPresent) { |
Tony Wickham | 21970cc | 2021-09-15 15:44:05 -0700 | [diff] [blame] | 935 | int hotseatHeight = workspacePadding.bottom; |
Sunny Goyal | 57b2279 | 2021-05-25 14:35:01 -0700 | [diff] [blame] | 936 | int taskbarOffset = getTaskbarOffsetY(); |
Thales Lima | a101290 | 2022-01-13 17:58:42 +0000 | [diff] [blame] | 937 | int additionalLeftSpace = 0; |
| 938 | |
| 939 | // Center the QSB with hotseat and push icons to the right |
| 940 | if (isQsbInline) { |
| 941 | additionalLeftSpace = qsbWidth + hotseatBorderSpace; |
| 942 | } |
| 943 | |
Tony Wickham | 21970cc | 2021-09-15 15:44:05 -0700 | [diff] [blame] | 944 | int hotseatTopDiff = hotseatHeight - taskbarOffset; |
Sunny Goyal | 57b2279 | 2021-05-25 14:35:01 -0700 | [diff] [blame] | 945 | |
Vinit Nayak | 8dcbde8 | 2021-07-19 12:53:28 -0700 | [diff] [blame] | 946 | int endOffset = ApiWrapper.getHotseatEndOffset(context); |
Thales Lima | 6e7f36c | 2022-01-04 12:14:11 +0000 | [diff] [blame] | 947 | int requiredWidth = iconSizePx * numShownHotseatIcons |
Thales Lima | a101290 | 2022-01-13 17:58:42 +0000 | [diff] [blame] | 948 | + hotseatBorderSpace * (numShownHotseatIcons - 1) |
| 949 | + additionalLeftSpace; |
Sunny Goyal | 57b2279 | 2021-05-25 14:35:01 -0700 | [diff] [blame] | 950 | |
Thales Lima | 6e7f36c | 2022-01-04 12:14:11 +0000 | [diff] [blame] | 951 | int hotseatSize = Math.min(requiredWidth, availableWidthPx - endOffset); |
Sunny Goyal | 57b2279 | 2021-05-25 14:35:01 -0700 | [diff] [blame] | 952 | int sideSpacing = (availableWidthPx - hotseatSize) / 2; |
Thales Lima | a101290 | 2022-01-13 17:58:42 +0000 | [diff] [blame] | 953 | mHotseatPadding.set(sideSpacing + additionalLeftSpace, hotseatTopDiff, sideSpacing, |
| 954 | taskbarOffset); |
Sunny Goyal | 57b2279 | 2021-05-25 14:35:01 -0700 | [diff] [blame] | 955 | |
Vinit Nayak | 8dcbde8 | 2021-07-19 12:53:28 -0700 | [diff] [blame] | 956 | if (endOffset > sideSpacing) { |
Sunny Goyal | 57b2279 | 2021-05-25 14:35:01 -0700 | [diff] [blame] | 957 | int diff = Utilities.isRtl(context.getResources()) |
Vinit Nayak | 8dcbde8 | 2021-07-19 12:53:28 -0700 | [diff] [blame] | 958 | ? sideSpacing - endOffset |
| 959 | : endOffset - sideSpacing; |
| 960 | mHotseatPadding.left -= diff; |
| 961 | mHotseatPadding.right += diff; |
Sunny Goyal | 57b2279 | 2021-05-25 14:35:01 -0700 | [diff] [blame] | 962 | } |
Sunny Goyal | 81b4c7b | 2018-03-26 12:10:31 -0700 | [diff] [blame] | 963 | } else { |
Sunny Goyal | 81b4c7b | 2018-03-26 12:10:31 -0700 | [diff] [blame] | 964 | // We want the edges of the hotseat to line up with the edges of the workspace, but the |
| 965 | // icons in the hotseat are a different size, and so don't line up perfectly. To account |
| 966 | // for this, we pad the left and right of the hotseat with half of the difference of a |
| 967 | // workspace cell vs a hotseat cell. |
| 968 | float workspaceCellWidth = (float) widthPx / inv.numColumns; |
Sunny Goyal | 19ff728 | 2021-04-22 10:12:54 -0700 | [diff] [blame] | 969 | float hotseatCellWidth = (float) widthPx / numShownHotseatIcons; |
Sunny Goyal | 81b4c7b | 2018-03-26 12:10:31 -0700 | [diff] [blame] | 970 | int hotseatAdjustment = Math.round((workspaceCellWidth - hotseatCellWidth) / 2); |
| 971 | mHotseatPadding.set( |
Sunny Goyal | 786940a | 2020-06-02 02:31:31 -0700 | [diff] [blame] | 972 | hotseatAdjustment + workspacePadding.left + cellLayoutPaddingLeftRightPx |
| 973 | + mInsets.left, |
Sunny Goyal | 81b4c7b | 2018-03-26 12:10:31 -0700 | [diff] [blame] | 974 | hotseatBarTopPaddingPx, |
Sunny Goyal | 786940a | 2020-06-02 02:31:31 -0700 | [diff] [blame] | 975 | hotseatAdjustment + workspacePadding.right + cellLayoutPaddingLeftRightPx |
| 976 | + mInsets.right, |
Jon Miranda | 0d28485 | 2021-06-22 14:50:55 -0700 | [diff] [blame] | 977 | hotseatBarSizePx - hotseatCellHeightPx - hotseatBarTopPaddingPx |
| 978 | + cellLayoutBottomPaddingPx + mInsets.bottom); |
Sunny Goyal | 81b4c7b | 2018-03-26 12:10:31 -0700 | [diff] [blame] | 979 | } |
| 980 | return mHotseatPadding; |
| 981 | } |
| 982 | |
Winson | fadbe8f | 2016-07-22 16:35:37 -0700 | [diff] [blame] | 983 | /** |
Sunny Goyal | 57b2279 | 2021-05-25 14:35:01 -0700 | [diff] [blame] | 984 | * Returns the number of pixels the QSB is translated from the bottom of the screen. |
| 985 | */ |
| 986 | public int getQsbOffsetY() { |
Thales Lima | a101290 | 2022-01-13 17:58:42 +0000 | [diff] [blame] | 987 | if (isQsbInline) { |
| 988 | return hotseatBarBottomPaddingPx; |
| 989 | } |
| 990 | |
Sunny Goyal | 57b2279 | 2021-05-25 14:35:01 -0700 | [diff] [blame] | 991 | int freeSpace = isTaskbarPresent |
| 992 | ? workspacePadding.bottom |
| 993 | : hotseatBarSizePx - hotseatCellHeightPx - hotseatQsbHeight; |
Jonathan Miranda | 7a273e2 | 2021-06-24 21:29:10 +0000 | [diff] [blame] | 994 | |
Jonathan Miranda | 8f16a77 | 2021-07-23 23:10:37 +0000 | [diff] [blame] | 995 | if (isScalableGrid && qsbBottomMarginPx > mInsets.bottom) { |
Tony Wickham | 21970cc | 2021-09-15 15:44:05 -0700 | [diff] [blame] | 996 | // Note that taskbarSize = 0 unless isTaskbarPresent. |
| 997 | return Math.min(qsbBottomMarginPx + taskbarSize, freeSpace); |
Jonathan Miranda | 8f16a77 | 2021-07-23 23:10:37 +0000 | [diff] [blame] | 998 | } else { |
Pratyush | 9afe1ea | 2021-10-13 11:13:27 +0000 | [diff] [blame] | 999 | return (int) (freeSpace * mQsbCenterFactor) |
| 1000 | + (isTaskbarPresent ? taskbarSize : mInsets.bottom); |
Jonathan Miranda | 7a273e2 | 2021-06-24 21:29:10 +0000 | [diff] [blame] | 1001 | } |
Sunny Goyal | 57b2279 | 2021-05-25 14:35:01 -0700 | [diff] [blame] | 1002 | } |
| 1003 | |
| 1004 | /** |
| 1005 | * Returns the number of pixels the taskbar is translated from the bottom of the screen. |
| 1006 | */ |
| 1007 | public int getTaskbarOffsetY() { |
Thales Lima | a101290 | 2022-01-13 17:58:42 +0000 | [diff] [blame] | 1008 | if (isQsbInline) { |
| 1009 | return getQsbOffsetY() + (Math.abs(hotseatQsbHeight - iconSizePx) / 2); |
| 1010 | } else { |
| 1011 | return (getQsbOffsetY() - taskbarSize) / 2; |
| 1012 | } |
Sunny Goyal | 57b2279 | 2021-05-25 14:35:01 -0700 | [diff] [blame] | 1013 | } |
| 1014 | |
| 1015 | /** |
Winson | fadbe8f | 2016-07-22 16:35:37 -0700 | [diff] [blame] | 1016 | * @return the bounds for which the open folders should be contained within |
| 1017 | */ |
| 1018 | public Rect getAbsoluteOpenFolderBounds() { |
| 1019 | if (isVerticalBarLayout()) { |
| 1020 | // Folders should only appear right of the drop target bar and left of the hotseat |
| 1021 | return new Rect(mInsets.left + dropTargetBarSizePx + edgeMarginPx, |
| 1022 | mInsets.top, |
Jon Miranda | 18751b6 | 2017-07-31 17:25:27 -0700 | [diff] [blame] | 1023 | mInsets.left + availableWidthPx - hotseatBarSizePx - edgeMarginPx, |
Winson | fadbe8f | 2016-07-22 16:35:37 -0700 | [diff] [blame] | 1024 | mInsets.top + availableHeightPx); |
| 1025 | } else { |
| 1026 | // Folders should only appear below the drop target bar and above the hotseat |
Tony Wickham | ae72b46 | 2021-03-10 16:18:40 -0800 | [diff] [blame] | 1027 | int hotseatTop = isTaskbarPresent ? taskbarSize : hotseatBarSizePx; |
Tony Wickham | b4b7e20 | 2018-01-12 17:39:24 -0800 | [diff] [blame] | 1028 | return new Rect(mInsets.left + edgeMarginPx, |
Winson | fadbe8f | 2016-07-22 16:35:37 -0700 | [diff] [blame] | 1029 | mInsets.top + dropTargetBarSizePx + edgeMarginPx, |
Tony Wickham | b4b7e20 | 2018-01-12 17:39:24 -0800 | [diff] [blame] | 1030 | mInsets.left + availableWidthPx - edgeMarginPx, |
Tony Wickham | ae72b46 | 2021-03-10 16:18:40 -0800 | [diff] [blame] | 1031 | mInsets.top + availableHeightPx - hotseatTop |
Tony Wickham | 5edf9e2 | 2020-03-27 20:06:52 -0700 | [diff] [blame] | 1032 | - workspacePageIndicatorHeight - edgeMarginPx); |
Winson | fadbe8f | 2016-07-22 16:35:37 -0700 | [diff] [blame] | 1033 | } |
| 1034 | } |
| 1035 | |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 1036 | public static int calculateCellWidth(int width, int borderSpacing, int countX) { |
| 1037 | return (width - ((countX - 1) * borderSpacing)) / countX; |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 1038 | } |
Pierre Barbier de Reuille | 578deba | 2021-09-24 13:47:44 +0100 | [diff] [blame] | 1039 | |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 1040 | public static int calculateCellHeight(int height, int borderSpacing, int countY) { |
| 1041 | return (height - ((countY - 1) * borderSpacing)) / countY; |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 1042 | } |
| 1043 | |
Hyunyoung Song | 18bfaaf | 2015-03-17 11:32:21 -0700 | [diff] [blame] | 1044 | /** |
Tony Wickham | 55616cd | 2015-09-23 14:55:17 -0700 | [diff] [blame] | 1045 | * When {@code true}, the device is in landscape mode and the hotseat is on the right column. |
| 1046 | * When {@code false}, either device is in portrait mode or the device is in landscape mode and |
| 1047 | * the hotseat is on the bottom row. |
Hyunyoung Song | 18bfaaf | 2015-03-17 11:32:21 -0700 | [diff] [blame] | 1048 | */ |
Tony Wickham | ab946a1 | 2015-09-16 15:38:16 -0700 | [diff] [blame] | 1049 | public boolean isVerticalBarLayout() { |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 1050 | return isLandscape && transposeLayoutWithOrientation; |
| 1051 | } |
| 1052 | |
Sunny Goyal | 59d086c | 2018-05-07 17:31:40 -0700 | [diff] [blame] | 1053 | /** |
| 1054 | * Updates orientation information and returns true if it has changed from the previous value. |
| 1055 | */ |
Winson Chung | 13c1c2c | 2019-09-06 11:46:19 -0700 | [diff] [blame] | 1056 | public boolean updateIsSeascape(Context context) { |
Sunny Goyal | 59d086c | 2018-05-07 17:31:40 -0700 | [diff] [blame] | 1057 | if (isVerticalBarLayout()) { |
Sunny Goyal | 35c7b19 | 2021-04-20 16:51:10 -0700 | [diff] [blame] | 1058 | boolean isSeascape = DisplayController.INSTANCE.get(context) |
| 1059 | .getInfo().rotation == Surface.ROTATION_270; |
Sunny Goyal | 59d086c | 2018-05-07 17:31:40 -0700 | [diff] [blame] | 1060 | if (mIsSeascape != isSeascape) { |
| 1061 | mIsSeascape = isSeascape; |
| 1062 | return true; |
| 1063 | } |
| 1064 | } |
| 1065 | return false; |
| 1066 | } |
| 1067 | |
Sunny Goyal | 7e2e67f | 2018-01-26 13:40:08 -0800 | [diff] [blame] | 1068 | public boolean isSeascape() { |
Sunny Goyal | 59d086c | 2018-05-07 17:31:40 -0700 | [diff] [blame] | 1069 | return isVerticalBarLayout() && mIsSeascape; |
Sunny Goyal | 7e2e67f | 2018-01-26 13:40:08 -0800 | [diff] [blame] | 1070 | } |
| 1071 | |
Sunny Goyal | 07b6929 | 2018-01-08 14:19:34 -0800 | [diff] [blame] | 1072 | public boolean shouldFadeAdjacentWorkspaceScreens() { |
Sunny Goyal | 19ff728 | 2021-04-22 10:12:54 -0700 | [diff] [blame] | 1073 | return isVerticalBarLayout(); |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 1074 | } |
| 1075 | |
Jon Miranda | 92c1b5d | 2021-07-20 13:57:16 -0700 | [diff] [blame] | 1076 | public int getCellContentHeight(@ContainerType int containerType) { |
Sunny Goyal | c13403c | 2016-11-18 23:44:48 -0800 | [diff] [blame] | 1077 | switch (containerType) { |
| 1078 | case CellLayout.WORKSPACE: |
| 1079 | return cellHeightPx; |
| 1080 | case CellLayout.FOLDER: |
| 1081 | return folderCellHeightPx; |
| 1082 | case CellLayout.HOTSEAT: |
Jon Miranda | 92c1b5d | 2021-07-20 13:57:16 -0700 | [diff] [blame] | 1083 | // The hotseat is the only container where the cell height is going to be |
| 1084 | // different from the content within that cell. |
| 1085 | return iconSizePx; |
Sunny Goyal | c13403c | 2016-11-18 23:44:48 -0800 | [diff] [blame] | 1086 | default: |
| 1087 | // ?? |
| 1088 | return 0; |
| 1089 | } |
| 1090 | } |
Sunny Goyal | 13178ac | 2016-04-04 16:35:22 -0700 | [diff] [blame] | 1091 | |
Jon Miranda | 58561d4 | 2021-03-17 10:51:54 -0400 | [diff] [blame] | 1092 | private String pxToDpStr(String name, float value) { |
Sunny Goyal | 35c7b19 | 2021-04-20 16:51:10 -0700 | [diff] [blame] | 1093 | return "\t" + name + ": " + value + "px (" + dpiFromPx(value, mMetrics.densityDpi) + "dp)"; |
Jon Miranda | 58561d4 | 2021-03-17 10:51:54 -0400 | [diff] [blame] | 1094 | } |
| 1095 | |
| 1096 | public void dump(String prefix, PrintWriter writer) { |
| 1097 | writer.println(prefix + "DeviceProfile:"); |
Sunny Goyal | 35c7b19 | 2021-04-20 16:51:10 -0700 | [diff] [blame] | 1098 | writer.println(prefix + "\t1 dp = " + mMetrics.density + " px"); |
Jon Miranda | 58561d4 | 2021-03-17 10:51:54 -0400 | [diff] [blame] | 1099 | |
| 1100 | writer.println(prefix + "\tisTablet:" + isTablet); |
Alex Chau | 6ed408f | 2022-03-04 12:58:05 +0000 | [diff] [blame] | 1101 | writer.println(prefix + "\tisLargeTablet:" + isLargeTablet); |
Jon Miranda | 58561d4 | 2021-03-17 10:51:54 -0400 | [diff] [blame] | 1102 | writer.println(prefix + "\tisPhone:" + isPhone); |
| 1103 | writer.println(prefix + "\ttransposeLayoutWithOrientation:" |
| 1104 | + transposeLayoutWithOrientation); |
Alex Chau | 6ed408f | 2022-03-04 12:58:05 +0000 | [diff] [blame] | 1105 | writer.println(prefix + "\tisGestureMode:" + isGestureMode); |
Jon Miranda | 58561d4 | 2021-03-17 10:51:54 -0400 | [diff] [blame] | 1106 | |
| 1107 | writer.println(prefix + "\tisLandscape:" + isLandscape); |
| 1108 | writer.println(prefix + "\tisMultiWindowMode:" + isMultiWindowMode); |
Sunny Goyal | 19ff728 | 2021-04-22 10:12:54 -0700 | [diff] [blame] | 1109 | writer.println(prefix + "\tisTwoPanels:" + isTwoPanels); |
Jon Miranda | 58561d4 | 2021-03-17 10:51:54 -0400 | [diff] [blame] | 1110 | |
| 1111 | writer.println(prefix + pxToDpStr("windowX", windowX)); |
| 1112 | writer.println(prefix + pxToDpStr("windowY", windowY)); |
| 1113 | writer.println(prefix + pxToDpStr("widthPx", widthPx)); |
| 1114 | writer.println(prefix + pxToDpStr("heightPx", heightPx)); |
| 1115 | |
| 1116 | writer.println(prefix + pxToDpStr("availableWidthPx", availableWidthPx)); |
| 1117 | writer.println(prefix + pxToDpStr("availableHeightPx", availableHeightPx)); |
| 1118 | |
| 1119 | writer.println(prefix + "\taspectRatio:" + aspectRatio); |
| 1120 | |
| 1121 | writer.println(prefix + "\tisScalableGrid:" + isScalableGrid); |
| 1122 | |
Thales Lima | 83bedbf | 2021-10-05 17:47:39 +0100 | [diff] [blame] | 1123 | writer.println(prefix + "\tinv.numRows: " + inv.numRows); |
Alex Chau | 9fee3fd | 2021-12-01 18:43:10 +0000 | [diff] [blame] | 1124 | writer.println(prefix + "\tinv.numColumns: " + inv.numColumns); |
| 1125 | writer.println(prefix + "\tinv.numSearchContainerColumns: " |
| 1126 | + inv.numSearchContainerColumns); |
Jon Miranda | 58561d4 | 2021-03-17 10:51:54 -0400 | [diff] [blame] | 1127 | |
Thales Lima | 83bedbf | 2021-10-05 17:47:39 +0100 | [diff] [blame] | 1128 | writer.println(prefix + "\tminCellSize: " + inv.minCellSize[mTypeIndex] + "dp"); |
Jon Miranda | ab3c681 | 2021-06-28 15:42:28 -0700 | [diff] [blame] | 1129 | |
Jon Miranda | 58561d4 | 2021-03-17 10:51:54 -0400 | [diff] [blame] | 1130 | writer.println(prefix + pxToDpStr("cellWidthPx", cellWidthPx)); |
| 1131 | writer.println(prefix + pxToDpStr("cellHeightPx", cellHeightPx)); |
| 1132 | |
| 1133 | writer.println(prefix + pxToDpStr("getCellSize().x", getCellSize().x)); |
| 1134 | writer.println(prefix + pxToDpStr("getCellSize().y", getCellSize().y)); |
| 1135 | |
Thales Lima | 83bedbf | 2021-10-05 17:47:39 +0100 | [diff] [blame] | 1136 | writer.println(prefix + pxToDpStr("cellLayoutBorderSpacePx Horizontal", |
| 1137 | cellLayoutBorderSpacePx.x)); |
| 1138 | writer.println(prefix + pxToDpStr("cellLayoutBorderSpacePx Vertical", |
| 1139 | cellLayoutBorderSpacePx.y)); |
| 1140 | |
Jon Miranda | 58561d4 | 2021-03-17 10:51:54 -0400 | [diff] [blame] | 1141 | writer.println(prefix + pxToDpStr("iconSizePx", iconSizePx)); |
| 1142 | writer.println(prefix + pxToDpStr("iconTextSizePx", iconTextSizePx)); |
| 1143 | writer.println(prefix + pxToDpStr("iconDrawablePaddingPx", iconDrawablePaddingPx)); |
| 1144 | |
| 1145 | writer.println(prefix + pxToDpStr("folderCellWidthPx", folderCellWidthPx)); |
| 1146 | writer.println(prefix + pxToDpStr("folderCellHeightPx", folderCellHeightPx)); |
| 1147 | writer.println(prefix + pxToDpStr("folderChildIconSizePx", folderChildIconSizePx)); |
| 1148 | writer.println(prefix + pxToDpStr("folderChildTextSizePx", folderChildTextSizePx)); |
| 1149 | writer.println(prefix + pxToDpStr("folderChildDrawablePaddingPx", |
| 1150 | folderChildDrawablePaddingPx)); |
Thales Lima | 78d00ad | 2021-09-30 11:29:06 +0100 | [diff] [blame] | 1151 | writer.println(prefix + pxToDpStr("folderCellLayoutBorderSpaceOriginalPx", |
| 1152 | folderCellLayoutBorderSpaceOriginalPx)); |
| 1153 | writer.println(prefix + pxToDpStr("folderCellLayoutBorderSpacePx Horizontal", |
| 1154 | folderCellLayoutBorderSpacePx.x)); |
| 1155 | writer.println(prefix + pxToDpStr("folderCellLayoutBorderSpacePx Vertical", |
| 1156 | folderCellLayoutBorderSpacePx.y)); |
Jon Miranda | 58561d4 | 2021-03-17 10:51:54 -0400 | [diff] [blame] | 1157 | |
Jon Miranda | 58561d4 | 2021-03-17 10:51:54 -0400 | [diff] [blame] | 1158 | writer.println(prefix + pxToDpStr("allAppsIconSizePx", allAppsIconSizePx)); |
| 1159 | writer.println(prefix + pxToDpStr("allAppsIconTextSizePx", allAppsIconTextSizePx)); |
| 1160 | writer.println(prefix + pxToDpStr("allAppsIconDrawablePaddingPx", |
| 1161 | allAppsIconDrawablePaddingPx)); |
| 1162 | writer.println(prefix + pxToDpStr("allAppsCellHeightPx", allAppsCellHeightPx)); |
Alex Chau | 27b39b9 | 2022-01-14 18:02:18 +0000 | [diff] [blame] | 1163 | writer.println(prefix + pxToDpStr("allAppsCellWidthPx", allAppsCellWidthPx)); |
Sunny Goyal | 19ff728 | 2021-04-22 10:12:54 -0700 | [diff] [blame] | 1164 | writer.println(prefix + "\tnumShownAllAppsColumns: " + numShownAllAppsColumns); |
Alex Chau | 27b39b9 | 2022-01-14 18:02:18 +0000 | [diff] [blame] | 1165 | writer.println(prefix + pxToDpStr("allAppsLeftRightPadding", allAppsLeftRightPadding)); |
| 1166 | writer.println(prefix + pxToDpStr("allAppsLeftRightMargin", allAppsLeftRightMargin)); |
Jon Miranda | 58561d4 | 2021-03-17 10:51:54 -0400 | [diff] [blame] | 1167 | |
| 1168 | writer.println(prefix + pxToDpStr("hotseatBarSizePx", hotseatBarSizePx)); |
| 1169 | writer.println(prefix + pxToDpStr("hotseatCellHeightPx", hotseatCellHeightPx)); |
| 1170 | writer.println(prefix + pxToDpStr("hotseatBarTopPaddingPx", hotseatBarTopPaddingPx)); |
| 1171 | writer.println(prefix + pxToDpStr("hotseatBarBottomPaddingPx", hotseatBarBottomPaddingPx)); |
| 1172 | writer.println(prefix + pxToDpStr("hotseatBarSidePaddingStartPx", |
| 1173 | hotseatBarSidePaddingStartPx)); |
| 1174 | writer.println(prefix + pxToDpStr("hotseatBarSidePaddingEndPx", |
| 1175 | hotseatBarSidePaddingEndPx)); |
Sunny Goyal | 19ff728 | 2021-04-22 10:12:54 -0700 | [diff] [blame] | 1176 | writer.println(prefix + "\tnumShownHotseatIcons: " + numShownHotseatIcons); |
Thales Lima | 116b51a | 2022-02-03 16:19:47 +0000 | [diff] [blame] | 1177 | writer.println(prefix + pxToDpStr("hotseatBorderSpace", hotseatBorderSpace)); |
Thales Lima | a101290 | 2022-01-13 17:58:42 +0000 | [diff] [blame] | 1178 | writer.println(prefix + "\tisQsbInline: " + isQsbInline); |
| 1179 | writer.println(prefix + pxToDpStr("qsbWidth", qsbWidth)); |
Jon Miranda | 58561d4 | 2021-03-17 10:51:54 -0400 | [diff] [blame] | 1180 | |
| 1181 | writer.println(prefix + "\tisTaskbarPresent:" + isTaskbarPresent); |
Tony Wickham | 635e180 | 2021-07-22 14:28:04 -1000 | [diff] [blame] | 1182 | writer.println(prefix + "\tisTaskbarPresentInApps:" + isTaskbarPresentInApps); |
Jon Miranda | 58561d4 | 2021-03-17 10:51:54 -0400 | [diff] [blame] | 1183 | writer.println(prefix + pxToDpStr("taskbarSize", taskbarSize)); |
Jon Miranda | 58561d4 | 2021-03-17 10:51:54 -0400 | [diff] [blame] | 1184 | |
Thales Lima | 83bedbf | 2021-10-05 17:47:39 +0100 | [diff] [blame] | 1185 | writer.println(prefix + pxToDpStr("desiredWorkspaceHorizontalMarginPx", |
| 1186 | desiredWorkspaceHorizontalMarginPx)); |
Jon Miranda | 58561d4 | 2021-03-17 10:51:54 -0400 | [diff] [blame] | 1187 | writer.println(prefix + pxToDpStr("workspacePadding.left", workspacePadding.left)); |
| 1188 | writer.println(prefix + pxToDpStr("workspacePadding.top", workspacePadding.top)); |
| 1189 | writer.println(prefix + pxToDpStr("workspacePadding.right", workspacePadding.right)); |
| 1190 | writer.println(prefix + pxToDpStr("workspacePadding.bottom", workspacePadding.bottom)); |
| 1191 | |
Jon Miranda | ab3c681 | 2021-06-28 15:42:28 -0700 | [diff] [blame] | 1192 | writer.println(prefix + pxToDpStr("iconScale", iconScale)); |
| 1193 | writer.println(prefix + pxToDpStr("cellScaleToFit ", cellScaleToFit)); |
Jon Miranda | 58561d4 | 2021-03-17 10:51:54 -0400 | [diff] [blame] | 1194 | writer.println(prefix + pxToDpStr("extraSpace", extraSpace)); |
Thales Lima | 7a6752d | 2021-09-23 14:31:00 +0100 | [diff] [blame] | 1195 | writer.println(prefix + pxToDpStr("unscaled extraSpace", extraSpace / iconScale)); |
Jon Miranda | c9e69fa | 2021-03-22 17:13:34 -0400 | [diff] [blame] | 1196 | |
| 1197 | if (inv.devicePaddings != null) { |
| 1198 | int unscaledExtraSpace = (int) (extraSpace / iconScale); |
| 1199 | writer.println(prefix + pxToDpStr("maxEmptySpace", |
| 1200 | inv.devicePaddings.getDevicePadding(unscaledExtraSpace).getMaxEmptySpacePx())); |
| 1201 | } |
Jon Miranda | 58561d4 | 2021-03-17 10:51:54 -0400 | [diff] [blame] | 1202 | writer.println(prefix + pxToDpStr("workspaceTopPadding", workspaceTopPadding)); |
| 1203 | writer.println(prefix + pxToDpStr("workspaceBottomPadding", workspaceBottomPadding)); |
| 1204 | writer.println(prefix + pxToDpStr("extraHotseatBottomPadding", extraHotseatBottomPadding)); |
Alex Chau | 635b3ab | 2022-01-26 16:49:10 +0000 | [diff] [blame] | 1205 | |
| 1206 | writer.println(prefix + pxToDpStr("overviewTaskMarginPx", overviewTaskMarginPx)); |
| 1207 | writer.println(prefix + pxToDpStr("overviewTaskMarginGridPx", overviewTaskMarginGridPx)); |
| 1208 | writer.println(prefix + pxToDpStr("overviewTaskIconSizePx", overviewTaskIconSizePx)); |
| 1209 | writer.println(prefix + pxToDpStr("overviewTaskIconDrawableSizePx", |
| 1210 | overviewTaskIconDrawableSizePx)); |
| 1211 | writer.println(prefix + pxToDpStr("overviewTaskIconDrawableSizeGridPx", |
| 1212 | overviewTaskIconDrawableSizeGridPx)); |
| 1213 | writer.println(prefix + pxToDpStr("overviewTaskThumbnailTopMarginPx", |
| 1214 | overviewTaskThumbnailTopMarginPx)); |
| 1215 | writer.println(prefix + pxToDpStr("overviewActionsMarginThreeButtonPx", |
| 1216 | overviewActionsMarginThreeButtonPx)); |
| 1217 | writer.println(prefix + pxToDpStr("overviewActionsTopMarginGesturePx", |
| 1218 | overviewActionsTopMarginGesturePx)); |
| 1219 | writer.println(prefix + pxToDpStr("overviewActionsBottomMarginGesturePx", |
| 1220 | overviewActionsBottomMarginGesturePx)); |
| 1221 | writer.println(prefix + pxToDpStr("overviewActionsButtonSpacing", |
| 1222 | overviewActionsButtonSpacing)); |
| 1223 | writer.println(prefix + pxToDpStr("overviewPageSpacing", overviewPageSpacing)); |
| 1224 | writer.println(prefix + pxToDpStr("overviewRowSpacing", overviewRowSpacing)); |
| 1225 | writer.println(prefix + pxToDpStr("overviewGridSideMargin", overviewGridSideMargin)); |
Jon Miranda | 58561d4 | 2021-03-17 10:51:54 -0400 | [diff] [blame] | 1226 | } |
| 1227 | |
Sunny Goyal | fd58da6 | 2020-08-11 12:06:49 -0700 | [diff] [blame] | 1228 | private static Context getContext(Context c, Info info, int orientation) { |
Sunny Goyal | 1890f67 | 2020-04-30 12:28:00 -0700 | [diff] [blame] | 1229 | Configuration config = new Configuration(c.getResources().getConfiguration()); |
| 1230 | config.orientation = orientation; |
Sunny Goyal | 35c7b19 | 2021-04-20 16:51:10 -0700 | [diff] [blame] | 1231 | config.densityDpi = info.densityDpi; |
Sunny Goyal | 1890f67 | 2020-04-30 12:28:00 -0700 | [diff] [blame] | 1232 | return c.createConfigurationContext(config); |
Jon Miranda | b28c4fc | 2017-06-20 10:58:36 -0700 | [diff] [blame] | 1233 | } |
Sunny Goyal | fde5505 | 2018-02-01 14:46:13 -0800 | [diff] [blame] | 1234 | |
| 1235 | /** |
| 1236 | * Callback when a component changes the DeviceProfile associated with it, as a result of |
| 1237 | * configuration change |
| 1238 | */ |
| 1239 | public interface OnDeviceProfileChangeListener { |
| 1240 | |
| 1241 | /** |
| 1242 | * Called when the device profile is reassigned. Note that for layout and measurements, it |
| 1243 | * is sufficient to listen for inset changes. Use this callback when you need to perform |
| 1244 | * a one time operation. |
| 1245 | */ |
| 1246 | void onDeviceProfileChanged(DeviceProfile dp); |
| 1247 | } |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 1248 | |
Brian Isganitis | 099945b | 2022-01-31 18:15:00 -0500 | [diff] [blame] | 1249 | /** Allows registering listeners for {@link DeviceProfile} changes. */ |
| 1250 | public interface DeviceProfileListenable { |
| 1251 | |
| 1252 | /** The current device profile. */ |
| 1253 | DeviceProfile getDeviceProfile(); |
| 1254 | |
| 1255 | /** Registered {@link OnDeviceProfileChangeListener} instances. */ |
| 1256 | List<OnDeviceProfileChangeListener> getOnDeviceProfileChangeListeners(); |
| 1257 | |
| 1258 | /** Notifies listeners of a {@link DeviceProfile} change. */ |
| 1259 | default void dispatchDeviceProfileChanged() { |
| 1260 | DeviceProfile deviceProfile = getDeviceProfile(); |
| 1261 | List<OnDeviceProfileChangeListener> listeners = getOnDeviceProfileChangeListeners(); |
| 1262 | for (int i = listeners.size() - 1; i >= 0; i--) { |
| 1263 | listeners.get(i).onDeviceProfileChanged(deviceProfile); |
| 1264 | } |
| 1265 | } |
| 1266 | |
| 1267 | /** Register listener for {@link DeviceProfile} changes. */ |
| 1268 | default void addOnDeviceProfileChangeListener(OnDeviceProfileChangeListener listener) { |
| 1269 | getOnDeviceProfileChangeListeners().add(listener); |
| 1270 | } |
| 1271 | |
| 1272 | /** Unregister listener for {@link DeviceProfile} changes. */ |
| 1273 | default void removeOnDeviceProfileChangeListener(OnDeviceProfileChangeListener listener) { |
| 1274 | getOnDeviceProfileChangeListeners().remove(listener); |
| 1275 | } |
| 1276 | } |
| 1277 | |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 1278 | public static class Builder { |
| 1279 | private Context mContext; |
| 1280 | private InvariantDeviceProfile mInv; |
Sunny Goyal | fd58da6 | 2020-08-11 12:06:49 -0700 | [diff] [blame] | 1281 | private Info mInfo; |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 1282 | |
Sunny Goyal | 19ff728 | 2021-04-22 10:12:54 -0700 | [diff] [blame] | 1283 | private WindowBounds mWindowBounds; |
| 1284 | private boolean mUseTwoPanels; |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 1285 | |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 1286 | private boolean mIsMultiWindowMode = false; |
Sunny Goyal | 19ff728 | 2021-04-22 10:12:54 -0700 | [diff] [blame] | 1287 | private Boolean mTransposeLayoutWithOrientation; |
Alex Chau | 6ed408f | 2022-03-04 12:58:05 +0000 | [diff] [blame] | 1288 | private Boolean mIsGestureMode; |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 1289 | |
Sunny Goyal | fd58da6 | 2020-08-11 12:06:49 -0700 | [diff] [blame] | 1290 | public Builder(Context context, InvariantDeviceProfile inv, Info info) { |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 1291 | mContext = context; |
| 1292 | mInv = inv; |
| 1293 | mInfo = info; |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 1294 | } |
| 1295 | |
| 1296 | public Builder setMultiWindowMode(boolean isMultiWindowMode) { |
| 1297 | mIsMultiWindowMode = isMultiWindowMode; |
| 1298 | return this; |
| 1299 | } |
| 1300 | |
Sunny Goyal | 19ff728 | 2021-04-22 10:12:54 -0700 | [diff] [blame] | 1301 | public Builder setUseTwoPanels(boolean useTwoPanels) { |
| 1302 | mUseTwoPanels = useTwoPanels; |
| 1303 | return this; |
| 1304 | } |
| 1305 | |
| 1306 | |
| 1307 | public Builder setWindowBounds(WindowBounds bounds) { |
| 1308 | mWindowBounds = bounds; |
Sunny Goyal | 0addbf0 | 2020-04-28 14:17:35 -0700 | [diff] [blame] | 1309 | return this; |
| 1310 | } |
| 1311 | |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 1312 | public Builder setTransposeLayoutWithOrientation(boolean transposeLayoutWithOrientation) { |
| 1313 | mTransposeLayoutWithOrientation = transposeLayoutWithOrientation; |
| 1314 | return this; |
| 1315 | } |
| 1316 | |
Alex Chau | 6ed408f | 2022-03-04 12:58:05 +0000 | [diff] [blame] | 1317 | public Builder setGestureMode(boolean isGestureMode) { |
| 1318 | mIsGestureMode = isGestureMode; |
| 1319 | return this; |
| 1320 | } |
| 1321 | |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 1322 | public DeviceProfile build() { |
Sunny Goyal | 19ff728 | 2021-04-22 10:12:54 -0700 | [diff] [blame] | 1323 | if (mWindowBounds == null) { |
| 1324 | throw new IllegalArgumentException("Window bounds not set"); |
| 1325 | } |
| 1326 | if (mTransposeLayoutWithOrientation == null) { |
| 1327 | mTransposeLayoutWithOrientation = !mInfo.isTablet(mWindowBounds); |
| 1328 | } |
Alex Chau | 6ed408f | 2022-03-04 12:58:05 +0000 | [diff] [blame] | 1329 | if (mIsGestureMode == null) { |
| 1330 | mIsGestureMode = DisplayController.getNavigationMode(mContext).hasGestures; |
| 1331 | } |
| 1332 | return new DeviceProfile(mContext, mInv, mInfo, mWindowBounds, mIsMultiWindowMode, |
| 1333 | mTransposeLayoutWithOrientation, mUseTwoPanels, mIsGestureMode); |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 1334 | } |
| 1335 | } |
| 1336 | |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 1337 | } |