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

Commit fa0ce372 authored by Peiyong Lin's avatar Peiyong Lin Committed by Automerger Merge Worker
Browse files

Merge "Refactor ANGLE usage code." into udc-dev am: b1e4e9fb am: cf72dfe4 

Original change: https://googleplex-android-review.googlesource.com/c/platform/frameworks/native/+/22557619



Change-Id: I334c922e7c90d66cd1bffca4fbb63defa6b4a9d1
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 67302092 cf72dfe4

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");