Revert "Change Android platform for when ANGLE is default" (2e62815e) · Commits · e / os / android_frameworks_native

libs/graphicsenv/GraphicsEnv.cpp

+4 −48

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

		bool GraphicsEnv::forceLegacyDriver() {
		// Make sure we are init'ed
		if (mAngleAppName.empty()) {
		ALOGV("NOT SETUP YET.");
		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) {
		ALOGI("Using ANGLE, the %s GLES driver for package '%s'",
		mAngleIsSystemDriver == YES ? "system" : "optional", mAngleAppName.c_str());
		ALOGV("User set \"Developer Options\" to force the use of ANGLE");
		mUseAngle = YES;
		} else if (mAngleDeveloperOptIn == ANGLE_PREFER_LEGACY \|\|
		mAngleDeveloperOptIn == ANGLE_PREFER_NATIVE) {
		ALOGI("Using the (%s) Legacy GLES driver driver for package '%s'",
		mAngleIsSystemDriver == YES ? "optional" : "system", mAngleAppName.c_str());
		} else if (mAngleDeveloperOptIn == ANGLE_PREFER_NATIVE) {
		ALOGV("User set \"Developer Options\" to force the use of Native");
		} else {
		ALOGV("User set invalid \"Developer Options\": '%s'", mAngleDeveloperOptIn.c_str());
		}
		}

		void GraphicsEnv::setAngleInfo(const std::string path, const std::string appName,
		const bool angleIsSystemDriver, const std::string developerOptIn,
		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(),
		@@ -429,25 +404,6 @@ 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 ANGLE 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

+1 −14

Original line number	Diff line number	Diff line
		@@ -91,26 +91,17 @@ public:
		bool shouldUseAngle(std::string appName);
		// Check if this app process should use ANGLE.
		bool shouldUseAngle();
		// If should use legacy driver instead of a system ANGLE driver
		bool forceLegacyDriver();
		// 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,
		const bool angleIsSystemDriver, std::string devOptIn,
		void setAngleInfo(const std::string path, const std::string appName, 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();

		@@ -165,10 +156,6 @@ 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

+17 −30

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

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

		// Firstly, try to load ANGLE driver.
		driver_t* hnd = attempt_to_load_angle(cnx);
		if (!hnd) {
		// Secondly, try to load from driver apk.
		hnd = attempt_to_load_updated_driver(cnx);
		@@ -235,15 +230,8 @@ 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. 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 (forceLegacyDriver) {
		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.
		// 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.
		// i.e.:
		// libGLES_${prop}.so, or:
		// libEGL_${prop}.so, libGLESv1_CM_${prop}.so, libGLESv2_${prop}.so
		@@ -260,7 +248,6 @@ void* Loader::open(egl_connection_t* cnx)
		}
		}
		}
		}

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