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

Commit 9679a98e authored by Peiyong Lin's avatar Peiyong Lin
Browse files

Refactor ANGLE usage code. 

Previously when ANGLE is the default system driver, the ro.hardware.egl
points to ANGLE. This is fine if ANGLE is the only system drvier.
However, we would like to make ANGLE coexist with the native GLES
drivers and allow a global switch. Hence this patch refactors the
majority of the ANGLE selection logic. Loading ANGLE in the form of an
apk as well as using ANGLE as a game mode intervention should remain
functional.

Bug: b/270994705
Test: atest CtsAngleIntegrationHostTestCases
Change-Id: I31a6a5dda04a1ffaeed101e58368ad4b4ad0d54e
parent 1861463b

libs/graphicsenv/GraphicsEnv.cpp

+4 −60
Original line number Diff line number Diff line
@@ -433,61 +433,24 @@ 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) {

        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 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(),
@@ -508,25 +471,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 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

+1 −16
Original line number Diff line number Diff line
@@ -100,28 +100,17 @@ 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,

                      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();
@@ -178,10 +167,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

+11 −13
Original line number Diff line number Diff line
@@ -139,7 +139,8 @@ static void* load_wrapper(const char* path) { 


static const char* DRIVER_SUFFIX_PROPERTY = "ro.hardware.egl";



static const char* HAL_SUBNAME_KEY_PROPERTIES[2] = {

static const char* HAL_SUBNAME_KEY_PROPERTIES[3] = {

        "persist.graphics.egl",

        DRIVER_SUFFIX_PROPERTY,

        "ro.board.platform",

};
@@ -208,8 +209,7 @@ void* Loader::open(egl_connection_t* cnx) 
    ATRACE_CALL();

    const nsecs_t openTime = systemTime();



    if (!android::GraphicsEnv::getInstance().angleIsSystemDriver() &&

        should_unload_system_driver(cnx)) {

    if (should_unload_system_driver(cnx)) {

        unload_system_driver(cnx);

    }
@@ -218,12 +218,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 shouldForceLegacyDriver = android::GraphicsEnv::getInstance().shouldForceLegacyDriver();

    driver_t* hnd = nullptr;

    if (!shouldForceLegacyDriver) {

        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.
@@ -285,8 +281,10 @@ void* Loader::open(egl_connection_t* cnx) 
    }



    LOG_ALWAYS_FATAL_IF(!hnd,

                        "couldn't find an OpenGL ES implementation, make sure you set %s or %s",

                        HAL_SUBNAME_KEY_PROPERTIES[0], HAL_SUBNAME_KEY_PROPERTIES[1]);

                        "couldn't find an OpenGL ES implementation, make sure one of %s, %s and %s "

                        "is set",

                        HAL_SUBNAME_KEY_PROPERTIES[0], HAL_SUBNAME_KEY_PROPERTIES[1],

                        HAL_SUBNAME_KEY_PROPERTIES[2]);



    if (!cnx->libEgl) {

        cnx->libEgl = load_wrapper(EGL_WRAPPER_DIR "/libEGL.so");