Merge "Can switch to legacy GLES driver when ANGLE is system driver" (8823e097) · Commits · e / os / android_frameworks_native

libs/graphicsenv/GraphicsEnv.cpp

+58 −4

Original line number	Diff line number	Diff line
		@@ -364,26 +364,61 @@ bool GraphicsEnv::shouldUseAngle() {
		return (mUseAngle == YES) ? true : false;
		}

		bool GraphicsEnv::angleIsSystemDriver() {
		// Make sure we are init'ed
		if (mAngleAppName.empty()) {
		ALOGV("App name is empty. setAngleInfo() has not been called to enable ANGLE.");
		return false;
		}

		return (mAngleIsSystemDriver == YES) ? true : false;
		}

		bool GraphicsEnv::shouldForceLegacyDriver() {
		// Make sure we are init'ed
		if (mAngleAppName.empty()) {
		ALOGV("App name is empty. setAngleInfo() has not been called to enable ANGLE.");
		return false;
		}

		return (mAngleIsSystemDriver == YES && mUseAngle == NO) ? true : false;
		}

		std::string GraphicsEnv::getLegacySuffix() {
		return mLegacyDriverSuffix;
		}

		void GraphicsEnv::updateUseAngle() {
		mUseAngle = NO;

		const char* ANGLE_PREFER_ANGLE = "angle";
		const char* ANGLE_PREFER_LEGACY = "legacy";
		// The following is a deprecated version of "legacy"
		const char* ANGLE_PREFER_NATIVE = "native";

		mUseAngle = NO;
		if (mAngleDeveloperOptIn == ANGLE_PREFER_ANGLE) {
		ALOGV("User set \"Developer Options\" to force the use of ANGLE");
		ALOGI("Using ANGLE, the %s GLES driver for package '%s'",
		mAngleIsSystemDriver == YES ? "system" : "optional", mAngleAppName.c_str());
		mUseAngle = YES;
		} else if (mAngleDeveloperOptIn == ANGLE_PREFER_NATIVE) {
		ALOGV("User set \"Developer Options\" to force the use of Native");
		} else if (mAngleDeveloperOptIn == ANGLE_PREFER_LEGACY \|\|
		mAngleDeveloperOptIn == ANGLE_PREFER_NATIVE) {
		ALOGI("Using the (%s) Legacy GLES driver for package '%s'",
		mAngleIsSystemDriver == YES ? "optional" : "system", mAngleAppName.c_str());
		} else {
		ALOGV("User set invalid \"Developer Options\": '%s'", mAngleDeveloperOptIn.c_str());
		}
		}

		void GraphicsEnv::setAngleInfo(const std::string path, const std::string appName,
		const std::string developerOptIn,
		const bool angleIsSystemDriver, const std::string developerOptIn,
		const std::vector<std::string> eglFeatures) {
		// Set whether ANGLE is the system driver:
		mAngleIsSystemDriver = angleIsSystemDriver ? YES : NO;

		// Note: Given the current logic and lack of the old rules file processing,
		// there seems to be little chance that mUseAngle != UNKNOWN. Leave this
		// for now, even though it seems outdated.
		if (mUseAngle != UNKNOWN) {
		// We've already figured out an answer for this app, so just return.
		ALOGV("Already evaluated the rules file for '%s': use ANGLE = %s", appName.c_str(),
		@@ -404,6 +439,25 @@ void GraphicsEnv::setAngleInfo(const std::string path, const std::string appName
		updateUseAngle();
		}

		void GraphicsEnv::setLegacyDriverInfo(const std::string appName, const bool angleIsSystemDriver,
		const std::string legacyDriverName) {
		ALOGV("setting legacy app name to '%s'", appName.c_str());
		mAngleAppName = appName;

		// Force the use of the legacy driver instead of ANGLE
		const char* ANGLE_PREFER_LEGACY = "legacy";
		mAngleDeveloperOptIn = ANGLE_PREFER_LEGACY;
		ALOGV("setting ANGLE application opt-in to 'legacy'");

		// Set whether ANGLE is the system driver:
		mAngleIsSystemDriver = angleIsSystemDriver ? YES : NO;

		mLegacyDriverSuffix = legacyDriverName;

		// Update the current status of whether we should use ANGLE or not
		updateUseAngle();
		}

		void GraphicsEnv::setLayerPaths(NativeLoaderNamespace* appNamespace, const std::string layerPaths) {
		if (mLayerPaths.empty()) {
		mLayerPaths = layerPaths;

libs/graphicsenv/include/graphicsenv/GraphicsEnv.h

+16 −1

Original line number	Diff line number	Diff line
		@@ -91,17 +91,28 @@ public:
		bool shouldUseAngle(std::string appName);
		// Check if this app process should use ANGLE.
		bool shouldUseAngle();
		// If ANGLE is the system GLES driver
		bool angleIsSystemDriver();
		// If should use legacy driver instead of a system ANGLE driver
		bool shouldForceLegacyDriver();
		// Set a search path for loading ANGLE libraries. The path is a list of
		// directories separated by ':'. A directory can be contained in a zip file
		// (libraries must be stored uncompressed and page aligned); such elements
		// in the search path must have a '!' after the zip filename, e.g.
		// /system/app/ANGLEPrebuilt/ANGLEPrebuilt.apk!/lib/arm64-v8a
		void setAngleInfo(const std::string path, const std::string appName, std::string devOptIn,
		void setAngleInfo(const std::string path, const std::string appName,
		const bool angleIsSystemDriver, std::string devOptIn,
		const std::vector<std::string> eglFeatures);
		// Set the state so that the legacy driver will be used, and in case ANGLE
		// is the system driver, provide the name of the legacy driver.
		void setLegacyDriverInfo(const std::string appName, const bool angleIsSystemDriver,
		const std::string legacyDriverName);
		// Get the ANGLE driver namespace.
		android_namespace_t* getAngleNamespace();
		// Get the app name for ANGLE debug message.
		std::string& getAngleAppName();
		// Get the legacy driver's suffix name.
		std::string getLegacySuffix();

		const std::vector<std::string>& getAngleEglFeatures();

		@@ -156,6 +167,10 @@ private:
		std::string mAngleDeveloperOptIn;
		// ANGLE EGL features;
		std::vector<std::string> mAngleEglFeatures;
		// ANGLE is System Driver flag.
		UseAngle mAngleIsSystemDriver = UNKNOWN;
		// Legacy driver name to use when ANGLE is the system driver.
		std::string mLegacyDriverSuffix;
		// Use ANGLE flag.
		UseAngle mUseAngle = UNKNOWN;
		// Vulkan debug layers libs.

opengl/libs/EGL/Loader.cpp

+32 −18

Original line number	Diff line number	Diff line
		@@ -207,7 +207,8 @@ void* Loader::open(egl_connection_t* cnx)
		ATRACE_CALL();
		const nsecs_t openTime = systemTime();

		if (should_unload_system_driver(cnx)) {
		if (!android::GraphicsEnv::getInstance().angleIsSystemDriver() &&
		should_unload_system_driver(cnx)) {
		unload_system_driver(cnx);
		}

		@@ -216,8 +217,13 @@ void* Loader::open(egl_connection_t* cnx)
		return cnx->dso;
		}

		// Firstly, try to load ANGLE driver.
		driver_t* hnd = attempt_to_load_angle(cnx);
		// Firstly, try to load ANGLE driver, unless we know that we shouldn't.
		bool shouldForceLegacyDriver = android::GraphicsEnv::getInstance().shouldForceLegacyDriver();
		driver_t* hnd = nullptr;
		if (!shouldForceLegacyDriver) {
		hnd = attempt_to_load_angle(cnx);
		}

		if (!hnd) {
		// Secondly, try to load from driver apk.
		hnd = attempt_to_load_updated_driver(cnx);
		@@ -230,8 +236,15 @@ void* Loader::open(egl_connection_t* cnx)
		LOG_ALWAYS_FATAL("couldn't find an OpenGL ES implementation from %s",
		android::GraphicsEnv::getInstance().getDriverPath().c_str());
		}
		// Finally, try to load system driver, start by searching for the library name appended by
		// the system properties of the GLES userspace driver in both locations.
		// Finally, try to load system driver. If ANGLE is the system driver
		// (i.e. we are forcing the legacy system driver instead of ANGLE), use
		// the driver suffix that was passed down from above.
		if (shouldForceLegacyDriver) {
		std::string suffix = android::GraphicsEnv::getInstance().getLegacySuffix();
		hnd = attempt_to_load_system_driver(cnx, suffix.c_str(), true);
		} else {
		// Start by searching for the library name appended by the system
		// properties of the GLES userspace driver in both locations.
		// i.e.:
		// libGLES_${prop}.so, or:
		// libEGL_${prop}.so, libGLESv1_CM_${prop}.so, libGLESv2_${prop}.so
		@@ -248,6 +261,7 @@ void* Loader::open(egl_connection_t* cnx)
		}
		}
		}
		}

		if (!hnd) {
		// Can't find graphics driver by appending system properties, now search for the exact name