/* * 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 android.window; import static android.graphics.Color.WHITE; import static android.graphics.Color.alpha; import static android.view.WindowInsetsController.APPEARANCE_LIGHT_NAVIGATION_BARS; import static android.view.WindowInsetsController.APPEARANCE_LIGHT_STATUS_BARS; import static android.view.WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM; import static android.view.WindowManager.LayoutParams.FLAG_DIM_BEHIND; import static android.view.WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED; import static android.view.WindowManager.LayoutParams.FLAG_IGNORE_CHEEK_PRESSES; import static android.view.WindowManager.LayoutParams.FLAG_LOCAL_FOCUS_MODE; import static android.view.WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE; import static android.view.WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE; import static android.view.WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL; import static android.view.WindowManager.LayoutParams.FLAG_SCALED; import static android.view.WindowManager.LayoutParams.FLAG_SECURE; import static android.view.WindowManager.LayoutParams.FLAG_SLIPPERY; import static android.view.WindowManager.LayoutParams.FLAG_SPLIT_TOUCH; import static android.view.WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION; import static android.view.WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS; import static android.view.WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH; import static android.view.WindowManager.LayoutParams.INPUT_FEATURE_NO_INPUT_CHANNEL; import static android.view.WindowManager.LayoutParams.PRIVATE_FLAG_EDGE_TO_EDGE_ENFORCED; import static android.view.WindowManager.LayoutParams.PRIVATE_FLAG_FORCE_DRAW_BAR_BACKGROUNDS; import static android.view.WindowManager.LayoutParams.PRIVATE_FLAG_TRUSTED_OVERLAY; import static com.android.internal.policy.DecorView.NAVIGATION_BAR_COLOR_VIEW_ATTRIBUTES; import static com.android.internal.policy.DecorView.STATUS_BAR_COLOR_VIEW_ATTRIBUTES; import static com.android.internal.policy.DecorView.getNavigationBarRect; import android.annotation.NonNull; import android.annotation.Nullable; import android.app.ActivityManager; import android.app.ActivityThread; import android.content.Context; import android.graphics.Canvas; import android.graphics.GraphicBuffer; import android.graphics.Paint; import android.graphics.PixelFormat; import android.graphics.Rect; import android.hardware.HardwareBuffer; import android.os.IBinder; import android.util.Log; import android.view.InsetsState; import android.view.SurfaceControl; import android.view.SurfaceSession; import android.view.ViewGroup; import android.view.WindowInsets; import android.view.WindowManager; import com.android.internal.R; import com.android.internal.annotations.VisibleForTesting; import com.android.internal.policy.DecorView; import com.android.window.flags.Flags; /** * Utils class to help draw a snapshot on a surface. * @hide */ public class SnapshotDrawerUtils { private static final String TAG = "SnapshotDrawerUtils"; /** * Used to check if toolkitSetFrameRateReadOnly flag is enabled * * @hide */ private static boolean sToolkitSetFrameRateReadOnlyFlagValue = android.view.flags.Flags.toolkitSetFrameRateReadOnly(); /** * When creating the starting window, we use the exact same layout flags such that we end up * with a window with the exact same dimensions etc. However, these flags are not used in layout * and might cause other side effects so we exclude them. */ static final int FLAG_INHERIT_EXCLUDES = FLAG_NOT_FOCUSABLE | FLAG_NOT_TOUCHABLE | FLAG_NOT_TOUCH_MODAL | FLAG_ALT_FOCUSABLE_IM | FLAG_NOT_FOCUSABLE | FLAG_HARDWARE_ACCELERATED | FLAG_IGNORE_CHEEK_PRESSES | FLAG_LOCAL_FOCUS_MODE | FLAG_SLIPPERY | FLAG_WATCH_OUTSIDE_TOUCH | FLAG_SPLIT_TOUCH | FLAG_SCALED | FLAG_SECURE | FLAG_DIM_BEHIND; private static final Paint sBackgroundPaint = new Paint(); /** * The internal object to hold the surface and drawing on it. */ @VisibleForTesting public static class SnapshotSurface { private final SurfaceControl.Transaction mTransaction = new SurfaceControl.Transaction(); private final SurfaceControl mRootSurface; private final TaskSnapshot mSnapshot; private final CharSequence mTitle; private SystemBarBackgroundPainter mSystemBarBackgroundPainter; private final Rect mFrame = new Rect(); private final Rect mSystemBarInsets = new Rect(); private final int mSnapshotW; private final int mSnapshotH; private boolean mSizeMismatch; public SnapshotSurface(SurfaceControl rootSurface, TaskSnapshot snapshot, CharSequence title) { mRootSurface = rootSurface; mSnapshot = snapshot; mTitle = title; final HardwareBuffer hwBuffer = snapshot.getHardwareBuffer(); mSnapshotW = hwBuffer.getWidth(); mSnapshotH = hwBuffer.getHeight(); } /** * Initiate system bar painter to draw the system bar background. */ @VisibleForTesting public void initiateSystemBarPainter(int windowFlags, int windowPrivateFlags, int appearance, ActivityManager.TaskDescription taskDescription, @WindowInsets.Type.InsetsType int requestedVisibleTypes) { mSystemBarBackgroundPainter = new SystemBarBackgroundPainter(windowFlags, windowPrivateFlags, appearance, taskDescription, 1f, requestedVisibleTypes); int backgroundColor = taskDescription.getBackgroundColor(); sBackgroundPaint.setColor(backgroundColor != 0 ? backgroundColor : WHITE); } /** * Set frame size that the snapshot should fill. It is the bounds of a task or activity. */ @VisibleForTesting public void setFrames(Rect frame, Rect systemBarInsets) { mFrame.set(frame); final Rect letterboxInsets = mSnapshot.getLetterboxInsets(); mSizeMismatch = (mFrame.width() != mSnapshotW || mFrame.height() != mSnapshotH) || letterboxInsets.left != 0 || letterboxInsets.top != 0; if (!Flags.drawSnapshotAspectRatioMatch() && systemBarInsets != null) { mSystemBarInsets.set(systemBarInsets); mSystemBarBackgroundPainter.setInsets(systemBarInsets); } } private void drawSnapshot(boolean releaseAfterDraw) { Log.v(TAG, "Drawing snapshot surface sizeMismatch=" + mSizeMismatch); if (mSizeMismatch) { // The dimensions of the buffer and the window don't match, so attaching the buffer // will fail. Better create a child window with the exact dimensions and fill the // parent window with the background color! drawSizeMismatchSnapshot(); } else { drawSizeMatchSnapshot(); } // In case window manager leaks us, make sure we don't retain the snapshot. if (mSnapshot.getHardwareBuffer() != null) { mSnapshot.getHardwareBuffer().close(); } if (releaseAfterDraw) { mRootSurface.release(); } } private void drawSizeMatchSnapshot() { mTransaction.setBuffer(mRootSurface, mSnapshot.getHardwareBuffer()) .setColorSpace(mRootSurface, mSnapshot.getColorSpace()) .apply(); } private void drawSizeMismatchSnapshot() { final HardwareBuffer buffer = mSnapshot.getHardwareBuffer(); final SurfaceSession session = new SurfaceSession(); // We consider nearly matched dimensions as there can be rounding errors and the user // won't notice very minute differences from scaling one dimension more than the other boolean aspectRatioMismatch = !isAspectRatioMatch(mFrame, mSnapshotW, mSnapshotH) && !Flags.drawSnapshotAspectRatioMatch(); // Keep a reference to it such that it doesn't get destroyed when finalized. SurfaceControl childSurfaceControl = new SurfaceControl.Builder(session) .setName(mTitle + " - task-snapshot-surface") .setBLASTLayer() .setFormat(buffer.getFormat()) .setParent(mRootSurface) .setCallsite("TaskSnapshotWindow.drawSizeMismatchSnapshot") .build(); final Rect frame; final Rect letterboxInsets = mSnapshot.getLetterboxInsets(); float offsetX = letterboxInsets.left; float offsetY = letterboxInsets.top; // We can just show the surface here as it will still be hidden as the parent is // still hidden. mTransaction.show(childSurfaceControl); if (aspectRatioMismatch) { Rect crop = null; if (letterboxInsets.left != 0 || letterboxInsets.top != 0 || letterboxInsets.right != 0 || letterboxInsets.bottom != 0) { // Clip off letterbox. crop = calculateSnapshotCrop(letterboxInsets); // If the snapshot can cover the frame, then no need to draw background. aspectRatioMismatch = !isAspectRatioMatch(mFrame, crop); } // if letterbox doesn't match window frame, try crop by content insets if (aspectRatioMismatch) { // Clip off ugly navigation bar. final Rect contentInsets = mSnapshot.getContentInsets(); crop = calculateSnapshotCrop(contentInsets); offsetX = contentInsets.left; offsetY = contentInsets.top; } frame = calculateSnapshotFrame(crop); mTransaction.setCrop(childSurfaceControl, crop); } else { frame = null; } // Align the snapshot with content area. if (offsetX != 0f || offsetY != 0f) { mTransaction.setPosition(childSurfaceControl, -offsetX * mFrame.width() / mSnapshot.getTaskSize().x, -offsetY * mFrame.height() / mSnapshot.getTaskSize().y); } // Scale the mismatch dimensions to fill the target frame. final float scaleX = (float) mFrame.width() / mSnapshotW; final float scaleY = (float) mFrame.height() / mSnapshotH; mTransaction.setScale(childSurfaceControl, scaleX, scaleY); mTransaction.setColorSpace(childSurfaceControl, mSnapshot.getColorSpace()); mTransaction.setBuffer(childSurfaceControl, mSnapshot.getHardwareBuffer()); if (aspectRatioMismatch) { GraphicBuffer background = GraphicBuffer.create(mFrame.width(), mFrame.height(), PixelFormat.RGBA_8888, GraphicBuffer.USAGE_HW_TEXTURE | GraphicBuffer.USAGE_HW_COMPOSER | GraphicBuffer.USAGE_SW_WRITE_RARELY); final Canvas c = background != null ? background.lockCanvas() : null; if (c == null) { Log.e(TAG, "Unable to draw snapshot: failed to allocate graphic buffer for " + mTitle); mTransaction.clear(); childSurfaceControl.release(); return; } drawBackgroundAndBars(c, frame); background.unlockCanvasAndPost(c); mTransaction.setBuffer(mRootSurface, HardwareBuffer.createFromGraphicBuffer(background)); } mTransaction.apply(); childSurfaceControl.release(); } /** * Calculates the snapshot crop in snapshot coordinate space. * @param insets Content insets or Letterbox insets * @return crop rect in snapshot coordinate space. */ @VisibleForTesting public Rect calculateSnapshotCrop(@NonNull Rect insets) { final Rect rect = new Rect(); rect.set(0, 0, mSnapshotW, mSnapshotH); final float scaleX = (float) mSnapshotW / mSnapshot.getTaskSize().x; final float scaleY = (float) mSnapshotH / mSnapshot.getTaskSize().y; // Let's remove all system decorations except the status bar, but only if the task is at // the very top of the screen. final boolean isTop = mFrame.top == 0; rect.inset((int) (insets.left * scaleX), isTop ? 0 : (int) (insets.top * scaleY), (int) (insets.right * scaleX), (int) (insets.bottom * scaleY)); return rect; } /** * Calculates the snapshot frame in window coordinate space from crop. * * @param crop rect that is in snapshot coordinate space. */ @VisibleForTesting public Rect calculateSnapshotFrame(Rect crop) { final float scaleX = (float) mSnapshotW / mSnapshot.getTaskSize().x; final float scaleY = (float) mSnapshotH / mSnapshot.getTaskSize().y; // Rescale the frame from snapshot to window coordinate space final Rect frame = new Rect(0, 0, (int) (crop.width() / scaleX + 0.5f), (int) (crop.height() / scaleY + 0.5f) ); // However, we also need to make space for the navigation bar on the left side. frame.offset(mSystemBarInsets.left, 0); return frame; } /** * Draw status bar and navigation bar background. */ @VisibleForTesting public void drawBackgroundAndBars(Canvas c, Rect frame) { final int statusBarHeight = mSystemBarBackgroundPainter.getStatusBarColorViewHeight(); final boolean fillHorizontally = c.getWidth() > frame.right; final boolean fillVertically = c.getHeight() > frame.bottom; if (fillHorizontally) { c.drawRect(frame.right, alpha(mSystemBarBackgroundPainter.mStatusBarColor) == 0xFF ? statusBarHeight : 0, c.getWidth(), fillVertically ? frame.bottom : c.getHeight(), sBackgroundPaint); } if (fillVertically) { c.drawRect(0, frame.bottom, c.getWidth(), c.getHeight(), sBackgroundPaint); } mSystemBarBackgroundPainter.drawDecors(c, frame); } /** * Ask system bar background painter to draw status bar background. */ @VisibleForTesting public void drawStatusBarBackground(Canvas c, @Nullable Rect alreadyDrawnFrame) { mSystemBarBackgroundPainter.drawStatusBarBackground(c, alreadyDrawnFrame, mSystemBarBackgroundPainter.getStatusBarColorViewHeight()); } /** * Ask system bar background painter to draw navigation bar background. */ @VisibleForTesting public void drawNavigationBarBackground(Canvas c) { mSystemBarBackgroundPainter.drawNavigationBarBackground(c); } } private static boolean isAspectRatioMatch(Rect frame, int w, int h) { if (frame.isEmpty()) { return false; } return Math.abs(((float) w / h) - ((float) frame.width() / frame.height())) <= 0.01f; } private static boolean isAspectRatioMatch(Rect frame1, Rect frame2) { if (frame1.isEmpty() || frame2.isEmpty()) { return false; } return Math.abs( ((float) frame2.width() / frame2.height()) - ((float) frame1.width() / frame1.height())) <= 0.01f; } /** * Get or create a TaskDescription from a RunningTaskInfo. */ public static ActivityManager.TaskDescription getOrCreateTaskDescription( ActivityManager.RunningTaskInfo runningTaskInfo) { final ActivityManager.TaskDescription taskDescription; if (runningTaskInfo.taskDescription != null) { taskDescription = runningTaskInfo.taskDescription; } else { taskDescription = new ActivityManager.TaskDescription(); taskDescription.setBackgroundColor(WHITE); } return taskDescription; } /** * Help method to draw the snapshot on a surface. */ public static void drawSnapshotOnSurface(StartingWindowInfo info, WindowManager.LayoutParams lp, SurfaceControl rootSurface, TaskSnapshot snapshot, Rect windowBounds, InsetsState topWindowInsetsState, boolean releaseAfterDraw) { if (windowBounds.isEmpty()) { Log.e(TAG, "Unable to draw snapshot on an empty windowBounds"); return; } final SnapshotSurface drawSurface = new SnapshotSurface( rootSurface, snapshot, lp.getTitle()); final WindowManager.LayoutParams attrs = Flags.drawSnapshotAspectRatioMatch() ? info.mainWindowLayoutParams : info.topOpaqueWindowLayoutParams; final ActivityManager.RunningTaskInfo runningTaskInfo = info.taskInfo; final ActivityManager.TaskDescription taskDescription = getOrCreateTaskDescription(runningTaskInfo); Rect systemBarInsets = null; if (!Flags.drawSnapshotAspectRatioMatch()) { drawSurface.initiateSystemBarPainter(lp.flags, lp.privateFlags, attrs.insetsFlags.appearance, taskDescription, info.requestedVisibleTypes); systemBarInsets = getSystemBarInsets(windowBounds, topWindowInsetsState); } drawSurface.setFrames(windowBounds, systemBarInsets); drawSurface.drawSnapshot(releaseAfterDraw); } /** * Help method to create a layout parameters for a window. */ public static WindowManager.LayoutParams createLayoutParameters(StartingWindowInfo info, CharSequence title, @WindowManager.LayoutParams.WindowType int windowType, int pixelFormat, IBinder token) { final WindowManager.LayoutParams attrs = Flags.drawSnapshotAspectRatioMatch() ? info.mainWindowLayoutParams : info.topOpaqueWindowLayoutParams; final WindowManager.LayoutParams mainWindowParams = info.mainWindowLayoutParams; final InsetsState topWindowInsetsState = info.topOpaqueWindowInsetsState; if (attrs == null || mainWindowParams == null || topWindowInsetsState == null) { Log.w(TAG, "unable to create taskSnapshot surface "); return null; } final WindowManager.LayoutParams layoutParams = new WindowManager.LayoutParams(); final int appearance = attrs.insetsFlags.appearance; final int windowFlags = attrs.flags; final int windowPrivateFlags = attrs.privateFlags; layoutParams.packageName = mainWindowParams.packageName; layoutParams.windowAnimations = mainWindowParams.windowAnimations; layoutParams.dimAmount = mainWindowParams.dimAmount; layoutParams.type = windowType; layoutParams.format = pixelFormat; layoutParams.flags = (windowFlags & ~FLAG_INHERIT_EXCLUDES) | FLAG_NOT_FOCUSABLE | FLAG_NOT_TOUCHABLE; layoutParams.privateFlags = (windowPrivateFlags & (PRIVATE_FLAG_FORCE_DRAW_BAR_BACKGROUNDS | PRIVATE_FLAG_EDGE_TO_EDGE_ENFORCED)) // Setting as trusted overlay to let touches pass through. This is safe because this // window is controlled by the system. | PRIVATE_FLAG_TRUSTED_OVERLAY; layoutParams.token = token; layoutParams.width = ViewGroup.LayoutParams.MATCH_PARENT; layoutParams.height = ViewGroup.LayoutParams.MATCH_PARENT; layoutParams.insetsFlags.appearance = appearance; layoutParams.insetsFlags.behavior = attrs.insetsFlags.behavior; layoutParams.layoutInDisplayCutoutMode = attrs.layoutInDisplayCutoutMode; layoutParams.setFitInsetsTypes(attrs.getFitInsetsTypes()); layoutParams.setFitInsetsSides(attrs.getFitInsetsSides()); layoutParams.setFitInsetsIgnoringVisibility(attrs.isFitInsetsIgnoringVisibility()); if (sToolkitSetFrameRateReadOnlyFlagValue) { layoutParams.setFrameRatePowerSavingsBalanced(false); } layoutParams.setTitle(title); layoutParams.inputFeatures |= INPUT_FEATURE_NO_INPUT_CHANNEL; return layoutParams; } static Rect getSystemBarInsets(Rect frame, InsetsState state) { return state.calculateInsets(frame, WindowInsets.Type.systemBars(), false /* ignoreVisibility */).toRect(); } /** * Helper class to draw the background of the system bars in regions the task snapshot isn't * filling the window. */ public static class SystemBarBackgroundPainter { private final Paint mStatusBarPaint = new Paint(); private final Paint mNavigationBarPaint = new Paint(); private final int mStatusBarColor; private final int mNavigationBarColor; private final int mWindowFlags; private final int mWindowPrivateFlags; private final float mScale; private final @WindowInsets.Type.InsetsType int mRequestedVisibleTypes; private final Rect mSystemBarInsets = new Rect(); public SystemBarBackgroundPainter(int windowFlags, int windowPrivateFlags, int appearance, ActivityManager.TaskDescription taskDescription, float scale, @WindowInsets.Type.InsetsType int requestedVisibleTypes) { mWindowFlags = windowFlags; mWindowPrivateFlags = windowPrivateFlags; mScale = scale; final Context context = ActivityThread.currentActivityThread().getSystemUiContext(); final int semiTransparent = context.getColor( R.color.system_bar_background_semi_transparent); mStatusBarColor = DecorView.calculateBarColor(windowFlags, FLAG_TRANSLUCENT_STATUS, semiTransparent, taskDescription.getStatusBarColor(), appearance, APPEARANCE_LIGHT_STATUS_BARS, taskDescription.getEnsureStatusBarContrastWhenTransparent(), false /* movesBarColorToScrim */); mNavigationBarColor = DecorView.calculateBarColor(windowFlags, FLAG_TRANSLUCENT_NAVIGATION, semiTransparent, taskDescription.getNavigationBarColor(), appearance, APPEARANCE_LIGHT_NAVIGATION_BARS, taskDescription.getEnsureNavigationBarContrastWhenTransparent() && context.getResources().getBoolean( R.bool.config_navBarNeedsScrim), (windowPrivateFlags & PRIVATE_FLAG_EDGE_TO_EDGE_ENFORCED) != 0); mStatusBarPaint.setColor(mStatusBarColor); mNavigationBarPaint.setColor(mNavigationBarColor); mRequestedVisibleTypes = requestedVisibleTypes; } /** * Set system bar insets. */ public void setInsets(Rect systemBarInsets) { mSystemBarInsets.set(systemBarInsets); } int getStatusBarColorViewHeight() { final boolean forceBarBackground = (mWindowPrivateFlags & PRIVATE_FLAG_FORCE_DRAW_BAR_BACKGROUNDS) != 0; if (STATUS_BAR_COLOR_VIEW_ATTRIBUTES.isVisible( mRequestedVisibleTypes, mStatusBarColor, mWindowFlags, forceBarBackground)) { return (int) (mSystemBarInsets.top * mScale); } else { return 0; } } private boolean isNavigationBarColorViewVisible() { final boolean forceBarBackground = (mWindowPrivateFlags & PRIVATE_FLAG_FORCE_DRAW_BAR_BACKGROUNDS) != 0; return NAVIGATION_BAR_COLOR_VIEW_ATTRIBUTES.isVisible( mRequestedVisibleTypes, mNavigationBarColor, mWindowFlags, forceBarBackground); } /** * Draw bar colors to a canvas. */ public void drawDecors(Canvas c, @Nullable Rect alreadyDrawnFrame) { drawStatusBarBackground(c, alreadyDrawnFrame, getStatusBarColorViewHeight()); drawNavigationBarBackground(c); } void drawStatusBarBackground(Canvas c, @Nullable Rect alreadyDrawnFrame, int statusBarHeight) { if (statusBarHeight > 0 && alpha(mStatusBarColor) != 0 && (alreadyDrawnFrame == null || c.getWidth() > alreadyDrawnFrame.right)) { final int rightInset = (int) (mSystemBarInsets.right * mScale); final int left = alreadyDrawnFrame != null ? alreadyDrawnFrame.right : 0; c.drawRect(left, 0, c.getWidth() - rightInset, statusBarHeight, mStatusBarPaint); } } void drawNavigationBarBackground(Canvas c) { final Rect navigationBarRect = new Rect(); getNavigationBarRect(c.getWidth(), c.getHeight(), mSystemBarInsets, navigationBarRect, mScale); final boolean visible = isNavigationBarColorViewVisible(); if (visible && alpha(mNavigationBarColor) != 0 && !navigationBarRect.isEmpty()) { c.drawRect(navigationBarRect, mNavigationBarPaint); } } } }