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