Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2008 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | package com.android.launcher3; |
| 18 | |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 19 | import static com.android.launcher3.ResourceUtils.pxFromDp; |
Jon Miranda | 58561d4 | 2021-03-17 10:51:54 -0400 | [diff] [blame] | 20 | import static com.android.launcher3.Utilities.dpiFromPx; |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 21 | |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 22 | import android.content.Context; |
Jon Miranda | b28c4fc | 2017-06-20 10:58:36 -0700 | [diff] [blame] | 23 | import android.content.res.Configuration; |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 24 | import android.content.res.Resources; |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 25 | import android.graphics.Point; |
Jon Miranda | 7ae64ff | 2016-11-21 16:18:46 -0800 | [diff] [blame] | 26 | import android.graphics.PointF; |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 27 | import android.graphics.Rect; |
Sunny Goyal | 59d086c | 2018-05-07 17:31:40 -0700 | [diff] [blame] | 28 | import android.view.Surface; |
Tony Wickham | 1588389 | 2021-02-12 11:24:40 -0800 | [diff] [blame] | 29 | import android.view.WindowInsets; |
| 30 | import android.view.WindowManager; |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 31 | |
Sunny Goyal | c13403c | 2016-11-18 23:44:48 -0800 | [diff] [blame] | 32 | import com.android.launcher3.CellLayout.ContainerType; |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 33 | import com.android.launcher3.DevicePaddings.DevicePadding; |
Tony Wickham | 1588389 | 2021-02-12 11:24:40 -0800 | [diff] [blame] | 34 | import com.android.launcher3.config.FeatureFlags; |
Tony Wickham | e1cb93f | 2019-05-03 11:27:32 -0700 | [diff] [blame] | 35 | import com.android.launcher3.graphics.IconShape; |
Tony Wickham | 8912b04 | 2018-11-29 15:28:53 -0800 | [diff] [blame] | 36 | import com.android.launcher3.icons.DotRenderer; |
Hyunyoung Song | 48cb7bc | 2018-09-25 17:03:34 -0700 | [diff] [blame] | 37 | import com.android.launcher3.icons.IconNormalizer; |
Sunny Goyal | fd58da6 | 2020-08-11 12:06:49 -0700 | [diff] [blame] | 38 | import com.android.launcher3.util.DisplayController; |
| 39 | import com.android.launcher3.util.DisplayController.Info; |
Sunny Goyal | b46703d | 2020-05-27 17:52:03 -0700 | [diff] [blame] | 40 | import com.android.launcher3.util.WindowBounds; |
Winson | 1f06427 | 2016-07-18 17:18:02 -0700 | [diff] [blame] | 41 | |
Jon Miranda | 58561d4 | 2021-03-17 10:51:54 -0400 | [diff] [blame] | 42 | import java.io.PrintWriter; |
| 43 | |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 44 | public class DeviceProfile { |
Adam Cohen | 2e6da15 | 2015-05-06 11:42:25 -0700 | [diff] [blame] | 45 | |
Sunny Goyal | 1890f67 | 2020-04-30 12:28:00 -0700 | [diff] [blame] | 46 | private static final float TABLET_MIN_DPS = 600; |
| 47 | private static final float LARGE_TABLET_MIN_DPS = 720; |
| 48 | |
| 49 | |
Adam Cohen | 2e6da15 | 2015-05-06 11:42:25 -0700 | [diff] [blame] | 50 | public final InvariantDeviceProfile inv; |
Sunny Goyal | fd58da6 | 2020-08-11 12:06:49 -0700 | [diff] [blame] | 51 | private final Info mInfo; |
Winson Chung | be87647 | 2014-05-14 14:15:20 -0700 | [diff] [blame] | 52 | |
Sunny Goyal | c620560 | 2015-05-21 20:46:33 -0700 | [diff] [blame] | 53 | // Device properties |
| 54 | public final boolean isTablet; |
| 55 | public final boolean isLargeTablet; |
| 56 | public final boolean isPhone; |
| 57 | public final boolean transposeLayoutWithOrientation; |
Hyunyoung Song | 18bfaaf | 2015-03-17 11:32:21 -0700 | [diff] [blame] | 58 | |
Sunny Goyal | c620560 | 2015-05-21 20:46:33 -0700 | [diff] [blame] | 59 | // Device properties in current orientation |
Sunny Goyal | d792a77 | 2018-04-05 13:37:46 -0700 | [diff] [blame] | 60 | public final boolean isLandscape; |
Sunny Goyal | d70e75a | 2018-02-22 10:07:32 -0800 | [diff] [blame] | 61 | public final boolean isMultiWindowMode; |
| 62 | |
Sunny Goyal | 0addbf0 | 2020-04-28 14:17:35 -0700 | [diff] [blame] | 63 | public final int windowX; |
| 64 | public final int windowY; |
Sunny Goyal | c620560 | 2015-05-21 20:46:33 -0700 | [diff] [blame] | 65 | public final int widthPx; |
| 66 | public final int heightPx; |
| 67 | public final int availableWidthPx; |
| 68 | public final int availableHeightPx; |
Jon Miranda | bba6451 | 2019-03-27 10:54:17 -0700 | [diff] [blame] | 69 | |
| 70 | public final float aspectRatio; |
| 71 | |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 72 | public final boolean isScalableGrid; |
| 73 | |
Tony Wickham | d6b4037 | 2015-09-23 18:37:57 -0700 | [diff] [blame] | 74 | /** |
| 75 | * The maximum amount of left/right workspace padding as a percentage of the screen width. |
| 76 | * To be clear, this means that up to 7% of the screen width can be used as left padding, and |
| 77 | * 7% of the screen width can be used as right padding. |
| 78 | */ |
| 79 | private static final float MAX_HORIZONTAL_PADDING_PERCENT = 0.14f; |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 80 | |
Jon Miranda | 3f9bab2 | 2017-07-28 14:50:17 -0700 | [diff] [blame] | 81 | private static final float TALL_DEVICE_ASPECT_RATIO_THRESHOLD = 2.0f; |
Jon Miranda | 30d0aa2 | 2017-07-25 15:55:29 -0700 | [diff] [blame] | 82 | |
Jon Miranda | 5eacbb7 | 2018-07-31 11:14:46 -0700 | [diff] [blame] | 83 | // To evenly space the icons, increase the left/right margins for tablets in portrait mode. |
| 84 | private static final int PORTRAIT_TABLET_LEFT_RIGHT_PADDING_MULTIPLIER = 4; |
| 85 | |
Sunny Goyal | c620560 | 2015-05-21 20:46:33 -0700 | [diff] [blame] | 86 | // Workspace |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 87 | public final int desiredWorkspaceLeftRightOriginalPx; |
| 88 | public int desiredWorkspaceLeftRightMarginPx; |
| 89 | public final int cellLayoutBorderSpacingOriginalPx; |
| 90 | public int cellLayoutBorderSpacingPx; |
Jon Miranda | 2803200 | 2017-07-13 16:18:56 -0700 | [diff] [blame] | 91 | public final int cellLayoutPaddingLeftRightPx; |
Jon Miranda | 18751b6 | 2017-07-31 17:25:27 -0700 | [diff] [blame] | 92 | public final int cellLayoutBottomPaddingPx; |
Sunny Goyal | c620560 | 2015-05-21 20:46:33 -0700 | [diff] [blame] | 93 | public final int edgeMarginPx; |
Sunny Goyal | 47328fd | 2016-05-25 18:56:41 -0700 | [diff] [blame] | 94 | public float workspaceSpringLoadShrinkFactor; |
| 95 | public final int workspaceSpringLoadedBottomSpace; |
Sunny Goyal | c620560 | 2015-05-21 20:46:33 -0700 | [diff] [blame] | 96 | |
Jon Miranda | 58561d4 | 2021-03-17 10:51:54 -0400 | [diff] [blame] | 97 | private final int extraSpace; |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 98 | public int workspaceTopPadding; |
| 99 | public int workspaceBottomPadding; |
Jon Miranda | 58561d4 | 2021-03-17 10:51:54 -0400 | [diff] [blame] | 100 | public int extraHotseatBottomPadding; |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 101 | |
Tony Wickham | 5edf9e2 | 2020-03-27 20:06:52 -0700 | [diff] [blame] | 102 | // Workspace page indicator |
| 103 | public final int workspacePageIndicatorHeight; |
| 104 | private final int mWorkspacePageIndicatorOverlapWorkspace; |
Winson | 1f06427 | 2016-07-18 17:18:02 -0700 | [diff] [blame] | 105 | |
Sunny Goyal | c620560 | 2015-05-21 20:46:33 -0700 | [diff] [blame] | 106 | // Workspace icons |
| 107 | public int iconSizePx; |
| 108 | public int iconTextSizePx; |
| 109 | public int iconDrawablePaddingPx; |
Winson Chung | 5f4e0fd | 2015-05-22 11:12:27 -0700 | [diff] [blame] | 110 | public int iconDrawablePaddingOriginalPx; |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 111 | |
Adam Cohen | 5940042 | 2014-03-05 18:07:04 -0800 | [diff] [blame] | 112 | public int cellWidthPx; |
| 113 | public int cellHeightPx; |
Jon Miranda | b28c4fc | 2017-06-20 10:58:36 -0700 | [diff] [blame] | 114 | public int workspaceCellPaddingXPx; |
Adam Cohen | 5940042 | 2014-03-05 18:07:04 -0800 | [diff] [blame] | 115 | |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 116 | public int cellYPaddingPx; |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 117 | |
Sunny Goyal | c620560 | 2015-05-21 20:46:33 -0700 | [diff] [blame] | 118 | // Folder |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 119 | public float folderLabelTextScale; |
| 120 | public int folderLabelTextSizePx; |
Sunny Goyal | c620560 | 2015-05-21 20:46:33 -0700 | [diff] [blame] | 121 | public int folderIconSizePx; |
Jon Miranda | 591e360 | 2018-03-28 11:37:00 -0700 | [diff] [blame] | 122 | public int folderIconOffsetYPx; |
Jon Miranda | bf7d812 | 2016-11-03 15:29:29 -0700 | [diff] [blame] | 123 | |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 124 | // Folder content |
| 125 | public int folderContentPaddingLeftRight; |
| 126 | public int folderContentPaddingTop; |
| 127 | |
Jon Miranda | bf7d812 | 2016-11-03 15:29:29 -0700 | [diff] [blame] | 128 | // Folder cell |
Sunny Goyal | c620560 | 2015-05-21 20:46:33 -0700 | [diff] [blame] | 129 | public int folderCellWidthPx; |
| 130 | public int folderCellHeightPx; |
Jon Miranda | bf7d812 | 2016-11-03 15:29:29 -0700 | [diff] [blame] | 131 | |
| 132 | // Folder child |
| 133 | public int folderChildIconSizePx; |
| 134 | public int folderChildTextSizePx; |
Sunny Goyal | baec6ff | 2016-09-14 11:26:21 -0700 | [diff] [blame] | 135 | public int folderChildDrawablePaddingPx; |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 136 | |
Sunny Goyal | c620560 | 2015-05-21 20:46:33 -0700 | [diff] [blame] | 137 | // Hotseat |
Sunny Goyal | c620560 | 2015-05-21 20:46:33 -0700 | [diff] [blame] | 138 | public int hotseatCellHeightPx; |
Jon Miranda | 18751b6 | 2017-07-31 17:25:27 -0700 | [diff] [blame] | 139 | // In portrait: size = height, in landscape: size = width |
| 140 | public int hotseatBarSizePx; |
Sunny Goyal | 07b6929 | 2018-01-08 14:19:34 -0800 | [diff] [blame] | 141 | public final int hotseatBarTopPaddingPx; |
Jon Miranda | 7e183c3 | 2018-06-20 11:05:27 -0700 | [diff] [blame] | 142 | public int hotseatBarBottomPaddingPx; |
Tony Wickham | 1eeffbe | 2018-06-12 15:01:15 -0700 | [diff] [blame] | 143 | // Start is the side next to the nav bar, end is the side next to the workspace |
| 144 | public final int hotseatBarSidePaddingStartPx; |
| 145 | public final int hotseatBarSidePaddingEndPx; |
Adam Cohen | 2e6da15 | 2015-05-06 11:42:25 -0700 | [diff] [blame] | 146 | |
Sunny Goyal | c620560 | 2015-05-21 20:46:33 -0700 | [diff] [blame] | 147 | // All apps |
Jon Miranda | b28c4fc | 2017-06-20 10:58:36 -0700 | [diff] [blame] | 148 | public int allAppsCellHeightPx; |
Samuel Fufa | f1424a3 | 2019-10-04 15:15:19 -0700 | [diff] [blame] | 149 | public int allAppsCellWidthPx; |
Winson | 1f06427 | 2016-07-18 17:18:02 -0700 | [diff] [blame] | 150 | public int allAppsIconSizePx; |
| 151 | public int allAppsIconDrawablePaddingPx; |
| 152 | public float allAppsIconTextSizePx; |
| 153 | |
Zak Cohen | 334efeb | 2021-03-19 16:42:07 -0700 | [diff] [blame] | 154 | // Overview |
| 155 | public int overviewTaskThumbnailTopMarginPx; |
| 156 | public int overviewTaskMarginPx; |
| 157 | |
Jon Miranda | 7ae64ff | 2016-11-21 16:18:46 -0800 | [diff] [blame] | 158 | // Widgets |
| 159 | public final PointF appWidgetScale = new PointF(1.0f, 1.0f); |
| 160 | |
Sunny Goyal | 47328fd | 2016-05-25 18:56:41 -0700 | [diff] [blame] | 161 | // Drop Target |
| 162 | public int dropTargetBarSizePx; |
Adam Cohen | 4ae96ce | 2014-08-29 15:05:48 -0700 | [diff] [blame] | 163 | |
Winson | 1f06427 | 2016-07-18 17:18:02 -0700 | [diff] [blame] | 164 | // Insets |
Sunny Goyal | 07b6929 | 2018-01-08 14:19:34 -0800 | [diff] [blame] | 165 | private final Rect mInsets = new Rect(); |
| 166 | public final Rect workspacePadding = new Rect(); |
Sunny Goyal | 81b4c7b | 2018-03-26 12:10:31 -0700 | [diff] [blame] | 167 | private final Rect mHotseatPadding = new Rect(); |
Jon Miranda | 0bd63d1 | 2019-03-06 17:29:29 -0800 | [diff] [blame] | 168 | // When true, nav bar is on the left side of the screen. |
Sunny Goyal | 59d086c | 2018-05-07 17:31:40 -0700 | [diff] [blame] | 169 | private boolean mIsSeascape; |
Winson | 1f06427 | 2016-07-18 17:18:02 -0700 | [diff] [blame] | 170 | |
Tony Wickham | f34bee8 | 2018-12-03 18:11:39 -0800 | [diff] [blame] | 171 | // Notification dots |
Samuel Fufa | c96fa24 | 2019-09-26 23:06:32 -0700 | [diff] [blame] | 172 | public DotRenderer mDotRendererWorkSpace; |
| 173 | public DotRenderer mDotRendererAllApps; |
Tony Wickham | 9a8d11f | 2017-01-11 09:53:12 -0800 | [diff] [blame] | 174 | |
Tony Wickham | 1588389 | 2021-02-12 11:24:40 -0800 | [diff] [blame] | 175 | // Taskbar |
| 176 | public boolean isTaskbarPresent; |
| 177 | public int taskbarSize; |
Tony Wickham | 145b7fd | 2021-03-11 10:03:12 -0800 | [diff] [blame] | 178 | // How much of the bottom inset is due to Taskbar rather than other system elements. |
| 179 | public int nonOverlappingTaskbarInset; |
Tony Wickham | 1588389 | 2021-02-12 11:24:40 -0800 | [diff] [blame] | 180 | |
Sunny Goyal | fd58da6 | 2020-08-11 12:06:49 -0700 | [diff] [blame] | 181 | DeviceProfile(Context context, InvariantDeviceProfile inv, Info info, |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 182 | Point minSize, Point maxSize, int width, int height, boolean isLandscape, |
Sunny Goyal | 0addbf0 | 2020-04-28 14:17:35 -0700 | [diff] [blame] | 183 | boolean isMultiWindowMode, boolean transposeLayoutWithOrientation, |
| 184 | Point windowPosition) { |
Sunny Goyal | fee35bb | 2015-05-11 11:38:19 -0700 | [diff] [blame] | 185 | |
Adam Cohen | 2e6da15 | 2015-05-06 11:42:25 -0700 | [diff] [blame] | 186 | this.inv = inv; |
Sunny Goyal | c620560 | 2015-05-21 20:46:33 -0700 | [diff] [blame] | 187 | this.isLandscape = isLandscape; |
Sunny Goyal | d70e75a | 2018-02-22 10:07:32 -0800 | [diff] [blame] | 188 | this.isMultiWindowMode = isMultiWindowMode; |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 189 | this.transposeLayoutWithOrientation = transposeLayoutWithOrientation; |
Sunny Goyal | 0addbf0 | 2020-04-28 14:17:35 -0700 | [diff] [blame] | 190 | windowX = windowPosition.x; |
| 191 | windowY = windowPosition.y; |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 192 | |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 193 | isScalableGrid = inv.isScalable && !isVerticalBarLayout() && !isMultiWindowMode; |
| 194 | |
Jon Miranda | 7e183c3 | 2018-06-20 11:05:27 -0700 | [diff] [blame] | 195 | // Determine sizes. |
| 196 | widthPx = width; |
| 197 | heightPx = height; |
Tony Wickham | 1588389 | 2021-02-12 11:24:40 -0800 | [diff] [blame] | 198 | int nonFinalAvailableHeightPx; |
Jon Miranda | 7e183c3 | 2018-06-20 11:05:27 -0700 | [diff] [blame] | 199 | if (isLandscape) { |
| 200 | availableWidthPx = maxSize.x; |
Tony Wickham | 1588389 | 2021-02-12 11:24:40 -0800 | [diff] [blame] | 201 | nonFinalAvailableHeightPx = minSize.y; |
Jon Miranda | 7e183c3 | 2018-06-20 11:05:27 -0700 | [diff] [blame] | 202 | } else { |
| 203 | availableWidthPx = minSize.x; |
Tony Wickham | 1588389 | 2021-02-12 11:24:40 -0800 | [diff] [blame] | 204 | nonFinalAvailableHeightPx = maxSize.y; |
Jon Miranda | 7e183c3 | 2018-06-20 11:05:27 -0700 | [diff] [blame] | 205 | } |
| 206 | |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 207 | mInfo = info; |
Adam Cohen | 2e6da15 | 2015-05-06 11:42:25 -0700 | [diff] [blame] | 208 | |
Sunny Goyal | c620560 | 2015-05-21 20:46:33 -0700 | [diff] [blame] | 209 | // Constants from resources |
Jon Miranda | 58561d4 | 2021-03-17 10:51:54 -0400 | [diff] [blame] | 210 | float swDPs = dpiFromPx(Math.min(info.smallestSize.x, info.smallestSize.y), info.metrics); |
Alex Chau | 4e2c25a | 2021-02-03 16:20:04 +0000 | [diff] [blame] | 211 | boolean allowRotation = context.getResources().getBoolean(R.bool.allow_rotation); |
| 212 | // Tablet UI is built with assumption that simulated landscape is disabled. |
| 213 | isTablet = allowRotation && swDPs >= TABLET_MIN_DPS; |
| 214 | isLargeTablet = isTablet && swDPs >= LARGE_TABLET_MIN_DPS; |
Sunny Goyal | c620560 | 2015-05-21 20:46:33 -0700 | [diff] [blame] | 215 | isPhone = !isTablet && !isLargeTablet; |
Jon Miranda | bba6451 | 2019-03-27 10:54:17 -0700 | [diff] [blame] | 216 | aspectRatio = ((float) Math.max(widthPx, heightPx)) / Math.min(widthPx, heightPx); |
Jon Miranda | 7e183c3 | 2018-06-20 11:05:27 -0700 | [diff] [blame] | 217 | boolean isTallDevice = Float.compare(aspectRatio, TALL_DEVICE_ASPECT_RATIO_THRESHOLD) >= 0; |
Sunny Goyal | c620560 | 2015-05-21 20:46:33 -0700 | [diff] [blame] | 218 | |
| 219 | // Some more constants |
Sunny Goyal | 1890f67 | 2020-04-30 12:28:00 -0700 | [diff] [blame] | 220 | context = getContext(context, info, isVerticalBarLayout() |
Jon Miranda | b28c4fc | 2017-06-20 10:58:36 -0700 | [diff] [blame] | 221 | ? Configuration.ORIENTATION_LANDSCAPE |
| 222 | : Configuration.ORIENTATION_PORTRAIT); |
Sunny Goyal | 1890f67 | 2020-04-30 12:28:00 -0700 | [diff] [blame] | 223 | final Resources res = context.getResources(); |
Jon Miranda | b28c4fc | 2017-06-20 10:58:36 -0700 | [diff] [blame] | 224 | |
Tony Wickham | 1588389 | 2021-02-12 11:24:40 -0800 | [diff] [blame] | 225 | isTaskbarPresent = isTablet && FeatureFlags.ENABLE_TASKBAR.get(); |
| 226 | if (isTaskbarPresent) { |
| 227 | // Taskbar will be added later, but provides bottom insets that we should subtract |
| 228 | // from availableHeightPx. |
| 229 | taskbarSize = res.getDimensionPixelSize(R.dimen.taskbar_size); |
| 230 | WindowInsets windowInsets = DisplayController.INSTANCE.get(context).getHolder(mInfo.id) |
| 231 | .getDisplayContext().getSystemService(WindowManager.class) |
| 232 | .getCurrentWindowMetrics().getWindowInsets(); |
Tony Wickham | 145b7fd | 2021-03-11 10:03:12 -0800 | [diff] [blame] | 233 | nonOverlappingTaskbarInset = |
Tony Wickham | 1588389 | 2021-02-12 11:24:40 -0800 | [diff] [blame] | 234 | taskbarSize - windowInsets.getSystemWindowInsetBottom(); |
| 235 | if (nonOverlappingTaskbarInset > 0) { |
| 236 | nonFinalAvailableHeightPx -= nonOverlappingTaskbarInset; |
| 237 | } |
| 238 | } |
| 239 | availableHeightPx = nonFinalAvailableHeightPx; |
| 240 | |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 241 | edgeMarginPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_edge_margin); |
Sunny Goyal | 58fa4b6 | 2019-03-22 16:23:25 -0700 | [diff] [blame] | 242 | |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 243 | desiredWorkspaceLeftRightMarginPx = isVerticalBarLayout() ? 0 : isScalableGrid |
| 244 | ? res.getDimensionPixelSize(R.dimen.scalable_grid_left_right_margin) |
| 245 | : res.getDimensionPixelSize(R.dimen.dynamic_grid_left_right_margin); |
| 246 | desiredWorkspaceLeftRightOriginalPx = desiredWorkspaceLeftRightMarginPx; |
| 247 | |
| 248 | folderLabelTextScale = res.getFloat(R.dimen.folder_label_text_scale); |
| 249 | folderContentPaddingLeftRight = |
| 250 | res.getDimensionPixelSize(R.dimen.folder_content_padding_left_right); |
| 251 | folderContentPaddingTop = res.getDimensionPixelSize(R.dimen.folder_content_padding_top); |
| 252 | |
| 253 | setCellLayoutBorderSpacing(pxFromDp(inv.borderSpacing, mInfo.metrics, 1f)); |
| 254 | cellLayoutBorderSpacingOriginalPx = cellLayoutBorderSpacingPx; |
| 255 | |
Jon Miranda | 5eacbb7 | 2018-07-31 11:14:46 -0700 | [diff] [blame] | 256 | int cellLayoutPaddingLeftRightMultiplier = !isVerticalBarLayout() && isTablet |
| 257 | ? PORTRAIT_TABLET_LEFT_RIGHT_PADDING_MULTIPLIER : 1; |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 258 | int cellLayoutPadding = isScalableGrid |
| 259 | ? 0 |
| 260 | : res.getDimensionPixelSize(R.dimen.dynamic_grid_cell_layout_padding); |
Andras Kloczl | 8e57cce | 2021-02-11 23:51:19 +0100 | [diff] [blame] | 261 | |
| 262 | if (FeatureFlags.ENABLE_TWO_PANEL_HOME.get() && isTablet) { |
| 263 | cellLayoutPaddingLeftRightPx = |
| 264 | res.getDimensionPixelSize(R.dimen.two_panel_home_side_padding); |
| 265 | cellLayoutBottomPaddingPx = 0; |
| 266 | } else if (isLandscape) { |
Sunny Goyal | 58fa4b6 | 2019-03-22 16:23:25 -0700 | [diff] [blame] | 267 | cellLayoutPaddingLeftRightPx = 0; |
| 268 | cellLayoutBottomPaddingPx = cellLayoutPadding; |
| 269 | } else { |
| 270 | cellLayoutPaddingLeftRightPx = cellLayoutPaddingLeftRightMultiplier * cellLayoutPadding; |
| 271 | cellLayoutBottomPaddingPx = 0; |
| 272 | } |
| 273 | |
Tony Wickham | 5edf9e2 | 2020-03-27 20:06:52 -0700 | [diff] [blame] | 274 | workspacePageIndicatorHeight = res.getDimensionPixelSize( |
| 275 | R.dimen.workspace_page_indicator_height); |
| 276 | mWorkspacePageIndicatorOverlapWorkspace = |
| 277 | res.getDimensionPixelSize(R.dimen.workspace_page_indicator_overlap_workspace); |
Sunny Goyal | 58fa4b6 | 2019-03-22 16:23:25 -0700 | [diff] [blame] | 278 | |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 279 | iconDrawablePaddingOriginalPx = |
| 280 | res.getDimensionPixelSize(R.dimen.dynamic_grid_icon_drawable_padding); |
Sunny Goyal | 47328fd | 2016-05-25 18:56:41 -0700 | [diff] [blame] | 281 | dropTargetBarSizePx = res.getDimensionPixelSize(R.dimen.dynamic_grid_drop_target_size); |
| 282 | workspaceSpringLoadedBottomSpace = |
| 283 | res.getDimensionPixelSize(R.dimen.dynamic_grid_min_spring_loaded_space); |
Sunny Goyal | d519052 | 2017-04-24 03:06:54 -0700 | [diff] [blame] | 284 | |
Jon Miranda | b28c4fc | 2017-06-20 10:58:36 -0700 | [diff] [blame] | 285 | workspaceCellPaddingXPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_cell_padding_x); |
Jon Miranda | 0966072 | 2017-06-14 14:20:14 -0700 | [diff] [blame] | 286 | |
Winson | 1f06427 | 2016-07-18 17:18:02 -0700 | [diff] [blame] | 287 | hotseatBarTopPaddingPx = |
| 288 | res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_top_padding); |
Jon Miranda | 7e183c3 | 2018-06-20 11:05:27 -0700 | [diff] [blame] | 289 | hotseatBarBottomPaddingPx = (isTallDevice ? 0 |
| 290 | : res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_bottom_non_tall_padding)) |
| 291 | + res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_bottom_padding); |
Tony Wickham | 1eeffbe | 2018-06-12 15:01:15 -0700 | [diff] [blame] | 292 | hotseatBarSidePaddingEndPx = |
Sunny Goyal | 228153d | 2018-01-04 15:35:22 -0800 | [diff] [blame] | 293 | res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_side_padding); |
Jon Miranda | 3f411e7 | 2019-05-16 17:15:16 -0700 | [diff] [blame] | 294 | // 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] | 295 | hotseatBarSidePaddingStartPx = isVerticalBarLayout() ? workspacePageIndicatorHeight : 0; |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 296 | int hotseatExtraVerticalSize = |
| 297 | res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_extra_vertical_size); |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 298 | hotseatBarSizePx = pxFromDp(inv.iconSize, mInfo.metrics, 1f) |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 299 | + (isVerticalBarLayout() |
Sunny Goyal | 415f173 | 2018-11-29 10:33:47 -0800 | [diff] [blame] | 300 | ? (hotseatBarSidePaddingStartPx + hotseatBarSidePaddingEndPx) |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 301 | : (hotseatBarTopPaddingPx + hotseatBarBottomPaddingPx |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 302 | + (isScalableGrid ? 0 : hotseatExtraVerticalSize))); |
Jon Miranda | b28c4fc | 2017-06-20 10:58:36 -0700 | [diff] [blame] | 303 | |
Zak Cohen | 334efeb | 2021-03-19 16:42:07 -0700 | [diff] [blame] | 304 | |
| 305 | overviewTaskMarginPx = res.getDimensionPixelSize(R.dimen.overview_task_margin); |
| 306 | overviewTaskThumbnailTopMarginPx = res.getDimensionPixelSize( |
| 307 | R.dimen.task_thumbnail_icon_size) + 2 * overviewTaskMarginPx; |
| 308 | |
Jon Miranda | 2ed276e | 2017-06-29 11:36:34 -0700 | [diff] [blame] | 309 | // Calculate all of the remaining variables. |
Jon Miranda | 58561d4 | 2021-03-17 10:51:54 -0400 | [diff] [blame] | 310 | extraSpace = updateAvailableDimensions(res); |
Jon Miranda | 2ed276e | 2017-06-29 11:36:34 -0700 | [diff] [blame] | 311 | // Now that we have all of the variables calculated, we can tune certain sizes. |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 312 | if (isScalableGrid) { |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 313 | DevicePadding padding = inv.devicePaddings.getDevicePadding(extraSpace); |
| 314 | workspaceTopPadding = padding.getWorkspaceTopPadding(extraSpace); |
| 315 | workspaceBottomPadding = padding.getWorkspaceBottomPadding(extraSpace); |
| 316 | |
Jon Miranda | 58561d4 | 2021-03-17 10:51:54 -0400 | [diff] [blame] | 317 | extraHotseatBottomPadding = padding.getHotseatBottomPadding(extraSpace); |
| 318 | hotseatBarSizePx += extraHotseatBottomPadding; |
| 319 | hotseatBarBottomPaddingPx += extraHotseatBottomPadding; |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 320 | } else if (!isVerticalBarLayout() && isPhone && isTallDevice) { |
Jon Miranda | 3f9bab2 | 2017-07-28 14:50:17 -0700 | [diff] [blame] | 321 | // We increase the hotseat size when there is extra space. |
Jon Miranda | 2ed276e | 2017-06-29 11:36:34 -0700 | [diff] [blame] | 322 | // ie. For a display with a large aspect ratio, we can keep the icons on the workspace |
Jon Miranda | 3f9bab2 | 2017-07-28 14:50:17 -0700 | [diff] [blame] | 323 | // in portrait mode closer together by adding more height to the hotseat. |
Jon Miranda | 30d0aa2 | 2017-07-25 15:55:29 -0700 | [diff] [blame] | 324 | // Note: This calculation was created after noticing a pattern in the design spec. |
Jon Miranda | 58561d4 | 2021-03-17 10:51:54 -0400 | [diff] [blame] | 325 | int extraSpace = getCellSize().y - iconSizePx - iconDrawablePaddingPx * 2 |
Tony Wickham | 5edf9e2 | 2020-03-27 20:06:52 -0700 | [diff] [blame] | 326 | - workspacePageIndicatorHeight; |
Jon Miranda | 7e183c3 | 2018-06-20 11:05:27 -0700 | [diff] [blame] | 327 | hotseatBarSizePx += extraSpace; |
| 328 | hotseatBarBottomPaddingPx += extraSpace; |
Jon Miranda | 30d0aa2 | 2017-07-25 15:55:29 -0700 | [diff] [blame] | 329 | |
Jon Miranda | 3f9bab2 | 2017-07-28 14:50:17 -0700 | [diff] [blame] | 330 | // Recalculate the available dimensions using the new hotseat size. |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 331 | updateAvailableDimensions(res); |
Jon Miranda | 2ed276e | 2017-06-29 11:36:34 -0700 | [diff] [blame] | 332 | } |
Sunny Goyal | 07b6929 | 2018-01-08 14:19:34 -0800 | [diff] [blame] | 333 | updateWorkspacePadding(); |
Tony Wickham | 1237df0 | 2017-02-24 08:59:36 -0800 | [diff] [blame] | 334 | |
| 335 | // This is done last, after iconSizePx is calculated above. |
Samuel Fufa | c96fa24 | 2019-09-26 23:06:32 -0700 | [diff] [blame] | 336 | mDotRendererWorkSpace = new DotRenderer(iconSizePx, IconShape.getShapePath(), |
Tony Wickham | e1cb93f | 2019-05-03 11:27:32 -0700 | [diff] [blame] | 337 | IconShape.DEFAULT_PATH_SIZE); |
Samuel Fufa | c96fa24 | 2019-09-26 23:06:32 -0700 | [diff] [blame] | 338 | mDotRendererAllApps = iconSizePx == allAppsIconSizePx ? mDotRendererWorkSpace : |
| 339 | new DotRenderer(allAppsIconSizePx, IconShape.getShapePath(), |
| 340 | IconShape.DEFAULT_PATH_SIZE); |
Adam Cohen | 63f1ec0 | 2014-08-12 09:23:13 -0700 | [diff] [blame] | 341 | } |
| 342 | |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 343 | private void setCellLayoutBorderSpacing(int borderSpacing) { |
| 344 | if (isScalableGrid) { |
| 345 | cellLayoutBorderSpacingPx = borderSpacing; |
| 346 | folderContentPaddingLeftRight = borderSpacing; |
| 347 | folderContentPaddingTop = borderSpacing; |
| 348 | } else { |
| 349 | cellLayoutBorderSpacingPx = 0; |
| 350 | } |
| 351 | } |
| 352 | |
Jon Miranda | 611dba4 | 2021-03-02 14:12:13 -0500 | [diff] [blame] | 353 | /** |
| 354 | * We inset the widget padding added by the system and instead rely on the border spacing |
| 355 | * between cells to create reliable consistency between widgets |
| 356 | */ |
| 357 | public boolean shouldInsetWidgets() { |
| 358 | Rect widgetPadding = inv.defaultWidgetPadding; |
| 359 | |
| 360 | // Check all sides to ensure that the widget won't overlap into another cell. |
| 361 | return cellLayoutBorderSpacingPx > widgetPadding.left |
| 362 | && cellLayoutBorderSpacingPx > widgetPadding.top |
| 363 | && cellLayoutBorderSpacingPx > widgetPadding.right |
| 364 | && cellLayoutBorderSpacingPx > widgetPadding.bottom; |
| 365 | } |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 366 | |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 367 | public Builder toBuilder(Context context) { |
Sunny Goyal | 1a52ef5 | 2018-01-11 10:15:03 -0800 | [diff] [blame] | 368 | Point size = new Point(availableWidthPx, availableHeightPx); |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 369 | return new Builder(context, inv, mInfo) |
| 370 | .setSizeRange(size, size) |
| 371 | .setSize(widthPx, heightPx) |
Sunny Goyal | 0addbf0 | 2020-04-28 14:17:35 -0700 | [diff] [blame] | 372 | .setWindowPosition(windowX, windowY) |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 373 | .setMultiWindowMode(isMultiWindowMode); |
Sunny Goyal | 1a52ef5 | 2018-01-11 10:15:03 -0800 | [diff] [blame] | 374 | } |
| 375 | |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 376 | public DeviceProfile copy(Context context) { |
| 377 | return toBuilder(context).build(); |
| 378 | } |
| 379 | |
| 380 | /** |
| 381 | * TODO: Move this to the builder as part of setMultiWindowMode |
| 382 | */ |
Sunny Goyal | b46703d | 2020-05-27 17:52:03 -0700 | [diff] [blame] | 383 | public DeviceProfile getMultiWindowProfile(Context context, WindowBounds windowBounds) { |
Jon Miranda | a11380d | 2017-08-24 11:30:03 -0700 | [diff] [blame] | 384 | // We take the minimum sizes of this profile and it's multi-window variant to ensure that |
| 385 | // the system decor is always excluded. |
Sunny Goyal | b46703d | 2020-05-27 17:52:03 -0700 | [diff] [blame] | 386 | Point mwSize = new Point(Math.min(availableWidthPx, windowBounds.availableSize.x), |
| 387 | Math.min(availableHeightPx, windowBounds.availableSize.y)); |
Jon Miranda | a11380d | 2017-08-24 11:30:03 -0700 | [diff] [blame] | 388 | |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 389 | DeviceProfile profile = toBuilder(context) |
| 390 | .setSizeRange(mwSize, mwSize) |
Sunny Goyal | b46703d | 2020-05-27 17:52:03 -0700 | [diff] [blame] | 391 | .setSize(windowBounds.bounds.width(), windowBounds.bounds.height()) |
| 392 | .setWindowPosition(windowBounds.bounds.left, windowBounds.bounds.top) |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 393 | .setMultiWindowMode(true) |
| 394 | .build(); |
Jon Miranda | 93e1f04 | 2016-11-11 14:13:04 -0800 | [diff] [blame] | 395 | |
Jon Miranda | 0cd0457 | 2017-09-19 11:31:42 -0700 | [diff] [blame] | 396 | // If there isn't enough vertical cell padding with the labels displayed, hide the labels. |
| 397 | float workspaceCellPaddingY = profile.getCellSize().y - profile.iconSizePx |
| 398 | - iconDrawablePaddingPx - profile.iconTextSizePx; |
| 399 | if (workspaceCellPaddingY < profile.iconDrawablePaddingPx * 2) { |
| 400 | profile.adjustToHideWorkspaceLabels(); |
| 401 | } |
Jon Miranda | 93e1f04 | 2016-11-11 14:13:04 -0800 | [diff] [blame] | 402 | |
Jon Miranda | 7ae64ff | 2016-11-21 16:18:46 -0800 | [diff] [blame] | 403 | // We use these scales to measure and layout the widgets using their full invariant profile |
| 404 | // sizes and then draw them scaled and centered to fit in their multi-window mode cellspans. |
| 405 | float appWidgetScaleX = (float) profile.getCellSize().x / getCellSize().x; |
| 406 | float appWidgetScaleY = (float) profile.getCellSize().y / getCellSize().y; |
| 407 | profile.appWidgetScale.set(appWidgetScaleX, appWidgetScaleY); |
Sunny Goyal | 07b6929 | 2018-01-08 14:19:34 -0800 | [diff] [blame] | 408 | profile.updateWorkspacePadding(); |
Jon Miranda | 7ae64ff | 2016-11-21 16:18:46 -0800 | [diff] [blame] | 409 | |
Jon Miranda | 93e1f04 | 2016-11-11 14:13:04 -0800 | [diff] [blame] | 410 | return profile; |
Jon Miranda | cc42c5b | 2016-10-27 17:15:27 -0700 | [diff] [blame] | 411 | } |
| 412 | |
Adam Cohen | 63f1ec0 | 2014-08-12 09:23:13 -0700 | [diff] [blame] | 413 | /** |
Sunny Goyal | b46703d | 2020-05-27 17:52:03 -0700 | [diff] [blame] | 414 | * Inverse of {@link #getMultiWindowProfile(Context, WindowBounds)} |
Sunny Goyal | 2e2e2b4 | 2018-02-27 16:52:55 -0800 | [diff] [blame] | 415 | * @return device profile corresponding to the current orientation in non multi-window mode. |
| 416 | */ |
| 417 | public DeviceProfile getFullScreenProfile() { |
| 418 | return isLandscape ? inv.landscapeProfile : inv.portraitProfile; |
| 419 | } |
| 420 | |
| 421 | /** |
Jon Miranda | 1091e53 | 2017-07-21 13:31:50 -0700 | [diff] [blame] | 422 | * Adjusts the profile so that the labels on the Workspace are hidden. |
| 423 | * It is important to call this method after the All Apps variables have been set. |
| 424 | */ |
| 425 | private void adjustToHideWorkspaceLabels() { |
| 426 | iconTextSizePx = 0; |
| 427 | iconDrawablePaddingPx = 0; |
| 428 | cellHeightPx = iconSizePx; |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 429 | autoResizeAllAppsCells(); |
| 430 | } |
Jon Miranda | 1091e53 | 2017-07-21 13:31:50 -0700 | [diff] [blame] | 431 | |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 432 | /** |
| 433 | * Re-computes the all-apps cell size to be independent of workspace |
| 434 | */ |
| 435 | public void autoResizeAllAppsCells() { |
Jon Miranda | 3f9bab2 | 2017-07-28 14:50:17 -0700 | [diff] [blame] | 436 | int topBottomPadding = allAppsIconDrawablePaddingPx * (isVerticalBarLayout() ? 2 : 1); |
Jon Miranda | 1091e53 | 2017-07-21 13:31:50 -0700 | [diff] [blame] | 437 | allAppsCellHeightPx = allAppsIconSizePx + allAppsIconDrawablePaddingPx |
| 438 | + Utilities.calculateTextHeight(allAppsIconTextSizePx) |
Jon Miranda | 3f9bab2 | 2017-07-28 14:50:17 -0700 | [diff] [blame] | 439 | + topBottomPadding * 2; |
Jon Miranda | 1091e53 | 2017-07-21 13:31:50 -0700 | [diff] [blame] | 440 | } |
| 441 | |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 442 | /** |
| 443 | * Returns the amount of extra (or unused) vertical space. |
| 444 | */ |
| 445 | private int updateAvailableDimensions(Resources res) { |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 446 | updateIconSize(1f, res); |
Winson Chung | 59a488a | 2013-12-10 12:32:14 -0800 | [diff] [blame] | 447 | |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 448 | Point workspacePadding = getTotalWorkspacePadding(); |
| 449 | |
| 450 | // Check to see if the icons fit within the available height. |
| 451 | float usedHeight = getCellLayoutHeight(); |
| 452 | final int maxHeight = availableHeightPx - workspacePadding.y; |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 453 | float extraHeight = Math.max(0, maxHeight - usedHeight); |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 454 | float scaleY = maxHeight / usedHeight; |
| 455 | boolean shouldScale = scaleY < 1f; |
| 456 | |
| 457 | float scaleX = 1f; |
| 458 | if (isScalableGrid) { |
| 459 | // We scale to fit the cellWidth and cellHeight in the available space. |
| 460 | // The benefit of scalable grids is that we can get consistent aspect ratios between |
| 461 | // devices. |
| 462 | float usedWidth = (cellWidthPx * inv.numColumns) |
| 463 | + (cellLayoutBorderSpacingPx * (inv.numColumns - 1)) |
| 464 | + (desiredWorkspaceLeftRightMarginPx * 2); |
| 465 | // We do not subtract padding here, as we also scale the workspace padding if needed. |
| 466 | scaleX = availableWidthPx / usedWidth; |
| 467 | shouldScale = true; |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 468 | } |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 469 | |
| 470 | if (shouldScale) { |
| 471 | float scale = Math.min(scaleX, scaleY); |
| 472 | updateIconSize(scale, res); |
| 473 | extraHeight = Math.max(0, maxHeight - getCellLayoutHeight()); |
| 474 | } |
| 475 | |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 476 | updateAvailableFolderCellDimensions(res); |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 477 | return Math.round(extraHeight); |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 478 | } |
| 479 | |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 480 | private int getCellLayoutHeight() { |
| 481 | return (cellHeightPx * inv.numRows) + (cellLayoutBorderSpacingPx * (inv.numRows - 1)); |
| 482 | } |
| 483 | |
Jon Miranda | 6f7e970 | 2019-09-16 14:44:14 -0700 | [diff] [blame] | 484 | /** |
| 485 | * Updating the iconSize affects many aspects of the launcher layout, such as: iconSizePx, |
| 486 | * iconTextSizePx, iconDrawablePaddingPx, cellWidth/Height, allApps* variants, |
| 487 | * hotseat sizes, workspaceSpringLoadedShrinkFactor, folderIconSizePx, and folderIconOffsetYPx. |
| 488 | */ |
Tony Wickham | 7ba547c | 2021-02-02 17:12:08 -0800 | [diff] [blame] | 489 | public void updateIconSize(float scale, Resources res) { |
Jon Miranda | 18751b6 | 2017-07-31 17:25:27 -0700 | [diff] [blame] | 490 | // Workspace |
Sunny Goyal | 07b6929 | 2018-01-08 14:19:34 -0800 | [diff] [blame] | 491 | final boolean isVerticalLayout = isVerticalBarLayout(); |
Jon Miranda | 6f7e970 | 2019-09-16 14:44:14 -0700 | [diff] [blame] | 492 | float invIconSizeDp = isVerticalLayout ? inv.landscapeIconSize : inv.iconSize; |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 493 | iconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mInfo.metrics, scale)); |
Jon Miranda | 378c11f | 2021-03-10 10:28:50 -0500 | [diff] [blame] | 494 | iconTextSizePx = (int) (Utilities.pxFromSp(inv.iconTextSize, mInfo.metrics) * scale); |
Jon Miranda | 0966072 | 2017-06-14 14:20:14 -0700 | [diff] [blame] | 495 | iconDrawablePaddingPx = (int) (iconDrawablePaddingOriginalPx * scale); |
Jon Miranda | b28c4fc | 2017-06-20 10:58:36 -0700 | [diff] [blame] | 496 | |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 497 | setCellLayoutBorderSpacing((int) (cellLayoutBorderSpacingOriginalPx * scale)); |
| 498 | |
| 499 | if (isScalableGrid) { |
| 500 | cellWidthPx = pxFromDp(inv.minCellWidth, mInfo.metrics, scale); |
| 501 | cellHeightPx = pxFromDp(inv.minCellHeight, mInfo.metrics, scale); |
| 502 | int cellContentHeight = iconSizePx + iconDrawablePaddingPx |
| 503 | + Utilities.calculateTextHeight(iconTextSizePx); |
| 504 | cellYPaddingPx = Math.max(0, cellHeightPx - cellContentHeight) / 2; |
| 505 | desiredWorkspaceLeftRightMarginPx = (int) (desiredWorkspaceLeftRightOriginalPx * scale); |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 506 | } else { |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 507 | cellWidthPx = iconSizePx + iconDrawablePaddingPx; |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 508 | cellHeightPx = iconSizePx + iconDrawablePaddingPx |
| 509 | + Utilities.calculateTextHeight(iconTextSizePx); |
| 510 | int cellPaddingY = (getCellSize().y - cellHeightPx) / 2; |
| 511 | if (iconDrawablePaddingPx > cellPaddingY && !isVerticalLayout |
| 512 | && !isMultiWindowMode) { |
| 513 | // Ensures that the label is closer to its corresponding icon. This is not an issue |
| 514 | // with vertical bar layout or multi-window mode since the issue is handled |
| 515 | // separately with their calls to {@link #adjustToHideWorkspaceLabels}. |
| 516 | cellHeightPx -= (iconDrawablePaddingPx - cellPaddingY); |
| 517 | iconDrawablePaddingPx = cellPaddingY; |
| 518 | } |
Jon Miranda | 846455e | 2017-10-02 14:58:52 -0700 | [diff] [blame] | 519 | } |
Jon Miranda | 18751b6 | 2017-07-31 17:25:27 -0700 | [diff] [blame] | 520 | |
Sunny Goyal | ae190ff | 2020-04-14 00:19:01 +0000 | [diff] [blame] | 521 | // All apps |
| 522 | if (allAppsHasDifferentNumColumns()) { |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 523 | allAppsIconSizePx = pxFromDp(inv.allAppsIconSize, mInfo.metrics); |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 524 | allAppsIconTextSizePx = Utilities.pxFromSp(inv.allAppsIconTextSize, mInfo.metrics); |
Sunny Goyal | ae190ff | 2020-04-14 00:19:01 +0000 | [diff] [blame] | 525 | allAppsIconDrawablePaddingPx = iconDrawablePaddingOriginalPx; |
Jon Miranda | 3535944 | 2020-07-09 14:54:23 -0700 | [diff] [blame] | 526 | // We use 4 below to ensure labels are closer to their corresponding icon. |
| 527 | allAppsCellHeightPx = Math.round(allAppsIconSizePx + allAppsIconTextSizePx |
| 528 | + (4 * allAppsIconDrawablePaddingPx)); |
Sunny Goyal | ae190ff | 2020-04-14 00:19:01 +0000 | [diff] [blame] | 529 | } else { |
| 530 | allAppsIconSizePx = iconSizePx; |
| 531 | allAppsIconTextSizePx = iconTextSizePx; |
| 532 | allAppsIconDrawablePaddingPx = iconDrawablePaddingPx; |
| 533 | allAppsCellHeightPx = getCellSize().y; |
| 534 | } |
| 535 | allAppsCellWidthPx = allAppsIconSizePx + allAppsIconDrawablePaddingPx; |
Jon Miranda | b28c4fc | 2017-06-20 10:58:36 -0700 | [diff] [blame] | 536 | |
Jon Miranda | 6f7e970 | 2019-09-16 14:44:14 -0700 | [diff] [blame] | 537 | if (isVerticalBarLayout()) { |
Jon Miranda | b28c4fc | 2017-06-20 10:58:36 -0700 | [diff] [blame] | 538 | // Always hide the Workspace text with vertical bar layout. |
Jon Miranda | 1091e53 | 2017-07-21 13:31:50 -0700 | [diff] [blame] | 539 | adjustToHideWorkspaceLabels(); |
Jon Miranda | b28c4fc | 2017-06-20 10:58:36 -0700 | [diff] [blame] | 540 | } |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 541 | |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 542 | // Hotseat |
Sunny Goyal | 07b6929 | 2018-01-08 14:19:34 -0800 | [diff] [blame] | 543 | if (isVerticalLayout) { |
Tony Wickham | 1eeffbe | 2018-06-12 15:01:15 -0700 | [diff] [blame] | 544 | hotseatBarSizePx = iconSizePx + hotseatBarSidePaddingStartPx |
| 545 | + hotseatBarSidePaddingEndPx; |
Jon Miranda | 18751b6 | 2017-07-31 17:25:27 -0700 | [diff] [blame] | 546 | } |
Jon Miranda | 5044c35 | 2017-08-09 11:37:59 -0700 | [diff] [blame] | 547 | hotseatCellHeightPx = iconSizePx; |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 548 | |
Sunny Goyal | 07b6929 | 2018-01-08 14:19:34 -0800 | [diff] [blame] | 549 | if (!isVerticalLayout) { |
Jon Miranda | 18751b6 | 2017-07-31 17:25:27 -0700 | [diff] [blame] | 550 | int expectedWorkspaceHeight = availableHeightPx - hotseatBarSizePx |
Tony Wickham | 5edf9e2 | 2020-03-27 20:06:52 -0700 | [diff] [blame] | 551 | - workspacePageIndicatorHeight - edgeMarginPx; |
Sunny Goyal | 47328fd | 2016-05-25 18:56:41 -0700 | [diff] [blame] | 552 | float minRequiredHeight = dropTargetBarSizePx + workspaceSpringLoadedBottomSpace; |
| 553 | workspaceSpringLoadShrinkFactor = Math.min( |
| 554 | res.getInteger(R.integer.config_workspaceSpringLoadShrinkPercentage) / 100.0f, |
| 555 | 1 - (minRequiredHeight / expectedWorkspaceHeight)); |
| 556 | } else { |
| 557 | workspaceSpringLoadShrinkFactor = |
| 558 | res.getInteger(R.integer.config_workspaceSpringLoadShrinkPercentage) / 100.0f; |
| 559 | } |
| 560 | |
Sunny Goyal | baec6ff | 2016-09-14 11:26:21 -0700 | [diff] [blame] | 561 | // Folder icon |
Jon Miranda | 591e360 | 2018-03-28 11:37:00 -0700 | [diff] [blame] | 562 | folderIconSizePx = IconNormalizer.getNormalizedCircleSize(iconSizePx); |
| 563 | folderIconOffsetYPx = (iconSizePx - folderIconSizePx) / 2; |
Winson Chung | 0f78572 | 2015-04-08 10:27:49 -0700 | [diff] [blame] | 564 | } |
| 565 | |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 566 | private void updateAvailableFolderCellDimensions(Resources res) { |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 567 | updateFolderCellSize(1f, res); |
Jon Miranda | bf7d812 | 2016-11-03 15:29:29 -0700 | [diff] [blame] | 568 | |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 569 | final int folderBottomPanelSize = res.getDimensionPixelSize(R.dimen.folder_label_height); |
| 570 | |
Jon Miranda | c1b2399 | 2016-12-13 08:57:36 -0800 | [diff] [blame] | 571 | // 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] | 572 | int folderMargin = edgeMarginPx * 2; |
Sunny Goyal | 07b6929 | 2018-01-08 14:19:34 -0800 | [diff] [blame] | 573 | Point totalWorkspacePadding = getTotalWorkspacePadding(); |
Jon Miranda | c1b2399 | 2016-12-13 08:57:36 -0800 | [diff] [blame] | 574 | |
| 575 | // Check if the icons fit within the available height. |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 576 | float contentUsedHeight = folderCellHeightPx * inv.numFolderRows |
| 577 | + ((inv.numFolderRows - 1) * cellLayoutBorderSpacingPx); |
Samuel Fufa | 1c8d90a | 2019-11-12 17:54:58 -0800 | [diff] [blame] | 578 | int contentMaxHeight = availableHeightPx - totalWorkspacePadding.y - folderBottomPanelSize |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 579 | - folderMargin - folderContentPaddingTop; |
Samuel Fufa | 1c8d90a | 2019-11-12 17:54:58 -0800 | [diff] [blame] | 580 | float scaleY = contentMaxHeight / contentUsedHeight; |
Jon Miranda | c1b2399 | 2016-12-13 08:57:36 -0800 | [diff] [blame] | 581 | |
| 582 | // Check if the icons fit within the available width. |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 583 | float contentUsedWidth = folderCellWidthPx * inv.numFolderColumns |
| 584 | + ((inv.numFolderColumns - 1) * cellLayoutBorderSpacingPx); |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 585 | int contentMaxWidth = availableWidthPx - totalWorkspacePadding.x - folderMargin |
| 586 | - folderContentPaddingLeftRight * 2; |
Samuel Fufa | 1c8d90a | 2019-11-12 17:54:58 -0800 | [diff] [blame] | 587 | float scaleX = contentMaxWidth / contentUsedWidth; |
Jon Miranda | c1b2399 | 2016-12-13 08:57:36 -0800 | [diff] [blame] | 588 | |
| 589 | float scale = Math.min(scaleX, scaleY); |
| 590 | if (scale < 1f) { |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 591 | updateFolderCellSize(scale, res); |
Jon Miranda | bf7d812 | 2016-11-03 15:29:29 -0700 | [diff] [blame] | 592 | } |
| 593 | } |
| 594 | |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 595 | private void updateFolderCellSize(float scale, Resources res) { |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 596 | float invIconSizeDp = isVerticalBarLayout() ? inv.landscapeIconSize : inv.iconSize; |
| 597 | folderChildIconSizePx = Math.max(1, pxFromDp(invIconSizeDp, mInfo.metrics, scale)); |
| 598 | folderChildTextSizePx = pxFromDp(inv.iconTextSize, mInfo.metrics, scale); |
| 599 | folderLabelTextSizePx = (int) (folderChildTextSizePx * folderLabelTextScale); |
Jon Miranda | bf7d812 | 2016-11-03 15:29:29 -0700 | [diff] [blame] | 600 | |
| 601 | int textHeight = Utilities.calculateTextHeight(folderChildTextSizePx); |
| 602 | int cellPaddingX = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_x_padding) * scale); |
| 603 | int cellPaddingY = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_y_padding) * scale); |
| 604 | |
Jon Miranda | c1b2399 | 2016-12-13 08:57:36 -0800 | [diff] [blame] | 605 | folderCellWidthPx = folderChildIconSizePx + 2 * cellPaddingX; |
Jonathan Miranda | 9ad8746 | 2017-07-26 17:41:02 +0000 | [diff] [blame] | 606 | folderCellHeightPx = folderChildIconSizePx + 2 * cellPaddingY + textHeight; |
| 607 | folderChildDrawablePaddingPx = Math.max(0, |
| 608 | (folderCellHeightPx - folderChildIconSizePx - textHeight) / 3); |
Jon Miranda | bf7d812 | 2016-11-03 15:29:29 -0700 | [diff] [blame] | 609 | } |
| 610 | |
Winson | 1f06427 | 2016-07-18 17:18:02 -0700 | [diff] [blame] | 611 | public void updateInsets(Rect insets) { |
| 612 | mInsets.set(insets); |
Sunny Goyal | 07b6929 | 2018-01-08 14:19:34 -0800 | [diff] [blame] | 613 | updateWorkspacePadding(); |
Winson | 1f06427 | 2016-07-18 17:18:02 -0700 | [diff] [blame] | 614 | } |
| 615 | |
Sunny Goyal | ae6e318 | 2019-04-30 12:04:37 -0700 | [diff] [blame] | 616 | /** |
| 617 | * The current device insets. This is generally same as the insets being dispatched to |
| 618 | * {@link Insettable} elements, but can differ if the element is using a different profile. |
| 619 | */ |
Sunny Goyal | 1a52ef5 | 2018-01-11 10:15:03 -0800 | [diff] [blame] | 620 | public Rect getInsets() { |
| 621 | return mInsets; |
| 622 | } |
| 623 | |
Sunny Goyal | 756cd26 | 2015-08-20 12:33:21 -0700 | [diff] [blame] | 624 | public Point getCellSize() { |
Jon Miranda | 6f7e970 | 2019-09-16 14:44:14 -0700 | [diff] [blame] | 625 | return getCellSize(inv.numColumns, inv.numRows); |
| 626 | } |
| 627 | |
| 628 | private Point getCellSize(int numColumns, int numRows) { |
Sunny Goyal | 756cd26 | 2015-08-20 12:33:21 -0700 | [diff] [blame] | 629 | Point result = new Point(); |
| 630 | // Since we are only concerned with the overall padding, layout direction does |
| 631 | // not matter. |
Sunny Goyal | 6c2975e | 2016-07-06 09:47:56 -0700 | [diff] [blame] | 632 | Point padding = getTotalWorkspacePadding(); |
Jon Miranda | 18751b6 | 2017-07-31 17:25:27 -0700 | [diff] [blame] | 633 | result.x = calculateCellWidth(availableWidthPx - padding.x |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 634 | - cellLayoutPaddingLeftRightPx * 2, cellLayoutBorderSpacingPx, numColumns); |
Jon Miranda | 18751b6 | 2017-07-31 17:25:27 -0700 | [diff] [blame] | 635 | result.y = calculateCellHeight(availableHeightPx - padding.y |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 636 | - cellLayoutBottomPaddingPx, cellLayoutBorderSpacingPx, numRows); |
Sunny Goyal | 756cd26 | 2015-08-20 12:33:21 -0700 | [diff] [blame] | 637 | return result; |
| 638 | } |
| 639 | |
Sunny Goyal | 6c2975e | 2016-07-06 09:47:56 -0700 | [diff] [blame] | 640 | public Point getTotalWorkspacePadding() { |
Sunny Goyal | 07b6929 | 2018-01-08 14:19:34 -0800 | [diff] [blame] | 641 | updateWorkspacePadding(); |
| 642 | return new Point(workspacePadding.left + workspacePadding.right, |
| 643 | workspacePadding.top + workspacePadding.bottom); |
Sunny Goyal | 6c2975e | 2016-07-06 09:47:56 -0700 | [diff] [blame] | 644 | } |
| 645 | |
| 646 | /** |
Sunny Goyal | 07b6929 | 2018-01-08 14:19:34 -0800 | [diff] [blame] | 647 | * Updates {@link #workspacePadding} as a result of any internal value change to reflect the |
| 648 | * new workspace padding |
Sunny Goyal | 6c2975e | 2016-07-06 09:47:56 -0700 | [diff] [blame] | 649 | */ |
Sunny Goyal | 07b6929 | 2018-01-08 14:19:34 -0800 | [diff] [blame] | 650 | private void updateWorkspacePadding() { |
| 651 | Rect padding = workspacePadding; |
Tony Wickham | 3a3517f | 2015-10-06 11:27:04 -0700 | [diff] [blame] | 652 | if (isVerticalBarLayout()) { |
Sunny Goyal | 228153d | 2018-01-04 15:35:22 -0800 | [diff] [blame] | 653 | padding.top = 0; |
| 654 | padding.bottom = edgeMarginPx; |
Sunny Goyal | 7e2e67f | 2018-01-26 13:40:08 -0800 | [diff] [blame] | 655 | if (isSeascape()) { |
Tony Wickham | 1eeffbe | 2018-06-12 15:01:15 -0700 | [diff] [blame] | 656 | padding.left = hotseatBarSizePx; |
Tony Wickham | 5edf9e2 | 2020-03-27 20:06:52 -0700 | [diff] [blame] | 657 | padding.right = hotseatBarSidePaddingStartPx; |
Winson | 1f06427 | 2016-07-18 17:18:02 -0700 | [diff] [blame] | 658 | } else { |
Tony Wickham | 5edf9e2 | 2020-03-27 20:06:52 -0700 | [diff] [blame] | 659 | padding.left = hotseatBarSidePaddingStartPx; |
Tony Wickham | 1eeffbe | 2018-06-12 15:01:15 -0700 | [diff] [blame] | 660 | padding.right = hotseatBarSizePx; |
Winson | 1f06427 | 2016-07-18 17:18:02 -0700 | [diff] [blame] | 661 | } |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 662 | } else { |
Tony Wickham | a29a046 | 2021-03-02 12:28:25 -0800 | [diff] [blame] | 663 | int hotseatTop = isTaskbarPresent ? taskbarSize : hotseatBarSizePx; |
| 664 | int paddingBottom = hotseatTop + workspacePageIndicatorHeight |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 665 | + workspaceBottomPadding - mWorkspacePageIndicatorOverlapWorkspace; |
Sunny Goyal | c620560 | 2015-05-21 20:46:33 -0700 | [diff] [blame] | 666 | if (isTablet) { |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 667 | // Pad the left and right of the workspace to ensure consistent spacing |
| 668 | // between all icons |
Tony Wickham | d6b4037 | 2015-09-23 18:37:57 -0700 | [diff] [blame] | 669 | // The amount of screen space available for left/right padding. |
Sunny Goyal | 228153d | 2018-01-04 15:35:22 -0800 | [diff] [blame] | 670 | int availablePaddingX = Math.max(0, widthPx - ((inv.numColumns * cellWidthPx) + |
Sunny Goyal | f5440cb | 2016-12-14 15:13:00 -0800 | [diff] [blame] | 671 | ((inv.numColumns - 1) * cellWidthPx))); |
Tony Wickham | d6b4037 | 2015-09-23 18:37:57 -0700 | [diff] [blame] | 672 | availablePaddingX = (int) Math.min(availablePaddingX, |
Sunny Goyal | 07b6929 | 2018-01-08 14:19:34 -0800 | [diff] [blame] | 673 | widthPx * MAX_HORIZONTAL_PADDING_PERCENT); |
Tony Wickham | a29a046 | 2021-03-02 12:28:25 -0800 | [diff] [blame] | 674 | int hotseatVerticalPadding = isTaskbarPresent ? 0 |
| 675 | : hotseatBarTopPaddingPx + hotseatBarBottomPaddingPx; |
Sunny Goyal | 58fa4b6 | 2019-03-22 16:23:25 -0700 | [diff] [blame] | 676 | int availablePaddingY = Math.max(0, heightPx - edgeMarginPx - paddingBottom |
Tony Wickham | a29a046 | 2021-03-02 12:28:25 -0800 | [diff] [blame] | 677 | - (2 * inv.numRows * cellHeightPx) - hotseatVerticalPadding); |
Sunny Goyal | 58fa4b6 | 2019-03-22 16:23:25 -0700 | [diff] [blame] | 678 | padding.set(availablePaddingX / 2, edgeMarginPx + availablePaddingY / 2, |
Tony Wickham | d6b4037 | 2015-09-23 18:37:57 -0700 | [diff] [blame] | 679 | availablePaddingX / 2, paddingBottom + availablePaddingY / 2); |
Andras Kloczl | 8e57cce | 2021-02-11 23:51:19 +0100 | [diff] [blame] | 680 | |
| 681 | if (FeatureFlags.ENABLE_TWO_PANEL_HOME.get()) { |
| 682 | padding.set(0, padding.top, 0, padding.bottom); |
| 683 | } |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 684 | } else { |
| 685 | // Pad the top and bottom of the workspace with search/hotseat bar sizes |
Winson | 1f06427 | 2016-07-18 17:18:02 -0700 | [diff] [blame] | 686 | padding.set(desiredWorkspaceLeftRightMarginPx, |
Jon Miranda | e126d72 | 2021-02-25 10:45:20 -0500 | [diff] [blame] | 687 | workspaceTopPadding + (isScalableGrid ? 0 : edgeMarginPx), |
Winson | 1f06427 | 2016-07-18 17:18:02 -0700 | [diff] [blame] | 688 | desiredWorkspaceLeftRightMarginPx, |
Winson | fadbe8f | 2016-07-22 16:35:37 -0700 | [diff] [blame] | 689 | paddingBottom); |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 690 | } |
| 691 | } |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 692 | } |
| 693 | |
Sunny Goyal | 81b4c7b | 2018-03-26 12:10:31 -0700 | [diff] [blame] | 694 | public Rect getHotseatLayoutPadding() { |
| 695 | if (isVerticalBarLayout()) { |
| 696 | if (isSeascape()) { |
Tony Wickham | 1eeffbe | 2018-06-12 15:01:15 -0700 | [diff] [blame] | 697 | mHotseatPadding.set(mInsets.left + hotseatBarSidePaddingStartPx, |
| 698 | mInsets.top, hotseatBarSidePaddingEndPx, mInsets.bottom); |
Sunny Goyal | 81b4c7b | 2018-03-26 12:10:31 -0700 | [diff] [blame] | 699 | } else { |
Tony Wickham | 1eeffbe | 2018-06-12 15:01:15 -0700 | [diff] [blame] | 700 | mHotseatPadding.set(hotseatBarSidePaddingEndPx, mInsets.top, |
| 701 | mInsets.right + hotseatBarSidePaddingStartPx, mInsets.bottom); |
Sunny Goyal | 81b4c7b | 2018-03-26 12:10:31 -0700 | [diff] [blame] | 702 | } |
| 703 | } else { |
Sunny Goyal | 81b4c7b | 2018-03-26 12:10:31 -0700 | [diff] [blame] | 704 | // We want the edges of the hotseat to line up with the edges of the workspace, but the |
| 705 | // icons in the hotseat are a different size, and so don't line up perfectly. To account |
| 706 | // for this, we pad the left and right of the hotseat with half of the difference of a |
| 707 | // workspace cell vs a hotseat cell. |
| 708 | float workspaceCellWidth = (float) widthPx / inv.numColumns; |
| 709 | float hotseatCellWidth = (float) widthPx / inv.numHotseatIcons; |
| 710 | int hotseatAdjustment = Math.round((workspaceCellWidth - hotseatCellWidth) / 2); |
| 711 | mHotseatPadding.set( |
Sunny Goyal | 786940a | 2020-06-02 02:31:31 -0700 | [diff] [blame] | 712 | hotseatAdjustment + workspacePadding.left + cellLayoutPaddingLeftRightPx |
| 713 | + mInsets.left, |
Sunny Goyal | 81b4c7b | 2018-03-26 12:10:31 -0700 | [diff] [blame] | 714 | hotseatBarTopPaddingPx, |
Sunny Goyal | 786940a | 2020-06-02 02:31:31 -0700 | [diff] [blame] | 715 | hotseatAdjustment + workspacePadding.right + cellLayoutPaddingLeftRightPx |
| 716 | + mInsets.right, |
Sunny Goyal | 81b4c7b | 2018-03-26 12:10:31 -0700 | [diff] [blame] | 717 | hotseatBarBottomPaddingPx + mInsets.bottom + cellLayoutBottomPaddingPx); |
| 718 | } |
| 719 | return mHotseatPadding; |
| 720 | } |
| 721 | |
Winson | fadbe8f | 2016-07-22 16:35:37 -0700 | [diff] [blame] | 722 | /** |
| 723 | * @return the bounds for which the open folders should be contained within |
| 724 | */ |
| 725 | public Rect getAbsoluteOpenFolderBounds() { |
| 726 | if (isVerticalBarLayout()) { |
| 727 | // Folders should only appear right of the drop target bar and left of the hotseat |
| 728 | return new Rect(mInsets.left + dropTargetBarSizePx + edgeMarginPx, |
| 729 | mInsets.top, |
Jon Miranda | 18751b6 | 2017-07-31 17:25:27 -0700 | [diff] [blame] | 730 | mInsets.left + availableWidthPx - hotseatBarSizePx - edgeMarginPx, |
Winson | fadbe8f | 2016-07-22 16:35:37 -0700 | [diff] [blame] | 731 | mInsets.top + availableHeightPx); |
| 732 | } else { |
| 733 | // 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] | 734 | int hotseatTop = isTaskbarPresent ? taskbarSize : hotseatBarSizePx; |
Tony Wickham | b4b7e20 | 2018-01-12 17:39:24 -0800 | [diff] [blame] | 735 | return new Rect(mInsets.left + edgeMarginPx, |
Winson | fadbe8f | 2016-07-22 16:35:37 -0700 | [diff] [blame] | 736 | mInsets.top + dropTargetBarSizePx + edgeMarginPx, |
Tony Wickham | b4b7e20 | 2018-01-12 17:39:24 -0800 | [diff] [blame] | 737 | mInsets.left + availableWidthPx - edgeMarginPx, |
Tony Wickham | ae72b46 | 2021-03-10 16:18:40 -0800 | [diff] [blame] | 738 | mInsets.top + availableHeightPx - hotseatTop |
Tony Wickham | 5edf9e2 | 2020-03-27 20:06:52 -0700 | [diff] [blame] | 739 | - workspacePageIndicatorHeight - edgeMarginPx); |
Winson | fadbe8f | 2016-07-22 16:35:37 -0700 | [diff] [blame] | 740 | } |
| 741 | } |
| 742 | |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 743 | public static int calculateCellWidth(int width, int borderSpacing, int countX) { |
| 744 | return (width - ((countX - 1) * borderSpacing)) / countX; |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 745 | } |
Jon Miranda | 228877d | 2021-02-09 11:05:00 -0500 | [diff] [blame] | 746 | public static int calculateCellHeight(int height, int borderSpacing, int countY) { |
| 747 | return (height - ((countY - 1) * borderSpacing)) / countY; |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 748 | } |
| 749 | |
Hyunyoung Song | 18bfaaf | 2015-03-17 11:32:21 -0700 | [diff] [blame] | 750 | /** |
Tony Wickham | 55616cd | 2015-09-23 14:55:17 -0700 | [diff] [blame] | 751 | * When {@code true}, the device is in landscape mode and the hotseat is on the right column. |
| 752 | * When {@code false}, either device is in portrait mode or the device is in landscape mode and |
| 753 | * the hotseat is on the bottom row. |
Hyunyoung Song | 18bfaaf | 2015-03-17 11:32:21 -0700 | [diff] [blame] | 754 | */ |
Tony Wickham | ab946a1 | 2015-09-16 15:38:16 -0700 | [diff] [blame] | 755 | public boolean isVerticalBarLayout() { |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 756 | return isLandscape && transposeLayoutWithOrientation; |
| 757 | } |
| 758 | |
Sunny Goyal | 59d086c | 2018-05-07 17:31:40 -0700 | [diff] [blame] | 759 | /** |
Jon Miranda | 6f7e970 | 2019-09-16 14:44:14 -0700 | [diff] [blame] | 760 | * Returns true when the number of workspace columns and all apps columns differs. |
| 761 | */ |
| 762 | private boolean allAppsHasDifferentNumColumns() { |
| 763 | return inv.numAllAppsColumns != inv.numColumns; |
| 764 | } |
| 765 | |
| 766 | /** |
Sunny Goyal | 59d086c | 2018-05-07 17:31:40 -0700 | [diff] [blame] | 767 | * Updates orientation information and returns true if it has changed from the previous value. |
| 768 | */ |
Winson Chung | 13c1c2c | 2019-09-06 11:46:19 -0700 | [diff] [blame] | 769 | public boolean updateIsSeascape(Context context) { |
Sunny Goyal | 59d086c | 2018-05-07 17:31:40 -0700 | [diff] [blame] | 770 | if (isVerticalBarLayout()) { |
Schneider Victor-tulias | 954bb63 | 2021-01-27 14:03:51 -0800 | [diff] [blame] | 771 | // Check an up-to-date info. |
Alex Chau | d25e87a | 2021-02-12 12:12:56 +0000 | [diff] [blame] | 772 | DisplayController.Info displayInfo = DisplayController.getDefaultDisplay(context) |
| 773 | .createInfoForContext(context); |
| 774 | if (displayInfo == null) { |
| 775 | return false; |
| 776 | } |
| 777 | |
| 778 | boolean isSeascape = displayInfo.rotation == Surface.ROTATION_270; |
Sunny Goyal | 59d086c | 2018-05-07 17:31:40 -0700 | [diff] [blame] | 779 | if (mIsSeascape != isSeascape) { |
| 780 | mIsSeascape = isSeascape; |
| 781 | return true; |
| 782 | } |
| 783 | } |
| 784 | return false; |
| 785 | } |
| 786 | |
Sunny Goyal | 7e2e67f | 2018-01-26 13:40:08 -0800 | [diff] [blame] | 787 | public boolean isSeascape() { |
Sunny Goyal | 59d086c | 2018-05-07 17:31:40 -0700 | [diff] [blame] | 788 | return isVerticalBarLayout() && mIsSeascape; |
Sunny Goyal | 7e2e67f | 2018-01-26 13:40:08 -0800 | [diff] [blame] | 789 | } |
| 790 | |
Sunny Goyal | 07b6929 | 2018-01-08 14:19:34 -0800 | [diff] [blame] | 791 | public boolean shouldFadeAdjacentWorkspaceScreens() { |
Sunny Goyal | c620560 | 2015-05-21 20:46:33 -0700 | [diff] [blame] | 792 | return isVerticalBarLayout() || isLargeTablet; |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 793 | } |
| 794 | |
Sunny Goyal | c13403c | 2016-11-18 23:44:48 -0800 | [diff] [blame] | 795 | public int getCellHeight(@ContainerType int containerType) { |
| 796 | switch (containerType) { |
| 797 | case CellLayout.WORKSPACE: |
| 798 | return cellHeightPx; |
| 799 | case CellLayout.FOLDER: |
| 800 | return folderCellHeightPx; |
| 801 | case CellLayout.HOTSEAT: |
| 802 | return hotseatCellHeightPx; |
| 803 | default: |
| 804 | // ?? |
| 805 | return 0; |
| 806 | } |
| 807 | } |
Sunny Goyal | 13178ac | 2016-04-04 16:35:22 -0700 | [diff] [blame] | 808 | |
Jon Miranda | 58561d4 | 2021-03-17 10:51:54 -0400 | [diff] [blame] | 809 | private String pxToDpStr(String name, float value) { |
| 810 | return "\t" + name + ": " + value + "px (" + dpiFromPx(value, mInfo.metrics) + "dp)"; |
| 811 | } |
| 812 | |
| 813 | public void dump(String prefix, PrintWriter writer) { |
| 814 | writer.println(prefix + "DeviceProfile:"); |
| 815 | writer.println(prefix + "\t1 dp = " + mInfo.metrics.density + " px"); |
| 816 | |
| 817 | writer.println(prefix + "\tisTablet:" + isTablet); |
| 818 | writer.println(prefix + "\tisLargeTablet:" + isLargeTablet); |
| 819 | writer.println(prefix + "\tisPhone:" + isPhone); |
| 820 | writer.println(prefix + "\ttransposeLayoutWithOrientation:" |
| 821 | + transposeLayoutWithOrientation); |
| 822 | |
| 823 | writer.println(prefix + "\tisLandscape:" + isLandscape); |
| 824 | writer.println(prefix + "\tisMultiWindowMode:" + isMultiWindowMode); |
| 825 | |
| 826 | writer.println(prefix + pxToDpStr("windowX", windowX)); |
| 827 | writer.println(prefix + pxToDpStr("windowY", windowY)); |
| 828 | writer.println(prefix + pxToDpStr("widthPx", widthPx)); |
| 829 | writer.println(prefix + pxToDpStr("heightPx", heightPx)); |
| 830 | |
| 831 | writer.println(prefix + pxToDpStr("availableWidthPx", availableWidthPx)); |
| 832 | writer.println(prefix + pxToDpStr("availableHeightPx", availableHeightPx)); |
| 833 | |
| 834 | writer.println(prefix + "\taspectRatio:" + aspectRatio); |
| 835 | |
| 836 | writer.println(prefix + "\tisScalableGrid:" + isScalableGrid); |
| 837 | |
| 838 | writer.println(prefix + "\tinv.minCellWidth:" + inv.minCellWidth + "dp"); |
| 839 | writer.println(prefix + "\tinv.minCellHeight:" + inv.minCellHeight + "dp"); |
| 840 | |
| 841 | writer.println(prefix + pxToDpStr("cellWidthPx", cellWidthPx)); |
| 842 | writer.println(prefix + pxToDpStr("cellHeightPx", cellHeightPx)); |
| 843 | |
| 844 | writer.println(prefix + pxToDpStr("getCellSize().x", getCellSize().x)); |
| 845 | writer.println(prefix + pxToDpStr("getCellSize().y", getCellSize().y)); |
| 846 | |
| 847 | writer.println(prefix + "\tinv.iconSize:" + inv.iconSize + "dp"); |
| 848 | writer.println(prefix + pxToDpStr("iconSizePx", iconSizePx)); |
| 849 | writer.println(prefix + pxToDpStr("iconTextSizePx", iconTextSizePx)); |
| 850 | writer.println(prefix + pxToDpStr("iconDrawablePaddingPx", iconDrawablePaddingPx)); |
| 851 | |
| 852 | writer.println(prefix + pxToDpStr("folderCellWidthPx", folderCellWidthPx)); |
| 853 | writer.println(prefix + pxToDpStr("folderCellHeightPx", folderCellHeightPx)); |
| 854 | writer.println(prefix + pxToDpStr("folderChildIconSizePx", folderChildIconSizePx)); |
| 855 | writer.println(prefix + pxToDpStr("folderChildTextSizePx", folderChildTextSizePx)); |
| 856 | writer.println(prefix + pxToDpStr("folderChildDrawablePaddingPx", |
| 857 | folderChildDrawablePaddingPx)); |
| 858 | |
| 859 | writer.println(prefix + pxToDpStr("cellLayoutBorderSpacingPx", |
| 860 | cellLayoutBorderSpacingPx)); |
| 861 | writer.println(prefix + pxToDpStr("desiredWorkspaceLeftRightMarginPx", |
| 862 | desiredWorkspaceLeftRightMarginPx)); |
| 863 | |
| 864 | writer.println(prefix + pxToDpStr("allAppsIconSizePx", allAppsIconSizePx)); |
| 865 | writer.println(prefix + pxToDpStr("allAppsIconTextSizePx", allAppsIconTextSizePx)); |
| 866 | writer.println(prefix + pxToDpStr("allAppsIconDrawablePaddingPx", |
| 867 | allAppsIconDrawablePaddingPx)); |
| 868 | writer.println(prefix + pxToDpStr("allAppsCellHeightPx", allAppsCellHeightPx)); |
| 869 | |
| 870 | writer.println(prefix + pxToDpStr("hotseatBarSizePx", hotseatBarSizePx)); |
| 871 | writer.println(prefix + pxToDpStr("hotseatCellHeightPx", hotseatCellHeightPx)); |
| 872 | writer.println(prefix + pxToDpStr("hotseatBarTopPaddingPx", hotseatBarTopPaddingPx)); |
| 873 | writer.println(prefix + pxToDpStr("hotseatBarBottomPaddingPx", hotseatBarBottomPaddingPx)); |
| 874 | writer.println(prefix + pxToDpStr("hotseatBarSidePaddingStartPx", |
| 875 | hotseatBarSidePaddingStartPx)); |
| 876 | writer.println(prefix + pxToDpStr("hotseatBarSidePaddingEndPx", |
| 877 | hotseatBarSidePaddingEndPx)); |
| 878 | |
| 879 | writer.println(prefix + "\tisTaskbarPresent:" + isTaskbarPresent); |
| 880 | |
| 881 | writer.println(prefix + pxToDpStr("taskbarSize", taskbarSize)); |
| 882 | writer.println(prefix + pxToDpStr("nonOverlappingTaskbarInset", |
| 883 | nonOverlappingTaskbarInset)); |
| 884 | |
| 885 | writer.println(prefix + pxToDpStr("workspacePadding.left", workspacePadding.left)); |
| 886 | writer.println(prefix + pxToDpStr("workspacePadding.top", workspacePadding.top)); |
| 887 | writer.println(prefix + pxToDpStr("workspacePadding.right", workspacePadding.right)); |
| 888 | writer.println(prefix + pxToDpStr("workspacePadding.bottom", workspacePadding.bottom)); |
| 889 | |
| 890 | writer.println(prefix + pxToDpStr("extraSpace", extraSpace)); |
| 891 | writer.println(prefix + pxToDpStr("workspaceTopPadding", workspaceTopPadding)); |
| 892 | writer.println(prefix + pxToDpStr("workspaceBottomPadding", workspaceBottomPadding)); |
| 893 | writer.println(prefix + pxToDpStr("extraHotseatBottomPadding", extraHotseatBottomPadding)); |
| 894 | } |
| 895 | |
Sunny Goyal | fd58da6 | 2020-08-11 12:06:49 -0700 | [diff] [blame] | 896 | private static Context getContext(Context c, Info info, int orientation) { |
Sunny Goyal | 1890f67 | 2020-04-30 12:28:00 -0700 | [diff] [blame] | 897 | Configuration config = new Configuration(c.getResources().getConfiguration()); |
| 898 | config.orientation = orientation; |
| 899 | config.densityDpi = info.metrics.densityDpi; |
| 900 | return c.createConfigurationContext(config); |
Jon Miranda | b28c4fc | 2017-06-20 10:58:36 -0700 | [diff] [blame] | 901 | } |
Sunny Goyal | fde5505 | 2018-02-01 14:46:13 -0800 | [diff] [blame] | 902 | |
| 903 | /** |
| 904 | * Callback when a component changes the DeviceProfile associated with it, as a result of |
| 905 | * configuration change |
| 906 | */ |
| 907 | public interface OnDeviceProfileChangeListener { |
| 908 | |
| 909 | /** |
| 910 | * Called when the device profile is reassigned. Note that for layout and measurements, it |
| 911 | * is sufficient to listen for inset changes. Use this callback when you need to perform |
| 912 | * a one time operation. |
| 913 | */ |
| 914 | void onDeviceProfileChanged(DeviceProfile dp); |
| 915 | } |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 916 | |
| 917 | public static class Builder { |
| 918 | private Context mContext; |
| 919 | private InvariantDeviceProfile mInv; |
Sunny Goyal | fd58da6 | 2020-08-11 12:06:49 -0700 | [diff] [blame] | 920 | private Info mInfo; |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 921 | |
Sunny Goyal | 0addbf0 | 2020-04-28 14:17:35 -0700 | [diff] [blame] | 922 | private final Point mWindowPosition = new Point(); |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 923 | private Point mMinSize, mMaxSize; |
| 924 | private int mWidth, mHeight; |
| 925 | |
| 926 | private boolean mIsLandscape; |
| 927 | private boolean mIsMultiWindowMode = false; |
| 928 | private boolean mTransposeLayoutWithOrientation; |
| 929 | |
Sunny Goyal | fd58da6 | 2020-08-11 12:06:49 -0700 | [diff] [blame] | 930 | public Builder(Context context, InvariantDeviceProfile inv, Info info) { |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 931 | mContext = context; |
| 932 | mInv = inv; |
| 933 | mInfo = info; |
| 934 | mTransposeLayoutWithOrientation = context.getResources() |
| 935 | .getBoolean(R.bool.hotseat_transpose_layout_with_orientation); |
| 936 | } |
| 937 | |
| 938 | public Builder setSizeRange(Point minSize, Point maxSize) { |
| 939 | mMinSize = minSize; |
| 940 | mMaxSize = maxSize; |
| 941 | return this; |
| 942 | } |
| 943 | |
| 944 | public Builder setSize(int width, int height) { |
| 945 | mWidth = width; |
| 946 | mHeight = height; |
| 947 | mIsLandscape = mWidth > mHeight; |
| 948 | return this; |
| 949 | } |
| 950 | |
| 951 | public Builder setMultiWindowMode(boolean isMultiWindowMode) { |
| 952 | mIsMultiWindowMode = isMultiWindowMode; |
| 953 | return this; |
| 954 | } |
| 955 | |
Sunny Goyal | 0addbf0 | 2020-04-28 14:17:35 -0700 | [diff] [blame] | 956 | /** |
| 957 | * Sets the window position if not full-screen |
| 958 | */ |
| 959 | public Builder setWindowPosition(int x, int y) { |
| 960 | mWindowPosition.set(x, y); |
| 961 | return this; |
| 962 | } |
| 963 | |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 964 | public Builder setTransposeLayoutWithOrientation(boolean transposeLayoutWithOrientation) { |
| 965 | mTransposeLayoutWithOrientation = transposeLayoutWithOrientation; |
| 966 | return this; |
| 967 | } |
| 968 | |
| 969 | public DeviceProfile build() { |
| 970 | return new DeviceProfile(mContext, mInv, mInfo, mMinSize, mMaxSize, |
| 971 | mWidth, mHeight, mIsLandscape, mIsMultiWindowMode, |
Sunny Goyal | 0addbf0 | 2020-04-28 14:17:35 -0700 | [diff] [blame] | 972 | mTransposeLayoutWithOrientation, mWindowPosition); |
Sunny Goyal | 0e7a338 | 2020-04-13 17:15:05 -0700 | [diff] [blame] | 973 | } |
| 974 | } |
| 975 | |
Winson Chung | b380024 | 2013-10-24 11:01:54 -0700 | [diff] [blame] | 976 | } |