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

Commit 5f744f14 authored by Tim Van Patten's avatar Tim Van Patten
Browse files

Refactor for Better Resource Management 

The GraphicsEnvironment/GraphicsEnv code is being refactored to allow
for better resource management related to open files and file
descriptors and reducing the amount of times the rules files are parsed.

This is also laying the groundwork for other modules to query if ANGLE
will be loaded or not, for example to display a dialog box to the user
when ANGLE is selected for an app.

Bug: 120910315
Test: Verify CtsAngleIntegrationHostTestCases passes.
Change-Id: If985df7d84d043942d5eccdc575a53cb2a08a0ba
parent 4ad97e2b

libs/graphicsenv/GraphicsEnv.cpp

+192 −43
Original line number Diff line number Diff line
@@ -19,6 +19,7 @@ 
#include <graphicsenv/GraphicsEnv.h>



#include <dlfcn.h>

#include <unistd.h>



#include <android-base/file.h>

#include <android-base/properties.h>
@@ -28,7 +29,11 @@ 
#include <log/log.h>

#include <sys/prctl.h>



#include <memory>

#include <mutex>

#include <string>



#include <dlfcn.h>



// TODO(b/37049319) Get this from a header once one exists

extern "C" {
@@ -46,6 +51,20 @@ enum { 
};

}



// TODO(ianelliott@): Get the following from an ANGLE header:

#define CURRENT_ANGLE_API_VERSION 2 // Current API verion we are targetting

// Version-2 API:

typedef bool (*fpANGLEGetFeatureSupportUtilAPIVersion)(unsigned int* versionToUse);

typedef bool (*fpANGLEAndroidParseRulesString)(const char* rulesString, void** rulesHandle,

                                               int* rulesVersion);

typedef bool (*fpANGLEGetSystemInfo)(void** handle);

typedef bool (*fpANGLEAddDeviceInfoToSystemInfo)(const char* deviceMfr, const char* deviceModel,

                                                 void* handle);

typedef bool (*fpANGLEShouldBeUsedForApplication)(void* rulesHandle, int rulesVersion,

                                                  void* systemInfoHandle, const char* appName);

typedef bool (*fpANGLEFreeRulesHandle)(void* handle);

typedef bool (*fpANGLEFreeSystemInfoHandle)(void* handle);



namespace android {



enum NativeLibrary {
@@ -134,39 +153,186 @@ void GraphicsEnv::setDriverPath(const std::string path) { 
    mDriverPath = path;

}



void GraphicsEnv::setAngleInfo(const std::string path, const std::string appName,

                               const std::string developerOptIn, const int rulesFd,

                               const long rulesOffset, const long rulesLength) {

    if (!mAnglePath.empty()) {

        ALOGV("ignoring attempt to change ANGLE path from '%s' to '%s'", mAnglePath.c_str(),

              path.c_str());

void* GraphicsEnv::loadLibrary(std::string name) {

    const android_dlextinfo dlextinfo = {

            .flags = ANDROID_DLEXT_USE_NAMESPACE,

            .library_namespace = getAngleNamespace(),

    };



    std::string libName = std::string("lib") + name + "_angle.so";



    void* so = android_dlopen_ext(libName.c_str(), RTLD_LOCAL | RTLD_NOW, &dlextinfo);



    if (so) {

        ALOGD("dlopen_ext from APK (%s) success at %p", libName.c_str(), so);

        return so;

    } else {

        ALOGV("setting ANGLE path to '%s'", path.c_str());

        mAnglePath = path;

        ALOGE("dlopen_ext(\"%s\") failed: %s", libName.c_str(), dlerror());

    }



    return nullptr;

}



    if (!mAngleAppName.empty()) {

        ALOGV("ignoring attempt to change ANGLE app name from '%s' to '%s'", mAngleAppName.c_str(),

bool GraphicsEnv::checkAngleRules(void* so) {

    char manufacturer[PROPERTY_VALUE_MAX];

    char model[PROPERTY_VALUE_MAX];

    property_get("ro.product.manufacturer", manufacturer, "UNSET");

    property_get("ro.product.model", model, "UNSET");



    auto ANGLEGetFeatureSupportUtilAPIVersion =

            (fpANGLEGetFeatureSupportUtilAPIVersion)dlsym(so,

                                                          "ANGLEGetFeatureSupportUtilAPIVersion");



    if (!ANGLEGetFeatureSupportUtilAPIVersion) {

        ALOGW("Cannot find ANGLEGetFeatureSupportUtilAPIVersion function");

        return false;

    }



    // Negotiate the interface version by requesting most recent known to the platform

    unsigned int versionToUse = CURRENT_ANGLE_API_VERSION;

    if (!(ANGLEGetFeatureSupportUtilAPIVersion)(&versionToUse)) {

        ALOGW("Cannot use ANGLE feature-support library, it is older than supported by EGL, "

              "requested version %u",

              versionToUse);

        return false;

    }



    // Add and remove versions below as needed

    bool useAngle = false;

    switch (versionToUse) {

        case 2: {

            ALOGV("Using version %d of ANGLE feature-support library", versionToUse);

            void* rulesHandle = nullptr;

            int rulesVersion = 0;

            void* systemInfoHandle = nullptr;



            // Get the symbols for the feature-support-utility library:

#define GET_SYMBOL(symbol)                                                 \

    fp##symbol symbol = (fp##symbol)dlsym(so, #symbol);                    \

    if (!symbol) {                                                         \

        ALOGW("Cannot find " #symbol " in ANGLE feature-support library"); \

        break;                                                             \

    }

            GET_SYMBOL(ANGLEAndroidParseRulesString);

            GET_SYMBOL(ANGLEGetSystemInfo);

            GET_SYMBOL(ANGLEAddDeviceInfoToSystemInfo);

            GET_SYMBOL(ANGLEShouldBeUsedForApplication);

            GET_SYMBOL(ANGLEFreeRulesHandle);

            GET_SYMBOL(ANGLEFreeSystemInfoHandle);



            // Parse the rules, obtain the SystemInfo, and evaluate the

            // application against the rules:

            if (!(ANGLEAndroidParseRulesString)(mRulesBuffer.data(), &rulesHandle, &rulesVersion)) {

                ALOGW("ANGLE feature-support library cannot parse rules file");

                break;

            }

            if (!(ANGLEGetSystemInfo)(&systemInfoHandle)) {

                ALOGW("ANGLE feature-support library cannot obtain SystemInfo");

                break;

            }

            if (!(ANGLEAddDeviceInfoToSystemInfo)(manufacturer, model, systemInfoHandle)) {

                ALOGW("ANGLE feature-support library cannot add device info to SystemInfo");

                break;

            }

            useAngle = (ANGLEShouldBeUsedForApplication)(rulesHandle, rulesVersion,

                                                         systemInfoHandle, mAngleAppName.c_str());

            (ANGLEFreeRulesHandle)(rulesHandle);

            (ANGLEFreeSystemInfoHandle)(systemInfoHandle);

        } break;



        default:

            ALOGW("Version %u of ANGLE feature-support library is NOT supported.", versionToUse);

    }



    ALOGV("Close temporarily-loaded ANGLE opt-in/out logic");

    return useAngle;

}



bool GraphicsEnv::shouldUseAngle(std::string appName) {

    if (appName != mAngleAppName) {

        // Make sure we are checking the app we were init'ed for

        ALOGE("App name does not match: expected '%s', got '%s'", mAngleAppName.c_str(),

              appName.c_str());

    } else {

        ALOGV("setting ANGLE app name to '%s'", appName.c_str());

        mAngleAppName = appName;

        return false;

    }



    return shouldUseAngle();

}



    if (!mAngleDeveloperOptIn.empty()) {

        ALOGV("ignoring attempt to change ANGLE application opt-in from '%s' to '%s'",

              mAngleDeveloperOptIn.c_str(), developerOptIn.c_str());

bool GraphicsEnv::shouldUseAngle() {

    // Make sure we are init'ed

    if (mAngleAppName.empty()) {

        ALOGE("App name is empty. setAngleInfo() must be called first to enable ANGLE.");

        return false;

    }



    return mUseAngle;

}



void GraphicsEnv::updateUseAngle() {

    mUseAngle = false;



    const char* ANGLE_PREFER_ANGLE = "angle";

    const char* ANGLE_PREFER_NATIVE = "native";



    if (mAngleDeveloperOptIn == ANGLE_PREFER_ANGLE) {

        ALOGV("User set \"Developer Options\" to force the use of ANGLE");

        mUseAngle = true;

    } else if (mAngleDeveloperOptIn == ANGLE_PREFER_NATIVE) {

        ALOGV("User set \"Developer Options\" to force the use of Native");

        mUseAngle = false;

    } else {

        // The "Developer Options" value wasn't set to force the use of ANGLE.  Need to temporarily

        // load ANGLE and call the updatable opt-in/out logic:



        // Check if ANGLE is enabled. Workaround for several bugs:

        // b/119305693 b/119322355 b/119305887

        // Something is not working correctly in the feature library

        char prop[PROPERTY_VALUE_MAX];

        property_get("debug.angle.enable", prop, "0");

        void* featureSo = nullptr;

        if (atoi(prop)) {

            featureSo = loadLibrary("feature_support");

        }

        if (featureSo) {

            ALOGV("loaded ANGLE's opt-in/out logic from namespace");

            mUseAngle = checkAngleRules(featureSo);

            dlclose(featureSo);

            featureSo = nullptr;

        } else {

            ALOGV("Could not load the ANGLE opt-in/out logic, cannot use ANGLE.");

        }

    }

}



void GraphicsEnv::setAngleInfo(const std::string path, const std::string appName,

                               const std::string developerOptIn, const int rulesFd,

                               const long rulesOffset, const long rulesLength) {

    ALOGV("setting ANGLE path to '%s'", path.c_str());

    mAnglePath = path;

    ALOGV("setting ANGLE app name to '%s'", appName.c_str());

    mAngleAppName = appName;

    ALOGV("setting ANGLE application opt-in to '%s'", developerOptIn.c_str());

    mAngleDeveloperOptIn = developerOptIn;



    lseek(rulesFd, rulesOffset, SEEK_SET);

    mRulesBuffer = std::vector<char>(rulesLength + 1);

    ssize_t numBytesRead = read(rulesFd, mRulesBuffer.data(), rulesLength);

    if (numBytesRead < 0) {

        ALOGE("Cannot read rules file: numBytesRead = %zd", numBytesRead);

        numBytesRead = 0;

    } else if (numBytesRead == 0) {

        ALOGW("Empty rules file");

    }

    if (numBytesRead != rulesLength) {

        ALOGW("Did not read all of the necessary bytes from the rules file."

              "expected: %ld, got: %zd",

              rulesLength, numBytesRead);

    }

    mRulesBuffer[numBytesRead] = '\0';



    ALOGV("setting ANGLE rules file descriptor to '%i'", rulesFd);

    mAngleRulesFd = rulesFd;

    ALOGV("setting ANGLE rules offset to '%li'", rulesOffset);

    mAngleRulesOffset = rulesOffset;

    ALOGV("setting ANGLE rules length to '%li'", rulesLength);

    mAngleRulesLength = rulesLength;

    // Update the current status of whether we should use ANGLE or not

    updateUseAngle();

}



void GraphicsEnv::setLayerPaths(NativeLoaderNamespace* appNamespace, const std::string layerPaths) {
@@ -183,25 +349,8 @@ NativeLoaderNamespace* GraphicsEnv::getAppNamespace() { 
    return mAppNamespace;

}



const char* GraphicsEnv::getAngleAppName() {

    if (mAngleAppName.empty()) return nullptr;

    return mAngleAppName.c_str();

}



const char* GraphicsEnv::getAngleDeveloperOptIn() {

    return mAngleDeveloperOptIn.c_str();

}



int GraphicsEnv::getAngleRulesFd() {

    return mAngleRulesFd;

}



long GraphicsEnv::getAngleRulesOffset() {

    return mAngleRulesOffset;

}



long GraphicsEnv::getAngleRulesLength() {

    return mAngleRulesLength;

std::string& GraphicsEnv::getAngleAppName() {

    return mAngleAppName;

}



const std::string& GraphicsEnv::getLayerPaths() {

libs/graphicsenv/include/graphicsenv/GraphicsEnv.h

+10 −9
Original line number Diff line number Diff line
@@ -18,6 +18,7 @@ 
#define ANDROID_UI_GRAPHICS_ENV_H 1



#include <string>

#include <vector>



struct android_namespace_t;
@@ -39,6 +40,8 @@ public: 
    void setDriverPath(const std::string path);

    android_namespace_t* getDriverNamespace();



    bool shouldUseAngle(std::string appName);

    bool shouldUseAngle();

    // 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
@@ -47,12 +50,7 @@ public: 
    void setAngleInfo(const std::string path, const std::string appName, std::string devOptIn,

                      const int rulesFd, const long rulesOffset, const long rulesLength);

    android_namespace_t* getAngleNamespace();

    const char* getAngleAppName();

    const char* getAngleAppPref();

    const char* getAngleDeveloperOptIn();

    int getAngleRulesFd();

    long getAngleRulesOffset();

    long getAngleRulesLength();

    std::string& getAngleAppName();



    void setLayerPaths(NativeLoaderNamespace* appNamespace, const std::string layerPaths);

    NativeLoaderNamespace* getAppNamespace();
@@ -65,14 +63,17 @@ public: 
    const std::string& getDebugLayersGLES();



private:

    void* loadLibrary(std::string name);

    bool checkAngleRules(void* so);

    void updateUseAngle();



    GraphicsEnv() = default;

    std::string mDriverPath;

    std::string mAnglePath;

    std::string mAngleAppName;

    std::string mAngleDeveloperOptIn;

    int mAngleRulesFd;

    long mAngleRulesOffset;

    long mAngleRulesLength;

    std::vector<char> mRulesBuffer;

    bool mUseAngle;

    std::string mDebugLayers;

    std::string mDebugLayersGLES;

    std::string mLayerPaths;

opengl/libs/EGL/Loader.cpp

+27 −196
Original line number Diff line number Diff line
@@ -17,7 +17,7 @@ 
//#define LOG_NDEBUG 0

#define ATRACE_TAG ATRACE_TAG_GRAPHICS



#include "Loader.h"

#include <EGL/Loader.h>



#include <string>
@@ -38,38 +38,6 @@ 
#include "egldefs.h"

#include <EGL/eglext_angle.h>



extern "C" {

  android_namespace_t* android_get_exported_namespace(const char*);



  typedef enum ANGLEPreference {

      ANGLE_PREFER_DEFAULT = 0,

      ANGLE_PREFER_NATIVE = 1,

      ANGLE_PREFER_ANGLE = 2,

  } ANGLEPreference;



  // TODO(ianelliott@): Get the following from an ANGLE header:

  // Version-1 API:

  typedef bool (*fpANGLEGetUtilityAPI)(unsigned int* versionToUse);

  typedef bool (*fpAndroidUseANGLEForApplication)(int fd, long offset, long length,

                                                  const char* appName, const char* deviceMfr,

                                                  const char* deviceModel);

  // Version-2 API:

  typedef bool (*fpANGLEGetFeatureSupportUtilAPIVersion)(unsigned int* versionToUse);

  typedef bool (*fpANGLEAndroidParseRulesString)(const char *rulesString,

                                                 void** rulesHandle, int* rulesVersion);

  typedef bool (*fpANGLEGetSystemInfo)(void** handle);

  typedef bool (*fpANGLEAddDeviceInfoToSystemInfo)(const char* deviceMfr,

                                                   const char* deviceModel,

                                                   void* handle);

  typedef bool (*fpANGLEShouldBeUsedForApplication)(void* rules_handle,

                                                    int rules_version,

                                                    void* system_info_handle,

                                                    const char *appName);

  typedef bool (*fpANGLEFreeRulesHandle)(void* handle);

  typedef bool (*fpANGLEFreeSystemInfoHandle)(void* handle);



}



// ----------------------------------------------------------------------------

namespace android {

// ----------------------------------------------------------------------------
@@ -255,6 +223,13 @@ void* Loader::open(egl_connection_t* cnx) 


    setEmulatorGlesValue();



    // Check if we should use ANGLE early, so loading each driver doesn't require repeated queries.

    if (android::GraphicsEnv::getInstance().shouldUseAngle()) {

        cnx->shouldUseAngle = true;

    } else {

        cnx->shouldUseAngle = false;

    }



    dso = load_driver("GLES", cnx, EGL | GLESv1_CM | GLESv2);

    if (dso) {

        hnd = new driver_t(dso);
@@ -289,11 +264,7 @@ void Loader::close(egl_connection_t* cnx) 
    delete hnd;

    cnx->dso = nullptr;



    if (cnx->featureSo) {

        dlclose(cnx->featureSo);

        cnx->featureSo = nullptr;

    }



    cnx->shouldUseAngle = false;

    cnx->angleDecided = false;

    cnx->useAngle = false;
@@ -530,173 +501,32 @@ static void* load_angle_from_namespace(const char* kind, android_namespace_t* ns 
    return nullptr;

}



static ANGLEPreference getAngleDevOption(const char* devOption) {

    if (devOption == nullptr)

        return ANGLE_PREFER_DEFAULT;



    if (strcmp(devOption, "angle") == 0) {

        return ANGLE_PREFER_ANGLE;

    } else if (strcmp(devOption, "native") == 0) {

        return ANGLE_PREFER_NATIVE;

    }

    return ANGLE_PREFER_DEFAULT;

}



static bool check_angle_rules(void* so, const char* app_name) {

    bool use_angle = false;

    const int rules_fd = android::GraphicsEnv::getInstance().getAngleRulesFd();

    const long rules_offset = android::GraphicsEnv::getInstance().getAngleRulesOffset();

    const long rules_length = android::GraphicsEnv::getInstance().getAngleRulesLength();



    std::string app_name_str = app_name ? app_name : "";

    char manufacturer[PROPERTY_VALUE_MAX];

    char model[PROPERTY_VALUE_MAX];

    property_get("ro.product.manufacturer", manufacturer, "UNSET");

    property_get("ro.product.model", model, "UNSET");



    fpANGLEGetFeatureSupportUtilAPIVersion ANGLEGetFeatureSupportUtilAPIVersion =

            (fpANGLEGetFeatureSupportUtilAPIVersion)dlsym(so, "ANGLEGetFeatureSupportUtilAPIVersion");



    if (ANGLEGetFeatureSupportUtilAPIVersion) {



        // Negotiate the interface version by requesting most recent known to the platform

        unsigned int versionToUse = 2;

        if ((ANGLEGetFeatureSupportUtilAPIVersion)(&versionToUse)) {



            // Add and remove versions below as needed

            switch(versionToUse) {

            case 2: {

                ALOGV("Using version 2 of ANGLE feature-support library");

                void* rules_handle = nullptr;

                int rules_version = 0;

                void* system_info_handle = nullptr;



                // Get the symbols for the feature-support-utility library:

#define GET_SYMBOL(symbol)                                               \

    fp##symbol symbol = (fp##symbol)dlsym(so, #symbol);                  \

    if (!symbol) {                                                       \

        ALOGW("Cannot find "#symbol" in ANGLE feature-support library"); \

        break;                                                           \

    }

                GET_SYMBOL(ANGLEAndroidParseRulesString);

                GET_SYMBOL(ANGLEGetSystemInfo);

                GET_SYMBOL(ANGLEAddDeviceInfoToSystemInfo);

                GET_SYMBOL(ANGLEShouldBeUsedForApplication);

                GET_SYMBOL(ANGLEFreeRulesHandle);

                GET_SYMBOL(ANGLEFreeSystemInfoHandle);



                // Read the contents of the file into a string:

                off_t fileSize       = rules_length;

                off_t startOfContent = rules_offset;

                lseek(rules_fd, startOfContent, SEEK_SET);

                char *buffer                   = new char[fileSize + 1];

                ssize_t numBytesRead           = read(rules_fd, buffer, fileSize);

                if (numBytesRead < 0) {

                    ALOGW("Cannot read rules file");

                    break;

                }

                if (numBytesRead == 0) {

                    ALOGW("Empty rules file");

                    break;

                }

                buffer[numBytesRead]           = '\0';

                std::string rule_file_contents = std::string(buffer);

                delete[] buffer;



                // Parse the rules, obtain the SystemInfo, and evaluate the

                // application against the rules:

                if (!(ANGLEAndroidParseRulesString)(rule_file_contents.c_str(),

                                                    &rules_handle, &rules_version)) {

                    ALOGW("ANGLE feature-support library cannot parse rules file");

                    break;

                }

                if (!(ANGLEGetSystemInfo)(&system_info_handle)) {

                    ALOGW("ANGLE feature-support library cannot obtain SystemInfo");

                    break;

                }

                if (!(ANGLEAddDeviceInfoToSystemInfo)(manufacturer, model, system_info_handle)) {

                    ALOGW("ANGLE feature-support library cannot add device info to SystemInfo");

                    break;

                }

                use_angle = (ANGLEShouldBeUsedForApplication)(rules_handle, rules_version,

                                                              system_info_handle, app_name_str.c_str());

                (ANGLEFreeRulesHandle)(rules_handle);

                (ANGLEFreeSystemInfoHandle)(system_info_handle);

            }

            break;

            default:

                ALOGW("Cannot find supported version of ANGLE feature-support library, found version %u", versionToUse);

            }

        } else {

            ALOGW("Cannot use ANGLE feature-support library, it is older than supported by EGL, requested version %u", versionToUse);

        }

    } else {

        ALOGW("Cannot find ANGLEGetFeatureSupportUtilAPIVersion function");

    }



    ALOGV("Close temporarily-loaded ANGLE opt-in/out logic");

    return use_angle;

}



static void* load_angle(const char* kind, android_namespace_t* ns, egl_connection_t* cnx) {

    // Only attempt to load ANGLE libs

    if (strcmp(kind, "EGL") != 0 && strcmp(kind, "GLESv2") != 0 && strcmp(kind, "GLESv1_CM") != 0)

    if (strcmp(kind, "EGL") != 0 && strcmp(kind, "GLESv2") != 0 && strcmp(kind, "GLESv1_CM") != 0) {

        return nullptr;



    std::string name;

    char prop[PROPERTY_VALUE_MAX];



    const char* app_name = android::GraphicsEnv::getInstance().getAngleAppName();

    const char* developer_opt_in = android::GraphicsEnv::getInstance().getAngleDeveloperOptIn();



    // Determine whether or not to use ANGLE:

    ANGLEPreference developer_option = getAngleDevOption(developer_opt_in);

    bool use_angle = (developer_option == ANGLE_PREFER_ANGLE);



    if (use_angle) {

        ALOGV("User set \"Developer Options\" to force the use of ANGLE");

    } else if (cnx->angleDecided) {

        use_angle = cnx->useAngle;

    } else if (developer_option == ANGLE_PREFER_NATIVE) {

        ALOGV("User set \"Developer Options\" to force the use of Native");

        use_angle = false;

    } else {

        // The "Developer Options" value wasn't set to force the use of ANGLE.  Need to temporarily

        // load ANGLE and call the updatable opt-in/out logic:



        // Check if ANGLE is enabled. Workaround for several bugs:

        // b/119305693 b/119322355 b/119305887

        // Something is not working correctly in the feature library

        property_get("debug.angle.enable", prop, "0");

        if (atoi(prop)) {

            cnx->featureSo = load_angle_from_namespace("feature_support", ns);

        }

        if (cnx->featureSo) {

            ALOGV("loaded ANGLE's opt-in/out logic from namespace");

            use_angle = check_angle_rules(cnx->featureSo, app_name);

        } else {

            // We weren't able to load and call the updateable opt-in/out logic.

            // If we can't load the library, there is no ANGLE available.

            use_angle = false;

            ALOGV("Could not load the ANGLE opt-in/out logic, cannot use ANGLE.");

        }

        cnx->angleDecided = true;

    }



    void* so = nullptr;

    if (use_angle) {



    if ((cnx->shouldUseAngle) || android::GraphicsEnv::getInstance().shouldUseAngle()) {

        so = load_angle_from_namespace(kind, ns);

        cnx->shouldUseAngle = true;

    } else {

        cnx->shouldUseAngle = false;

    }



    if (so) {

        ALOGV("Loaded ANGLE %s library for %s (instead of native)",

              kind, app_name ? app_name : "nullptr");

        ALOGV("Loaded ANGLE %s library for '%s' (instead of native)", kind,

            android::GraphicsEnv::getInstance().getAngleAppName().c_str());

        cnx->useAngle = true;



        char prop[PROPERTY_VALUE_MAX];



        property_get("debug.hwui.renderer", prop, "UNSET");

        ALOGV("Skia's renderer set to %s", prop);

        cnx->useAngle = true;



        EGLint angleBackendDefault = EGL_PLATFORM_ANGLE_TYPE_VULKAN_ANGLE;



        char prop[PROPERTY_VALUE_MAX];

        property_get("debug.angle.backend", prop, "0");

        switch (atoi(prop)) {

            case 1:
@@ -716,13 +546,14 @@ static void* load_angle(const char* kind, android_namespace_t* ns, egl_connectio 
            // Find and load vendor libEGL for ANGLE's GL back-end to use.

            cnx->vendorEGL = load_system_driver("EGL");

        }

        return so;

    } else {

        ALOGV("Loaded native %s library for %s (instead of ANGLE)",

              kind, app_name ? app_name : "nullptr");

        ALOGV("Loaded native %s library for '%s' (instead of ANGLE)", kind,

            android::GraphicsEnv::getInstance().getAngleAppName().c_str());

        cnx->useAngle = false;

    }

    cnx->angleDecided = true;



    return nullptr;

    return so;

}



static const char* HAL_SUBNAME_KEY_PROPERTIES[2] = {

opengl/libs/EGL/egldefs.h

+3 −3
Original line number Diff line number Diff line
@@ -76,11 +76,11 @@ struct egl_connection_t { 
    void*               libGles1;

    void*               libGles2;



    bool                angleDecided;

    bool                useAngle;

    bool                shouldUseAngle; // Should we attempt to load ANGLE

    bool                angleDecided;   // Have we tried to load ANGLE

    bool                useAngle;       // Was ANGLE successfully loaded

    EGLint              angleBackend;

    void*               vendorEGL;

    void*               featureSo;

};

// clang-format on