Charlie Anderson
cd4382aa43
Bug: 413707700 Test: N/A just logs Flag: EXEMPT just logs Change-Id: I2377a6bcf7fa8d219fec784570ff92eface1118e
514 lines
22 KiB
Java
514 lines
22 KiB
Java
/*
|
|
* Copyright (C) 2023 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.graphics;
|
|
|
|
import static com.android.launcher3.BuildConfig.IS_DEBUG_DEVICE;
|
|
import static com.android.launcher3.Flags.enableLauncherIconShapes;
|
|
import static com.android.launcher3.graphics.PreviewSurfaceRenderer.KEY_BITMAP_GENERATION_DELAY_MS;
|
|
import static com.android.launcher3.graphics.PreviewSurfaceRenderer.KEY_VIEW_HEIGHT;
|
|
import static com.android.launcher3.graphics.PreviewSurfaceRenderer.KEY_VIEW_WIDTH;
|
|
import static com.android.launcher3.graphics.PreviewSurfaceRenderer.MIN_BITMAP_GENERATION_DELAY_MS;
|
|
import static com.android.launcher3.graphics.ThemeManager.PREF_ICON_SHAPE;
|
|
import static com.android.launcher3.util.Executors.MAIN_EXECUTOR;
|
|
import static com.android.launcher3.util.Executors.UI_HELPER_EXECUTOR;
|
|
|
|
import static java.util.Objects.requireNonNullElse;
|
|
import static java.util.concurrent.CompletableFuture.delayedExecutor;
|
|
import static java.util.concurrent.TimeUnit.MILLISECONDS;
|
|
|
|
import android.content.ContentValues;
|
|
import android.content.Context;
|
|
import android.database.Cursor;
|
|
import android.database.MatrixCursor;
|
|
import android.graphics.Bitmap;
|
|
import android.net.Uri;
|
|
import android.os.Binder;
|
|
import android.os.Bundle;
|
|
import android.os.Handler;
|
|
import android.os.IBinder.DeathRecipient;
|
|
import android.os.Message;
|
|
import android.os.Messenger;
|
|
import android.text.TextUtils;
|
|
import android.util.Log;
|
|
|
|
import androidx.annotation.NonNull;
|
|
|
|
import com.android.launcher3.InvariantDeviceProfile;
|
|
import com.android.launcher3.InvariantDeviceProfile.GridOption;
|
|
import com.android.launcher3.LauncherAppState;
|
|
import com.android.launcher3.LauncherModel;
|
|
import com.android.launcher3.LauncherPrefs;
|
|
import com.android.launcher3.dagger.ApplicationContext;
|
|
import com.android.launcher3.dagger.LauncherAppSingleton;
|
|
import com.android.launcher3.model.BgDataModel;
|
|
import com.android.launcher3.shapes.IconShapeModel;
|
|
import com.android.launcher3.shapes.ShapesProvider;
|
|
import com.android.launcher3.util.ApiWrapper;
|
|
import com.android.launcher3.util.ContentProviderProxy.ProxyProvider;
|
|
import com.android.launcher3.util.DaggerSingletonTracker;
|
|
import com.android.launcher3.util.Executors;
|
|
import com.android.launcher3.util.Preconditions;
|
|
import com.android.launcher3.util.RunnableList;
|
|
import com.android.systemui.shared.Flags;
|
|
|
|
import java.lang.ref.WeakReference;
|
|
import java.util.Arrays;
|
|
import java.util.Collections;
|
|
import java.util.Comparator;
|
|
import java.util.List;
|
|
import java.util.Set;
|
|
import java.util.concurrent.ConcurrentHashMap;
|
|
import java.util.concurrent.ExecutionException;
|
|
|
|
import javax.inject.Inject;
|
|
|
|
/**
|
|
* Exposes various launcher grid options and allows the caller to change them.
|
|
* APIs:
|
|
* /shape_options: List of various available shape options, where each has following fields
|
|
* shape_key: key of the shape option
|
|
* title: translated title of the shape option
|
|
* path: path of the shape, assuming drawn on 100x100 view port
|
|
* is_default: true if this shape option is currently set to the system
|
|
*
|
|
* /list_options: List the various available grid options, where each has following fields
|
|
* name: key of the grid option
|
|
* rows: number of rows in the grid
|
|
* cols: number of columns in the grid
|
|
* preview_count: number of previews available for this grid option. The preview uri
|
|
* looks like /preview/[grid-name]/[preview index starting with 0]
|
|
* is_default: true if this grid option is currently set to the system
|
|
*
|
|
* /get_preview: Open a file stream for the grid preview
|
|
*
|
|
* /default_grid: Call update to set the current shape and grid, with values
|
|
* shape_key: key of the shape to apply
|
|
* name: key of the grid to apply
|
|
*/
|
|
@LauncherAppSingleton
|
|
public class GridCustomizationsProxy implements ProxyProvider {
|
|
|
|
private static final String TAG = "GridCustomizationsProvider";
|
|
|
|
// KEY_NAME is the name of the grid used internally while the KEY_GRID_TITLE is the translated
|
|
// string title of the grid.
|
|
private static final String KEY_NAME = "name";
|
|
private static final String KEY_GRID_TITLE = "grid_title";
|
|
private static final String KEY_ROWS = "rows";
|
|
private static final String KEY_COLS = "cols";
|
|
private static final String KEY_GRID_ICON_ID = "grid_icon_id";
|
|
private static final String KEY_PREVIEW_COUNT = "preview_count";
|
|
// is_default means if a certain option is currently set to the system
|
|
private static final String KEY_IS_DEFAULT = "is_default";
|
|
private static final String KEY_SHAPE_KEY = "shape_key";
|
|
private static final String KEY_SHAPE_TITLE = "shape_title";
|
|
private static final String KEY_PATH = "path";
|
|
|
|
// list_options is the key for grid option list
|
|
private static final String KEY_LIST_OPTIONS = "/list_options";
|
|
private static final String KEY_SHAPE_OPTIONS = "/shape_options";
|
|
// default_grid is for setting grid and shape to system settings
|
|
private static final String KEY_DEFAULT_GRID = "/default_grid";
|
|
private static final String SET_SHAPE = "/shape";
|
|
|
|
private static final String METHOD_GET_PREVIEW = "get_preview";
|
|
public static final String METHOD_GET_PREVIEW_BITMAP = "get_preview_bitmap";
|
|
|
|
private static final String GET_ICON_THEMED = "/get_icon_themed";
|
|
private static final String SET_ICON_THEMED = "/set_icon_themed";
|
|
private static final String ICON_THEMED = "/icon_themed";
|
|
private static final String BOOLEAN_VALUE = "boolean_value";
|
|
|
|
private static final String KEY_SURFACE_PACKAGE = "surface_package";
|
|
private static final String KEY_CALLBACK = "callback";
|
|
public static final String KEY_HIDE_BOTTOM_ROW = "hide_bottom_row";
|
|
public static final String KEY_GRID_NAME = "grid_name";
|
|
public static final String KEY_IMAGE = "image";
|
|
|
|
private static final int MESSAGE_ID_UPDATE_PREVIEW = 1337;
|
|
private static final int MESSAGE_ID_UPDATE_SHAPE = 2586;
|
|
private static final int MESSAGE_ID_UPDATE_GRID = 7414;
|
|
private static final int MESSAGE_ID_UPDATE_COLOR = 856;
|
|
private static final int MESSAGE_ID_UPDATE_ICON_THEMED = 311;
|
|
|
|
// Set of all active previews used to track duplicate memory allocations
|
|
private final Set<PreviewLifecycleObserver> mActivePreviews =
|
|
Collections.newSetFromMap(new ConcurrentHashMap<>());
|
|
|
|
private final Context mContext;
|
|
private final ThemeManager mThemeManager;
|
|
private final LauncherPrefs mPrefs;
|
|
private final InvariantDeviceProfile mIdp;
|
|
|
|
@Inject
|
|
protected GridCustomizationsProxy(
|
|
@ApplicationContext Context context,
|
|
ThemeManager themeManager,
|
|
LauncherPrefs prefs,
|
|
InvariantDeviceProfile idp,
|
|
DaggerSingletonTracker lifeCycle
|
|
) {
|
|
mContext = context;
|
|
mThemeManager = themeManager;
|
|
mPrefs = prefs;
|
|
mIdp = idp;
|
|
lifeCycle.addCloseable(() -> mActivePreviews.forEach(PreviewLifecycleObserver::binderDied));
|
|
}
|
|
|
|
@Override
|
|
public Cursor query(Uri uri, String[] projection, String selection,
|
|
String[] selectionArgs, String sortOrder) {
|
|
String path = uri.getPath();
|
|
if (IS_DEBUG_DEVICE) {
|
|
Log.d(TAG, "query: path=" + path);
|
|
}
|
|
if (path == null) {
|
|
return null;
|
|
}
|
|
|
|
switch (path) {
|
|
case KEY_SHAPE_OPTIONS: {
|
|
if (Flags.newCustomizationPickerUi()) {
|
|
MatrixCursor cursor = new MatrixCursor(new String[]{
|
|
KEY_SHAPE_KEY, KEY_SHAPE_TITLE, KEY_PATH, KEY_IS_DEFAULT});
|
|
final String currentShape = mPrefs.get(PREF_ICON_SHAPE);
|
|
IconShapeModel[] availableShapes = ShapesProvider.INSTANCE.getIconShapes();
|
|
|
|
if (availableShapes.length == 0) {
|
|
// This is unexpected as we should always provide at least 1 default shape.
|
|
Log.e(TAG, "query: No icon shape options are available"
|
|
+ ", returning null.");
|
|
return null;
|
|
} else {
|
|
Log.d(TAG, "query: Found " + availableShapes.length
|
|
+ " available shape options");
|
|
}
|
|
|
|
// Assign first available shape as default if current shape doesn't exist.
|
|
boolean doesCurrentShapeExist = Arrays.stream(availableShapes)
|
|
.anyMatch(shape -> shape.getKey().equals(currentShape));
|
|
String selectedShape = !TextUtils.isEmpty(currentShape) && doesCurrentShapeExist
|
|
? currentShape
|
|
: availableShapes[0].getKey();
|
|
|
|
for (IconShapeModel shape : availableShapes) {
|
|
cursor.newRow()
|
|
.add(KEY_SHAPE_KEY, shape.getKey())
|
|
.add(KEY_SHAPE_TITLE, mContext.getString(shape.getTitleId()))
|
|
.add(KEY_PATH, shape.getPathString())
|
|
.add(KEY_IS_DEFAULT, shape.getKey().equals(selectedShape));
|
|
}
|
|
return cursor;
|
|
} else {
|
|
Log.w(TAG, "query: Shape options queried outside of flag"
|
|
+ ", returning null.");
|
|
return null;
|
|
}
|
|
}
|
|
case KEY_LIST_OPTIONS: {
|
|
MatrixCursor cursor = new MatrixCursor(new String[]{
|
|
KEY_NAME, KEY_GRID_TITLE, KEY_ROWS, KEY_COLS, KEY_PREVIEW_COUNT,
|
|
KEY_IS_DEFAULT, KEY_GRID_ICON_ID});
|
|
List<GridOption> gridOptionList = mIdp.parseAllGridOptions(mContext);
|
|
if (gridOptionList.isEmpty()) {
|
|
Log.e(TAG, "query: No grid options are available, returning null.");
|
|
return null;
|
|
} else {
|
|
Log.d(TAG, "query: Found " + gridOptionList.size()
|
|
+ " available grid options.");
|
|
}
|
|
if (com.android.launcher3.Flags.oneGridSpecs()) {
|
|
gridOptionList.sort(Comparator
|
|
.comparingInt((GridOption option) -> option.numColumns)
|
|
.reversed());
|
|
}
|
|
for (GridOption gridOption : gridOptionList) {
|
|
cursor.newRow()
|
|
.add(KEY_NAME, gridOption.name)
|
|
.add(KEY_GRID_TITLE, gridOption.gridTitle)
|
|
.add(KEY_ROWS, gridOption.numRows)
|
|
.add(KEY_COLS, gridOption.numColumns)
|
|
.add(KEY_PREVIEW_COUNT, 1)
|
|
.add(KEY_IS_DEFAULT, mIdp.numColumns == gridOption.numColumns
|
|
&& mIdp.numRows == gridOption.numRows)
|
|
.add(KEY_GRID_ICON_ID, gridOption.gridIconId);
|
|
}
|
|
return cursor;
|
|
}
|
|
case GET_ICON_THEMED:
|
|
case ICON_THEMED: {
|
|
MatrixCursor cursor = new MatrixCursor(new String[]{BOOLEAN_VALUE});
|
|
cursor.newRow().add(BOOLEAN_VALUE, mThemeManager.isMonoThemeEnabled() ? 1 : 0);
|
|
Log.d(TAG, "query: path=" + path
|
|
+ ", isMonoThemeEnabled=" + mThemeManager.isMonoThemeEnabled());
|
|
return cursor;
|
|
}
|
|
default: {
|
|
Log.d(TAG, "query: path=" + path + " not found, returning null.");
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
|
|
String path = uri.getPath();
|
|
if (path == null) {
|
|
return 0;
|
|
}
|
|
switch (path) {
|
|
case KEY_DEFAULT_GRID: {
|
|
String gridName = values.getAsString(KEY_NAME);
|
|
// Verify that this is a valid grid option
|
|
GridOption match = null;
|
|
for (GridOption option : mIdp.parseAllGridOptions(mContext)) {
|
|
String name = option.name;
|
|
if (name != null && name.equals(gridName)) {
|
|
match = option;
|
|
break;
|
|
}
|
|
}
|
|
if (match == null) {
|
|
return 0;
|
|
}
|
|
mIdp.setCurrentGrid(mContext, gridName);
|
|
if (Flags.newCustomizationPickerUi()) {
|
|
try {
|
|
// Wait for device profile to be fully reloaded and applied to the launcher
|
|
loadModelSync(mContext);
|
|
} catch (ExecutionException | InterruptedException e) {
|
|
Log.e(TAG, "Fail to load model", e);
|
|
}
|
|
}
|
|
mContext.getContentResolver().notifyChange(uri, null);
|
|
return 1;
|
|
}
|
|
case SET_SHAPE:
|
|
if (Flags.newCustomizationPickerUi()) {
|
|
mPrefs.put(PREF_ICON_SHAPE,
|
|
requireNonNullElse(values.getAsString(KEY_SHAPE_KEY), ""));
|
|
}
|
|
return 1;
|
|
case ICON_THEMED:
|
|
case SET_ICON_THEMED: {
|
|
mThemeManager.setMonoThemeEnabled(values.getAsBoolean(BOOLEAN_VALUE));
|
|
mContext.getContentResolver().notifyChange(uri, null);
|
|
return 1;
|
|
}
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Loads the model in memory synchronously
|
|
*/
|
|
private void loadModelSync(Context context) throws ExecutionException, InterruptedException {
|
|
Preconditions.assertNonUiThread();
|
|
BgDataModel.Callbacks emptyCallbacks = new BgDataModel.Callbacks() { };
|
|
LauncherModel launcherModel = LauncherAppState.getInstance(context).getModel();
|
|
MAIN_EXECUTOR.submit(
|
|
() -> launcherModel.addCallbacksAndLoad(emptyCallbacks)
|
|
).get();
|
|
|
|
Executors.MODEL_EXECUTOR.submit(() -> { }).get();
|
|
MAIN_EXECUTOR.submit(
|
|
() -> launcherModel.removeCallbacks(emptyCallbacks)
|
|
).get();
|
|
}
|
|
|
|
@Override
|
|
public Bundle call(@NonNull String method, String arg, Bundle extras) {
|
|
return switch (method) {
|
|
case METHOD_GET_PREVIEW -> getPreview(extras);
|
|
case METHOD_GET_PREVIEW_BITMAP -> getPreviewBitmap(extras);
|
|
default -> null;
|
|
};
|
|
}
|
|
|
|
private Bundle getPreviewBitmap(Bundle request) {
|
|
RunnableList lifeCycleTracker = new RunnableList();
|
|
try {
|
|
int width = request.getInt(KEY_VIEW_WIDTH);
|
|
int height = request.getInt(KEY_VIEW_HEIGHT);
|
|
long previewDelay = Math.max(request.getLong(KEY_BITMAP_GENERATION_DELAY_MS, 0),
|
|
MIN_BITMAP_GENERATION_DELAY_MS);
|
|
|
|
PreviewSurfaceRenderer renderer = new PreviewSurfaceRenderer(
|
|
mContext, lifeCycleTracker, request, Binder.getCallingPid(),
|
|
true /* skip animations */);
|
|
renderer.loadAsync().thenRunAsync(
|
|
() -> { }, delayedExecutor(previewDelay, MILLISECONDS, MAIN_EXECUTOR)).get();
|
|
Bitmap previewBitmap = ApiWrapper.INSTANCE.get(mContext)
|
|
.captureSnapshot(renderer.getHost(), width, height);
|
|
|
|
Bundle result = new Bundle();
|
|
result.putParcelable(KEY_IMAGE, previewBitmap);
|
|
return result;
|
|
} catch (Exception e) {
|
|
Log.e(TAG, "Unable to generate preview", e);
|
|
}
|
|
MAIN_EXECUTOR.execute(lifeCycleTracker::executeAllAndDestroy);
|
|
return null;
|
|
}
|
|
|
|
private synchronized Bundle getPreview(Bundle request) {
|
|
RunnableList lifeCycleTracker = new RunnableList();
|
|
try {
|
|
PreviewSurfaceRenderer renderer = new PreviewSurfaceRenderer(
|
|
mContext, lifeCycleTracker, request, Binder.getCallingPid(),
|
|
false /* skip animations */);
|
|
PreviewLifecycleObserver observer =
|
|
new PreviewLifecycleObserver(lifeCycleTracker, renderer);
|
|
|
|
// Destroy previous renderers to avoid any duplicate memory
|
|
mActivePreviews.stream().filter(observer::isSameRenderer).forEach(o ->
|
|
MAIN_EXECUTOR.execute(o.lifeCycleTracker::executeAllAndDestroy));
|
|
|
|
renderer.loadAsync();
|
|
lifeCycleTracker.add(() -> renderer.getHostToken().unlinkToDeath(observer, 0));
|
|
renderer.getHostToken().linkToDeath(observer, 0);
|
|
|
|
Bundle result = new Bundle();
|
|
result.putParcelable(KEY_SURFACE_PACKAGE, renderer.getHost().getSurfacePackage());
|
|
|
|
mActivePreviews.add(observer);
|
|
lifeCycleTracker.add(() -> mActivePreviews.remove(observer));
|
|
|
|
// Wrap the callback in a weak reference. This ensures that the callback is not kept
|
|
// alive due to the Messenger's IBinder
|
|
Messenger messenger = new Messenger(new Handler(
|
|
UI_HELPER_EXECUTOR.getLooper(),
|
|
new WeakCallbackWrapper(observer)));
|
|
|
|
Message msg = Message.obtain();
|
|
msg.replyTo = messenger;
|
|
result.putParcelable(KEY_CALLBACK, msg);
|
|
return result;
|
|
} catch (Exception e) {
|
|
Log.e(TAG, "Unable to generate preview", e);
|
|
MAIN_EXECUTOR.execute(lifeCycleTracker::executeAllAndDestroy);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private static class PreviewLifecycleObserver implements Handler.Callback, DeathRecipient {
|
|
|
|
public final RunnableList lifeCycleTracker;
|
|
public final PreviewSurfaceRenderer renderer;
|
|
public boolean destroyed = false;
|
|
|
|
PreviewLifecycleObserver(
|
|
RunnableList lifeCycleTracker,
|
|
PreviewSurfaceRenderer renderer) {
|
|
this.lifeCycleTracker = lifeCycleTracker;
|
|
this.renderer = renderer;
|
|
lifeCycleTracker.add(() -> destroyed = true);
|
|
// Preview grid change currently affects actual widget size. Revert grid changes
|
|
// when preview is destroyed to make sure Launcher widgets display correctly.
|
|
lifeCycleTracker.add(() -> renderer.updateGrid(null));
|
|
}
|
|
|
|
@Override
|
|
public boolean handleMessage(Message message) {
|
|
if (destroyed) {
|
|
return true;
|
|
}
|
|
|
|
switch (message.what) {
|
|
case MESSAGE_ID_UPDATE_PREVIEW:
|
|
renderer.hideBottomRow(message.getData().getBoolean(KEY_HIDE_BOTTOM_ROW));
|
|
break;
|
|
case MESSAGE_ID_UPDATE_SHAPE:
|
|
if (Flags.newCustomizationPickerUi()
|
|
&& enableLauncherIconShapes()) {
|
|
String shapeKey = message.getData().getString(KEY_SHAPE_KEY);
|
|
if (!TextUtils.isEmpty(shapeKey)) {
|
|
renderer.updateShape(shapeKey);
|
|
}
|
|
}
|
|
break;
|
|
case MESSAGE_ID_UPDATE_GRID:
|
|
String gridName = message.getData().getString(KEY_GRID_NAME);
|
|
renderer.updateGrid(gridName);
|
|
break;
|
|
case MESSAGE_ID_UPDATE_COLOR:
|
|
if (Flags.newCustomizationPickerUi()) {
|
|
renderer.previewColor(message.getData());
|
|
}
|
|
break;
|
|
case MESSAGE_ID_UPDATE_ICON_THEMED:
|
|
if (Flags.newCustomizationPickerUi()) {
|
|
boolean iconThemed = message.getData().getBoolean(BOOLEAN_VALUE);
|
|
renderer.updateTheme(iconThemed);
|
|
}
|
|
break;
|
|
default:
|
|
// Unknown command, destroy lifecycle
|
|
Log.d(TAG, "Unknown preview command: " + message.what + ", destroying preview");
|
|
MAIN_EXECUTOR.execute(lifeCycleTracker::executeAllAndDestroy);
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
@Override
|
|
public void binderDied() {
|
|
MAIN_EXECUTOR.execute(lifeCycleTracker::executeAllAndDestroy);
|
|
}
|
|
|
|
/**
|
|
* Two renderers are considered same if they have the same host token and display Id
|
|
*/
|
|
public boolean isSameRenderer(PreviewLifecycleObserver plo) {
|
|
return plo != null
|
|
&& plo.renderer.getHostToken().equals(renderer.getHostToken())
|
|
&& plo.renderer.getDisplayId() == renderer.getDisplayId();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A WeakReference wrapper around Handler.Callback to avoid passing hard-reference over IPC
|
|
* when using a Messenger
|
|
*/
|
|
private static class WeakCallbackWrapper implements Handler.Callback {
|
|
|
|
private final WeakReference<Handler.Callback> mActual;
|
|
private final Message mCleanupMessage;
|
|
|
|
WeakCallbackWrapper(Handler.Callback actual) {
|
|
mActual = new WeakReference<>(actual);
|
|
mCleanupMessage = new Message();
|
|
}
|
|
|
|
@Override
|
|
public boolean handleMessage(Message message) {
|
|
Handler.Callback actual = mActual.get();
|
|
return actual != null && actual.handleMessage(message);
|
|
}
|
|
|
|
@Override
|
|
protected void finalize() throws Throwable {
|
|
super.finalize();
|
|
Handler.Callback actual = mActual.get();
|
|
if (actual != null) {
|
|
actual.handleMessage(mCleanupMessage);
|
|
}
|
|
}
|
|
}
|
|
}
|