436 lines
16 KiB
Java
436 lines
16 KiB
Java
/*
|
|
* Copyright (C) 2022 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.wm.shell.compatui;
|
|
|
|
import static android.view.WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE;
|
|
import static android.view.WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL;
|
|
import static android.view.WindowManager.LayoutParams.PRIVATE_FLAG_NO_MOVE_ANIMATION;
|
|
import static android.view.WindowManager.LayoutParams.PRIVATE_FLAG_TRUSTED_OVERLAY;
|
|
import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY;
|
|
|
|
import static com.android.internal.annotations.VisibleForTesting.Visibility.PACKAGE;
|
|
import static com.android.internal.annotations.VisibleForTesting.Visibility.PRIVATE;
|
|
import static com.android.internal.annotations.VisibleForTesting.Visibility.PROTECTED;
|
|
|
|
import android.annotation.NonNull;
|
|
import android.annotation.Nullable;
|
|
import android.app.TaskInfo;
|
|
import android.content.Context;
|
|
import android.content.res.Configuration;
|
|
import android.graphics.PixelFormat;
|
|
import android.graphics.Rect;
|
|
import android.os.Binder;
|
|
import android.util.Log;
|
|
import android.view.IWindow;
|
|
import android.view.SurfaceControl;
|
|
import android.view.SurfaceControlViewHost;
|
|
import android.view.SurfaceSession;
|
|
import android.view.View;
|
|
import android.view.WindowManager;
|
|
import android.view.WindowlessWindowManager;
|
|
|
|
import com.android.internal.annotations.VisibleForTesting;
|
|
import com.android.wm.shell.ShellTaskOrganizer;
|
|
import com.android.wm.shell.common.DisplayLayout;
|
|
import com.android.wm.shell.common.SyncTransactionQueue;
|
|
|
|
/**
|
|
* A superclass for all Compat UI {@link WindowlessWindowManager}s that holds shared logic and
|
|
* exposes general API for {@link CompatUIController}.
|
|
*
|
|
* <p>Holds view hierarchy of a root surface and helps to inflate and manage layout.
|
|
*/
|
|
public abstract class CompatUIWindowManagerAbstract extends WindowlessWindowManager {
|
|
|
|
protected final int mTaskId;
|
|
protected Context mContext;
|
|
|
|
private final SyncTransactionQueue mSyncQueue;
|
|
private final int mDisplayId;
|
|
private Configuration mTaskConfig;
|
|
private ShellTaskOrganizer.TaskListener mTaskListener;
|
|
private DisplayLayout mDisplayLayout;
|
|
private final Rect mStableBounds;
|
|
|
|
@NonNull
|
|
private TaskInfo mTaskInfo;
|
|
|
|
/**
|
|
* Utility class for adding and releasing a View hierarchy for this {@link
|
|
* WindowlessWindowManager} to {@code mLeash}.
|
|
*/
|
|
@Nullable
|
|
protected SurfaceControlViewHost mViewHost;
|
|
|
|
/**
|
|
* A surface leash to position the layout relative to the task, since we can't set position for
|
|
* the {@code mViewHost} directly.
|
|
*/
|
|
@Nullable
|
|
protected SurfaceControl mLeash;
|
|
|
|
protected CompatUIWindowManagerAbstract(Context context, TaskInfo taskInfo,
|
|
SyncTransactionQueue syncQueue, ShellTaskOrganizer.TaskListener taskListener,
|
|
DisplayLayout displayLayout) {
|
|
super(taskInfo.configuration, null /* rootSurface */, null /* hostInputToken */);
|
|
mTaskInfo = taskInfo;
|
|
mContext = context;
|
|
mSyncQueue = syncQueue;
|
|
mTaskConfig = taskInfo.configuration;
|
|
mDisplayId = mContext.getDisplayId();
|
|
mTaskId = taskInfo.taskId;
|
|
mTaskListener = taskListener;
|
|
mDisplayLayout = displayLayout;
|
|
mStableBounds = new Rect();
|
|
mDisplayLayout.getStableBounds(mStableBounds);
|
|
}
|
|
|
|
/**
|
|
* @return {@code true} if the instance of the specific {@link CompatUIWindowManagerAbstract}
|
|
* for the current task id needs to be recreated loading the related resources. This happens
|
|
* if the user switches between Light/Dark mode, if the device is docked/undocked or if the
|
|
* user switches between multi-window mode to fullscreen where the
|
|
* {@link ShellTaskOrganizer.TaskListener} implementation is different.
|
|
*/
|
|
boolean needsToBeRecreated(TaskInfo taskInfo, ShellTaskOrganizer.TaskListener taskListener) {
|
|
return hasUiModeChanged(mTaskInfo, taskInfo) || hasTaskListenerChanged(taskListener);
|
|
}
|
|
|
|
/**
|
|
* Returns the z-order of this window which will be passed to the {@link SurfaceControl} once
|
|
* {@link #attachToParentSurface} is called.
|
|
*
|
|
* <p>See {@link SurfaceControl.Transaction#setLayer}.
|
|
*/
|
|
protected abstract int getZOrder();
|
|
|
|
/** Returns the layout of this window manager. */
|
|
protected abstract @Nullable View getLayout();
|
|
|
|
/**
|
|
* Inflates and inits the layout of this window manager on to the root surface if both {@code
|
|
* canShow} and {@link #eligibleToShowLayout} are true.
|
|
*
|
|
* <p>Doesn't do anything if layout is not eligible to be shown.
|
|
*
|
|
* @param canShow whether the layout is allowed to be shown by the parent controller.
|
|
* @return whether the layout is eligible to be shown.
|
|
*/
|
|
@VisibleForTesting(visibility = PROTECTED)
|
|
public boolean createLayout(boolean canShow) {
|
|
if (!eligibleToShowLayout()) {
|
|
return false;
|
|
}
|
|
if (!canShow || getLayout() != null) {
|
|
// Wait until layout should be visible, or layout was already created.
|
|
return true;
|
|
}
|
|
|
|
if (mViewHost != null) {
|
|
throw new IllegalStateException(
|
|
"A UI has already been created with this window manager.");
|
|
}
|
|
|
|
// Construction extracted into separate methods to allow injection for tests.
|
|
mViewHost = createSurfaceViewHost();
|
|
mViewHost.setView(createLayout(), getWindowLayoutParams());
|
|
|
|
updateSurfacePosition();
|
|
|
|
return true;
|
|
}
|
|
|
|
/** Inflates and inits the layout of this window manager. */
|
|
protected abstract View createLayout();
|
|
|
|
protected abstract void removeLayout();
|
|
|
|
/**
|
|
* Whether the layout is eligible to be shown according to the internal state of the subclass.
|
|
*/
|
|
protected abstract boolean eligibleToShowLayout();
|
|
|
|
@Override
|
|
public void setConfiguration(Configuration configuration) {
|
|
super.setConfiguration(configuration);
|
|
mContext = mContext.createConfigurationContext(configuration);
|
|
}
|
|
|
|
@Override
|
|
protected SurfaceControl getParentSurface(IWindow window, WindowManager.LayoutParams attrs) {
|
|
String className = getClass().getSimpleName();
|
|
final SurfaceControl.Builder builder = new SurfaceControl.Builder(new SurfaceSession())
|
|
.setContainerLayer()
|
|
.setName(className + "Leash")
|
|
.setHidden(false)
|
|
.setCallsite(className + "#attachToParentSurface");
|
|
attachToParentSurface(builder);
|
|
mLeash = builder.build();
|
|
initSurface(mLeash);
|
|
return mLeash;
|
|
}
|
|
|
|
protected ShellTaskOrganizer.TaskListener getTaskListener() {
|
|
return mTaskListener;
|
|
}
|
|
|
|
/** Inits the z-order of the surface. */
|
|
private void initSurface(SurfaceControl leash) {
|
|
final int z = getZOrder();
|
|
mSyncQueue.runInSync(t -> {
|
|
if (leash == null || !leash.isValid()) {
|
|
Log.w(getTag(), "The leash has been released.");
|
|
return;
|
|
}
|
|
t.setLayer(leash, z);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Called when compat info changed.
|
|
*
|
|
* <p>The window manager is released if the layout is no longer eligible to be shown.
|
|
*
|
|
* @param canShow whether the layout is allowed to be shown by the parent controller.
|
|
* @return whether the layout is eligible to be shown.
|
|
*/
|
|
@VisibleForTesting(visibility = PROTECTED)
|
|
public boolean updateCompatInfo(TaskInfo taskInfo,
|
|
ShellTaskOrganizer.TaskListener taskListener, boolean canShow) {
|
|
mTaskInfo = taskInfo;
|
|
final Configuration prevTaskConfig = mTaskConfig;
|
|
final ShellTaskOrganizer.TaskListener prevTaskListener = mTaskListener;
|
|
mTaskConfig = taskInfo.configuration;
|
|
mTaskListener = taskListener;
|
|
|
|
// Update configuration.
|
|
setConfiguration(mTaskConfig);
|
|
|
|
if (!eligibleToShowLayout()) {
|
|
release();
|
|
return false;
|
|
}
|
|
|
|
View layout = getLayout();
|
|
if (layout == null || prevTaskListener != taskListener
|
|
|| mTaskConfig.uiMode != prevTaskConfig.uiMode) {
|
|
// Layout wasn't created yet or TaskListener changed, recreate the layout for new
|
|
// surface parent.
|
|
release();
|
|
return createLayout(canShow);
|
|
}
|
|
|
|
boolean boundsUpdated = !mTaskConfig.windowConfiguration.getBounds().equals(
|
|
prevTaskConfig.windowConfiguration.getBounds());
|
|
boolean layoutDirectionUpdated =
|
|
mTaskConfig.getLayoutDirection() != prevTaskConfig.getLayoutDirection();
|
|
if (boundsUpdated || layoutDirectionUpdated) {
|
|
onParentBoundsChanged();
|
|
}
|
|
|
|
if (layout != null && layoutDirectionUpdated) {
|
|
// Update layout for RTL.
|
|
layout.setLayoutDirection(mTaskConfig.getLayoutDirection());
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Updates the visibility of the layout.
|
|
*
|
|
* @param canShow whether the layout is allowed to be shown by the parent controller.
|
|
*/
|
|
@VisibleForTesting(visibility = PACKAGE)
|
|
public void updateVisibility(boolean canShow) {
|
|
View layout = getLayout();
|
|
if (layout == null) {
|
|
// Layout may not have been created because it was hidden previously.
|
|
createLayout(canShow);
|
|
return;
|
|
}
|
|
|
|
final int newVisibility = canShow && eligibleToShowLayout() ? View.VISIBLE : View.GONE;
|
|
if (layout.getVisibility() != newVisibility) {
|
|
layout.setVisibility(newVisibility);
|
|
}
|
|
}
|
|
|
|
/** Called when display layout changed. */
|
|
@VisibleForTesting(visibility = PACKAGE)
|
|
public void updateDisplayLayout(DisplayLayout displayLayout) {
|
|
final Rect prevStableBounds = mStableBounds;
|
|
final Rect curStableBounds = new Rect();
|
|
displayLayout.getStableBounds(curStableBounds);
|
|
mDisplayLayout = displayLayout;
|
|
if (!prevStableBounds.equals(curStableBounds)) {
|
|
// mStableBounds should be updated before we call onParentBoundsChanged.
|
|
mStableBounds.set(curStableBounds);
|
|
onParentBoundsChanged();
|
|
}
|
|
}
|
|
|
|
/** Called when the surface is ready to be placed under the task surface. */
|
|
@VisibleForTesting(visibility = PRIVATE)
|
|
void attachToParentSurface(SurfaceControl.Builder b) {
|
|
mTaskListener.attachChildSurfaceToTask(mTaskId, b);
|
|
}
|
|
|
|
public int getDisplayId() {
|
|
return mDisplayId;
|
|
}
|
|
|
|
public int getTaskId() {
|
|
return mTaskId;
|
|
}
|
|
|
|
/** Releases the surface control and tears down the view hierarchy. */
|
|
public void release() {
|
|
// Hiding before releasing to avoid flickering when transitioning to the Home screen.
|
|
View layout = getLayout();
|
|
if (layout != null) {
|
|
layout.setVisibility(View.GONE);
|
|
}
|
|
removeLayout();
|
|
|
|
if (mViewHost != null) {
|
|
mViewHost.release();
|
|
mViewHost = null;
|
|
}
|
|
|
|
if (mLeash != null) {
|
|
final SurfaceControl leash = mLeash;
|
|
mSyncQueue.runInSync(t -> t.remove(leash));
|
|
mLeash = null;
|
|
}
|
|
}
|
|
|
|
/** Re-layouts the view host and updates the surface position. */
|
|
void relayout() {
|
|
relayout(getWindowLayoutParams());
|
|
}
|
|
|
|
protected void relayout(WindowManager.LayoutParams windowLayoutParams) {
|
|
if (mViewHost == null) {
|
|
return;
|
|
}
|
|
mViewHost.relayout(windowLayoutParams);
|
|
updateSurfacePosition();
|
|
}
|
|
|
|
@NonNull
|
|
protected TaskInfo getLastTaskInfo() {
|
|
return mTaskInfo;
|
|
}
|
|
|
|
/**
|
|
* Called following a change in the task bounds, display layout stable bounds, or the layout
|
|
* direction.
|
|
*/
|
|
protected void onParentBoundsChanged() {
|
|
updateSurfacePosition();
|
|
}
|
|
|
|
/**
|
|
* Updates the position of the surface with respect to the parent bounds.
|
|
*/
|
|
protected abstract void updateSurfacePosition();
|
|
|
|
/**
|
|
* Updates the position of the surface with respect to the given {@code positionX} and {@code
|
|
* positionY}.
|
|
*/
|
|
protected void updateSurfacePosition(int positionX, int positionY) {
|
|
if (mLeash == null) {
|
|
return;
|
|
}
|
|
mSyncQueue.runInSync(t -> {
|
|
if (mLeash == null || !mLeash.isValid()) {
|
|
Log.w(getTag(), "The leash has been released.");
|
|
return;
|
|
}
|
|
t.setPosition(mLeash, positionX, positionY);
|
|
});
|
|
}
|
|
|
|
protected int getLayoutDirection() {
|
|
return mContext.getResources().getConfiguration().getLayoutDirection();
|
|
}
|
|
|
|
protected Rect getTaskBounds() {
|
|
return mTaskConfig.windowConfiguration.getBounds();
|
|
}
|
|
|
|
/** Returns the intersection between the task bounds and the display layout stable bounds. */
|
|
protected Rect getTaskStableBounds() {
|
|
final Rect result = new Rect(mStableBounds);
|
|
result.intersect(getTaskBounds());
|
|
return result;
|
|
}
|
|
|
|
/** Creates a {@link SurfaceControlViewHost} for this window manager. */
|
|
@VisibleForTesting(visibility = PRIVATE)
|
|
public SurfaceControlViewHost createSurfaceViewHost() {
|
|
return new SurfaceControlViewHost(mContext, mContext.getDisplay(), this,
|
|
getClass().getSimpleName());
|
|
}
|
|
|
|
/** Gets the layout params. */
|
|
protected WindowManager.LayoutParams getWindowLayoutParams() {
|
|
View layout = getLayout();
|
|
if (layout == null) {
|
|
return new WindowManager.LayoutParams();
|
|
}
|
|
// Measure how big the hint is since its size depends on the text size.
|
|
layout.measure(View.MeasureSpec.UNSPECIFIED, View.MeasureSpec.UNSPECIFIED);
|
|
return getWindowLayoutParams(layout.getMeasuredWidth(), layout.getMeasuredHeight());
|
|
}
|
|
|
|
/** Gets the layout params given the width and height of the layout. */
|
|
protected WindowManager.LayoutParams getWindowLayoutParams(int width, int height) {
|
|
final WindowManager.LayoutParams winParams = new WindowManager.LayoutParams(
|
|
// Cannot be wrap_content as this determines the actual window size
|
|
width, height,
|
|
TYPE_APPLICATION_OVERLAY,
|
|
getWindowManagerLayoutParamsFlags(),
|
|
PixelFormat.TRANSLUCENT);
|
|
winParams.token = new Binder();
|
|
winParams.setTitle(getClass().getSimpleName() + mTaskId);
|
|
winParams.privateFlags |= PRIVATE_FLAG_NO_MOVE_ANIMATION | PRIVATE_FLAG_TRUSTED_OVERLAY;
|
|
return winParams;
|
|
}
|
|
|
|
/**
|
|
* @return Flags to use for the {@link WindowManager} layout
|
|
*/
|
|
protected int getWindowManagerLayoutParamsFlags() {
|
|
return FLAG_NOT_FOCUSABLE | FLAG_NOT_TOUCH_MODAL;
|
|
}
|
|
|
|
protected final String getTag() {
|
|
return getClass().getSimpleName();
|
|
}
|
|
|
|
protected boolean hasTaskListenerChanged(ShellTaskOrganizer.TaskListener newTaskListener) {
|
|
return !mTaskListener.equals(newTaskListener);
|
|
}
|
|
|
|
protected static boolean hasUiModeChanged(TaskInfo currentTaskInfo, TaskInfo newTaskInfo) {
|
|
return currentTaskInfo.configuration.uiMode != newTaskInfo.configuration.uiMode;
|
|
}
|
|
}
|