mirror of
https://github.com/LawnchairLauncher/lawnchair.git
synced 2026-02-28 07:46:55 +00:00
dc1e7d004c
It's no longer used/needed Bug: 407120123 Flag: EXEMPT internal cleanup Test: EXEMPT internal cleanup Change-Id: Ie0ae18b67ed4d7119b7901e652c27c024450da4b
1567 lines
71 KiB
Java
1567 lines
71 KiB
Java
/*
|
|
* Copyright (C) 2021 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package com.android.launcher3;
|
|
|
|
import static com.android.launcher3.GridType.GRID_TYPE_ANY;
|
|
import static com.android.launcher3.GridType.GRID_TYPE_NON_ONE_GRID;
|
|
import static com.android.launcher3.GridType.GRID_TYPE_ONE_GRID;
|
|
import static com.android.launcher3.LauncherPrefs.DB_FILE;
|
|
import static com.android.launcher3.LauncherPrefs.ENABLE_TWOLINE_ALLAPPS_TOGGLE;
|
|
import static com.android.launcher3.LauncherPrefs.FIXED_LANDSCAPE_MODE;
|
|
import static com.android.launcher3.LauncherPrefs.GRID_NAME;
|
|
import static com.android.launcher3.LauncherPrefs.NON_FIXED_LANDSCAPE_GRID_NAME;
|
|
import static com.android.launcher3.Utilities.dpiFromPx;
|
|
import static com.android.launcher3.testing.shared.ResourceUtils.INVALID_RESOURCE_HANDLE;
|
|
import static com.android.launcher3.util.DisplayController.CHANGE_DENSITY;
|
|
import static com.android.launcher3.util.DisplayController.CHANGE_DESKTOP_MODE;
|
|
import static com.android.launcher3.util.DisplayController.CHANGE_NAVIGATION_MODE;
|
|
import static com.android.launcher3.util.DisplayController.CHANGE_SUPPORTED_BOUNDS;
|
|
import static com.android.launcher3.util.DisplayController.CHANGE_TASKBAR_PINNING;
|
|
import static com.android.launcher3.util.Executors.MAIN_EXECUTOR;
|
|
|
|
import android.content.Context;
|
|
import android.content.Intent;
|
|
import android.content.res.Resources;
|
|
import android.content.res.TypedArray;
|
|
import android.content.res.XmlResourceParser;
|
|
import android.graphics.Point;
|
|
import android.graphics.PointF;
|
|
import android.graphics.Rect;
|
|
import android.os.Trace;
|
|
import android.text.TextUtils;
|
|
import android.util.AttributeSet;
|
|
import android.util.DisplayMetrics;
|
|
import android.util.Log;
|
|
import android.util.SparseArray;
|
|
import android.util.Xml;
|
|
|
|
import androidx.annotation.DimenRes;
|
|
import androidx.annotation.IntDef;
|
|
import androidx.annotation.StyleRes;
|
|
import androidx.annotation.VisibleForTesting;
|
|
import androidx.annotation.XmlRes;
|
|
import androidx.core.content.res.ResourcesCompat;
|
|
|
|
import com.android.launcher3.config.FeatureFlags;
|
|
import com.android.launcher3.dagger.ApplicationContext;
|
|
import com.android.launcher3.dagger.LauncherAppComponent;
|
|
import com.android.launcher3.dagger.LauncherAppSingleton;
|
|
import com.android.launcher3.graphics.ThemeManager;
|
|
import com.android.launcher3.icons.DotRenderer;
|
|
import com.android.launcher3.logging.FileLog;
|
|
import com.android.launcher3.model.DeviceGridState;
|
|
import com.android.launcher3.provider.RestoreDbTask;
|
|
import com.android.launcher3.testing.shared.ResourceUtils;
|
|
import com.android.launcher3.util.DaggerSingletonObject;
|
|
import com.android.launcher3.util.DaggerSingletonTracker;
|
|
import com.android.launcher3.util.DisplayController;
|
|
import com.android.launcher3.util.DisplayController.Info;
|
|
import com.android.launcher3.util.Partner;
|
|
import com.android.launcher3.util.ResourceHelper;
|
|
import com.android.launcher3.util.SimpleBroadcastReceiver;
|
|
import com.android.launcher3.util.WindowBounds;
|
|
import com.android.launcher3.util.window.CachedDisplayInfo;
|
|
import com.android.launcher3.util.window.WindowManagerProxy;
|
|
|
|
import org.xmlpull.v1.XmlPullParser;
|
|
import org.xmlpull.v1.XmlPullParserException;
|
|
|
|
import java.io.IOException;
|
|
import java.lang.annotation.Retention;
|
|
import java.lang.annotation.RetentionPolicy;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Collections;
|
|
import java.util.List;
|
|
import java.util.Objects;
|
|
import java.util.concurrent.CopyOnWriteArrayList;
|
|
import java.util.stream.Collectors;
|
|
|
|
import javax.inject.Inject;
|
|
|
|
@LauncherAppSingleton
|
|
public class InvariantDeviceProfile {
|
|
|
|
public static final String TAG = "IDP";
|
|
// We do not need any synchronization for this variable as its only written on UI thread.
|
|
public static final DaggerSingletonObject<InvariantDeviceProfile> INSTANCE =
|
|
new DaggerSingletonObject<>(LauncherAppComponent::getIDP);
|
|
|
|
public static final String GRID_NAME_PREFS_KEY = "idp_grid_name";
|
|
public static final String NON_FIXED_LANDSCAPE_GRID_NAME_PREFS_KEY =
|
|
"idp_non_fixed_landscape_grid_name";
|
|
|
|
@Retention(RetentionPolicy.SOURCE)
|
|
@IntDef({TYPE_PHONE, TYPE_MULTI_DISPLAY, TYPE_TABLET})
|
|
public @interface DeviceType {
|
|
}
|
|
|
|
public static final int TYPE_PHONE = 0;
|
|
public static final int TYPE_MULTI_DISPLAY = 1;
|
|
public static final int TYPE_TABLET = 2;
|
|
|
|
private static final float ICON_SIZE_DEFINED_IN_APP_DP = 48;
|
|
|
|
// Constants that affects the interpolation curve between statically defined device profile
|
|
// buckets.
|
|
private static final float KNEARESTNEIGHBOR = 3;
|
|
private static final float WEIGHT_POWER = 5;
|
|
|
|
// used to offset float not being able to express extremely small weights in extreme cases.
|
|
private static final float WEIGHT_EFFICIENT = 100000f;
|
|
|
|
// Used for arrays to specify different sizes (e.g. border spaces, width/height) in different
|
|
// constraints
|
|
static final int COUNT_SIZES = 4;
|
|
static final int INDEX_DEFAULT = 0;
|
|
static final int INDEX_LANDSCAPE = 1;
|
|
static final int INDEX_TWO_PANEL_PORTRAIT = 2;
|
|
static final int INDEX_TWO_PANEL_LANDSCAPE = 3;
|
|
|
|
/** These resources are used to override the device profile */
|
|
private static final String RES_GRID_NUM_ROWS = "grid_num_rows";
|
|
private static final String RES_GRID_NUM_COLUMNS = "grid_num_columns";
|
|
private static final String RES_GRID_ICON_SIZE_DP = "grid_icon_size_dp";
|
|
|
|
private final DisplayController mDisplayController;
|
|
private final WindowManagerProxy mWMProxy;
|
|
private final LauncherPrefs mPrefs;
|
|
private final ThemeManager mThemeManager;
|
|
|
|
/**
|
|
* Number of icons per row and column in the workspace.
|
|
*/
|
|
public int numRows;
|
|
public int numColumns;
|
|
public int numSearchContainerColumns;
|
|
|
|
/**
|
|
* Number of icons per row and column in the folder.
|
|
*/
|
|
public int[] numFolderRows;
|
|
public int[] numFolderColumns;
|
|
public float[] iconSize;
|
|
public float[] iconTextSize;
|
|
public int iconBitmapSize;
|
|
public int fillResIconDpi;
|
|
public @DeviceType int deviceType;
|
|
public Info displayInfo;
|
|
|
|
public PointF[] minCellSize;
|
|
|
|
public PointF[] borderSpaces;
|
|
public @DimenRes int inlineNavButtonsEndSpacing;
|
|
|
|
public @StyleRes int folderStyle;
|
|
|
|
public @StyleRes int cellStyle;
|
|
|
|
public float[] horizontalMargin;
|
|
|
|
public PointF[] allAppsCellSize;
|
|
public float[] allAppsIconSize;
|
|
public float[] allAppsIconTextSize;
|
|
public PointF[] allAppsBorderSpaces;
|
|
|
|
public float[] transientTaskbarIconSize;
|
|
|
|
public boolean[] startAlignTaskbar;
|
|
|
|
/**
|
|
* Number of icons inside the hotseat area.
|
|
*/
|
|
public int numShownHotseatIcons;
|
|
|
|
/**
|
|
* Number of icons inside the hotseat area that is stored in the database. This is greater than
|
|
* or equal to numnShownHotseatIcons, allowing for a seamless transition between two hotseat
|
|
* sizes that share the same DB.
|
|
*/
|
|
public int numDatabaseHotseatIcons;
|
|
|
|
public float[] hotseatBarBottomSpace;
|
|
public float[] hotseatQsbSpace;
|
|
|
|
/**
|
|
* Number of columns in the all apps list.
|
|
*/
|
|
public int numAllAppsColumns;
|
|
public int numAllAppsRowsForCellHeightCalculation;
|
|
public int numDatabaseAllAppsColumns;
|
|
public @StyleRes int allAppsStyle;
|
|
|
|
/**
|
|
* Do not query directly. see {@link DeviceProfile#isScalableGrid}.
|
|
*/
|
|
protected boolean isScalable;
|
|
@XmlRes
|
|
public int devicePaddingId = INVALID_RESOURCE_HANDLE;
|
|
@XmlRes
|
|
public int workspaceSpecsId = INVALID_RESOURCE_HANDLE;
|
|
@XmlRes
|
|
public int gridSizeSpecsId = INVALID_RESOURCE_HANDLE;;
|
|
@XmlRes
|
|
public int workspaceSpecsTwoPanelId = INVALID_RESOURCE_HANDLE;
|
|
@XmlRes
|
|
public int allAppsSpecsId = INVALID_RESOURCE_HANDLE;
|
|
@XmlRes
|
|
public int allAppsSpecsTwoPanelId = INVALID_RESOURCE_HANDLE;
|
|
@XmlRes
|
|
public int folderSpecsId = INVALID_RESOURCE_HANDLE;
|
|
@XmlRes
|
|
public int folderSpecsTwoPanelId = INVALID_RESOURCE_HANDLE;
|
|
@XmlRes
|
|
public int hotseatSpecsId = INVALID_RESOURCE_HANDLE;
|
|
@XmlRes
|
|
public int hotseatSpecsTwoPanelId = INVALID_RESOURCE_HANDLE;
|
|
@XmlRes
|
|
public int workspaceCellSpecsId = INVALID_RESOURCE_HANDLE;
|
|
@XmlRes
|
|
public int workspaceCellSpecsTwoPanelId = INVALID_RESOURCE_HANDLE;
|
|
@XmlRes
|
|
public int allAppsCellSpecsId = INVALID_RESOURCE_HANDLE;
|
|
@XmlRes
|
|
public int allAppsCellSpecsTwoPanelId = INVALID_RESOURCE_HANDLE;
|
|
|
|
private String mLocale = "";
|
|
public boolean enableTwoLinesInAllApps = false;
|
|
/**
|
|
* Fixed landscape mode is the landscape on the phones.
|
|
*/
|
|
public boolean isFixedLandscape = false;
|
|
|
|
@GridType
|
|
public int gridType;
|
|
public String dbFile;
|
|
public int defaultLayoutId;
|
|
public boolean[] inlineQsb = new boolean[COUNT_SIZES];
|
|
|
|
/**
|
|
* An immutable list of supported profiles.
|
|
*/
|
|
public List<DeviceProfile> supportedProfiles = Collections.EMPTY_LIST;
|
|
|
|
public Point defaultWallpaperSize;
|
|
|
|
private final List<OnIDPChangeListener> mChangeListeners = new CopyOnWriteArrayList<>();
|
|
|
|
@Inject
|
|
InvariantDeviceProfile(
|
|
@ApplicationContext Context context,
|
|
LauncherPrefs prefs,
|
|
DisplayController dc,
|
|
WindowManagerProxy wmProxy,
|
|
ThemeManager themeManager,
|
|
DaggerSingletonTracker lifeCycle) {
|
|
mDisplayController = dc;
|
|
mWMProxy = wmProxy;
|
|
mPrefs = prefs;
|
|
mThemeManager = themeManager;
|
|
|
|
String gridName = prefs.get(GRID_NAME);
|
|
initGrid(context, gridName);
|
|
|
|
dc.setPriorityListener(
|
|
(displayContext, info, flags) -> {
|
|
if ((flags & (CHANGE_DENSITY | CHANGE_SUPPORTED_BOUNDS
|
|
| CHANGE_NAVIGATION_MODE | CHANGE_TASKBAR_PINNING
|
|
| CHANGE_DESKTOP_MODE)) != 0) {
|
|
onConfigChanged(displayContext);
|
|
}
|
|
});
|
|
lifeCycle.addCloseable(() -> dc.setPriorityListener(null));
|
|
|
|
LauncherPrefChangeListener prefListener = key -> {
|
|
if (FIXED_LANDSCAPE_MODE.getSharedPrefKey().equals(key)
|
|
&& isFixedLandscape != prefs.get(FIXED_LANDSCAPE_MODE)) {
|
|
Trace.beginSection("InvariantDeviceProfile#setFixedLandscape");
|
|
if (isFixedLandscape) {
|
|
setCurrentGrid(context, prefs.get(NON_FIXED_LANDSCAPE_GRID_NAME));
|
|
} else {
|
|
prefs.put(NON_FIXED_LANDSCAPE_GRID_NAME, mPrefs.get(GRID_NAME));
|
|
onConfigChanged(context);
|
|
}
|
|
Trace.endSection();
|
|
} else if (ENABLE_TWOLINE_ALLAPPS_TOGGLE.getSharedPrefKey().equals(key)
|
|
&& enableTwoLinesInAllApps != prefs.get(ENABLE_TWOLINE_ALLAPPS_TOGGLE)) {
|
|
onConfigChanged(context);
|
|
}
|
|
};
|
|
prefs.addListener(prefListener, FIXED_LANDSCAPE_MODE, ENABLE_TWOLINE_ALLAPPS_TOGGLE);
|
|
lifeCycle.addCloseable(() -> prefs.removeListener(prefListener,
|
|
FIXED_LANDSCAPE_MODE, ENABLE_TWOLINE_ALLAPPS_TOGGLE));
|
|
|
|
SimpleBroadcastReceiver localeReceiver = new SimpleBroadcastReceiver(context,
|
|
MAIN_EXECUTOR, i -> onConfigChanged(context));
|
|
localeReceiver.register(Intent.ACTION_LOCALE_CHANGED);
|
|
lifeCycle.addCloseable(() -> localeReceiver.unregisterReceiverSafely());
|
|
}
|
|
|
|
private String initGrid(Context context, String gridName) {
|
|
Info displayInfo = mDisplayController.getInfo();
|
|
List<DisplayOption> allOptions = getPredefinedDeviceProfiles(
|
|
context,
|
|
gridName,
|
|
displayInfo,
|
|
(RestoreDbTask.isPending(mPrefs) && !Flags.oneGridSpecs()),
|
|
mPrefs.get(FIXED_LANDSCAPE_MODE)
|
|
);
|
|
|
|
// Filter out options that don't have the same number of columns as the grid
|
|
DeviceGridState deviceGridState = new DeviceGridState(mPrefs);
|
|
List<DisplayOption> allOptionsFilteredByColCount =
|
|
filterByColumnCount(allOptions, deviceGridState.getColumns());
|
|
|
|
DisplayOption displayOption =
|
|
invDistWeightedInterpolate(displayInfo, allOptionsFilteredByColCount.isEmpty()
|
|
? new ArrayList<>(allOptions)
|
|
: new ArrayList<>(allOptionsFilteredByColCount),
|
|
displayInfo.getDeviceType());
|
|
|
|
if (!displayOption.grid.name.equals(gridName)) {
|
|
mPrefs.put(GRID_NAME, displayOption.grid.name);
|
|
}
|
|
|
|
initGrid(context, displayInfo, displayOption);
|
|
FileLog.d(TAG, "After initGrid:"
|
|
+ "gridName:" + gridName
|
|
+ ", dbFile:" + dbFile
|
|
+ ", LauncherPrefs GRID_NAME:" + mPrefs.get(GRID_NAME)
|
|
+ ", LauncherPrefs DB_FILE:" + mPrefs.get(DB_FILE));
|
|
return displayOption.grid.name;
|
|
}
|
|
|
|
private List<DisplayOption> filterByColumnCount(
|
|
List<DisplayOption> allOptions, int numColumns) {
|
|
return allOptions.stream()
|
|
.filter(option -> option.grid.numColumns == numColumns)
|
|
.collect(Collectors.toList());
|
|
}
|
|
|
|
/**
|
|
* @deprecated This is a temporary solution because on the backup and restore case we modify the
|
|
* IDP, this resets it. b/332974074
|
|
*/
|
|
@Deprecated
|
|
public void reset(Context context) {
|
|
initGrid(context, mPrefs.get(GRID_NAME));
|
|
}
|
|
|
|
private void initGrid(Context context, Info displayInfo, DisplayOption displayOption) {
|
|
enableTwoLinesInAllApps = Flags.enableTwolineToggle()
|
|
&& Utilities.isEnglishLanguage(context)
|
|
&& mPrefs.get(ENABLE_TWOLINE_ALLAPPS_TOGGLE);
|
|
mLocale = context.getResources().getConfiguration().locale.toString();
|
|
|
|
DisplayMetrics metrics = context.getResources().getDisplayMetrics();
|
|
GridOption closestProfile = displayOption.grid;
|
|
numRows = closestProfile.numRows;
|
|
numColumns = closestProfile.numColumns;
|
|
numSearchContainerColumns = closestProfile.numSearchContainerColumns;
|
|
dbFile = closestProfile.dbFile;
|
|
gridType = closestProfile.gridType;
|
|
defaultLayoutId = closestProfile.defaultLayoutId;
|
|
|
|
numFolderRows = closestProfile.numFolderRows;
|
|
numFolderColumns = closestProfile.numFolderColumns;
|
|
folderStyle = closestProfile.folderStyle;
|
|
|
|
cellStyle = closestProfile.cellStyle;
|
|
|
|
isScalable = closestProfile.isScalable;
|
|
devicePaddingId = closestProfile.devicePaddingId;
|
|
workspaceSpecsId = closestProfile.mWorkspaceSpecsId;
|
|
gridSizeSpecsId = closestProfile.mGridSizeSpecsId;
|
|
workspaceSpecsTwoPanelId = closestProfile.mWorkspaceSpecsTwoPanelId;
|
|
allAppsSpecsId = closestProfile.mAllAppsSpecsId;
|
|
allAppsSpecsTwoPanelId = closestProfile.mAllAppsSpecsTwoPanelId;
|
|
folderSpecsId = closestProfile.mFolderSpecsId;
|
|
folderSpecsTwoPanelId = closestProfile.mFolderSpecsTwoPanelId;
|
|
hotseatSpecsId = closestProfile.mHotseatSpecsId;
|
|
hotseatSpecsTwoPanelId = closestProfile.mHotseatSpecsTwoPanelId;
|
|
workspaceCellSpecsId = closestProfile.mWorkspaceCellSpecsId;
|
|
workspaceCellSpecsTwoPanelId = closestProfile.mWorkspaceCellSpecsTwoPanelId;
|
|
allAppsCellSpecsId = closestProfile.mAllAppsCellSpecsId;
|
|
allAppsCellSpecsTwoPanelId = closestProfile.mAllAppsCellSpecsTwoPanelId;
|
|
numAllAppsRowsForCellHeightCalculation =
|
|
closestProfile.mNumAllAppsRowsForCellHeightCalculation;
|
|
this.deviceType = displayInfo.getDeviceType();
|
|
this.displayInfo = displayInfo;
|
|
|
|
inlineNavButtonsEndSpacing = closestProfile.inlineNavButtonsEndSpacing;
|
|
|
|
iconSize = displayOption.iconSizes;
|
|
float maxIconSize = iconSize[0];
|
|
for (int i = 1; i < iconSize.length; i++) {
|
|
maxIconSize = Math.max(maxIconSize, iconSize[i]);
|
|
}
|
|
iconBitmapSize = ResourceUtils.pxFromDp(maxIconSize, metrics);
|
|
fillResIconDpi = getLauncherIconDensity(iconBitmapSize);
|
|
|
|
iconTextSize = displayOption.textSizes;
|
|
|
|
minCellSize = displayOption.minCellSize;
|
|
|
|
borderSpaces = displayOption.borderSpaces;
|
|
|
|
horizontalMargin = displayOption.horizontalMargin;
|
|
|
|
numShownHotseatIcons = closestProfile.numHotseatIcons;
|
|
numDatabaseHotseatIcons = deviceType == TYPE_MULTI_DISPLAY
|
|
? closestProfile.numDatabaseHotseatIcons : closestProfile.numHotseatIcons;
|
|
hotseatBarBottomSpace = displayOption.hotseatBarBottomSpace;
|
|
hotseatQsbSpace = displayOption.hotseatQsbSpace;
|
|
|
|
allAppsStyle = closestProfile.allAppsStyle;
|
|
|
|
numAllAppsColumns = closestProfile.numAllAppsColumns;
|
|
|
|
numDatabaseAllAppsColumns = deviceType == TYPE_MULTI_DISPLAY
|
|
? closestProfile.numDatabaseAllAppsColumns : closestProfile.numAllAppsColumns;
|
|
|
|
allAppsCellSize = displayOption.allAppsCellSize;
|
|
allAppsBorderSpaces = displayOption.allAppsBorderSpaces;
|
|
allAppsIconSize = displayOption.allAppsIconSizes;
|
|
allAppsIconTextSize = displayOption.allAppsIconTextSizes;
|
|
|
|
inlineQsb = closestProfile.inlineQsb;
|
|
|
|
transientTaskbarIconSize = displayOption.transientTaskbarIconSize;
|
|
|
|
startAlignTaskbar = displayOption.startAlignTaskbar;
|
|
|
|
// Fixed Landscape mode
|
|
isFixedLandscape = closestProfile.mIsFixedLandscape;
|
|
|
|
// If the partner customization apk contains any grid overrides, apply them
|
|
// Supported overrides: numRows, numColumns, iconSize
|
|
applyPartnerDeviceProfileOverrides(context, metrics);
|
|
|
|
final List<DeviceProfile> localSupportedProfiles = new ArrayList<>();
|
|
defaultWallpaperSize = new Point(displayInfo.currentSize);
|
|
SparseArray<DotRenderer> dotRendererCache = new SparseArray<>();
|
|
for (WindowBounds bounds : displayInfo.supportedBounds) {
|
|
localSupportedProfiles.add(newDPBuilder(context, displayInfo)
|
|
.setIsMultiDisplay(deviceType == TYPE_MULTI_DISPLAY)
|
|
.setWindowBounds(bounds)
|
|
.setDotRendererCache(dotRendererCache)
|
|
.build());
|
|
|
|
// Wallpaper size should be the maximum of the all possible sizes Launcher expects
|
|
int displayWidth = bounds.bounds.width();
|
|
int displayHeight = bounds.bounds.height();
|
|
defaultWallpaperSize.y = Math.max(defaultWallpaperSize.y, displayHeight);
|
|
|
|
// We need to ensure that there is enough extra space in the wallpaper
|
|
// for the intended parallax effects
|
|
float parallaxFactor =
|
|
dpiFromPx(Math.min(displayWidth, displayHeight), displayInfo.getDensityDpi())
|
|
< 720
|
|
? 2
|
|
: wallpaperTravelToScreenWidthRatio(displayWidth, displayHeight);
|
|
defaultWallpaperSize.x =
|
|
Math.max(defaultWallpaperSize.x, Math.round(parallaxFactor * displayWidth));
|
|
}
|
|
supportedProfiles = Collections.unmodifiableList(localSupportedProfiles);
|
|
|
|
int numMinShownHotseatIconsForTablet = supportedProfiles
|
|
.stream()
|
|
.filter(deviceProfile -> deviceProfile.isTablet)
|
|
.mapToInt(deviceProfile -> deviceProfile.numShownHotseatIcons)
|
|
.min()
|
|
.orElse(0);
|
|
|
|
supportedProfiles
|
|
.stream()
|
|
.filter(deviceProfile -> deviceProfile.isTablet)
|
|
.forEach(deviceProfile -> {
|
|
deviceProfile.numShownHotseatIcons = numMinShownHotseatIconsForTablet;
|
|
deviceProfile.recalculateHotseatWidthAndBorderSpace();
|
|
});
|
|
}
|
|
|
|
DeviceProfile.Builder newDPBuilder(Context context, Info info) {
|
|
return new DeviceProfile.Builder(context, this, info, mWMProxy, mThemeManager);
|
|
}
|
|
|
|
public void addOnChangeListener(OnIDPChangeListener listener) {
|
|
mChangeListeners.add(listener);
|
|
}
|
|
|
|
public void removeOnChangeListener(OnIDPChangeListener listener) {
|
|
mChangeListeners.remove(listener);
|
|
}
|
|
|
|
/**
|
|
* Updates the current grid, this triggers a new IDP, reloads the database and triggers a grid
|
|
* migration.
|
|
*/
|
|
@VisibleForTesting
|
|
public void setCurrentGrid(Context context, String newGridName) {
|
|
mPrefs.put(GRID_NAME, newGridName);
|
|
MAIN_EXECUTOR.execute(() -> {
|
|
Trace.beginSection("InvariantDeviceProfile#setCurrentGrid");
|
|
onConfigChanged(context.getApplicationContext());
|
|
Trace.endSection();
|
|
});
|
|
}
|
|
|
|
private Object[] toModelState() {
|
|
return new Object[]{
|
|
numColumns, numRows, numSearchContainerColumns, numDatabaseHotseatIcons,
|
|
iconBitmapSize, fillResIconDpi, numDatabaseAllAppsColumns, dbFile, mLocale};
|
|
}
|
|
|
|
/** Updates IDP using the provided context. Notifies listeners of change. */
|
|
@VisibleForTesting
|
|
public void onConfigChanged(Context context) {
|
|
Object[] oldState = toModelState();
|
|
|
|
// Re-init grid
|
|
initGrid(context, mPrefs.get(GRID_NAME));
|
|
|
|
boolean modelPropsChanged = !Arrays.equals(oldState, toModelState());
|
|
for (OnIDPChangeListener listener : mChangeListeners) {
|
|
listener.onIdpChanged(modelPropsChanged);
|
|
}
|
|
}
|
|
|
|
private static boolean firstGridFilter(GridOption gridOption, int deviceType,
|
|
boolean allowDisabledGrid, boolean isFixedLandscapeMode) {
|
|
return (gridOption.isEnabled(deviceType) || allowDisabledGrid)
|
|
&& gridOption.filterByFlag(deviceType, isFixedLandscapeMode);
|
|
}
|
|
|
|
private static List<DisplayOption> getPredefinedDeviceProfiles(
|
|
Context context,
|
|
String gridName,
|
|
Info displayInfo,
|
|
boolean allowDisabledGrid,
|
|
boolean isFixedLandscapeMode
|
|
) {
|
|
ArrayList<DisplayOption> profiles = new ArrayList<>();
|
|
|
|
try (XmlResourceParser parser = context.getResources().getXml(R.xml.device_profiles)) {
|
|
final int depth = parser.getDepth();
|
|
int type;
|
|
while (((type = parser.next()) != XmlPullParser.END_TAG ||
|
|
parser.getDepth() > depth) && type != XmlPullParser.END_DOCUMENT) {
|
|
if ((type == XmlPullParser.START_TAG)
|
|
&& GridOption.TAG_NAME.equals(parser.getName())) {
|
|
GridOption gridOption = new GridOption(
|
|
context, Xml.asAttributeSet(parser), displayInfo);
|
|
if (firstGridFilter(gridOption, displayInfo.getDeviceType(), allowDisabledGrid,
|
|
isFixedLandscapeMode)) {
|
|
final int displayDepth = parser.getDepth();
|
|
while (((type = parser.next()) != XmlPullParser.END_TAG
|
|
|| parser.getDepth() > displayDepth)
|
|
&& type != XmlPullParser.END_DOCUMENT) {
|
|
if ((type == XmlPullParser.START_TAG) && "display-option".equals(
|
|
parser.getName())) {
|
|
profiles.add(new DisplayOption(gridOption, context,
|
|
Xml.asAttributeSet(parser)));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} catch (IOException | XmlPullParserException e) {
|
|
throw new RuntimeException(e);
|
|
}
|
|
ArrayList<DisplayOption> filteredProfiles = new ArrayList<>();
|
|
if (!TextUtils.isEmpty(gridName)) {
|
|
for (DisplayOption option : profiles) {
|
|
if (gridName.equals(option.grid.name) && (option.grid.isEnabled(
|
|
displayInfo.getDeviceType()) || allowDisabledGrid)) {
|
|
filteredProfiles.add(option);
|
|
}
|
|
}
|
|
}
|
|
if (filteredProfiles.isEmpty() && TextUtils.isEmpty(gridName)) {
|
|
// Use the default options since gridName is empty and there's no valid grids.
|
|
for (DisplayOption option : profiles) {
|
|
if (option.canBeDefault) {
|
|
filteredProfiles.add(option);
|
|
}
|
|
}
|
|
} else if (filteredProfiles.isEmpty()) {
|
|
// In this case we had a grid selected but we couldn't find it.
|
|
filteredProfiles.addAll(profiles);
|
|
}
|
|
if (filteredProfiles.isEmpty()) {
|
|
throw new RuntimeException("No display option with canBeDefault=true");
|
|
}
|
|
return filteredProfiles;
|
|
}
|
|
|
|
/**
|
|
* Parses through the xml to find GridSize specs. Then calls findBestGridSize to get the
|
|
* correct grid size for this GridOption.
|
|
*
|
|
* @return the result of {@link #findBestGridSize(List, int, int)}.
|
|
*/
|
|
private static GridSize getGridSize(ResourceHelper resourceHelper, Context context,
|
|
Info displayInfo) {
|
|
ArrayList<GridSize> gridSizes = new ArrayList<>();
|
|
|
|
try (XmlResourceParser parser = resourceHelper.getXml()) {
|
|
final int depth = parser.getDepth();
|
|
int type;
|
|
while (((type = parser.next()) != XmlPullParser.END_TAG
|
|
|| parser.getDepth() > depth) && type != XmlPullParser.END_DOCUMENT) {
|
|
if ((type == XmlPullParser.START_TAG)
|
|
&& "GridSize".equals(parser.getName())) {
|
|
gridSizes.add(new GridSize(context, Xml.asAttributeSet(parser)));
|
|
}
|
|
}
|
|
} catch (IOException | XmlPullParserException e) {
|
|
throw new RuntimeException(e);
|
|
}
|
|
|
|
// Finds the min width and height in dp for all displays.
|
|
int[] dimens = findMinWidthAndHeightPxForDevice(displayInfo);
|
|
|
|
return findBestGridSize(gridSizes, dimens[0], dimens[1]);
|
|
}
|
|
|
|
/**
|
|
* @return the biggest grid size that fits the display dimensions.
|
|
* If no best grid size is found, return null.
|
|
*/
|
|
private static GridSize findBestGridSize(List<GridSize> list, int minWidthPx,
|
|
int minHeightPx) {
|
|
GridSize selectedGridSize = null;
|
|
for (GridSize item: list) {
|
|
if (minWidthPx >= item.mMinDeviceWidthPx && minHeightPx >= item.mMinDeviceHeightPx) {
|
|
if (selectedGridSize == null
|
|
|| (selectedGridSize.mNumColumns <= item.mNumColumns
|
|
&& selectedGridSize.mNumRows <= item.mNumRows)) {
|
|
selectedGridSize = item;
|
|
}
|
|
}
|
|
}
|
|
return selectedGridSize;
|
|
}
|
|
|
|
private static int[] findMinWidthAndHeightPxForDevice(Info displayInfo) {
|
|
int minDisplayWidthPx = Integer.MAX_VALUE;
|
|
int minDisplayHeightPx = Integer.MAX_VALUE;
|
|
for (CachedDisplayInfo display: displayInfo.getAllDisplays()) {
|
|
minDisplayWidthPx = Math.min(minDisplayWidthPx, display.size.x);
|
|
minDisplayHeightPx = Math.min(minDisplayHeightPx, display.size.y);
|
|
}
|
|
return new int[]{minDisplayWidthPx, minDisplayHeightPx};
|
|
}
|
|
|
|
/**
|
|
* Returns the GridOption associated to the given file name or null if the fileName is not
|
|
* supported.
|
|
* Ej, launcher.db -> "normal grid", launcher_4_by_4.db -> "practical grid"
|
|
*/
|
|
public GridOption getGridOptionFromFileName(Context context, String fileName) {
|
|
return parseAllGridOptions(context).stream()
|
|
.filter(gridOption -> Objects.equals(gridOption.dbFile, fileName))
|
|
.findFirst()
|
|
.orElse(null);
|
|
}
|
|
|
|
/**
|
|
* Returns the name of the given size on the current device or empty string if the size is not
|
|
* supported. Ej. 4x4 -> normal, 5x4 -> practical, etc.
|
|
* (Note: the name of the grid can be different for the same grid size depending of
|
|
* the values of the InvariantDeviceProfile)
|
|
*/
|
|
public String getGridNameFromSize(Context context, Point size) {
|
|
return parseAllGridOptions(context).stream()
|
|
.filter(gridOption -> gridOption.numColumns == size.x
|
|
&& gridOption.numRows == size.y)
|
|
.map(gridOption -> gridOption.name)
|
|
.findFirst()
|
|
.orElse("");
|
|
}
|
|
|
|
/**
|
|
* Returns the grid option for the given gridName on the current device (Note: the gridOption
|
|
* be different for the same gridName depending on the values of the InvariantDeviceProfile).
|
|
*/
|
|
public GridOption getGridOptionFromName(Context context, String gridName) {
|
|
return parseAllGridOptions(context).stream()
|
|
.filter(gridOption -> Objects.equals(gridOption.name, gridName))
|
|
.findFirst()
|
|
.orElse(null);
|
|
}
|
|
|
|
/**
|
|
* @return all the grid options that can be shown on the device
|
|
*/
|
|
public List<GridOption> parseAllGridOptions(Context context) {
|
|
return parseAllDefinedGridOptions(context, displayInfo)
|
|
.stream()
|
|
.filter(go -> go.isEnabled(deviceType))
|
|
.filter(go -> go.filterByFlag(deviceType, isFixedLandscape))
|
|
.collect(Collectors.toList());
|
|
}
|
|
|
|
/**
|
|
* @return all the grid options that can be shown on the device
|
|
*/
|
|
public static List<GridOption> parseAllDefinedGridOptions(Context context, Info displayInfo) {
|
|
List<GridOption> result = new ArrayList<>();
|
|
try (XmlResourceParser parser = context.getResources().getXml(R.xml.device_profiles)) {
|
|
final int depth = parser.getDepth();
|
|
int type;
|
|
while (((type = parser.next()) != XmlPullParser.END_TAG
|
|
|| parser.getDepth() > depth) && type != XmlPullParser.END_DOCUMENT) {
|
|
if ((type == XmlPullParser.START_TAG)
|
|
&& GridOption.TAG_NAME.equals(parser.getName())) {
|
|
result.add(new GridOption(context, Xml.asAttributeSet(parser), displayInfo));
|
|
}
|
|
}
|
|
} catch (IOException | XmlPullParserException e) {
|
|
Log.e(TAG, "Error parsing device profile", e);
|
|
return Collections.emptyList();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private int getLauncherIconDensity(int requiredSize) {
|
|
// Densities typically defined by an app.
|
|
int[] densityBuckets = new int[]{
|
|
DisplayMetrics.DENSITY_LOW,
|
|
DisplayMetrics.DENSITY_MEDIUM,
|
|
DisplayMetrics.DENSITY_TV,
|
|
DisplayMetrics.DENSITY_HIGH,
|
|
DisplayMetrics.DENSITY_XHIGH,
|
|
DisplayMetrics.DENSITY_XXHIGH,
|
|
DisplayMetrics.DENSITY_XXXHIGH
|
|
};
|
|
|
|
int density = DisplayMetrics.DENSITY_XXXHIGH;
|
|
for (int i = densityBuckets.length - 1; i >= 0; i--) {
|
|
float expectedSize = ICON_SIZE_DEFINED_IN_APP_DP * densityBuckets[i]
|
|
/ DisplayMetrics.DENSITY_DEFAULT;
|
|
if (expectedSize >= requiredSize) {
|
|
density = densityBuckets[i];
|
|
}
|
|
}
|
|
|
|
return density;
|
|
}
|
|
|
|
/**
|
|
* Apply any Partner customization grid overrides.
|
|
*
|
|
* Currently we support: all apps row / column count.
|
|
*/
|
|
private void applyPartnerDeviceProfileOverrides(Context context, DisplayMetrics dm) {
|
|
Partner p = Partner.get(context.getPackageManager());
|
|
if (p == null) {
|
|
return;
|
|
}
|
|
try {
|
|
int numRows = p.getIntValue(RES_GRID_NUM_ROWS, -1);
|
|
int numColumns = p.getIntValue(RES_GRID_NUM_COLUMNS, -1);
|
|
float iconSizePx = p.getDimenValue(RES_GRID_ICON_SIZE_DP, -1);
|
|
|
|
if (numRows > 0 && numColumns > 0) {
|
|
this.numRows = numRows;
|
|
this.numColumns = numColumns;
|
|
}
|
|
if (iconSizePx > 0) {
|
|
this.iconSize[InvariantDeviceProfile.INDEX_DEFAULT] =
|
|
Utilities.dpiFromPx(iconSizePx, dm.densityDpi);
|
|
}
|
|
} catch (Resources.NotFoundException ex) {
|
|
Log.e(TAG, "Invalid Partner grid resource!", ex);
|
|
}
|
|
}
|
|
|
|
private static float dist(float x0, float y0, float x1, float y1) {
|
|
return (float) Math.hypot(x1 - x0, y1 - y0);
|
|
}
|
|
|
|
private static DisplayOption invDistWeightedInterpolate(
|
|
Info displayInfo, List<DisplayOption> points, @DeviceType int deviceType) {
|
|
int minWidthPx = Integer.MAX_VALUE;
|
|
int minHeightPx = Integer.MAX_VALUE;
|
|
for (WindowBounds bounds : displayInfo.supportedBounds) {
|
|
boolean isTablet = displayInfo.isTablet(bounds);
|
|
if (isTablet && deviceType == TYPE_MULTI_DISPLAY) {
|
|
// For split displays, take half width per page
|
|
minWidthPx = Math.min(minWidthPx, bounds.availableSize.x / 2);
|
|
minHeightPx = Math.min(minHeightPx, bounds.availableSize.y);
|
|
|
|
} else if (!isTablet && bounds.isLandscape()) {
|
|
// We will use transposed layout in this case
|
|
minWidthPx = Math.min(minWidthPx, bounds.availableSize.y);
|
|
minHeightPx = Math.min(minHeightPx, bounds.availableSize.x);
|
|
} else {
|
|
minWidthPx = Math.min(minWidthPx, bounds.availableSize.x);
|
|
minHeightPx = Math.min(minHeightPx, bounds.availableSize.y);
|
|
}
|
|
}
|
|
|
|
float width = dpiFromPx(minWidthPx, displayInfo.getDensityDpi());
|
|
float height = dpiFromPx(minHeightPx, displayInfo.getDensityDpi());
|
|
|
|
// Sort the profiles based on the closeness to the device size
|
|
points.sort((a, b) ->
|
|
Float.compare(dist(width, height, a.minWidthDps, a.minHeightDps),
|
|
dist(width, height, b.minWidthDps, b.minHeightDps)));
|
|
|
|
DisplayOption closestPoint = points.get(0);
|
|
GridOption closestOption = closestPoint.grid;
|
|
float weights = 0;
|
|
|
|
if (dist(width, height, closestPoint.minWidthDps, closestPoint.minHeightDps) == 0) {
|
|
return closestPoint;
|
|
}
|
|
|
|
DisplayOption out = new DisplayOption(closestOption);
|
|
for (int i = 0; i < points.size() && i < KNEARESTNEIGHBOR; ++i) {
|
|
DisplayOption p = points.get(i);
|
|
float w = weight(width, height, p.minWidthDps, p.minHeightDps, WEIGHT_POWER);
|
|
weights += w;
|
|
out.add(new DisplayOption().add(p).multiply(w));
|
|
}
|
|
out.multiply(1.0f / weights);
|
|
|
|
// Since the bitmaps are persisted, ensure that all bitmap sizes are not larger than
|
|
// predefined size to avoid cache invalidation
|
|
for (int i = INDEX_DEFAULT; i < COUNT_SIZES; i++) {
|
|
out.iconSizes[i] = Math.min(out.iconSizes[i], closestPoint.iconSizes[i]);
|
|
}
|
|
|
|
return out;
|
|
}
|
|
|
|
public DeviceProfile createDeviceProfileForSecondaryDisplay(Context displayContext) {
|
|
// Disable transpose layout and use multi-window mode so that the icons are scaled properly
|
|
return newDPBuilder(displayContext, new Info(displayContext))
|
|
.setIsMultiDisplay(false)
|
|
.setMultiWindowMode(true)
|
|
.setWindowBounds(mWMProxy.getRealBounds(
|
|
displayContext, mWMProxy.getDisplayInfo(displayContext)))
|
|
.setTransposeLayoutWithOrientation(false)
|
|
.build();
|
|
}
|
|
|
|
public DeviceProfile getDeviceProfile(Context context) {
|
|
Rect bounds = mWMProxy.getCurrentBounds(context);
|
|
int rotation = mWMProxy.getRotation(context);
|
|
return getBestMatch(bounds.width(), bounds.height(), rotation);
|
|
}
|
|
|
|
/**
|
|
* Returns the device profile matching the provided screen configuration
|
|
*/
|
|
public DeviceProfile getBestMatch(float screenWidth, float screenHeight, int rotation) {
|
|
DeviceProfile bestMatch = supportedProfiles.get(0);
|
|
float minDiff = Float.MAX_VALUE;
|
|
|
|
for (DeviceProfile profile : supportedProfiles) {
|
|
float diff = Math.abs(profile.widthPx - screenWidth)
|
|
+ Math.abs(profile.heightPx - screenHeight);
|
|
if (diff < minDiff) {
|
|
minDiff = diff;
|
|
bestMatch = profile;
|
|
} else if (diff == minDiff && profile.rotationHint == rotation) {
|
|
bestMatch = profile;
|
|
}
|
|
}
|
|
return bestMatch;
|
|
}
|
|
|
|
private static float weight(float x0, float y0, float x1, float y1, float pow) {
|
|
float d = dist(x0, y0, x1, y1);
|
|
if (Float.compare(d, 0f) == 0) {
|
|
return Float.POSITIVE_INFINITY;
|
|
}
|
|
return (float) (WEIGHT_EFFICIENT / Math.pow(d, pow));
|
|
}
|
|
|
|
/**
|
|
* As a ratio of screen height, the total distance we want the parallax effect to span
|
|
* horizontally
|
|
*/
|
|
private static float wallpaperTravelToScreenWidthRatio(int width, int height) {
|
|
float aspectRatio = width / (float) height;
|
|
|
|
// At an aspect ratio of 16/10, the wallpaper parallax effect should span 1.5 * screen width
|
|
// At an aspect ratio of 10/16, the wallpaper parallax effect should span 1.2 * screen width
|
|
// We will use these two data points to extrapolate how much the wallpaper parallax effect
|
|
// to span (ie travel) at any aspect ratio:
|
|
|
|
final float ASPECT_RATIO_LANDSCAPE = 16 / 10f;
|
|
final float ASPECT_RATIO_PORTRAIT = 10 / 16f;
|
|
final float WALLPAPER_WIDTH_TO_SCREEN_RATIO_LANDSCAPE = 1.5f;
|
|
final float WALLPAPER_WIDTH_TO_SCREEN_RATIO_PORTRAIT = 1.2f;
|
|
|
|
// To find out the desired width at different aspect ratios, we use the following two
|
|
// formulas, where the coefficient on x is the aspect ratio (width/height):
|
|
// (16/10)x + y = 1.5
|
|
// (10/16)x + y = 1.2
|
|
// We solve for x and y and end up with a final formula:
|
|
final float x =
|
|
(WALLPAPER_WIDTH_TO_SCREEN_RATIO_LANDSCAPE
|
|
- WALLPAPER_WIDTH_TO_SCREEN_RATIO_PORTRAIT) /
|
|
(ASPECT_RATIO_LANDSCAPE - ASPECT_RATIO_PORTRAIT);
|
|
final float y = WALLPAPER_WIDTH_TO_SCREEN_RATIO_PORTRAIT - x * ASPECT_RATIO_PORTRAIT;
|
|
return x * aspectRatio + y;
|
|
}
|
|
|
|
public interface OnIDPChangeListener {
|
|
|
|
/**
|
|
* Called when the device provide changes
|
|
*/
|
|
void onIdpChanged(boolean modelPropertiesChanged);
|
|
}
|
|
|
|
|
|
public static final class GridOption {
|
|
|
|
public static final String TAG_NAME = "grid-option";
|
|
|
|
private static final int DEVICE_CATEGORY_PHONE = 1 << 0;
|
|
private static final int DEVICE_CATEGORY_TABLET = 1 << 1;
|
|
private static final int DEVICE_CATEGORY_MULTI_DISPLAY = 1 << 2;
|
|
private static final int DEVICE_CATEGORY_ANY =
|
|
DEVICE_CATEGORY_PHONE | DEVICE_CATEGORY_TABLET | DEVICE_CATEGORY_MULTI_DISPLAY;
|
|
|
|
private static final int INLINE_QSB_FOR_PORTRAIT = 1 << 0;
|
|
private static final int INLINE_QSB_FOR_LANDSCAPE = 1 << 1;
|
|
private static final int INLINE_QSB_FOR_TWO_PANEL_PORTRAIT = 1 << 2;
|
|
private static final int INLINE_QSB_FOR_TWO_PANEL_LANDSCAPE = 1 << 3;
|
|
private static final int DONT_INLINE_QSB = 0;
|
|
|
|
public final String name;
|
|
public final String gridTitle;
|
|
public final int gridIconId;
|
|
public final int numRows;
|
|
public final int numColumns;
|
|
public final int numSearchContainerColumns;
|
|
public final int deviceCategory;
|
|
@GridType
|
|
public final int gridType;
|
|
|
|
private final int[] numFolderRows = new int[COUNT_SIZES];
|
|
private final int[] numFolderColumns = new int[COUNT_SIZES];
|
|
private final @StyleRes int folderStyle;
|
|
private final @StyleRes int cellStyle;
|
|
|
|
private final @StyleRes int allAppsStyle;
|
|
private final int numAllAppsColumns;
|
|
private final int mNumAllAppsRowsForCellHeightCalculation;
|
|
private final int numDatabaseAllAppsColumns;
|
|
private final int numHotseatIcons;
|
|
private final int numDatabaseHotseatIcons;
|
|
|
|
private final boolean[] inlineQsb = new boolean[COUNT_SIZES];
|
|
|
|
private @DimenRes int inlineNavButtonsEndSpacing;
|
|
private final String dbFile;
|
|
|
|
private final int defaultLayoutId;
|
|
|
|
private final boolean isScalable;
|
|
private final boolean mIsDualGrid;
|
|
private final int devicePaddingId;
|
|
private final int mWorkspaceSpecsId;
|
|
private final int mWorkspaceSpecsTwoPanelId;
|
|
private final int mAllAppsSpecsId;
|
|
private final int mAllAppsSpecsTwoPanelId;
|
|
private final int mFolderSpecsId;
|
|
private final int mFolderSpecsTwoPanelId;
|
|
private final int mHotseatSpecsId;
|
|
private final int mHotseatSpecsTwoPanelId;
|
|
private final int mWorkspaceCellSpecsId;
|
|
private final int mWorkspaceCellSpecsTwoPanelId;
|
|
private final int mAllAppsCellSpecsId;
|
|
private final int mAllAppsCellSpecsTwoPanelId;
|
|
private final int mGridSizeSpecsId;
|
|
private final boolean mIsFixedLandscape;
|
|
|
|
public GridOption(Context context, AttributeSet attrs, Info displayInfo) {
|
|
TypedArray a = context.obtainStyledAttributes(
|
|
attrs, R.styleable.GridDisplayOption);
|
|
name = a.getString(R.styleable.GridDisplayOption_name);
|
|
gridTitle = a.getString(R.styleable.GridDisplayOption_gridTitle);
|
|
gridIconId = a.getResourceId(
|
|
R.styleable.GridDisplayOption_gridIconId, INVALID_RESOURCE_HANDLE);
|
|
deviceCategory = a.getInt(R.styleable.GridDisplayOption_deviceCategory,
|
|
DEVICE_CATEGORY_ANY);
|
|
mGridSizeSpecsId = a.getResourceId(
|
|
R.styleable.GridDisplayOption_gridSizeSpecsId, INVALID_RESOURCE_HANDLE);
|
|
mIsDualGrid = a.getBoolean(R.styleable.GridDisplayOption_isDualGrid, false);
|
|
if (mGridSizeSpecsId != INVALID_RESOURCE_HANDLE) {
|
|
ResourceHelper resourceHelper = new ResourceHelper(context, mGridSizeSpecsId);
|
|
GridSize gridSize = getGridSize(resourceHelper, context, displayInfo);
|
|
numColumns = gridSize.mNumColumns;
|
|
numRows = gridSize.mNumRows;
|
|
dbFile = gridSize.mDbFile;
|
|
defaultLayoutId = gridSize.mDefaultLayoutId;
|
|
} else {
|
|
numRows = a.getInt(R.styleable.GridDisplayOption_numRows, 0);
|
|
numColumns = a.getInt(R.styleable.GridDisplayOption_numColumns, 0);
|
|
dbFile = a.getString(R.styleable.GridDisplayOption_dbFile);
|
|
defaultLayoutId = a.getResourceId(
|
|
R.styleable.GridDisplayOption_defaultLayoutId, 0);
|
|
}
|
|
|
|
numSearchContainerColumns = a.getInt(
|
|
R.styleable.GridDisplayOption_numSearchContainerColumns, numColumns);
|
|
|
|
allAppsStyle = a.getResourceId(R.styleable.GridDisplayOption_allAppsStyle,
|
|
R.style.AllAppsStyleDefault);
|
|
numAllAppsColumns = a.getInt(
|
|
R.styleable.GridDisplayOption_numAllAppsColumns, numColumns);
|
|
numDatabaseAllAppsColumns = a.getInt(
|
|
R.styleable.GridDisplayOption_numExtendedAllAppsColumns, 2 * numAllAppsColumns);
|
|
|
|
numHotseatIcons = a.getInt(
|
|
R.styleable.GridDisplayOption_numHotseatIcons, numColumns);
|
|
numDatabaseHotseatIcons = a.getInt(
|
|
R.styleable.GridDisplayOption_numExtendedHotseatIcons, 2 * numHotseatIcons);
|
|
|
|
inlineNavButtonsEndSpacing =
|
|
a.getResourceId(R.styleable.GridDisplayOption_inlineNavButtonsEndSpacing,
|
|
R.dimen.taskbar_button_margin_default);
|
|
|
|
numFolderRows[INDEX_DEFAULT] = a.getInt(
|
|
R.styleable.GridDisplayOption_numFolderRows, numRows);
|
|
numFolderColumns[INDEX_DEFAULT] = a.getInt(
|
|
R.styleable.GridDisplayOption_numFolderColumns, numColumns);
|
|
|
|
if (FeatureFlags.enableResponsiveWorkspace()) {
|
|
numFolderRows[INDEX_LANDSCAPE] = a.getInt(
|
|
R.styleable.GridDisplayOption_numFolderRowsLandscape,
|
|
numFolderRows[INDEX_DEFAULT]);
|
|
numFolderColumns[INDEX_LANDSCAPE] = a.getInt(
|
|
R.styleable.GridDisplayOption_numFolderColumnsLandscape,
|
|
numFolderColumns[INDEX_DEFAULT]);
|
|
numFolderRows[INDEX_TWO_PANEL_PORTRAIT] = a.getInt(
|
|
R.styleable.GridDisplayOption_numFolderRowsTwoPanelPortrait,
|
|
numFolderRows[INDEX_DEFAULT]);
|
|
numFolderColumns[INDEX_TWO_PANEL_PORTRAIT] = a.getInt(
|
|
R.styleable.GridDisplayOption_numFolderColumnsTwoPanelPortrait,
|
|
numFolderColumns[INDEX_DEFAULT]);
|
|
numFolderRows[INDEX_TWO_PANEL_LANDSCAPE] = a.getInt(
|
|
R.styleable.GridDisplayOption_numFolderRowsTwoPanelLandscape,
|
|
numFolderRows[INDEX_DEFAULT]);
|
|
numFolderColumns[INDEX_TWO_PANEL_LANDSCAPE] = a.getInt(
|
|
R.styleable.GridDisplayOption_numFolderColumnsTwoPanelLandscape,
|
|
numFolderColumns[INDEX_DEFAULT]);
|
|
} else {
|
|
numFolderRows[INDEX_LANDSCAPE] = numFolderRows[INDEX_DEFAULT];
|
|
numFolderColumns[INDEX_LANDSCAPE] = numFolderColumns[INDEX_DEFAULT];
|
|
numFolderRows[INDEX_TWO_PANEL_PORTRAIT] = numFolderRows[INDEX_DEFAULT];
|
|
numFolderColumns[INDEX_TWO_PANEL_PORTRAIT] = numFolderColumns[INDEX_DEFAULT];
|
|
numFolderRows[INDEX_TWO_PANEL_LANDSCAPE] = numFolderRows[INDEX_DEFAULT];
|
|
numFolderColumns[INDEX_TWO_PANEL_LANDSCAPE] = numFolderColumns[INDEX_DEFAULT];
|
|
}
|
|
|
|
folderStyle = a.getResourceId(R.styleable.GridDisplayOption_folderStyle,
|
|
INVALID_RESOURCE_HANDLE);
|
|
|
|
cellStyle = a.getResourceId(R.styleable.GridDisplayOption_cellStyle,
|
|
R.style.CellStyleDefault);
|
|
|
|
isScalable = a.getBoolean(
|
|
R.styleable.GridDisplayOption_isScalable, false);
|
|
devicePaddingId = a.getResourceId(
|
|
R.styleable.GridDisplayOption_devicePaddingId, INVALID_RESOURCE_HANDLE);
|
|
|
|
if (FeatureFlags.enableResponsiveWorkspace()) {
|
|
mWorkspaceSpecsId = a.getResourceId(
|
|
R.styleable.GridDisplayOption_workspaceSpecsId, INVALID_RESOURCE_HANDLE);
|
|
mWorkspaceSpecsTwoPanelId = a.getResourceId(
|
|
R.styleable.GridDisplayOption_workspaceSpecsTwoPanelId,
|
|
mWorkspaceSpecsId);
|
|
mAllAppsSpecsId = a.getResourceId(
|
|
R.styleable.GridDisplayOption_allAppsSpecsId, INVALID_RESOURCE_HANDLE);
|
|
mAllAppsSpecsTwoPanelId = a.getResourceId(
|
|
R.styleable.GridDisplayOption_allAppsSpecsTwoPanelId,
|
|
mAllAppsSpecsId);
|
|
mFolderSpecsId = a.getResourceId(
|
|
R.styleable.GridDisplayOption_folderSpecsId, INVALID_RESOURCE_HANDLE);
|
|
mFolderSpecsTwoPanelId = a.getResourceId(
|
|
R.styleable.GridDisplayOption_folderSpecsTwoPanelId,
|
|
mFolderSpecsId);
|
|
mHotseatSpecsId = a.getResourceId(
|
|
R.styleable.GridDisplayOption_hotseatSpecsId, INVALID_RESOURCE_HANDLE);
|
|
mHotseatSpecsTwoPanelId = a.getResourceId(
|
|
R.styleable.GridDisplayOption_hotseatSpecsTwoPanelId,
|
|
mHotseatSpecsId);
|
|
mWorkspaceCellSpecsId = a.getResourceId(
|
|
R.styleable.GridDisplayOption_workspaceCellSpecsId,
|
|
INVALID_RESOURCE_HANDLE);
|
|
mWorkspaceCellSpecsTwoPanelId = a.getResourceId(
|
|
R.styleable.GridDisplayOption_workspaceCellSpecsTwoPanelId,
|
|
mWorkspaceCellSpecsId);
|
|
mAllAppsCellSpecsId = a.getResourceId(
|
|
R.styleable.GridDisplayOption_allAppsCellSpecsId,
|
|
INVALID_RESOURCE_HANDLE);
|
|
mAllAppsCellSpecsTwoPanelId = a.getResourceId(
|
|
R.styleable.GridDisplayOption_allAppsCellSpecsTwoPanelId,
|
|
mAllAppsCellSpecsId);
|
|
mNumAllAppsRowsForCellHeightCalculation = a.getInt(
|
|
R.styleable.GridDisplayOption_numAllAppsRowsForCellHeightCalculation,
|
|
numRows);
|
|
} else {
|
|
mWorkspaceSpecsId = INVALID_RESOURCE_HANDLE;
|
|
mWorkspaceSpecsTwoPanelId = INVALID_RESOURCE_HANDLE;
|
|
mAllAppsSpecsId = INVALID_RESOURCE_HANDLE;
|
|
mAllAppsSpecsTwoPanelId = INVALID_RESOURCE_HANDLE;
|
|
mFolderSpecsId = INVALID_RESOURCE_HANDLE;
|
|
mFolderSpecsTwoPanelId = INVALID_RESOURCE_HANDLE;
|
|
mHotseatSpecsId = INVALID_RESOURCE_HANDLE;
|
|
mHotseatSpecsTwoPanelId = INVALID_RESOURCE_HANDLE;
|
|
mWorkspaceCellSpecsId = INVALID_RESOURCE_HANDLE;
|
|
mWorkspaceCellSpecsTwoPanelId = INVALID_RESOURCE_HANDLE;
|
|
mAllAppsCellSpecsId = INVALID_RESOURCE_HANDLE;
|
|
mAllAppsCellSpecsTwoPanelId = INVALID_RESOURCE_HANDLE;
|
|
mNumAllAppsRowsForCellHeightCalculation = numRows;
|
|
}
|
|
|
|
mIsFixedLandscape = a.getBoolean(R.styleable.GridDisplayOption_isFixedLandscape, false);
|
|
gridType = a.getInt(R.styleable.GridDisplayOption_gridType, GRID_TYPE_ANY);
|
|
|
|
int inlineForRotation = a.getInt(R.styleable.GridDisplayOption_inlineQsb,
|
|
DONT_INLINE_QSB);
|
|
inlineQsb[INDEX_DEFAULT] =
|
|
(inlineForRotation & INLINE_QSB_FOR_PORTRAIT) == INLINE_QSB_FOR_PORTRAIT;
|
|
inlineQsb[INDEX_LANDSCAPE] =
|
|
(inlineForRotation & INLINE_QSB_FOR_LANDSCAPE) == INLINE_QSB_FOR_LANDSCAPE;
|
|
inlineQsb[INDEX_TWO_PANEL_PORTRAIT] =
|
|
(inlineForRotation & INLINE_QSB_FOR_TWO_PANEL_PORTRAIT)
|
|
== INLINE_QSB_FOR_TWO_PANEL_PORTRAIT;
|
|
inlineQsb[INDEX_TWO_PANEL_LANDSCAPE] =
|
|
(inlineForRotation & INLINE_QSB_FOR_TWO_PANEL_LANDSCAPE)
|
|
== INLINE_QSB_FOR_TWO_PANEL_LANDSCAPE;
|
|
|
|
a.recycle();
|
|
}
|
|
|
|
public boolean isEnabled(@DeviceType int deviceType) {
|
|
switch (deviceType) {
|
|
case TYPE_PHONE:
|
|
return (deviceCategory & DEVICE_CATEGORY_PHONE) == DEVICE_CATEGORY_PHONE;
|
|
case TYPE_TABLET:
|
|
return (deviceCategory & DEVICE_CATEGORY_TABLET) == DEVICE_CATEGORY_TABLET;
|
|
case TYPE_MULTI_DISPLAY:
|
|
return (deviceCategory & DEVICE_CATEGORY_MULTI_DISPLAY)
|
|
== DEVICE_CATEGORY_MULTI_DISPLAY;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns true if the grid option should be used given the flags that are toggled on/off.
|
|
*/
|
|
public boolean filterByFlag(int deviceType, boolean isFixedLandscape) {
|
|
if (deviceType == TYPE_TABLET) {
|
|
return Flags.oneGridRotationHandling() == mIsDualGrid;
|
|
}
|
|
|
|
// Here we return true if fixed landscape mode should be on.
|
|
if (mIsFixedLandscape || isFixedLandscape) {
|
|
return mIsFixedLandscape && isFixedLandscape && Flags.oneGridSpecs();
|
|
}
|
|
|
|
// If the grid type is one grid we return true when the flag is on, if the grid type
|
|
// is non-one grid we return true when the flag is off. Otherwise, we return true.
|
|
if (gridType == GRID_TYPE_ONE_GRID) {
|
|
return Flags.oneGridSpecs();
|
|
} else if (gridType == GRID_TYPE_NON_ONE_GRID) {
|
|
return !Flags.oneGridSpecs();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public static final class GridSize {
|
|
final int mNumRows;
|
|
final int mNumColumns;
|
|
final float mMinDeviceWidthPx;
|
|
final float mMinDeviceHeightPx;
|
|
final String mDbFile;
|
|
final int mDefaultLayoutId;
|
|
|
|
GridSize(Context context, AttributeSet attrs) {
|
|
TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.GridSize);
|
|
|
|
mNumRows = (int) a.getFloat(R.styleable.GridSize_numGridRows, 0);
|
|
mNumColumns = (int) a.getFloat(R.styleable.GridSize_numGridColumns, 0);
|
|
mMinDeviceWidthPx = a.getFloat(R.styleable.GridSize_minDeviceWidthPx, 0);
|
|
mMinDeviceHeightPx = a.getFloat(R.styleable.GridSize_minDeviceHeightPx, 0);
|
|
mDbFile = a.getString(R.styleable.GridSize_dbFile);
|
|
mDefaultLayoutId = a.getResourceId(
|
|
R.styleable.GridSize_defaultLayoutId, 0);
|
|
|
|
a.recycle();
|
|
}
|
|
}
|
|
|
|
@VisibleForTesting
|
|
static final class DisplayOption {
|
|
public final GridOption grid;
|
|
|
|
private final float minWidthDps;
|
|
private final float minHeightDps;
|
|
private final boolean canBeDefault;
|
|
|
|
private final PointF[] minCellSize = new PointF[COUNT_SIZES];
|
|
|
|
private final PointF[] borderSpaces = new PointF[COUNT_SIZES];
|
|
private final float[] horizontalMargin = new float[COUNT_SIZES];
|
|
private final float[] hotseatBarBottomSpace = new float[COUNT_SIZES];
|
|
private final float[] hotseatQsbSpace = new float[COUNT_SIZES];
|
|
|
|
private final float[] iconSizes = new float[COUNT_SIZES];
|
|
private final float[] textSizes = new float[COUNT_SIZES];
|
|
|
|
private final PointF[] allAppsCellSize = new PointF[COUNT_SIZES];
|
|
private final float[] allAppsIconSizes = new float[COUNT_SIZES];
|
|
private final float[] allAppsIconTextSizes = new float[COUNT_SIZES];
|
|
private final PointF[] allAppsBorderSpaces = new PointF[COUNT_SIZES];
|
|
|
|
private final float[] transientTaskbarIconSize = new float[COUNT_SIZES];
|
|
|
|
private final boolean[] startAlignTaskbar = new boolean[COUNT_SIZES];
|
|
|
|
DisplayOption(GridOption grid, Context context, AttributeSet attrs) {
|
|
this.grid = grid;
|
|
|
|
Resources res = context.getResources();
|
|
|
|
TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.ProfileDisplayOption);
|
|
|
|
minWidthDps = a.getFloat(R.styleable.ProfileDisplayOption_minWidthDps, 0);
|
|
minHeightDps = a.getFloat(R.styleable.ProfileDisplayOption_minHeightDps, 0);
|
|
|
|
canBeDefault = a.getBoolean(R.styleable.ProfileDisplayOption_canBeDefault, false);
|
|
|
|
float x;
|
|
float y;
|
|
|
|
x = a.getFloat(R.styleable.ProfileDisplayOption_minCellWidth, 0);
|
|
y = a.getFloat(R.styleable.ProfileDisplayOption_minCellHeight, 0);
|
|
minCellSize[INDEX_DEFAULT] = new PointF(x, y);
|
|
|
|
x = a.getFloat(R.styleable.ProfileDisplayOption_minCellWidthLandscape,
|
|
minCellSize[INDEX_DEFAULT].x);
|
|
y = a.getFloat(R.styleable.ProfileDisplayOption_minCellHeightLandscape,
|
|
minCellSize[INDEX_DEFAULT].y);
|
|
minCellSize[INDEX_LANDSCAPE] = new PointF(x, y);
|
|
|
|
x = a.getFloat(R.styleable.ProfileDisplayOption_minCellWidthTwoPanelPortrait,
|
|
minCellSize[INDEX_DEFAULT].x);
|
|
y = a.getFloat(R.styleable.ProfileDisplayOption_minCellHeightTwoPanelPortrait,
|
|
minCellSize[INDEX_DEFAULT].y);
|
|
minCellSize[INDEX_TWO_PANEL_PORTRAIT] = new PointF(x, y);
|
|
|
|
x = a.getFloat(R.styleable.ProfileDisplayOption_minCellWidthTwoPanelLandscape,
|
|
minCellSize[INDEX_DEFAULT].x);
|
|
y = a.getFloat(R.styleable.ProfileDisplayOption_minCellHeightTwoPanelLandscape,
|
|
minCellSize[INDEX_DEFAULT].y);
|
|
minCellSize[INDEX_TWO_PANEL_LANDSCAPE] = new PointF(x, y);
|
|
|
|
float borderSpace = a.getFloat(R.styleable.ProfileDisplayOption_borderSpace, 0);
|
|
float borderSpaceLandscape = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_borderSpaceLandscape, borderSpace);
|
|
float borderSpaceTwoPanelPortrait = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_borderSpaceTwoPanelPortrait, borderSpace);
|
|
float borderSpaceTwoPanelLandscape = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_borderSpaceTwoPanelLandscape, borderSpace);
|
|
|
|
x = a.getFloat(R.styleable.ProfileDisplayOption_borderSpaceHorizontal, borderSpace);
|
|
y = a.getFloat(R.styleable.ProfileDisplayOption_borderSpaceVertical, borderSpace);
|
|
borderSpaces[INDEX_DEFAULT] = new PointF(x, y);
|
|
|
|
x = a.getFloat(R.styleable.ProfileDisplayOption_borderSpaceLandscapeHorizontal,
|
|
borderSpaceLandscape);
|
|
y = a.getFloat(R.styleable.ProfileDisplayOption_borderSpaceLandscapeVertical,
|
|
borderSpaceLandscape);
|
|
borderSpaces[INDEX_LANDSCAPE] = new PointF(x, y);
|
|
|
|
x = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_borderSpaceTwoPanelPortraitHorizontal,
|
|
borderSpaceTwoPanelPortrait);
|
|
y = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_borderSpaceTwoPanelPortraitVertical,
|
|
borderSpaceTwoPanelPortrait);
|
|
borderSpaces[INDEX_TWO_PANEL_PORTRAIT] = new PointF(x, y);
|
|
|
|
x = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_borderSpaceTwoPanelLandscapeHorizontal,
|
|
borderSpaceTwoPanelLandscape);
|
|
y = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_borderSpaceTwoPanelLandscapeVertical,
|
|
borderSpaceTwoPanelLandscape);
|
|
borderSpaces[INDEX_TWO_PANEL_LANDSCAPE] = new PointF(x, y);
|
|
|
|
x = a.getFloat(R.styleable.ProfileDisplayOption_allAppsCellWidth,
|
|
minCellSize[INDEX_DEFAULT].x);
|
|
y = a.getFloat(R.styleable.ProfileDisplayOption_allAppsCellHeight,
|
|
minCellSize[INDEX_DEFAULT].y);
|
|
allAppsCellSize[INDEX_DEFAULT] = new PointF(x, y);
|
|
|
|
x = a.getFloat(R.styleable.ProfileDisplayOption_allAppsCellWidthLandscape,
|
|
allAppsCellSize[INDEX_DEFAULT].x);
|
|
y = a.getFloat(R.styleable.ProfileDisplayOption_allAppsCellHeightLandscape,
|
|
allAppsCellSize[INDEX_DEFAULT].y);
|
|
allAppsCellSize[INDEX_LANDSCAPE] = new PointF(x, y);
|
|
|
|
x = a.getFloat(R.styleable.ProfileDisplayOption_allAppsCellWidthTwoPanelPortrait,
|
|
allAppsCellSize[INDEX_DEFAULT].x);
|
|
y = a.getFloat(R.styleable.ProfileDisplayOption_allAppsCellHeightTwoPanelPortrait,
|
|
allAppsCellSize[INDEX_DEFAULT].y);
|
|
allAppsCellSize[INDEX_TWO_PANEL_PORTRAIT] = new PointF(x, y);
|
|
|
|
x = a.getFloat(R.styleable.ProfileDisplayOption_allAppsCellWidthTwoPanelLandscape,
|
|
allAppsCellSize[INDEX_DEFAULT].x);
|
|
y = a.getFloat(R.styleable.ProfileDisplayOption_allAppsCellHeightTwoPanelLandscape,
|
|
allAppsCellSize[INDEX_DEFAULT].y);
|
|
allAppsCellSize[INDEX_TWO_PANEL_LANDSCAPE] = new PointF(x, y);
|
|
|
|
float allAppsBorderSpace = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_allAppsBorderSpace, borderSpace);
|
|
float allAppsBorderSpaceLandscape = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_allAppsBorderSpaceLandscape,
|
|
allAppsBorderSpace);
|
|
float allAppsBorderSpaceTwoPanelPortrait = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_allAppsBorderSpaceTwoPanelPortrait,
|
|
allAppsBorderSpace);
|
|
float allAppsBorderSpaceTwoPanelLandscape = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_allAppsBorderSpaceTwoPanelLandscape,
|
|
allAppsBorderSpace);
|
|
|
|
x = a.getFloat(R.styleable.ProfileDisplayOption_allAppsBorderSpaceHorizontal,
|
|
allAppsBorderSpace);
|
|
y = a.getFloat(R.styleable.ProfileDisplayOption_allAppsBorderSpaceVertical,
|
|
allAppsBorderSpace);
|
|
allAppsBorderSpaces[INDEX_DEFAULT] = new PointF(x, y);
|
|
|
|
x = a.getFloat(R.styleable.ProfileDisplayOption_allAppsBorderSpaceLandscapeHorizontal,
|
|
allAppsBorderSpaceLandscape);
|
|
y = a.getFloat(R.styleable.ProfileDisplayOption_allAppsBorderSpaceLandscapeVertical,
|
|
allAppsBorderSpaceLandscape);
|
|
allAppsBorderSpaces[INDEX_LANDSCAPE] = new PointF(x, y);
|
|
|
|
x = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_allAppsBorderSpaceTwoPanelPortraitHorizontal,
|
|
allAppsBorderSpaceTwoPanelPortrait);
|
|
y = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_allAppsBorderSpaceTwoPanelPortraitVertical,
|
|
allAppsBorderSpaceTwoPanelPortrait);
|
|
allAppsBorderSpaces[INDEX_TWO_PANEL_PORTRAIT] = new PointF(x, y);
|
|
|
|
x = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_allAppsBorderSpaceTwoPanelLandscapeHorizontal,
|
|
allAppsBorderSpaceTwoPanelLandscape);
|
|
y = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_allAppsBorderSpaceTwoPanelLandscapeVertical,
|
|
allAppsBorderSpaceTwoPanelLandscape);
|
|
allAppsBorderSpaces[INDEX_TWO_PANEL_LANDSCAPE] = new PointF(x, y);
|
|
|
|
iconSizes[INDEX_DEFAULT] =
|
|
a.getFloat(R.styleable.ProfileDisplayOption_iconImageSize, 0);
|
|
iconSizes[INDEX_LANDSCAPE] =
|
|
a.getFloat(R.styleable.ProfileDisplayOption_iconSizeLandscape,
|
|
iconSizes[INDEX_DEFAULT]);
|
|
iconSizes[INDEX_TWO_PANEL_PORTRAIT] =
|
|
a.getFloat(R.styleable.ProfileDisplayOption_iconSizeTwoPanelPortrait,
|
|
iconSizes[INDEX_DEFAULT]);
|
|
iconSizes[INDEX_TWO_PANEL_LANDSCAPE] =
|
|
a.getFloat(R.styleable.ProfileDisplayOption_iconSizeTwoPanelLandscape,
|
|
iconSizes[INDEX_DEFAULT]);
|
|
|
|
allAppsIconSizes[INDEX_DEFAULT] = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_allAppsIconSize, iconSizes[INDEX_DEFAULT]);
|
|
allAppsIconSizes[INDEX_LANDSCAPE] = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_allAppsIconSizeLandscape,
|
|
allAppsIconSizes[INDEX_DEFAULT]);
|
|
allAppsIconSizes[INDEX_TWO_PANEL_PORTRAIT] = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_allAppsIconSizeTwoPanelPortrait,
|
|
allAppsIconSizes[INDEX_DEFAULT]);
|
|
allAppsIconSizes[INDEX_TWO_PANEL_LANDSCAPE] = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_allAppsIconSizeTwoPanelLandscape,
|
|
allAppsIconSizes[INDEX_DEFAULT]);
|
|
|
|
textSizes[INDEX_DEFAULT] =
|
|
a.getFloat(R.styleable.ProfileDisplayOption_iconTextSize, 0);
|
|
textSizes[INDEX_LANDSCAPE] =
|
|
a.getFloat(R.styleable.ProfileDisplayOption_iconTextSizeLandscape,
|
|
textSizes[INDEX_DEFAULT]);
|
|
textSizes[INDEX_TWO_PANEL_PORTRAIT] =
|
|
a.getFloat(R.styleable.ProfileDisplayOption_iconTextSizeTwoPanelPortrait,
|
|
textSizes[INDEX_DEFAULT]);
|
|
textSizes[INDEX_TWO_PANEL_LANDSCAPE] =
|
|
a.getFloat(R.styleable.ProfileDisplayOption_iconTextSizeTwoPanelLandscape,
|
|
textSizes[INDEX_DEFAULT]);
|
|
|
|
allAppsIconTextSizes[INDEX_DEFAULT] = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_allAppsIconTextSize, textSizes[INDEX_DEFAULT]);
|
|
allAppsIconTextSizes[INDEX_LANDSCAPE] = allAppsIconTextSizes[INDEX_DEFAULT];
|
|
allAppsIconTextSizes[INDEX_TWO_PANEL_PORTRAIT] = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_allAppsIconTextSizeTwoPanelPortrait,
|
|
allAppsIconTextSizes[INDEX_DEFAULT]);
|
|
allAppsIconTextSizes[INDEX_TWO_PANEL_LANDSCAPE] = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_allAppsIconTextSizeTwoPanelLandscape,
|
|
allAppsIconTextSizes[INDEX_DEFAULT]);
|
|
|
|
horizontalMargin[INDEX_DEFAULT] = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_horizontalMargin, 0);
|
|
horizontalMargin[INDEX_LANDSCAPE] = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_horizontalMarginLandscape,
|
|
horizontalMargin[INDEX_DEFAULT]);
|
|
horizontalMargin[INDEX_TWO_PANEL_LANDSCAPE] = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_horizontalMarginTwoPanelLandscape,
|
|
horizontalMargin[INDEX_DEFAULT]);
|
|
horizontalMargin[INDEX_TWO_PANEL_PORTRAIT] = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_horizontalMarginTwoPanelPortrait,
|
|
horizontalMargin[INDEX_DEFAULT]);
|
|
|
|
hotseatBarBottomSpace[INDEX_DEFAULT] = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_hotseatBarBottomSpace,
|
|
ResourcesCompat.getFloat(res, R.dimen.hotseat_bar_bottom_space_default));
|
|
hotseatBarBottomSpace[INDEX_LANDSCAPE] = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_hotseatBarBottomSpaceLandscape,
|
|
hotseatBarBottomSpace[INDEX_DEFAULT]);
|
|
hotseatBarBottomSpace[INDEX_TWO_PANEL_LANDSCAPE] = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_hotseatBarBottomSpaceTwoPanelLandscape,
|
|
hotseatBarBottomSpace[INDEX_DEFAULT]);
|
|
hotseatBarBottomSpace[INDEX_TWO_PANEL_PORTRAIT] = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_hotseatBarBottomSpaceTwoPanelPortrait,
|
|
hotseatBarBottomSpace[INDEX_DEFAULT]);
|
|
|
|
hotseatQsbSpace[INDEX_DEFAULT] = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_hotseatQsbSpace,
|
|
ResourcesCompat.getFloat(res, R.dimen.hotseat_qsb_space_default));
|
|
hotseatQsbSpace[INDEX_LANDSCAPE] = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_hotseatQsbSpaceLandscape,
|
|
hotseatQsbSpace[INDEX_DEFAULT]);
|
|
hotseatQsbSpace[INDEX_TWO_PANEL_LANDSCAPE] = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_hotseatQsbSpaceTwoPanelLandscape,
|
|
hotseatQsbSpace[INDEX_DEFAULT]);
|
|
hotseatQsbSpace[INDEX_TWO_PANEL_PORTRAIT] = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_hotseatQsbSpaceTwoPanelPortrait,
|
|
hotseatQsbSpace[INDEX_DEFAULT]);
|
|
|
|
transientTaskbarIconSize[INDEX_DEFAULT] = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_transientTaskbarIconSize,
|
|
ResourcesCompat.getFloat(res, R.dimen.taskbar_icon_size));
|
|
transientTaskbarIconSize[INDEX_LANDSCAPE] = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_transientTaskbarIconSizeLandscape,
|
|
transientTaskbarIconSize[INDEX_DEFAULT]);
|
|
transientTaskbarIconSize[INDEX_TWO_PANEL_LANDSCAPE] = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_transientTaskbarIconSizeTwoPanelLandscape,
|
|
transientTaskbarIconSize[INDEX_DEFAULT]);
|
|
transientTaskbarIconSize[INDEX_TWO_PANEL_PORTRAIT] = a.getFloat(
|
|
R.styleable.ProfileDisplayOption_transientTaskbarIconSizeTwoPanelPortrait,
|
|
transientTaskbarIconSize[INDEX_DEFAULT]);
|
|
|
|
startAlignTaskbar[INDEX_DEFAULT] = a.getBoolean(
|
|
R.styleable.ProfileDisplayOption_startAlignTaskbar, false);
|
|
startAlignTaskbar[INDEX_LANDSCAPE] = a.getBoolean(
|
|
R.styleable.ProfileDisplayOption_startAlignTaskbarLandscape,
|
|
startAlignTaskbar[INDEX_DEFAULT]);
|
|
startAlignTaskbar[INDEX_TWO_PANEL_LANDSCAPE] = a.getBoolean(
|
|
R.styleable.ProfileDisplayOption_startAlignTaskbarTwoPanelLandscape,
|
|
startAlignTaskbar[INDEX_LANDSCAPE]);
|
|
startAlignTaskbar[INDEX_TWO_PANEL_PORTRAIT] = a.getBoolean(
|
|
R.styleable.ProfileDisplayOption_startAlignTaskbarTwoPanelPortrait,
|
|
startAlignTaskbar[INDEX_DEFAULT]);
|
|
|
|
a.recycle();
|
|
}
|
|
|
|
DisplayOption() {
|
|
this(null);
|
|
}
|
|
|
|
DisplayOption(GridOption grid) {
|
|
this.grid = grid;
|
|
minWidthDps = 0;
|
|
minHeightDps = 0;
|
|
canBeDefault = false;
|
|
for (int i = 0; i < COUNT_SIZES; i++) {
|
|
iconSizes[i] = 0;
|
|
textSizes[i] = 0;
|
|
borderSpaces[i] = new PointF();
|
|
minCellSize[i] = new PointF();
|
|
allAppsCellSize[i] = new PointF();
|
|
allAppsIconSizes[i] = 0;
|
|
allAppsIconTextSizes[i] = 0;
|
|
allAppsBorderSpaces[i] = new PointF();
|
|
transientTaskbarIconSize[i] = 0;
|
|
startAlignTaskbar[i] = false;
|
|
}
|
|
}
|
|
|
|
private DisplayOption multiply(float w) {
|
|
for (int i = 0; i < COUNT_SIZES; i++) {
|
|
iconSizes[i] *= w;
|
|
textSizes[i] *= w;
|
|
borderSpaces[i].x *= w;
|
|
borderSpaces[i].y *= w;
|
|
minCellSize[i].x *= w;
|
|
minCellSize[i].y *= w;
|
|
horizontalMargin[i] *= w;
|
|
hotseatBarBottomSpace[i] *= w;
|
|
hotseatQsbSpace[i] *= w;
|
|
allAppsCellSize[i].x *= w;
|
|
allAppsCellSize[i].y *= w;
|
|
allAppsIconSizes[i] *= w;
|
|
allAppsIconTextSizes[i] *= w;
|
|
allAppsBorderSpaces[i].x *= w;
|
|
allAppsBorderSpaces[i].y *= w;
|
|
transientTaskbarIconSize[i] *= w;
|
|
}
|
|
|
|
return this;
|
|
}
|
|
|
|
private DisplayOption add(DisplayOption p) {
|
|
for (int i = 0; i < COUNT_SIZES; i++) {
|
|
iconSizes[i] += p.iconSizes[i];
|
|
textSizes[i] += p.textSizes[i];
|
|
borderSpaces[i].x += p.borderSpaces[i].x;
|
|
borderSpaces[i].y += p.borderSpaces[i].y;
|
|
minCellSize[i].x += p.minCellSize[i].x;
|
|
minCellSize[i].y += p.minCellSize[i].y;
|
|
horizontalMargin[i] += p.horizontalMargin[i];
|
|
hotseatBarBottomSpace[i] += p.hotseatBarBottomSpace[i];
|
|
hotseatQsbSpace[i] += p.hotseatQsbSpace[i];
|
|
allAppsCellSize[i].x += p.allAppsCellSize[i].x;
|
|
allAppsCellSize[i].y += p.allAppsCellSize[i].y;
|
|
allAppsIconSizes[i] += p.allAppsIconSizes[i];
|
|
allAppsIconTextSizes[i] += p.allAppsIconTextSizes[i];
|
|
allAppsBorderSpaces[i].x += p.allAppsBorderSpaces[i].x;
|
|
allAppsBorderSpaces[i].y += p.allAppsBorderSpaces[i].y;
|
|
transientTaskbarIconSize[i] += p.transientTaskbarIconSize[i];
|
|
startAlignTaskbar[i] |= p.startAlignTaskbar[i];
|
|
}
|
|
|
|
return this;
|
|
}
|
|
}
|
|
}
|