Merge "Add a new CanvasEngine, gated by flag" into tm-qpr-dev am: fe97f28bed (82c2adb0) · Commits · e / os / android_frameworks_base

packages/SystemUI/src/com/android/systemui/wallpapers/ImageWallpaper.java

+286 −2

Original line number	Original line	Diff line number	Diff line
	@@ -16,12 +16,21 @@

	package com.android.systemui.wallpapers;		package com.android.systemui.wallpapers;

			import static android.view.Display.DEFAULT_DISPLAY;

			import static com.android.systemui.flags.Flags.USE_CANVAS_RENDERER;

	import android.app.WallpaperColors;		import android.app.WallpaperColors;
			import android.app.WallpaperManager;
			import android.content.ComponentCallbacks2;
			import android.content.Context;
	import android.graphics.Bitmap;		import android.graphics.Bitmap;
			import android.graphics.RecordingCanvas;
	import android.graphics.Rect;		import android.graphics.Rect;
	import android.graphics.RectF;		import android.graphics.RectF;
	import android.hardware.display.DisplayManager;		import android.hardware.display.DisplayManager;
	import android.hardware.display.DisplayManager.DisplayListener;		import android.hardware.display.DisplayManager.DisplayListener;
			import android.os.AsyncTask;
	import android.os.Handler;		import android.os.Handler;
	import android.os.HandlerThread;		import android.os.HandlerThread;
	import android.os.SystemClock;		import android.os.SystemClock;
	@@ -31,16 +40,22 @@ import android.util.ArraySet;
	import android.util.Log;		import android.util.Log;
	import android.util.MathUtils;		import android.util.MathUtils;
	import android.util.Size;		import android.util.Size;
			import android.view.Display;
			import android.view.DisplayInfo;
			import android.view.Surface;
	import android.view.SurfaceHolder;		import android.view.SurfaceHolder;
	import android.view.WindowManager;		import android.view.WindowManager;

	import androidx.annotation.NonNull;		import androidx.annotation.NonNull;

	import com.android.internal.annotations.VisibleForTesting;		import com.android.internal.annotations.VisibleForTesting;
			import com.android.systemui.flags.FeatureFlags;
			import com.android.systemui.wallpapers.canvas.ImageCanvasWallpaperRenderer;
	import com.android.systemui.wallpapers.gl.EglHelper;		import com.android.systemui.wallpapers.gl.EglHelper;
	import com.android.systemui.wallpapers.gl.ImageWallpaperRenderer;		import com.android.systemui.wallpapers.gl.ImageWallpaperRenderer;

	import java.io.FileDescriptor;		import java.io.FileDescriptor;
			import java.io.IOException;
	import java.io.PrintWriter;		import java.io.PrintWriter;
	import java.util.ArrayList;		import java.util.ArrayList;
	import java.util.List;		import java.util.List;
	@@ -59,16 +74,19 @@ public class ImageWallpaper extends WallpaperService {
	private static final @android.annotation.NonNull RectF LOCAL_COLOR_BOUNDS =		private static final @android.annotation.NonNull RectF LOCAL_COLOR_BOUNDS =
	new RectF(0, 0, 1, 1);		new RectF(0, 0, 1, 1);
	private static final boolean DEBUG = false;		private static final boolean DEBUG = false;

	private final ArrayList<RectF> mLocalColorsToAdd = new ArrayList<>();		private final ArrayList<RectF> mLocalColorsToAdd = new ArrayList<>();
	private final ArraySet<RectF> mColorAreas = new ArraySet<>();		private final ArraySet<RectF> mColorAreas = new ArraySet<>();
	private volatile int mPages = 1;		private volatile int mPages = 1;
	private HandlerThread mWorker;		private HandlerThread mWorker;
	// scaled down version		// scaled down version
	private Bitmap mMiniBitmap;		private Bitmap mMiniBitmap;
			private final FeatureFlags mFeatureFlags;

	@Inject		@Inject
	public ImageWallpaper() {		public ImageWallpaper(FeatureFlags featureFlags) {
	super();		super();
			mFeatureFlags = featureFlags;
	}		}

	@Override		@Override
	@@ -80,7 +98,7 @@ public class ImageWallpaper extends WallpaperService {

	@Override		@Override
	public Engine onCreateEngine() {		public Engine onCreateEngine() {
	return new GLEngine();		return mFeatureFlags.isEnabled(USE_CANVAS_RENDERER) ? new CanvasEngine() : new GLEngine();
	}		}

	@Override		@Override
	@@ -489,4 +507,270 @@ public class ImageWallpaper extends WallpaperService {
	mRenderer.dump(prefix, fd, out, args);		mRenderer.dump(prefix, fd, out, args);
	}		}
	}		}


			class CanvasEngine extends WallpaperService.Engine implements DisplayListener {

			// time [ms] before unloading the wallpaper after it is loaded
			private static final int DELAY_FORGET_WALLPAPER = 5000;

			private final Runnable mUnloadWallpaperCallback = this::unloadWallpaper;

			private WallpaperManager mWallpaperManager;
			private ImageCanvasWallpaperRenderer mImageCanvasWallpaperRenderer;
			private Bitmap mBitmap;

			private Display mDisplay;
			private final DisplayInfo mTmpDisplayInfo = new DisplayInfo();

			private AsyncTask<Void, Void, Bitmap> mLoader;
			private boolean mNeedsDrawAfterLoadingWallpaper = false;

			CanvasEngine() {
			super();
			setFixedSizeAllowed(true);
			setShowForAllUsers(true);
			}

			void trimMemory(int level) {
			if (level >= ComponentCallbacks2.TRIM_MEMORY_RUNNING_LOW
			&& level <= ComponentCallbacks2.TRIM_MEMORY_RUNNING_CRITICAL
			&& isBitmapLoaded()) {
			if (DEBUG) {
			Log.d(TAG, "trimMemory");
			}
			unloadWallpaper();
			}
			}

			@Override
			public void onCreate(SurfaceHolder surfaceHolder) {
			if (DEBUG) {
			Log.d(TAG, "onCreate");
			}

			mWallpaperManager = getSystemService(WallpaperManager.class);
			super.onCreate(surfaceHolder);

			final Context displayContext = getDisplayContext();
			final int displayId = displayContext == null ? DEFAULT_DISPLAY :
			displayContext.getDisplayId();
			DisplayManager dm = getSystemService(DisplayManager.class);
			if (dm != null) {
			mDisplay = dm.getDisplay(displayId);
			if (mDisplay == null) {
			Log.e(TAG, "Cannot find display! Fallback to default.");
			mDisplay = dm.getDisplay(DEFAULT_DISPLAY);
			}
			}
			setOffsetNotificationsEnabled(false);

			mImageCanvasWallpaperRenderer = new ImageCanvasWallpaperRenderer(surfaceHolder);
			loadWallpaper(false);
			}

			@Override
			public void onDestroy() {
			super.onDestroy();
			unloadWallpaper();
			}

			@Override
			public boolean shouldZoomOutWallpaper() {
			return true;
			}

			@Override
			public void onSurfaceChanged(SurfaceHolder holder, int format, int width, int height) {
			if (DEBUG) {
			Log.d(TAG, "onSurfaceChanged: width=" + width + ", height=" + height);
			}
			super.onSurfaceChanged(holder, format, width, height);
			mImageCanvasWallpaperRenderer.setSurfaceHolder(holder);
			drawFrame(false);
			}

			@Override
			public void onSurfaceDestroyed(SurfaceHolder holder) {
			super.onSurfaceDestroyed(holder);
			if (DEBUG) {
			Log.i(TAG, "onSurfaceDestroyed");
			}
			mImageCanvasWallpaperRenderer.setSurfaceHolder(null);
			}

			@Override
			public void onSurfaceCreated(SurfaceHolder holder) {
			super.onSurfaceCreated(holder);
			if (DEBUG) {
			Log.i(TAG, "onSurfaceCreated");
			}
			mImageCanvasWallpaperRenderer.setSurfaceHolder(holder);
			}

			@Override
			public void onSurfaceRedrawNeeded(SurfaceHolder holder) {
			if (DEBUG) {
			Log.d(TAG, "onSurfaceRedrawNeeded");
			}
			super.onSurfaceRedrawNeeded(holder);
			// At the end of this method we should have drawn into the surface.
			// This means that the bitmap should be loaded synchronously if
			// it was already unloaded.
			if (!isBitmapLoaded()) {
			setBitmap(mWallpaperManager.getBitmap(true /* hardware */));
			}
			drawFrame(true);
			}

			private DisplayInfo getDisplayInfo() {
			mDisplay.getDisplayInfo(mTmpDisplayInfo);
			return mTmpDisplayInfo;
			}

			private void drawFrame(boolean forceRedraw) {
			if (!mImageCanvasWallpaperRenderer.isSurfaceHolderLoaded()) {
			Log.e(TAG, "attempt to draw a frame without a valid surface");
			return;
			}

			if (!isBitmapLoaded()) {
			// ensure that we load the wallpaper.
			// if the wallpaper is currently loading, this call will have no effect.
			loadWallpaper(true);
			return;
			}
			mImageCanvasWallpaperRenderer.drawFrame(mBitmap, forceRedraw);
			}

			private void setBitmap(Bitmap bitmap) {
			if (bitmap == null) {
			Log.e(TAG, "Attempt to set a null bitmap");
			} else if (mBitmap == bitmap) {
			Log.e(TAG, "The value of bitmap is the same");
			} else if (bitmap.getWidth() < 1 \|\| bitmap.getHeight() < 1) {
			Log.e(TAG, "Attempt to set an invalid wallpaper of length "
			+ bitmap.getWidth() + "x" + bitmap.getHeight());
			} else {
			if (mBitmap != null) {
			mBitmap.recycle();
			}
			mBitmap = bitmap;
			}
			}

			private boolean isBitmapLoaded() {
			return mBitmap != null && !mBitmap.isRecycled();
			}

			/**
			* Loads the wallpaper on background thread and schedules updating the surface frame,
			* and if {@code needsDraw} is set also draws a frame.
			*
			* If loading is already in-flight, subsequent loads are ignored (but needDraw is or-ed to
			* the active request).
			*
			*/
			private void loadWallpaper(boolean needsDraw) {
			mNeedsDrawAfterLoadingWallpaper \|= needsDraw;
			if (mLoader != null) {
			if (DEBUG) {
			Log.d(TAG, "Skipping loadWallpaper, already in flight ");
			}
			return;
			}
			mLoader = new AsyncTask<Void, Void, Bitmap>() {
			@Override
			protected Bitmap doInBackground(Void... params) {
			Throwable exception;
			try {
			Bitmap wallpaper = mWallpaperManager.getBitmap(true /* hardware */);
			if (wallpaper != null
			&& wallpaper.getByteCount() > RecordingCanvas.MAX_BITMAP_SIZE) {
			throw new RuntimeException("Wallpaper is too large to draw!");
			}
			return wallpaper;
			} catch (RuntimeException \| OutOfMemoryError e) {
			exception = e;
			}

			if (isCancelled()) {
			return null;
			}

			// Note that if we do fail at this, and the default wallpaper can't
			// be loaded, we will go into a cycle. Don't do a build where the
			// default wallpaper can't be loaded.
			Log.w(TAG, "Unable to load wallpaper!", exception);
			try {
			mWallpaperManager.clear();
			} catch (IOException ex) {
			// now we're really screwed.
			Log.w(TAG, "Unable reset to default wallpaper!", ex);
			}

			if (isCancelled()) {
			return null;
			}

			try {
			return mWallpaperManager.getBitmap(true /* hardware */);
			} catch (RuntimeException \| OutOfMemoryError e) {
			Log.w(TAG, "Unable to load default wallpaper!", e);
			}
			return null;
			}

			@Override
			protected void onPostExecute(Bitmap bitmap) {
			setBitmap(bitmap);

			if (mNeedsDrawAfterLoadingWallpaper) {
			drawFrame(true);
			}

			mLoader = null;
			mNeedsDrawAfterLoadingWallpaper = false;
			scheduleUnloadWallpaper();
			}
			}.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
			}

			private void unloadWallpaper() {
			if (mLoader != null) {
			mLoader.cancel(false);
			mLoader = null;
			}

			if (mBitmap != null) {
			mBitmap.recycle();
			}
			mBitmap = null;

			final Surface surface = getSurfaceHolder().getSurface();
			surface.hwuiDestroy();
			mWallpaperManager.forgetLoadedWallpaper();
			}

			private void scheduleUnloadWallpaper() {
			Handler handler = getMainThreadHandler();
			handler.removeCallbacks(mUnloadWallpaperCallback);
			handler.postDelayed(mUnloadWallpaperCallback, DELAY_FORGET_WALLPAPER);
			}

			@Override
			public void onDisplayAdded(int displayId) {

			}

			@Override
			public void onDisplayChanged(int displayId) {

			}

			@Override
			public void onDisplayRemoved(int displayId) {

			}
			}
	}		}

packages/SystemUI/src/com/android/systemui/wallpapers/canvas/ImageCanvasWallpaperRenderer.java

0 → 100644

+145 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* 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.systemui.wallpapers.canvas;

			import android.graphics.Bitmap;
			import android.graphics.Canvas;
			import android.graphics.Rect;
			import android.util.Log;
			import android.view.SurfaceHolder;

			import com.android.internal.annotations.VisibleForTesting;

			/**
			* Helper to draw a wallpaper on a surface.
			* It handles the geometry regarding the dimensions of the display and the wallpaper,
			* and rescales the surface and the wallpaper accordingly.
			*/
			public class ImageCanvasWallpaperRenderer {

			private static final String TAG = ImageCanvasWallpaperRenderer.class.getSimpleName();
			private static final boolean DEBUG = false;

			private SurfaceHolder mSurfaceHolder;
			//private Bitmap mBitmap = null;

			@VisibleForTesting
			static final int MIN_SURFACE_WIDTH = 128;
			@VisibleForTesting
			static final int MIN_SURFACE_HEIGHT = 128;

			private boolean mSurfaceRedrawNeeded;

			private int mLastSurfaceWidth = -1;
			private int mLastSurfaceHeight = -1;

			public ImageCanvasWallpaperRenderer(SurfaceHolder surfaceHolder) {
			mSurfaceHolder = surfaceHolder;
			}

			/**
			* Set the surface holder on which to draw.
			* Should be called when the surface holder is created or changed
			* @param surfaceHolder the surface on which to draw the wallpaper
			*/
			public void setSurfaceHolder(SurfaceHolder surfaceHolder) {
			mSurfaceHolder = surfaceHolder;
			}

			/**
			* Check if a surface holder is loaded
			* @return true if a valid surfaceHolder has been set.
			*/
			public boolean isSurfaceHolderLoaded() {
			return mSurfaceHolder != null;
			}

			/**
			* Computes and set the surface dimensions, by using the play and the bitmap dimensions.
			* The Bitmap must be loaded before any call to this function
			*/
			private boolean updateSurfaceSize(Bitmap bitmap) {
			int surfaceWidth = Math.max(MIN_SURFACE_WIDTH, bitmap.getWidth());
			int surfaceHeight = Math.max(MIN_SURFACE_HEIGHT, bitmap.getHeight());
			boolean surfaceChanged =
			surfaceWidth != mLastSurfaceWidth \|\| surfaceHeight != mLastSurfaceHeight;
			if (surfaceChanged) {
			/*
			Used a fixed size surface, because we are special. We can do
			this because we know the current design of window animations doesn't
			cause this to break.
			*/
			mSurfaceHolder.setFixedSize(surfaceWidth, surfaceHeight);
			mLastSurfaceWidth = surfaceWidth;
			mLastSurfaceHeight = surfaceHeight;
			}
			return surfaceChanged;
			}

			/**
			* Draw a the wallpaper on the surface.
			* The bitmap and the surface must be loaded before calling
			* this function.
			* @param forceRedraw redraw the wallpaper even if no changes are detected
			*/
			public void drawFrame(Bitmap bitmap, boolean forceRedraw) {

			if (bitmap == null \|\| bitmap.isRecycled()) {
			Log.e(TAG, "Attempt to draw frame before background is loaded:");
			return;
			}

			if (bitmap.getWidth() < 1 \|\| bitmap.getHeight() < 1) {
			Log.e(TAG, "Attempt to set an invalid wallpaper of length "
			+ bitmap.getWidth() + "x" + bitmap.getHeight());
			return;
			}

			mSurfaceRedrawNeeded \|= forceRedraw;
			boolean surfaceChanged = updateSurfaceSize(bitmap);

			boolean redrawNeeded = surfaceChanged \|\| mSurfaceRedrawNeeded;
			mSurfaceRedrawNeeded = false;

			if (!redrawNeeded) {
			if (DEBUG) {
			Log.d(TAG, "Suppressed drawFrame since redraw is not needed ");
			}
			return;
			}

			if (DEBUG) {
			Log.d(TAG, "Redrawing wallpaper");
			}
			drawWallpaperWithCanvas(bitmap);
			}

			@VisibleForTesting
			void drawWallpaperWithCanvas(Bitmap bitmap) {
			Canvas c = mSurfaceHolder.lockHardwareCanvas();
			if (c != null) {
			Rect dest = mSurfaceHolder.getSurfaceFrame();
			Log.i(TAG, "Redrawing in rect: " + dest + " with surface size: "
			+ mLastSurfaceWidth + "x" + mLastSurfaceHeight);
			try {
			c.drawBitmap(bitmap, null, dest, null);
			} finally {
			mSurfaceHolder.unlockCanvasAndPost(c);
			}
			}
			}
			}

packages/SystemUI/tests/src/com/android/systemui/wallpapers/ImageWallpaperTest.java

+4 −1

Original line number	Original line	Diff line number	Diff line
	@@ -41,6 +41,7 @@ import android.view.DisplayInfo;
	import android.view.SurfaceHolder;		import android.view.SurfaceHolder;

	import com.android.systemui.SysuiTestCase;		import com.android.systemui.SysuiTestCase;
			import com.android.systemui.flags.FeatureFlags;
	import com.android.systemui.wallpapers.gl.ImageWallpaperRenderer;		import com.android.systemui.wallpapers.gl.ImageWallpaperRenderer;

	import org.junit.Before;		import org.junit.Before;
	@@ -72,6 +73,8 @@ public class ImageWallpaperTest extends SysuiTestCase {
	private Bitmap mWallpaperBitmap;		private Bitmap mWallpaperBitmap;
	@Mock		@Mock
	private Handler mHandler;		private Handler mHandler;
			@Mock
			private FeatureFlags mFeatureFlags;

	private CountDownLatch mEventCountdown;		private CountDownLatch mEventCountdown;

	@@ -100,7 +103,7 @@ public class ImageWallpaperTest extends SysuiTestCase {
	}		}

	private ImageWallpaper createImageWallpaper() {		private ImageWallpaper createImageWallpaper() {
	return new ImageWallpaper() {		return new ImageWallpaper(mFeatureFlags) {
	@Override		@Override
	public Engine onCreateEngine() {		public Engine onCreateEngine() {
	return new GLEngine(mHandler) {		return new GLEngine(mHandler) {

packages/SystemUI/tests/src/com/android/systemui/wallpapers/canvas/ImageCanvasWallpaperRendererTest.java

0 → 100644

+133 −0

Original line number	Original line	Diff line number	Diff line
			/*
			* 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.systemui.wallpapers.canvas;

			import static org.hamcrest.Matchers.greaterThanOrEqualTo;
			import static org.mockito.ArgumentMatchers.any;
			import static org.mockito.ArgumentMatchers.anyInt;
			import static org.mockito.Mockito.clearInvocations;
			import static org.mockito.Mockito.never;
			import static org.mockito.Mockito.spy;
			import static org.mockito.Mockito.times;
			import static org.mockito.Mockito.verify;
			import static org.mockito.Mockito.when;
			import static org.mockito.hamcrest.MockitoHamcrest.intThat;

			import android.graphics.Bitmap;
			import android.test.suitebuilder.annotation.SmallTest;
			import android.testing.AndroidTestingRunner;
			import android.testing.TestableLooper;
			import android.view.DisplayInfo;
			import android.view.SurfaceHolder;

			import com.android.systemui.SysuiTestCase;

			import org.junit.Before;
			import org.junit.Test;
			import org.junit.runner.RunWith;
			import org.mockito.Mock;
			import org.mockito.MockitoAnnotations;

			@SmallTest
			@RunWith(AndroidTestingRunner.class)
			@TestableLooper.RunWithLooper
			public class ImageCanvasWallpaperRendererTest extends SysuiTestCase {

			private static final int MOBILE_DISPLAY_WIDTH = 720;
			private static final int MOBILE_DISPLAY_HEIGHT = 1600;

			@Mock
			private SurfaceHolder mMockSurfaceHolder;

			@Mock
			private DisplayInfo mMockDisplayInfo;

			@Mock
			private Bitmap mMockBitmap;

			@Before
			public void setUp() throws Exception {
			allowTestableLooperAsMainThread();
			MockitoAnnotations.initMocks(this);
			}

			private void setDimensions(
			int bitmapWidth, int bitmapHeight,
			int displayWidth, int displayHeight) {
			when(mMockBitmap.getWidth()).thenReturn(bitmapWidth);
			when(mMockBitmap.getHeight()).thenReturn(bitmapHeight);
			mMockDisplayInfo.logicalWidth = displayWidth;
			mMockDisplayInfo.logicalHeight = displayHeight;
			}

			private void testMinDimensions(
			int bitmapWidth, int bitmapHeight) {

			clearInvocations(mMockSurfaceHolder);
			setDimensions(bitmapWidth, bitmapHeight,
			ImageCanvasWallpaperRendererTest.MOBILE_DISPLAY_WIDTH,
			ImageCanvasWallpaperRendererTest.MOBILE_DISPLAY_HEIGHT);

			ImageCanvasWallpaperRenderer renderer =
			new ImageCanvasWallpaperRenderer(mMockSurfaceHolder);
			renderer.drawFrame(mMockBitmap, true);

			verify(mMockSurfaceHolder, times(1)).setFixedSize(
			intThat(greaterThanOrEqualTo(ImageCanvasWallpaperRenderer.MIN_SURFACE_WIDTH)),
			intThat(greaterThanOrEqualTo(ImageCanvasWallpaperRenderer.MIN_SURFACE_HEIGHT)));
			}

			@Test
			public void testMinSurface() {
			// test that the surface is always at least MIN_SURFACE_WIDTH x MIN_SURFACE_HEIGHT
			testMinDimensions(8, 8);

			testMinDimensions(100, 2000);

			testMinDimensions(200, 1);
			}

			private void testZeroDimensions(int bitmapWidth, int bitmapHeight) {

			clearInvocations(mMockSurfaceHolder);
			setDimensions(bitmapWidth, bitmapHeight,
			ImageCanvasWallpaperRendererTest.MOBILE_DISPLAY_WIDTH,
			ImageCanvasWallpaperRendererTest.MOBILE_DISPLAY_HEIGHT);

			ImageCanvasWallpaperRenderer renderer =
			new ImageCanvasWallpaperRenderer(mMockSurfaceHolder);
			ImageCanvasWallpaperRenderer spyRenderer = spy(renderer);
			spyRenderer.drawFrame(mMockBitmap, true);

			verify(mMockSurfaceHolder, never()).setFixedSize(anyInt(), anyInt());
			verify(spyRenderer, never()).drawWallpaperWithCanvas(any());
			}

			@Test
			public void testZeroBitmap() {
			// test that updateSurfaceSize is not called with a bitmap of width 0 or height 0
			testZeroDimensions(
			0, 1
			);

			testZeroDimensions(1, 0
			);

			testZeroDimensions(0, 0
			);
			}
			}