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