Backport 'Add ability to disable GL draws'. am: 3f8b9fe50b (3dd1928c) · Commits · e / os / android_frameworks_base

graphics/java/android/graphics/HardwareRenderer.java

+52 −0

Original line number	Diff line number	Diff line
		@@ -22,6 +22,7 @@ import android.annotation.NonNull;
		import android.annotation.Nullable;
		import android.app.Activity;
		import android.app.ActivityManager;
		import android.compat.annotation.UnsupportedAppUsage;
		import android.content.Context;
		import android.content.pm.ActivityInfo;
		import android.content.res.Configuration;
		@@ -1075,6 +1076,53 @@ public class HardwareRenderer {
		ProcessInitializer.sInstance.setContext(context);
		}

		/**
		* Returns true if HardwareRender will produce output.
		*
		* This value is global to the process and affects all uses of HardwareRenderer,
		* including
		* those created by the system such as those used by the View tree when using hardware
		* accelerated rendering.
		*
		* Default is true in all production environments, but may be false in testing-focused
		* emulators or if {@link #setDrawingEnabled(boolean)} is used.
		*
		* Backported from android T.
		*
		* @hide
		*/
		@UnsupportedAppUsage
		public static boolean isDrawingEnabled() {
		return nIsDrawingEnabled();
		}

		/**
		* Toggles whether or not HardwareRenderer will produce drawing output globally in the current
		* process.
		*
		* This applies to all HardwareRenderer instances, including those created by the platform such
		* as those used by the system for hardware accelerated View rendering.
		*
		* The capability to disable drawing output is intended for test environments, primarily
		* headless ones. By setting this to false, tests that launch activities or interact with Views
		* can be quicker with less RAM usage by skipping the final step of View drawing. All View
		* lifecycle events will occur as normal, only the final step of rendering on the GPU to the
		* display will be skipped.
		*
		* This can be toggled on and off at will, so screenshot tests can also run in this same
		* environment by toggling drawing back on and forcing a frame to be drawn such as by calling
		* view#invalidate(). Once drawn and the screenshot captured, this can then be turned back off.
		*
		* Backported from android T.
		*
		* @hide
		*/
		// TODO: Add link to androidx's Screenshot library for help with this
		@UnsupportedAppUsage
		public static void setDrawingEnabled(boolean drawingEnabled) {
		nSetDrawingEnabled(drawingEnabled);
		}

		private static final class DestroyContextRunnable implements Runnable {
		private final long mNativeInstance;

		@@ -1393,4 +1441,8 @@ public class HardwareRenderer {

		private static native void nInitDisplayInfo(int width, int height, float refreshRate,
		int wideColorDataspace, long appVsyncOffsetNanos, long presentationDeadlineNanos);

		private static native void nSetDrawingEnabled(boolean drawingEnabled);

		private static native boolean nIsDrawingEnabled();
		}

libs/hwui/Properties.cpp

+21 −0

Original line number	Diff line number	Diff line
		@@ -88,6 +88,9 @@ bool Properties::enableWebViewOverlays = false;

		StretchEffectBehavior Properties::stretchEffectBehavior = StretchEffectBehavior::ShaderHWUI;

		bool Properties::drawingEnabled = true;
		OverrideDrawingEnabled Properties::overrideDrawingEnabled = OverrideDrawingEnabled::Default;

		bool Properties::load() {
		bool prevDebugLayersUpdates = debugLayersUpdates;
		bool prevDebugOverdraw = debugOverdraw;
		@@ -141,6 +144,11 @@ bool Properties::load() {

		enableWebViewOverlays = base::GetBoolProperty(PROPERTY_WEBVIEW_OVERLAYS_ENABLED, false);

		drawingEnabled = base::GetBoolProperty(PROPERTY_DRAWING_ENABLED, true);
		if (!drawingEnabled) {
		enableRTAnimations = false;
		}

		return (prevDebugLayersUpdates != debugLayersUpdates) \|\| (prevDebugOverdraw != debugOverdraw);
		}

		@@ -210,5 +218,18 @@ void Properties::overrideRenderPipelineType(RenderPipelineType type, bool inUnit
		sRenderPipelineType = type;
		}

		void Properties::setDrawingEnabled(bool newDrawingEnabled) {
		overrideDrawingEnabled =
		newDrawingEnabled ? OverrideDrawingEnabled::On : OverrideDrawingEnabled::Off;
		enableRTAnimations = newDrawingEnabled;
		}

		bool Properties::isDrawingEnabled() {
		if (overrideDrawingEnabled == OverrideDrawingEnabled::Default) {
		return drawingEnabled;
		}
		return overrideDrawingEnabled == OverrideDrawingEnabled::On;
		}

		} // namespace uirenderer
		} // namespace android

libs/hwui/Properties.h

+14 −0

Original line number	Diff line number	Diff line
		@@ -187,6 +187,12 @@ enum DebugLevel {
		*/
		#define PROPERTY_WEBVIEW_OVERLAYS_ENABLED "debug.hwui.webview_overlays_enabled"

		/**
		* Property for globally GL drawing state. Can be overridden per process with
		* setDrawingEnabled.
		*/
		#define PROPERTY_DRAWING_ENABLED "debug.hwui.drawing_enabled"

		///////////////////////////////////////////////////////////////////////////////
		// Misc
		///////////////////////////////////////////////////////////////////////////////
		@@ -208,6 +214,8 @@ enum class StretchEffectBehavior {
		UniformScale // Uniform scale stretch everywhere
		};

		enum class OverrideDrawingEnabled { Default, On, Off };

		/**
		* Renderthread-only singleton which manages several static rendering properties. Most of these
		* are driven by system properties which are queried once at initialization, and again if init()
		@@ -301,6 +309,12 @@ public:
		stretchEffectBehavior = behavior;
		}

		// Represents if GL drawing is enabled. Should only be false in headless testing environments
		static bool drawingEnabled;
		static OverrideDrawingEnabled overrideDrawingEnabled;
		static bool isDrawingEnabled();
		static void setDrawingEnabled(bool enable);

		private:
		static StretchEffectBehavior stretchEffectBehavior;
		static ProfileType sProfileType;

libs/hwui/jni/android_graphics_HardwareRenderer.cpp

+11 −0

Original line number	Diff line number	Diff line
		@@ -817,6 +817,14 @@ static void android_view_ThreadedRenderer_initDisplayInfo(JNIEnv*, jclass, jint
		DeviceInfo::setPresentationDeadlineNanos(presentationDeadlineNanos);
		}

		static void android_view_ThreadedRenderer_setDrawingEnabled(JNIEnv*, jclass, jboolean enabled) {
		Properties::setDrawingEnabled(enabled);
		}

		static jboolean android_view_ThreadedRenderer_isDrawingEnabled(JNIEnv*, jclass) {
		return Properties::isDrawingEnabled();
		}

		// ----------------------------------------------------------------------------
		// HardwareRendererObserver
		// ----------------------------------------------------------------------------
		@@ -953,6 +961,9 @@ static const JNINativeMethod gMethods[] = {
		{"preload", "()V", (void*)android_view_ThreadedRenderer_preload},
		{"isWebViewOverlaysEnabled", "()Z",
		(void*)android_view_ThreadedRenderer_isWebViewOverlaysEnabled},
		{"nSetDrawingEnabled", "(Z)V", (void*)android_view_ThreadedRenderer_setDrawingEnabled},
		{"nIsDrawingEnabled", "()Z", (void*)android_view_ThreadedRenderer_isDrawingEnabled},

		};

		static JavaVM* mJvm = nullptr;

libs/hwui/renderthread/CanvasContext.cpp

+3 −2

Original line number	Diff line number	Diff line
		@@ -256,7 +256,7 @@ void CanvasContext::setStopped(bool stopped) {
		}

		void CanvasContext::allocateBuffers() {
		if (mNativeSurface) {
		if (mNativeSurface && Properties::isDrawingEnabled()) {
		ANativeWindow_tryAllocateBuffers(mNativeSurface->getNativeWindow());
		}
		}
		@@ -480,7 +480,8 @@ nsecs_t CanvasContext::draw() {
		SkRect dirty;
		mDamageAccumulator.finish(&dirty);

		if (dirty.isEmpty() && Properties::skipEmptyFrames && !surfaceRequiresRedraw()) {
		if (!Properties::isDrawingEnabled() \|\|
		(dirty.isEmpty() && Properties::skipEmptyFrames && !surfaceRequiresRedraw())) {
		mCurrentFrameInfo->addFlag(FrameInfoFlags::SkippedFrame);
		if (auto grContext = getGrContext()) {
		// Submit to ensure that any texture uploads complete and Skia can