Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 845fee95 authored by Ian Elliott's avatar Ian Elliott
Browse files

Change Android platform for when ANGLE is default 

Allow adb commands to select ANGLE vs the legacy GLES driver
regardless of which driver is the system (default) driver, and to
select between different versions of ANGLE if multiple versions are
installed (e.g. the built-in system driver vs. an updated APK).

Test: logcat
Bug: 224558229

Change-Id: I83e59002b67181fda4da6070b80ffa595bc25ac4
parent b0bf5723

libs/graphicsenv/GraphicsEnv.cpp

+48 −4
Original line number Diff line number Diff line
@@ -364,26 +364,51 @@ 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) {

        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 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 +429,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 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

+14 −1
Original line number Diff line number Diff line
@@ -91,17 +91,26 @@ 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, 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 +165,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

+30 −17
Original line number Diff line number Diff line
@@ -216,8 +216,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 forceLegacyDriver = android::GraphicsEnv::getInstance().forceLegacyDriver();

    driver_t* hnd = nullptr;

    if (!forceLegacyDriver) {

        hnd = attempt_to_load_angle(cnx);

    }



    if (!hnd) {

        // Secondly, try to load from driver apk.

        hnd = attempt_to_load_updated_driver(cnx);
@@ -230,8 +235,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 (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.

            // i.e.:

            //      libGLES_${prop}.so, or:

            //      libEGL_${prop}.so, libGLESv1_CM_${prop}.so, libGLESv2_${prop}.so
@@ -248,6 +260,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