GraphicsEnv: add documentations for the class

public:

    static GraphicsEnv& getInstance();

    // Check if device is debuggable.

    int getCanLoadSystemLibraries();

    /*

     * Apis for updatable driver

     */

    // Set a search path for loading graphics drivers. The path is a list of

    // directories separated by ':'. A directory can be contained in a zip file

    // (drivers must be stored uncompressed and page aligned); such elements

    // graphics drivers. The string is a list of libraries separated by ':',

    // which is required by android_link_namespaces.

    void setDriverPathAndSphalLibraries(const std::string path, const std::string sphalLibraries);

    // Get the updatable driver namespace.

    android_namespace_t* getDriverNamespace();

    /*

     * Apis for GpuStats

     */

    // Hint there's real activity launching on the app process.

    void hintActivityLaunch();

    // Set the initial GpuStats.

    void setGpuStats(const std::string& driverPackageName, const std::string& driverVersionName,

                     uint64_t versionCode, int64_t driverBuildTime,

                     const std::string& appPackageName, const int32_t vulkanVersion);

    // Set that CPU type physical device is in use.

    void setCpuVulkanInUse();

    // Set which driver is intended to load.

    void setDriverToLoad(GpuStatsInfo::Driver driver);

    // Set which driver is actually loaded.

    void setDriverLoaded(GpuStatsInfo::Api api, bool isDriverLoaded, int64_t driverLoadingTime);

    void sendGpuStatsLocked(GpuStatsInfo::Api api, bool isDriverLoaded, int64_t driverLoadingTime);

    /*

     * Apis for ANGLE

     */

    // Check if the requested app should use ANGLE.

    bool shouldUseAngle(std::string appName);

    // Check if this app process should use ANGLE.

    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

    //     /system/app/ANGLEPrebuilt/ANGLEPrebuilt.apk!/lib/arm64-v8a

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

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

    // Get the ANGLE driver namespace.

    android_namespace_t* getAngleNamespace();

    // Get the app name for ANGLE debug message.

    std::string& getAngleAppName();

    /*

     * Apis for debug layer

     */

    // Set additional layer search paths.

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

    // Get the app namespace for loading layers.

    NativeLoaderNamespace* getAppNamespace();

    // Get additional layer search paths.

    const std::string& getLayerPaths();

    // Set the Vulkan debug layers.

    void setDebugLayers(const std::string layers);

    // Set the GL debug layers.

    void setDebugLayersGLES(const std::string layers);

    // Get the debug layers to load.

    const std::string& getDebugLayers();

    // Get the debug layers to load.

    const std::string& getDebugLayersGLES();

private:

    enum UseAngle { UNKNOWN, YES, NO };

    // Load requested ANGLE library.

    void* loadLibrary(std::string name);

    // Check ANGLE support with the rules.

    bool checkAngleRules(void* so);

    // Update whether ANGLE should be used.

    void updateUseAngle();

    // Link updatable driver namespace with llndk and vndk-sp libs.

    bool linkDriverNamespaceLocked(android_namespace_t* vndkNamespace);

    // Send the initial complete GpuStats to GpuService.

    void sendGpuStatsLocked(GpuStatsInfo::Api api, bool isDriverLoaded, int64_t driverLoadingTime);

    GraphicsEnv() = default;

    // Path to updatable driver libs.

    std::string mDriverPath;

    // Path to additional sphal libs linked to updatable driver namespace.

    std::string mSphalLibraries;

    // This mutex protects mGpuStats and get gpuservice call.

    std::mutex mStatsLock;

    // Information bookkept for GpuStats.

    GpuStatsInfo mGpuStats;

    // Path to ANGLE libs.

    std::string mAnglePath;

    // This App's name.

    std::string mAngleAppName;

    // ANGLE developer opt in status.

    std::string mAngleDeveloperOptIn;

    // ANGLE rules.

    std::vector<char> mRulesBuffer;

    // Use ANGLE flag.

    UseAngle mUseAngle = UNKNOWN;

    // Vulkan debug layers libs.

    std::string mDebugLayers;

    // GL debug layers libs.

    std::string mDebugLayersGLES;

    // Additional debug layers search path.

    std::string mLayerPaths;

    // This mutex protects the namespace creation.

    std::mutex mNamespaceMutex;

    // Updatable driver namespace.

    android_namespace_t* mDriverNamespace = nullptr;

    // ANGLE namespace.

    android_namespace_t* mAngleNamespace = nullptr;

    // This App's namespace.

    NativeLoaderNamespace* mAppNamespace = nullptr;

};