blob: 7919d293586f562c0cdae95e51cf24b81db36033 [file] [log] [blame]
Winson Chungb3800242013-10-24 11:01:54 -07001/*
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
17package com.android.launcher3;
18
19import android.appwidget.AppWidgetHostView;
20import android.content.ComponentName;
21import android.content.Context;
Jon Mirandab28c4fc2017-06-20 10:58:36 -070022import android.content.res.Configuration;
Winson Chungb3800242013-10-24 11:01:54 -070023import android.content.res.Resources;
Winson Chungb3800242013-10-24 11:01:54 -070024import android.graphics.Point;
Jon Miranda7ae64ff2016-11-21 16:18:46 -080025import android.graphics.PointF;
Winson Chungb3800242013-10-24 11:01:54 -070026import android.graphics.Rect;
27import android.util.DisplayMetrics;
Sunny Goyal59d086c2018-05-07 17:31:40 -070028import android.view.Surface;
Jon Miranda0128d3f2019-02-14 09:19:31 -080029import android.view.View;
Sunny Goyal59d086c2018-05-07 17:31:40 -070030import android.view.WindowManager;
Winson Chungb3800242013-10-24 11:01:54 -070031
Sunny Goyalc13403c2016-11-18 23:44:48 -080032import com.android.launcher3.CellLayout.ContainerType;
Tony Wickham8912b042018-11-29 15:28:53 -080033import com.android.launcher3.icons.DotRenderer;
Hyunyoung Song48cb7bc2018-09-25 17:03:34 -070034import com.android.launcher3.icons.IconNormalizer;
Winson1f064272016-07-18 17:18:02 -070035
Jon Miranda0128d3f2019-02-14 09:19:31 -080036import static com.android.launcher3.LauncherSettings.Favorites.CONTAINER_HOTSEAT;
37
Winson Chungb3800242013-10-24 11:01:54 -070038public class DeviceProfile {
Adam Cohen2e6da152015-05-06 11:42:25 -070039
Adam Cohen2e6da152015-05-06 11:42:25 -070040 public final InvariantDeviceProfile inv;
Winson Chungbe876472014-05-14 14:15:20 -070041
Sunny Goyalc6205602015-05-21 20:46:33 -070042 // Device properties
43 public final boolean isTablet;
44 public final boolean isLargeTablet;
45 public final boolean isPhone;
46 public final boolean transposeLayoutWithOrientation;
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -070047
Sunny Goyalc6205602015-05-21 20:46:33 -070048 // Device properties in current orientation
Sunny Goyald792a772018-04-05 13:37:46 -070049 public final boolean isLandscape;
Sunny Goyald70e75a2018-02-22 10:07:32 -080050 public final boolean isMultiWindowMode;
51
Sunny Goyalc6205602015-05-21 20:46:33 -070052 public final int widthPx;
53 public final int heightPx;
54 public final int availableWidthPx;
55 public final int availableHeightPx;
Tony Wickhamd6b40372015-09-23 18:37:57 -070056 /**
57 * The maximum amount of left/right workspace padding as a percentage of the screen width.
58 * To be clear, this means that up to 7% of the screen width can be used as left padding, and
59 * 7% of the screen width can be used as right padding.
60 */
61 private static final float MAX_HORIZONTAL_PADDING_PERCENT = 0.14f;
Winson Chungb3800242013-10-24 11:01:54 -070062
Jon Miranda3f9bab22017-07-28 14:50:17 -070063 private static final float TALL_DEVICE_ASPECT_RATIO_THRESHOLD = 2.0f;
Jon Miranda30d0aa22017-07-25 15:55:29 -070064
Jon Miranda5eacbb72018-07-31 11:14:46 -070065 // To evenly space the icons, increase the left/right margins for tablets in portrait mode.
66 private static final int PORTRAIT_TABLET_LEFT_RIGHT_PADDING_MULTIPLIER = 4;
67
Sunny Goyalc6205602015-05-21 20:46:33 -070068 // Workspace
Sunny Goyal07b69292018-01-08 14:19:34 -080069 public final int desiredWorkspaceLeftRightMarginPx;
Jon Miranda28032002017-07-13 16:18:56 -070070 public final int cellLayoutPaddingLeftRightPx;
Jon Miranda18751b62017-07-31 17:25:27 -070071 public final int cellLayoutBottomPaddingPx;
Sunny Goyalc6205602015-05-21 20:46:33 -070072 public final int edgeMarginPx;
73 public final Rect defaultWidgetPadding;
Sunny Goyal07b69292018-01-08 14:19:34 -080074 public final int defaultPageSpacingPx;
Sunny Goyal47328fd2016-05-25 18:56:41 -070075 private final int topWorkspacePadding;
Sunny Goyal47328fd2016-05-25 18:56:41 -070076 public float workspaceSpringLoadShrinkFactor;
77 public final int workspaceSpringLoadedBottomSpace;
Sunny Goyalc6205602015-05-21 20:46:33 -070078
Sunny Goyal08ef6672018-05-10 11:32:00 -070079 // Drag handle
80 public final int verticalDragHandleSizePx;
Jon Miranda7e183c32018-06-20 11:05:27 -070081 private final int verticalDragHandleOverlapWorkspace;
Winson1f064272016-07-18 17:18:02 -070082
Sunny Goyalc6205602015-05-21 20:46:33 -070083 // Workspace icons
84 public int iconSizePx;
85 public int iconTextSizePx;
86 public int iconDrawablePaddingPx;
Winson Chung5f4e0fd2015-05-22 11:12:27 -070087 public int iconDrawablePaddingOriginalPx;
Winson Chungb3800242013-10-24 11:01:54 -070088
Adam Cohen59400422014-03-05 18:07:04 -080089 public int cellWidthPx;
90 public int cellHeightPx;
Jon Mirandab28c4fc2017-06-20 10:58:36 -070091 public int workspaceCellPaddingXPx;
Adam Cohen59400422014-03-05 18:07:04 -080092
Sunny Goyalc6205602015-05-21 20:46:33 -070093 // Folder
Sunny Goyalc6205602015-05-21 20:46:33 -070094 public int folderIconSizePx;
Jon Miranda591e3602018-03-28 11:37:00 -070095 public int folderIconOffsetYPx;
Jon Mirandabf7d8122016-11-03 15:29:29 -070096
97 // Folder cell
Sunny Goyalc6205602015-05-21 20:46:33 -070098 public int folderCellWidthPx;
99 public int folderCellHeightPx;
Jon Mirandabf7d8122016-11-03 15:29:29 -0700100
101 // Folder child
102 public int folderChildIconSizePx;
103 public int folderChildTextSizePx;
Sunny Goyalbaec6ff2016-09-14 11:26:21 -0700104 public int folderChildDrawablePaddingPx;
Winson Chungb3800242013-10-24 11:01:54 -0700105
Miranda Kephart1a359a22019-02-11 13:07:04 -0500106 // Hints
107 public int chipHintHeightPx;
108 public int chipHintBottomMarginPx;
109
Sunny Goyalc6205602015-05-21 20:46:33 -0700110 // Hotseat
Sunny Goyalc6205602015-05-21 20:46:33 -0700111 public int hotseatCellHeightPx;
Jon Miranda18751b62017-07-31 17:25:27 -0700112 // In portrait: size = height, in landscape: size = width
113 public int hotseatBarSizePx;
Sunny Goyal07b69292018-01-08 14:19:34 -0800114 public final int hotseatBarTopPaddingPx;
Jon Miranda7e183c32018-06-20 11:05:27 -0700115 public int hotseatBarBottomPaddingPx;
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700116 // Start is the side next to the nav bar, end is the side next to the workspace
117 public final int hotseatBarSidePaddingStartPx;
118 public final int hotseatBarSidePaddingEndPx;
Adam Cohen2e6da152015-05-06 11:42:25 -0700119
Sunny Goyalc6205602015-05-21 20:46:33 -0700120 // All apps
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700121 public int allAppsCellHeightPx;
Winson1f064272016-07-18 17:18:02 -0700122 public int allAppsIconSizePx;
123 public int allAppsIconDrawablePaddingPx;
124 public float allAppsIconTextSizePx;
125
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800126 // Widgets
127 public final PointF appWidgetScale = new PointF(1.0f, 1.0f);
128
Sunny Goyal47328fd2016-05-25 18:56:41 -0700129 // Drop Target
130 public int dropTargetBarSizePx;
Adam Cohen4ae96ce2014-08-29 15:05:48 -0700131
Winson1f064272016-07-18 17:18:02 -0700132 // Insets
Sunny Goyal07b69292018-01-08 14:19:34 -0800133 private final Rect mInsets = new Rect();
134 public final Rect workspacePadding = new Rect();
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700135 private final Rect mHotseatPadding = new Rect();
Jon Miranda0bd63d12019-03-06 17:29:29 -0800136 // When true, nav bar is on the left side of the screen.
Sunny Goyal59d086c2018-05-07 17:31:40 -0700137 private boolean mIsSeascape;
Winson1f064272016-07-18 17:18:02 -0700138
Tony Wickhamf34bee82018-12-03 18:11:39 -0800139 // Notification dots
Tony Wickham8912b042018-11-29 15:28:53 -0800140 public DotRenderer mDotRenderer;
Tony Wickham9a8d11f2017-01-11 09:53:12 -0800141
Sunny Goyalc6205602015-05-21 20:46:33 -0700142 public DeviceProfile(Context context, InvariantDeviceProfile inv,
143 Point minSize, Point maxSize,
Sunny Goyald70e75a2018-02-22 10:07:32 -0800144 int width, int height, boolean isLandscape, boolean isMultiWindowMode) {
Sunny Goyalfee35bb2015-05-11 11:38:19 -0700145
Adam Cohen2e6da152015-05-06 11:42:25 -0700146 this.inv = inv;
Sunny Goyalc6205602015-05-21 20:46:33 -0700147 this.isLandscape = isLandscape;
Sunny Goyald70e75a2018-02-22 10:07:32 -0800148 this.isMultiWindowMode = isMultiWindowMode;
Winson Chungb3800242013-10-24 11:01:54 -0700149
Jon Miranda7e183c32018-06-20 11:05:27 -0700150 // Determine sizes.
151 widthPx = width;
152 heightPx = height;
153 if (isLandscape) {
154 availableWidthPx = maxSize.x;
155 availableHeightPx = minSize.y;
156 } else {
157 availableWidthPx = minSize.x;
158 availableHeightPx = maxSize.y;
159 }
160
Adam Cohen2e6da152015-05-06 11:42:25 -0700161 Resources res = context.getResources();
Winson Chungb3800242013-10-24 11:01:54 -0700162 DisplayMetrics dm = res.getDisplayMetrics();
Adam Cohen2e6da152015-05-06 11:42:25 -0700163
Sunny Goyalc6205602015-05-21 20:46:33 -0700164 // Constants from resources
165 isTablet = res.getBoolean(R.bool.is_tablet);
166 isLargeTablet = res.getBoolean(R.bool.is_large_tablet);
167 isPhone = !isTablet && !isLargeTablet;
Jon Miranda7e183c32018-06-20 11:05:27 -0700168 float aspectRatio = ((float) Math.max(widthPx, heightPx)) / Math.min(widthPx, heightPx);
169 boolean isTallDevice = Float.compare(aspectRatio, TALL_DEVICE_ASPECT_RATIO_THRESHOLD) >= 0;
Sunny Goyalc6205602015-05-21 20:46:33 -0700170
171 // Some more constants
Winson Chungb3800242013-10-24 11:01:54 -0700172 transposeLayoutWithOrientation =
173 res.getBoolean(R.bool.hotseat_transpose_layout_with_orientation);
Winson Chungb3800242013-10-24 11:01:54 -0700174
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700175 context = getContext(context, isVerticalBarLayout()
176 ? Configuration.ORIENTATION_LANDSCAPE
177 : Configuration.ORIENTATION_PORTRAIT);
178 res = context.getResources();
179
180
Winson Chungb3800242013-10-24 11:01:54 -0700181 ComponentName cn = new ComponentName(context.getPackageName(),
182 this.getClass().getName());
183 defaultWidgetPadding = AppWidgetHostView.getDefaultPaddingForWidget(context, cn, null);
184 edgeMarginPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_edge_margin);
Jon Miranda28032002017-07-13 16:18:56 -0700185 desiredWorkspaceLeftRightMarginPx = isVerticalBarLayout() ? 0 : edgeMarginPx;
Jon Miranda5eacbb72018-07-31 11:14:46 -0700186 int cellLayoutPaddingLeftRightMultiplier = !isVerticalBarLayout() && isTablet
187 ? PORTRAIT_TABLET_LEFT_RIGHT_PADDING_MULTIPLIER : 1;
188 cellLayoutPaddingLeftRightPx = cellLayoutPaddingLeftRightMultiplier *
Jon Miranda30d0aa22017-07-25 15:55:29 -0700189 res.getDimensionPixelSize(R.dimen.dynamic_grid_cell_layout_padding);
Jon Miranda18751b62017-07-31 17:25:27 -0700190 cellLayoutBottomPaddingPx =
191 res.getDimensionPixelSize(R.dimen.dynamic_grid_cell_layout_bottom_padding);
Sunny Goyal08ef6672018-05-10 11:32:00 -0700192 verticalDragHandleSizePx = res.getDimensionPixelSize(
193 R.dimen.vertical_drag_handle_size);
Jon Miranda7e183c32018-06-20 11:05:27 -0700194 verticalDragHandleOverlapWorkspace =
195 res.getDimensionPixelSize(R.dimen.vertical_drag_handle_overlap_workspace);
Winson Chungb3800242013-10-24 11:01:54 -0700196 defaultPageSpacingPx =
197 res.getDimensionPixelSize(R.dimen.dynamic_grid_workspace_page_spacing);
Sunny Goyal47328fd2016-05-25 18:56:41 -0700198 topWorkspacePadding =
199 res.getDimensionPixelSize(R.dimen.dynamic_grid_workspace_top_padding);
Winson Chungb3800242013-10-24 11:01:54 -0700200 iconDrawablePaddingOriginalPx =
201 res.getDimensionPixelSize(R.dimen.dynamic_grid_icon_drawable_padding);
Sunny Goyal47328fd2016-05-25 18:56:41 -0700202 dropTargetBarSizePx = res.getDimensionPixelSize(R.dimen.dynamic_grid_drop_target_size);
203 workspaceSpringLoadedBottomSpace =
204 res.getDimensionPixelSize(R.dimen.dynamic_grid_min_spring_loaded_space);
Sunny Goyald5190522017-04-24 03:06:54 -0700205
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700206 workspaceCellPaddingXPx = res.getDimensionPixelSize(R.dimen.dynamic_grid_cell_padding_x);
Jon Miranda09660722017-06-14 14:20:14 -0700207
Miranda Kephart1a359a22019-02-11 13:07:04 -0500208 chipHintHeightPx = res.getDimensionPixelSize(R.dimen.chip_hint_height);
209 chipHintBottomMarginPx = res.getDimensionPixelSize(R.dimen.chip_hint_bottom_margin);
210
Winson1f064272016-07-18 17:18:02 -0700211 hotseatBarTopPaddingPx =
212 res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_top_padding);
Jon Miranda7e183c32018-06-20 11:05:27 -0700213 hotseatBarBottomPaddingPx = (isTallDevice ? 0
214 : res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_bottom_non_tall_padding))
215 + res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_bottom_padding);
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700216 hotseatBarSidePaddingEndPx =
Sunny Goyal228153d2018-01-04 15:35:22 -0800217 res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_side_padding);
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700218 // Add a bit of space between nav bar and hotseat in multi-window vertical bar layout.
219 hotseatBarSidePaddingStartPx = isMultiWindowMode && isVerticalBarLayout()
220 ? edgeMarginPx : 0;
Sunny Goyal415f1732018-11-29 10:33:47 -0800221 hotseatBarSizePx = Utilities.pxFromDp(inv.iconSize, dm) + (isVerticalBarLayout()
222 ? (hotseatBarSidePaddingStartPx + hotseatBarSidePaddingEndPx)
223 : (res.getDimensionPixelSize(R.dimen.dynamic_grid_hotseat_extra_vertical_size)
224 + hotseatBarTopPaddingPx + hotseatBarBottomPaddingPx));
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700225
Jon Miranda2ed276e2017-06-29 11:36:34 -0700226 // Calculate all of the remaining variables.
Sunny Goyalc6205602015-05-21 20:46:33 -0700227 updateAvailableDimensions(dm, res);
Jon Miranda2ed276e2017-06-29 11:36:34 -0700228
229 // Now that we have all of the variables calculated, we can tune certain sizes.
Jon Miranda30d0aa22017-07-25 15:55:29 -0700230 if (!isVerticalBarLayout() && isPhone && isTallDevice) {
Jon Miranda3f9bab22017-07-28 14:50:17 -0700231 // We increase the hotseat size when there is extra space.
Jon Miranda2ed276e2017-06-29 11:36:34 -0700232 // ie. For a display with a large aspect ratio, we can keep the icons on the workspace
Jon Miranda3f9bab22017-07-28 14:50:17 -0700233 // in portrait mode closer together by adding more height to the hotseat.
Jon Miranda30d0aa22017-07-25 15:55:29 -0700234 // Note: This calculation was created after noticing a pattern in the design spec.
Jon Miranda7e183c32018-06-20 11:05:27 -0700235 int extraSpace = getCellSize().y - iconSizePx - iconDrawablePaddingPx * 2
236 - verticalDragHandleSizePx;
237 hotseatBarSizePx += extraSpace;
238 hotseatBarBottomPaddingPx += extraSpace;
Jon Miranda30d0aa22017-07-25 15:55:29 -0700239
Jon Miranda3f9bab22017-07-28 14:50:17 -0700240 // Recalculate the available dimensions using the new hotseat size.
Jon Miranda30d0aa22017-07-25 15:55:29 -0700241 updateAvailableDimensions(dm, res);
Jon Miranda2ed276e2017-06-29 11:36:34 -0700242 }
Sunny Goyal07b69292018-01-08 14:19:34 -0800243 updateWorkspacePadding();
Tony Wickham1237df02017-02-24 08:59:36 -0800244
245 // This is done last, after iconSizePx is calculated above.
Tony Wickham8912b042018-11-29 15:28:53 -0800246 mDotRenderer = new DotRenderer(iconSizePx);
Adam Cohen63f1ec02014-08-12 09:23:13 -0700247 }
248
Sunny Goyal1a52ef52018-01-11 10:15:03 -0800249 public DeviceProfile copy(Context context) {
250 Point size = new Point(availableWidthPx, availableHeightPx);
Sunny Goyald70e75a2018-02-22 10:07:32 -0800251 return new DeviceProfile(context, inv, size, size, widthPx, heightPx, isLandscape,
252 isMultiWindowMode);
Sunny Goyal1a52ef52018-01-11 10:15:03 -0800253 }
254
Winson Chung2fda6ce2018-01-31 14:09:49 -0800255 public DeviceProfile getMultiWindowProfile(Context context, Point mwSize) {
Jon Mirandaa11380d2017-08-24 11:30:03 -0700256 // We take the minimum sizes of this profile and it's multi-window variant to ensure that
257 // the system decor is always excluded.
258 mwSize.set(Math.min(availableWidthPx, mwSize.x), Math.min(availableHeightPx, mwSize.y));
259
Jon Mirandacc42c5b2016-10-27 17:15:27 -0700260 // In multi-window mode, we can have widthPx = availableWidthPx
261 // and heightPx = availableHeightPx because Launcher uses the InvariantDeviceProfiles'
262 // widthPx and heightPx values where it's needed.
Jon Miranda93e1f042016-11-11 14:13:04 -0800263 DeviceProfile profile = new DeviceProfile(context, inv, mwSize, mwSize, mwSize.x, mwSize.y,
Sunny Goyald70e75a2018-02-22 10:07:32 -0800264 isLandscape, true);
Jon Miranda93e1f042016-11-11 14:13:04 -0800265
Jon Miranda0cd04572017-09-19 11:31:42 -0700266 // If there isn't enough vertical cell padding with the labels displayed, hide the labels.
267 float workspaceCellPaddingY = profile.getCellSize().y - profile.iconSizePx
268 - iconDrawablePaddingPx - profile.iconTextSizePx;
269 if (workspaceCellPaddingY < profile.iconDrawablePaddingPx * 2) {
270 profile.adjustToHideWorkspaceLabels();
271 }
Jon Miranda93e1f042016-11-11 14:13:04 -0800272
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800273 // We use these scales to measure and layout the widgets using their full invariant profile
274 // sizes and then draw them scaled and centered to fit in their multi-window mode cellspans.
275 float appWidgetScaleX = (float) profile.getCellSize().x / getCellSize().x;
276 float appWidgetScaleY = (float) profile.getCellSize().y / getCellSize().y;
277 profile.appWidgetScale.set(appWidgetScaleX, appWidgetScaleY);
Sunny Goyal07b69292018-01-08 14:19:34 -0800278 profile.updateWorkspacePadding();
Jon Miranda7ae64ff2016-11-21 16:18:46 -0800279
Jon Miranda93e1f042016-11-11 14:13:04 -0800280 return profile;
Jon Mirandacc42c5b2016-10-27 17:15:27 -0700281 }
282
Adam Cohen63f1ec02014-08-12 09:23:13 -0700283 /**
Sunny Goyal2e2e2b42018-02-27 16:52:55 -0800284 * Inverse of {@link #getMultiWindowProfile(Context, Point)}
285 * @return device profile corresponding to the current orientation in non multi-window mode.
286 */
287 public DeviceProfile getFullScreenProfile() {
288 return isLandscape ? inv.landscapeProfile : inv.portraitProfile;
289 }
290
291 /**
Jon Miranda1091e532017-07-21 13:31:50 -0700292 * Adjusts the profile so that the labels on the Workspace are hidden.
293 * It is important to call this method after the All Apps variables have been set.
294 */
295 private void adjustToHideWorkspaceLabels() {
296 iconTextSizePx = 0;
297 iconDrawablePaddingPx = 0;
298 cellHeightPx = iconSizePx;
299
300 // In normal cases, All Apps cell height should equal the Workspace cell height.
301 // Since we are removing labels from the Workspace, we need to manually compute the
302 // All Apps cell height.
Jon Miranda3f9bab22017-07-28 14:50:17 -0700303 int topBottomPadding = allAppsIconDrawablePaddingPx * (isVerticalBarLayout() ? 2 : 1);
Jon Miranda1091e532017-07-21 13:31:50 -0700304 allAppsCellHeightPx = allAppsIconSizePx + allAppsIconDrawablePaddingPx
305 + Utilities.calculateTextHeight(allAppsIconTextSizePx)
Jon Miranda3f9bab22017-07-28 14:50:17 -0700306 + topBottomPadding * 2;
Jon Miranda1091e532017-07-21 13:31:50 -0700307 }
308
Sunny Goyalc6205602015-05-21 20:46:33 -0700309 private void updateAvailableDimensions(DisplayMetrics dm, Resources res) {
Jon Miranda09660722017-06-14 14:20:14 -0700310 updateIconSize(1f, res, dm);
Winson Chung59a488a2013-12-10 12:32:14 -0800311
Jon Mirandabf7d8122016-11-03 15:29:29 -0700312 // Check to see if the icons fit within the available height. If not, then scale down.
313 float usedHeight = (cellHeightPx * inv.numRows);
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700314 int maxHeight = (availableHeightPx - getTotalWorkspacePadding().y);
Winson Chungb3800242013-10-24 11:01:54 -0700315 if (usedHeight > maxHeight) {
Jon Mirandabf7d8122016-11-03 15:29:29 -0700316 float scale = maxHeight / usedHeight;
Jon Miranda09660722017-06-14 14:20:14 -0700317 updateIconSize(scale, res, dm);
Winson Chungb3800242013-10-24 11:01:54 -0700318 }
Jon Mirandabf7d8122016-11-03 15:29:29 -0700319 updateAvailableFolderCellDimensions(dm, res);
Winson Chungb3800242013-10-24 11:01:54 -0700320 }
321
Jon Miranda09660722017-06-14 14:20:14 -0700322 private void updateIconSize(float scale, Resources res, DisplayMetrics dm) {
Jon Miranda18751b62017-07-31 17:25:27 -0700323 // Workspace
Sunny Goyal07b69292018-01-08 14:19:34 -0800324 final boolean isVerticalLayout = isVerticalBarLayout();
325 float invIconSizePx = isVerticalLayout ? inv.landscapeIconSize : inv.iconSize;
Sunny Goyal238124e2019-02-20 23:08:36 -0800326 iconSizePx = Math.max(1, (int) (Utilities.pxFromDp(invIconSizePx, dm) * scale));
Sunny Goyala50a4192015-12-11 09:50:49 -0800327 iconTextSizePx = (int) (Utilities.pxFromSp(inv.iconTextSize, dm) * scale);
Jon Miranda09660722017-06-14 14:20:14 -0700328 iconDrawablePaddingPx = (int) (iconDrawablePaddingOriginalPx * scale);
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700329
Jon Miranda18751b62017-07-31 17:25:27 -0700330 cellHeightPx = iconSizePx + iconDrawablePaddingPx
331 + Utilities.calculateTextHeight(iconTextSizePx);
Jon Miranda846455e2017-10-02 14:58:52 -0700332 int cellYPadding = (getCellSize().y - cellHeightPx) / 2;
Sunny Goyal07b69292018-01-08 14:19:34 -0800333 if (iconDrawablePaddingPx > cellYPadding && !isVerticalLayout
Sunny Goyald70e75a2018-02-22 10:07:32 -0800334 && !isMultiWindowMode) {
Jon Miranda846455e2017-10-02 14:58:52 -0700335 // Ensures that the label is closer to its corresponding icon. This is not an issue
336 // with vertical bar layout or multi-window mode since the issue is handled separately
337 // with their calls to {@link #adjustToHideWorkspaceLabels}.
338 cellHeightPx -= (iconDrawablePaddingPx - cellYPadding);
339 iconDrawablePaddingPx = cellYPadding;
340 }
341 cellWidthPx = iconSizePx + iconDrawablePaddingPx;
Jon Miranda18751b62017-07-31 17:25:27 -0700342
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700343 // All apps
344 allAppsIconTextSizePx = iconTextSizePx;
Winson1f064272016-07-18 17:18:02 -0700345 allAppsIconSizePx = iconSizePx;
346 allAppsIconDrawablePaddingPx = iconDrawablePaddingPx;
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700347 allAppsCellHeightPx = getCellSize().y;
348
Sunny Goyal07b69292018-01-08 14:19:34 -0800349 if (isVerticalLayout) {
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700350 // Always hide the Workspace text with vertical bar layout.
Jon Miranda1091e532017-07-21 13:31:50 -0700351 adjustToHideWorkspaceLabels();
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700352 }
Winson Chungb3800242013-10-24 11:01:54 -0700353
Winson Chungb3800242013-10-24 11:01:54 -0700354 // Hotseat
Sunny Goyal07b69292018-01-08 14:19:34 -0800355 if (isVerticalLayout) {
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700356 hotseatBarSizePx = iconSizePx + hotseatBarSidePaddingStartPx
357 + hotseatBarSidePaddingEndPx;
Jon Miranda18751b62017-07-31 17:25:27 -0700358 }
Jon Miranda5044c352017-08-09 11:37:59 -0700359 hotseatCellHeightPx = iconSizePx;
Winson Chungb3800242013-10-24 11:01:54 -0700360
Sunny Goyal07b69292018-01-08 14:19:34 -0800361 if (!isVerticalLayout) {
Jon Miranda18751b62017-07-31 17:25:27 -0700362 int expectedWorkspaceHeight = availableHeightPx - hotseatBarSizePx
Sunny Goyal08ef6672018-05-10 11:32:00 -0700363 - verticalDragHandleSizePx - topWorkspacePadding;
Sunny Goyal47328fd2016-05-25 18:56:41 -0700364 float minRequiredHeight = dropTargetBarSizePx + workspaceSpringLoadedBottomSpace;
365 workspaceSpringLoadShrinkFactor = Math.min(
366 res.getInteger(R.integer.config_workspaceSpringLoadShrinkPercentage) / 100.0f,
367 1 - (minRequiredHeight / expectedWorkspaceHeight));
368 } else {
369 workspaceSpringLoadShrinkFactor =
370 res.getInteger(R.integer.config_workspaceSpringLoadShrinkPercentage) / 100.0f;
371 }
372
Sunny Goyalbaec6ff2016-09-14 11:26:21 -0700373 // Folder icon
Jon Miranda591e3602018-03-28 11:37:00 -0700374 folderIconSizePx = IconNormalizer.getNormalizedCircleSize(iconSizePx);
375 folderIconOffsetYPx = (iconSizePx - folderIconSizePx) / 2;
Winson Chung0f785722015-04-08 10:27:49 -0700376 }
377
Jon Mirandabf7d8122016-11-03 15:29:29 -0700378 private void updateAvailableFolderCellDimensions(DisplayMetrics dm, Resources res) {
379 int folderBottomPanelSize = res.getDimensionPixelSize(R.dimen.folder_label_padding_top)
380 + res.getDimensionPixelSize(R.dimen.folder_label_padding_bottom)
381 + Utilities.calculateTextHeight(res.getDimension(R.dimen.folder_label_text_size));
382
Jon Mirandac1b23992016-12-13 08:57:36 -0800383 updateFolderCellSize(1f, dm, res);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700384
Jon Mirandac1b23992016-12-13 08:57:36 -0800385 // Don't let the folder get too close to the edges of the screen.
Jon Miranda1786df32018-09-25 13:05:23 -0700386 int folderMargin = edgeMarginPx * 2;
Sunny Goyal07b69292018-01-08 14:19:34 -0800387 Point totalWorkspacePadding = getTotalWorkspacePadding();
Jon Mirandac1b23992016-12-13 08:57:36 -0800388
389 // Check if the icons fit within the available height.
390 float usedHeight = folderCellHeightPx * inv.numFolderRows + folderBottomPanelSize;
Sunny Goyal07b69292018-01-08 14:19:34 -0800391 int maxHeight = availableHeightPx - totalWorkspacePadding.y - folderMargin;
Jon Mirandac1b23992016-12-13 08:57:36 -0800392 float scaleY = maxHeight / usedHeight;
393
394 // Check if the icons fit within the available width.
395 float usedWidth = folderCellWidthPx * inv.numFolderColumns;
Sunny Goyal07b69292018-01-08 14:19:34 -0800396 int maxWidth = availableWidthPx - totalWorkspacePadding.x - folderMargin;
Jon Mirandac1b23992016-12-13 08:57:36 -0800397 float scaleX = maxWidth / usedWidth;
398
399 float scale = Math.min(scaleX, scaleY);
400 if (scale < 1f) {
401 updateFolderCellSize(scale, dm, res);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700402 }
403 }
404
Jon Mirandac1b23992016-12-13 08:57:36 -0800405 private void updateFolderCellSize(float scale, DisplayMetrics dm, Resources res) {
Jon Mirandabf7d8122016-11-03 15:29:29 -0700406 folderChildIconSizePx = (int) (Utilities.pxFromDp(inv.iconSize, dm) * scale);
407 folderChildTextSizePx =
408 (int) (res.getDimensionPixelSize(R.dimen.folder_child_text_size) * scale);
409
410 int textHeight = Utilities.calculateTextHeight(folderChildTextSizePx);
411 int cellPaddingX = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_x_padding) * scale);
412 int cellPaddingY = (int) (res.getDimensionPixelSize(R.dimen.folder_cell_y_padding) * scale);
413
Jon Mirandac1b23992016-12-13 08:57:36 -0800414 folderCellWidthPx = folderChildIconSizePx + 2 * cellPaddingX;
Jonathan Miranda9ad87462017-07-26 17:41:02 +0000415 folderCellHeightPx = folderChildIconSizePx + 2 * cellPaddingY + textHeight;
416 folderChildDrawablePaddingPx = Math.max(0,
417 (folderCellHeightPx - folderChildIconSizePx - textHeight) / 3);
Jon Mirandabf7d8122016-11-03 15:29:29 -0700418 }
419
Winson1f064272016-07-18 17:18:02 -0700420 public void updateInsets(Rect insets) {
421 mInsets.set(insets);
Sunny Goyal07b69292018-01-08 14:19:34 -0800422 updateWorkspacePadding();
Winson1f064272016-07-18 17:18:02 -0700423 }
424
Sunny Goyal1a52ef52018-01-11 10:15:03 -0800425 public Rect getInsets() {
426 return mInsets;
427 }
428
Sunny Goyal756cd262015-08-20 12:33:21 -0700429 public Point getCellSize() {
430 Point result = new Point();
431 // Since we are only concerned with the overall padding, layout direction does
432 // not matter.
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700433 Point padding = getTotalWorkspacePadding();
Jon Miranda18751b62017-07-31 17:25:27 -0700434 result.x = calculateCellWidth(availableWidthPx - padding.x
435 - cellLayoutPaddingLeftRightPx * 2, inv.numColumns);
436 result.y = calculateCellHeight(availableHeightPx - padding.y
437 - cellLayoutBottomPaddingPx, inv.numRows);
Sunny Goyal756cd262015-08-20 12:33:21 -0700438 return result;
439 }
440
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700441 public Point getTotalWorkspacePadding() {
Sunny Goyal07b69292018-01-08 14:19:34 -0800442 updateWorkspacePadding();
443 return new Point(workspacePadding.left + workspacePadding.right,
444 workspacePadding.top + workspacePadding.bottom);
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700445 }
446
447 /**
Sunny Goyal07b69292018-01-08 14:19:34 -0800448 * Updates {@link #workspacePadding} as a result of any internal value change to reflect the
449 * new workspace padding
Sunny Goyal6c2975e2016-07-06 09:47:56 -0700450 */
Sunny Goyal07b69292018-01-08 14:19:34 -0800451 private void updateWorkspacePadding() {
452 Rect padding = workspacePadding;
Tony Wickham3a3517f2015-10-06 11:27:04 -0700453 if (isVerticalBarLayout()) {
Sunny Goyal228153d2018-01-04 15:35:22 -0800454 padding.top = 0;
455 padding.bottom = edgeMarginPx;
Sunny Goyal7e2e67f2018-01-26 13:40:08 -0800456 if (isSeascape()) {
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700457 padding.left = hotseatBarSizePx;
458 padding.right = verticalDragHandleSizePx;
Winson1f064272016-07-18 17:18:02 -0700459 } else {
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700460 padding.left = verticalDragHandleSizePx;
461 padding.right = hotseatBarSizePx;
Winson1f064272016-07-18 17:18:02 -0700462 }
Winson Chungb3800242013-10-24 11:01:54 -0700463 } else {
Jon Miranda7e183c32018-06-20 11:05:27 -0700464 int paddingBottom = hotseatBarSizePx + verticalDragHandleSizePx
465 - verticalDragHandleOverlapWorkspace;
Sunny Goyalc6205602015-05-21 20:46:33 -0700466 if (isTablet) {
Winson Chungb3800242013-10-24 11:01:54 -0700467 // Pad the left and right of the workspace to ensure consistent spacing
468 // between all icons
Tony Wickhamd6b40372015-09-23 18:37:57 -0700469 // The amount of screen space available for left/right padding.
Sunny Goyal228153d2018-01-04 15:35:22 -0800470 int availablePaddingX = Math.max(0, widthPx - ((inv.numColumns * cellWidthPx) +
Sunny Goyalf5440cb2016-12-14 15:13:00 -0800471 ((inv.numColumns - 1) * cellWidthPx)));
Tony Wickhamd6b40372015-09-23 18:37:57 -0700472 availablePaddingX = (int) Math.min(availablePaddingX,
Sunny Goyal07b69292018-01-08 14:19:34 -0800473 widthPx * MAX_HORIZONTAL_PADDING_PERCENT);
Sunny Goyal228153d2018-01-04 15:35:22 -0800474 int availablePaddingY = Math.max(0, heightPx - topWorkspacePadding - paddingBottom
Jon Mirandac1b08c52016-11-15 14:37:56 -0800475 - (2 * inv.numRows * cellHeightPx) - hotseatBarTopPaddingPx
476 - hotseatBarBottomPaddingPx);
Sunny Goyal47328fd2016-05-25 18:56:41 -0700477 padding.set(availablePaddingX / 2, topWorkspacePadding + availablePaddingY / 2,
Tony Wickhamd6b40372015-09-23 18:37:57 -0700478 availablePaddingX / 2, paddingBottom + availablePaddingY / 2);
Winson Chungb3800242013-10-24 11:01:54 -0700479 } else {
480 // Pad the top and bottom of the workspace with search/hotseat bar sizes
Winson1f064272016-07-18 17:18:02 -0700481 padding.set(desiredWorkspaceLeftRightMarginPx,
Sunny Goyal47328fd2016-05-25 18:56:41 -0700482 topWorkspacePadding,
Winson1f064272016-07-18 17:18:02 -0700483 desiredWorkspaceLeftRightMarginPx,
Winsonfadbe8f2016-07-22 16:35:37 -0700484 paddingBottom);
Winson Chungb3800242013-10-24 11:01:54 -0700485 }
486 }
Winson Chungb3800242013-10-24 11:01:54 -0700487 }
488
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700489 public Rect getHotseatLayoutPadding() {
490 if (isVerticalBarLayout()) {
491 if (isSeascape()) {
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700492 mHotseatPadding.set(mInsets.left + hotseatBarSidePaddingStartPx,
493 mInsets.top, hotseatBarSidePaddingEndPx, mInsets.bottom);
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700494 } else {
Tony Wickham1eeffbe2018-06-12 15:01:15 -0700495 mHotseatPadding.set(hotseatBarSidePaddingEndPx, mInsets.top,
496 mInsets.right + hotseatBarSidePaddingStartPx, mInsets.bottom);
Sunny Goyal81b4c7b2018-03-26 12:10:31 -0700497 }
498 } else {
499
500 // We want the edges of the hotseat to line up with the edges of the workspace, but the
501 // icons in the hotseat are a different size, and so don't line up perfectly. To account
502 // for this, we pad the left and right of the hotseat with half of the difference of a
503 // workspace cell vs a hotseat cell.
504 float workspaceCellWidth = (float) widthPx / inv.numColumns;
505 float hotseatCellWidth = (float) widthPx / inv.numHotseatIcons;
506 int hotseatAdjustment = Math.round((workspaceCellWidth - hotseatCellWidth) / 2);
507 mHotseatPadding.set(
508 hotseatAdjustment + workspacePadding.left + cellLayoutPaddingLeftRightPx,
509 hotseatBarTopPaddingPx,
510 hotseatAdjustment + workspacePadding.right + cellLayoutPaddingLeftRightPx,
511 hotseatBarBottomPaddingPx + mInsets.bottom + cellLayoutBottomPaddingPx);
512 }
513 return mHotseatPadding;
514 }
515
Winsonfadbe8f2016-07-22 16:35:37 -0700516 /**
517 * @return the bounds for which the open folders should be contained within
518 */
519 public Rect getAbsoluteOpenFolderBounds() {
520 if (isVerticalBarLayout()) {
521 // Folders should only appear right of the drop target bar and left of the hotseat
522 return new Rect(mInsets.left + dropTargetBarSizePx + edgeMarginPx,
523 mInsets.top,
Jon Miranda18751b62017-07-31 17:25:27 -0700524 mInsets.left + availableWidthPx - hotseatBarSizePx - edgeMarginPx,
Winsonfadbe8f2016-07-22 16:35:37 -0700525 mInsets.top + availableHeightPx);
526 } else {
527 // Folders should only appear below the drop target bar and above the hotseat
Tony Wickhamb4b7e202018-01-12 17:39:24 -0800528 return new Rect(mInsets.left + edgeMarginPx,
Winsonfadbe8f2016-07-22 16:35:37 -0700529 mInsets.top + dropTargetBarSizePx + edgeMarginPx,
Tony Wickhamb4b7e202018-01-12 17:39:24 -0800530 mInsets.left + availableWidthPx - edgeMarginPx,
Jon Miranda18751b62017-07-31 17:25:27 -0700531 mInsets.top + availableHeightPx - hotseatBarSizePx
Sunny Goyal08ef6672018-05-10 11:32:00 -0700532 - verticalDragHandleSizePx - edgeMarginPx);
Winsonfadbe8f2016-07-22 16:35:37 -0700533 }
534 }
535
Adam Cohen2e6da152015-05-06 11:42:25 -0700536 public static int calculateCellWidth(int width, int countX) {
Winson Chungb3800242013-10-24 11:01:54 -0700537 return width / countX;
538 }
Adam Cohen2e6da152015-05-06 11:42:25 -0700539 public static int calculateCellHeight(int height, int countY) {
Winson Chungb3800242013-10-24 11:01:54 -0700540 return height / countY;
541 }
542
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -0700543 /**
Tony Wickham55616cd2015-09-23 14:55:17 -0700544 * When {@code true}, the device is in landscape mode and the hotseat is on the right column.
545 * When {@code false}, either device is in portrait mode or the device is in landscape mode and
546 * the hotseat is on the bottom row.
Hyunyoung Song18bfaaf2015-03-17 11:32:21 -0700547 */
Tony Wickhamab946a12015-09-16 15:38:16 -0700548 public boolean isVerticalBarLayout() {
Winson Chungb3800242013-10-24 11:01:54 -0700549 return isLandscape && transposeLayoutWithOrientation;
550 }
551
Sunny Goyal59d086c2018-05-07 17:31:40 -0700552 /**
553 * Updates orientation information and returns true if it has changed from the previous value.
554 */
555 public boolean updateIsSeascape(WindowManager wm) {
556 if (isVerticalBarLayout()) {
557 boolean isSeascape = wm.getDefaultDisplay().getRotation() == Surface.ROTATION_270;
558 if (mIsSeascape != isSeascape) {
559 mIsSeascape = isSeascape;
560 return true;
561 }
562 }
563 return false;
564 }
565
Sunny Goyal7e2e67f2018-01-26 13:40:08 -0800566 public boolean isSeascape() {
Sunny Goyal59d086c2018-05-07 17:31:40 -0700567 return isVerticalBarLayout() && mIsSeascape;
Sunny Goyal7e2e67f2018-01-26 13:40:08 -0800568 }
569
Sunny Goyal07b69292018-01-08 14:19:34 -0800570 public boolean shouldFadeAdjacentWorkspaceScreens() {
Sunny Goyalc6205602015-05-21 20:46:33 -0700571 return isVerticalBarLayout() || isLargeTablet;
Winson Chungb3800242013-10-24 11:01:54 -0700572 }
573
Sunny Goyalc13403c2016-11-18 23:44:48 -0800574 public int getCellHeight(@ContainerType int containerType) {
575 switch (containerType) {
576 case CellLayout.WORKSPACE:
577 return cellHeightPx;
578 case CellLayout.FOLDER:
579 return folderCellHeightPx;
580 case CellLayout.HOTSEAT:
581 return hotseatCellHeightPx;
582 default:
583 // ??
584 return 0;
585 }
586 }
Sunny Goyal13178ac2016-04-04 16:35:22 -0700587
Jon Miranda0128d3f2019-02-14 09:19:31 -0800588 /**
589 * Gets an item's location on the home screen. This is useful if the home screen
590 * is animating, otherwise use {@link View#getLocationOnScreen(int[])}.
Jon Miranda0128d3f2019-02-14 09:19:31 -0800591 * @param pageDiff The page difference relative to the current page.
592 */
593 public void getItemLocation(int cellX, int cellY, int spanX, int spanY, int container,
594 int pageDiff, Rect outBounds) {
595 outBounds.setEmpty();
Jon Miranda0128d3f2019-02-14 09:19:31 -0800596 if (container == CONTAINER_HOTSEAT) {
Jon Miranda0bd63d12019-03-06 17:29:29 -0800597 final int actualHotseatCellHeight;
598 if (isVerticalBarLayout()) {
599 actualHotseatCellHeight = availableHeightPx / inv.numRows;
600 if (mIsSeascape) {
601 outBounds.left = mHotseatPadding.left;
602 } else {
603 outBounds.left = availableWidthPx - hotseatBarSizePx + mHotseatPadding.left;
604 }
605 outBounds.right = outBounds.left + iconSizePx;
606 outBounds.top = mHotseatPadding.top
607 + actualHotseatCellHeight * (inv.numRows - cellX - 1);
608 outBounds.bottom = outBounds.top + actualHotseatCellHeight;
609 } else {
610 actualHotseatCellHeight = hotseatBarSizePx - hotseatBarBottomPaddingPx
611 - hotseatBarTopPaddingPx;
612 outBounds.left = mInsets.left + workspacePadding.left + cellLayoutPaddingLeftRightPx
613 + (cellX * getCellSize().x);
614 outBounds.right = outBounds.left + getCellSize().x;
615 outBounds.top = mInsets.top + availableHeightPx - hotseatBarSizePx;
616 outBounds.bottom = outBounds.top + actualHotseatCellHeight;
617 }
Jon Miranda0128d3f2019-02-14 09:19:31 -0800618 } else {
Jon Miranda0bd63d12019-03-06 17:29:29 -0800619 outBounds.left = mInsets.left + workspacePadding.left + cellLayoutPaddingLeftRightPx
620 + (cellX * getCellSize().x) + (pageDiff * availableWidthPx);
621 outBounds.right = outBounds.left + (getCellSize().x * spanX);
622 outBounds.top = mInsets.top + workspacePadding.top + (cellY * getCellSize().y);
Jon Miranda0128d3f2019-02-14 09:19:31 -0800623 outBounds.bottom = outBounds.top + (getCellSize().y * spanY);
Jon Miranda0128d3f2019-02-14 09:19:31 -0800624 }
Jon Miranda0128d3f2019-02-14 09:19:31 -0800625 }
626
Jon Miranda1a49fb52019-02-19 15:34:41 -0800627 public float getAspectRatioWithInsets() {
628 int w = widthPx - mInsets.left - mInsets.right;
629 int h = heightPx - mInsets.top - mInsets.bottom;
630 return ((float) Math.max(w, h)) / Math.min(w, h);
631 }
632
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700633 private static Context getContext(Context c, int orientation) {
634 Configuration context = new Configuration(c.getResources().getConfiguration());
635 context.orientation = orientation;
636 return c.createConfigurationContext(context);
Jon Mirandab28c4fc2017-06-20 10:58:36 -0700637 }
Sunny Goyalfde55052018-02-01 14:46:13 -0800638
639 /**
640 * Callback when a component changes the DeviceProfile associated with it, as a result of
641 * configuration change
642 */
643 public interface OnDeviceProfileChangeListener {
644
645 /**
646 * Called when the device profile is reassigned. Note that for layout and measurements, it
647 * is sufficient to listen for inset changes. Use this callback when you need to perform
648 * a one time operation.
649 */
650 void onDeviceProfileChanged(DeviceProfile dp);
651 }
Winson Chungb3800242013-10-24 11:01:54 -0700652}