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

Commit 79d076f3 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: I2446b18e96de5e5ed0b5e2ef4d1f933e2315bfe7
parent 809ec619

core/java/android/os/GraphicsEnvironment.java

+111 −30
Original line number Diff line number Diff line
@@ -105,13 +105,21 @@ public class GraphicsEnvironment { 
    private static final int UPDATABLE_DRIVER_GLOBAL_OPT_IN_PRERELEASE_DRIVER = 2;

    private static final int UPDATABLE_DRIVER_GLOBAL_OPT_IN_OFF = 3;



    // System properties related to ANGLE and legacy GLES graphics drivers.

    private static final String PROPERTY_EGL_SYSTEM_DRIVER = "ro.hardware.egl";

    // TODO (b/224558229): Properly add this to the list of system properties for a device:

    private static final String PROPERTY_EGL_LEGACY_DRIVER = "ro.hardware.egl.legacy";



    // Values for ANGLE_GL_DRIVER_ALL_ANGLE

    private static final int ANGLE_GL_DRIVER_ALL_ANGLE_ON = 1;

    private static final int ANGLE_GL_DRIVER_ALL_ANGLE_OFF = 0;

    private static final int ANGLE_GL_DRIVER_ALL_LEGACY = -1;



    // Values for ANGLE_GL_DRIVER_SELECTION_VALUES

    private static final String ANGLE_GL_DRIVER_CHOICE_DEFAULT = "default";

    private static final String ANGLE_GL_DRIVER_CHOICE_ANGLE = "angle";

    private static final String ANGLE_GL_DRIVER_CHOICE_LEGACY = "legacy";

    // The following value is a deprecated choice for "legacy"

    private static final String ANGLE_GL_DRIVER_CHOICE_NATIVE = "native";



    private ClassLoader mClassLoader;
@@ -119,6 +127,13 @@ public class GraphicsEnvironment { 
    private String mLibraryPermittedPaths;

    private GameManager mGameManager;



    private boolean mAngleIsSystemDriver = false;

    // When ANGLE is the system driver, this is the name of the legacy driver.

    //

    // TODO (b/224558229): This is temporarily set to a value that works for Pixel 6, until

    // PROPERTY_EGL_LEGACY_DRIVER has been properly plumbed and this becomes broadly available.

    private String mEglLegacyDriver = "mali";



    private int mAngleOptInIndex = -1;



    /**
@@ -136,6 +151,24 @@ public class GraphicsEnvironment { 
        setupGpuLayers(context, coreSettings, pm, packageName, appInfoWithMetaData);

        Trace.traceEnd(Trace.TRACE_TAG_GRAPHICS);



        // Determine if ANGLE is the system driver, as this will determine other logic

        final String eglSystemDriver = SystemProperties.get(PROPERTY_EGL_SYSTEM_DRIVER);

        Log.v(TAG, "GLES system driver is '" + eglSystemDriver + "'");

        mAngleIsSystemDriver = eglSystemDriver.equals(ANGLE_DRIVER_NAME);

        if (mAngleIsSystemDriver) {

            // Lookup the legacy driver, to send down to the EGL loader

            /* TODO (b/224558229): This is temporarily set to a value that works for Pixel 6, until

             * PROPERTY_EGL_LEGACY_DRIVER has been properly plumbed and this becomes broadly

             * available:

            final String eglLegacyDriver = SystemProperties.get(PROPERTY_EGL_LEGACY_DRIVER);

            if (eglLegacyDriver.isEmpty()) {

            */

            mEglLegacyDriver = "mali";

            /*}*/

            Log.v(TAG, "Legacy GLES driver is '" + mEglLegacyDriver + "'");

        }



        // Setup ANGLE and pass down ANGLE details to the C++ code

        Trace.traceBegin(Trace.TRACE_TAG_GRAPHICS, "setupAngle");

        boolean useAngle = false;

        if (setupAngle(context, coreSettings, pm, packageName)) {
@@ -186,13 +219,13 @@ public class GraphicsEnvironment { 
    /**

     * Query to determine if ANGLE should be used

     */

    private boolean shouldUseAngle(Context context, Bundle coreSettings,

            String packageName) {

    private boolean shouldUseAngle(Context context, Bundle coreSettings, String packageName) {

        if (TextUtils.isEmpty(packageName)) {

            Log.v(TAG, "No package name specified, ANGLE should not be used");

            return false;

            Log.v(TAG, "No package name specified; use the system driver");

            return mAngleIsSystemDriver ? true : false;

        }



        // getDriverForPackage() will change "default" into either "angle" or "legacy"

        final String devOptIn = getDriverForPackage(context, coreSettings, packageName);

        Log.v(TAG, "ANGLE Developer option for '" + packageName + "' "

                + "set to: '" + devOptIn + "'");
@@ -200,14 +233,14 @@ public class GraphicsEnvironment { 
        // We only want to use ANGLE if the developer has explicitly chosen something other than

        // default driver.

        final boolean forceAngle = devOptIn.equals(ANGLE_GL_DRIVER_CHOICE_ANGLE);

        final boolean forceNative = devOptIn.equals(ANGLE_GL_DRIVER_CHOICE_NATIVE);

        if (forceAngle || forceNative) {

        final boolean forceLegacy = devOptIn.equals(ANGLE_GL_DRIVER_CHOICE_LEGACY);

        if (forceAngle || forceLegacy) {

            Log.v(TAG, "ANGLE developer option for " + packageName + ": " + devOptIn);

        }



        final boolean gameModeEnabledAngle = isAngleEnabledByGameMode(context, packageName);



        return !forceNative && (forceAngle || gameModeEnabledAngle);

        return !forceLegacy && (forceAngle || gameModeEnabledAngle);

    }



    private int getVulkanVersion(PackageManager pm) {
@@ -407,34 +440,51 @@ public class GraphicsEnvironment { 
        return ai;

    }



    /**

     * Return the appropriate "default" driver choice.

     */

    private String getDefaultDriverChoice() {

        if (mAngleIsSystemDriver) {

            return ANGLE_GL_DRIVER_CHOICE_ANGLE;

        } else {

            return ANGLE_GL_DRIVER_CHOICE_LEGACY;

        }

    }



    private String getDriverForPackage(Context context, Bundle bundle, String packageName) {

        // Check the semi-global switch (i.e. once system has booted enough) for whether ANGLE

        // should be forced on or off for "all appplications"

        final int allUseAngle;

        if (bundle != null) {

            allUseAngle =

                    bundle.getInt(Settings.Global.ANGLE_GL_DRIVER_ALL_ANGLE);

            allUseAngle = bundle.getInt(Settings.Global.ANGLE_GL_DRIVER_ALL_ANGLE);

        } else {

            ContentResolver contentResolver = context.getContentResolver();

            allUseAngle = Settings.Global.getInt(contentResolver,

                    Settings.Global.ANGLE_GL_DRIVER_ALL_ANGLE,

                    ANGLE_GL_DRIVER_ALL_ANGLE_OFF);

                    Settings.Global.ANGLE_GL_DRIVER_ALL_ANGLE, ANGLE_GL_DRIVER_ALL_ANGLE_OFF);

        }

        if (allUseAngle == ANGLE_GL_DRIVER_ALL_ANGLE_ON) {

            Log.v(TAG, "Turn on ANGLE for all applications.");

            return ANGLE_GL_DRIVER_CHOICE_ANGLE;

        }

        if (allUseAngle == ANGLE_GL_DRIVER_ALL_LEGACY) {

            Log.v(TAG, "Disable ANGLE for all applications.");

            return ANGLE_GL_DRIVER_CHOICE_LEGACY;

        }



        // Make sure we have a good package name

        if (TextUtils.isEmpty(packageName)) {

            return ANGLE_GL_DRIVER_CHOICE_DEFAULT;

            return getDefaultDriverChoice();

        }



        // Get the per-application settings lists

        final ContentResolver contentResolver = context.getContentResolver();

        final List<String> optInPackages =

                getGlobalSettingsString(contentResolver, bundle,

                        Settings.Global.ANGLE_GL_DRIVER_SELECTION_PKGS);

        final List<String> optInValues =

                getGlobalSettingsString(contentResolver, bundle,

                        Settings.Global.ANGLE_GL_DRIVER_SELECTION_VALUES);

        final List<String> optInPackages = getGlobalSettingsString(

                contentResolver, bundle, Settings.Global.ANGLE_GL_DRIVER_SELECTION_PKGS);

        final List<String> optInValues = getGlobalSettingsString(

                contentResolver, bundle, Settings.Global.ANGLE_GL_DRIVER_SELECTION_VALUES);

        Log.v(TAG, "getDriverForPackage(): Currently set values for:");

        Log.v(TAG, "getDriverForPackage():   angle_gl_driver_selection_pkgs =" + optInPackages);

        Log.v(TAG, "getDriverForPackage():   angle_gl_driver_selection_values =" + optInValues);



        // Make sure we have good settings to use

        if (optInPackages.size() != optInValues.size()) {
@@ -444,17 +494,34 @@ public class GraphicsEnvironment { 
                            + optInPackages.size() + ", "

                        + "number of values: "

                            + optInValues.size());

            return ANGLE_GL_DRIVER_CHOICE_DEFAULT;

            return getDefaultDriverChoice();

        }



        // See if this application is listed in the per-application settings lists

        final int pkgIndex = getPackageIndex(packageName, optInPackages);



        if (pkgIndex < 0) {

            return ANGLE_GL_DRIVER_CHOICE_DEFAULT;

            // The application is NOT listed in the per-application settings lists; and so use the

            // system driver (i.e. either ANGLE or the Legacy driver)

            Log.v(TAG, "getDriverForPackage(): No per-application setting");

            return getDefaultDriverChoice();

        }

        mAngleOptInIndex = pkgIndex;



        return optInValues.get(pkgIndex);

        Log.v(TAG,

                "getDriverForPackage(): using per-application switch: "

                        + optInValues.get(pkgIndex));

        // The application IS listed in the per-application settings lists; and so use the

        // setting--choosing the current system driver if the setting is "default" (i.e. either

        // ANGLE or the Legacy driver)

        String rtnValue = optInValues.get(pkgIndex);

        if (rtnValue.equals(ANGLE_GL_DRIVER_CHOICE_DEFAULT)) {

            return getDefaultDriverChoice();

        }

        if (rtnValue.equals(ANGLE_GL_DRIVER_CHOICE_NATIVE)) {

            return ANGLE_GL_DRIVER_CHOICE_LEGACY;

        }

        return rtnValue;

    }



    /**
@@ -504,7 +571,13 @@ public class GraphicsEnvironment { 
    }



    /**

     * Pass ANGLE details down to trigger enable logic

     * Determine whether ANGLE should be used, set it up if so, and pass ANGLE details down to

     * the C++ GraphicsEnv class.

     *

     * If ANGLE will be used, GraphicsEnv::setAngleInfo() will be called to enable ANGLE to be

     * properly used.  Otherwise, GraphicsEnv::setLegacyDriverInfo() will be called to

     * enable the legacy GLES driver (e.g. when ANGLE is the system driver) to be identified and

     * used.

     *

     * @param context

     * @param bundle
@@ -517,6 +590,7 @@ public class GraphicsEnvironment { 
            String packageName) {



        if (!shouldUseAngle(context, bundle, packageName)) {

            setLegacyDriverInfo(packageName, mAngleIsSystemDriver, mEglLegacyDriver);

            return false;

        }
@@ -531,6 +605,7 @@ public class GraphicsEnvironment { 
                angleInfo = pm.getApplicationInfo(anglePkgName, 0);

            } catch (PackageManager.NameNotFoundException e) {

                Log.w(TAG, "ANGLE debug package '" + anglePkgName + "' not installed");

                setLegacyDriverInfo(packageName, mAngleIsSystemDriver, mEglLegacyDriver);

                return false;

            }

        }
@@ -540,16 +615,18 @@ public class GraphicsEnvironment { 
            anglePkgName = getAnglePackageName(pm);

            if (TextUtils.isEmpty(anglePkgName)) {

                Log.w(TAG, "Failed to find ANGLE package.");

                setLegacyDriverInfo(packageName, mAngleIsSystemDriver, mEglLegacyDriver);

                return false;

            }



            Log.i(TAG, "ANGLE package enabled: " + anglePkgName);

            Log.v(TAG, "ANGLE package enabled: " + anglePkgName);

            try {

                // Production ANGLE libraries must be pre-installed as a system app

                angleInfo = pm.getApplicationInfo(anglePkgName,

                        PackageManager.MATCH_SYSTEM_ONLY);

            } catch (PackageManager.NameNotFoundException e) {

                Log.w(TAG, "ANGLE package '" + anglePkgName + "' not installed");

                setLegacyDriverInfo(packageName, mAngleIsSystemDriver, mEglLegacyDriver);

                return false;

            }

        }
@@ -563,10 +640,12 @@ public class GraphicsEnvironment { 
                + "!/lib/"

                + abi;



        if (DEBUG) Log.v(TAG, "ANGLE package libs: " + paths);

        if (DEBUG) {

            Log.v(TAG, "ANGLE package libs: " + paths);

        }



        // We need to call setAngleInfo() with the package name and the developer option value

        //(native/angle/other). Then later when we are actually trying to load a driver,

        // (legacy/angle/other).  Later, when we are actually trying to load a driver,

        // GraphicsEnv::getShouldUseAngle() has seen the package name before and can confidently

        // answer yes/no based on the previously set developer option value.

        final String devOptIn;
@@ -577,7 +656,7 @@ public class GraphicsEnvironment { 
        } else {

            devOptIn = getDriverForPackage(context, bundle, packageName);

        }

        setAngleInfo(paths, packageName, devOptIn, features);

        setAngleInfo(paths, packageName, mAngleIsSystemDriver, devOptIn, features);



        return true;

    }
@@ -866,8 +945,10 @@ public class GraphicsEnvironment { 
    private static native void setDriverPathAndSphalLibraries(String path, String sphalLibraries);

    private static native void setGpuStats(String driverPackageName, String driverVersionName,

            long driverVersionCode, long driverBuildTime, String appPackageName, int vulkanVersion);

    private static native void setAngleInfo(String path, String appPackage, String devOptIn,

            String[] features);

    private static native void setAngleInfo(String path, String appPackage,

            boolean angleIsSystemDriver, String devOptIn, String[] features);

    private static native void setLegacyDriverInfo(

            String appPackage, boolean angleIsSystemDriver, String legacyDriverName);

    private static native boolean getShouldUseAngle(String packageName);

    private static native boolean setInjectLayersPrSetDumpable();

core/jni/android_os_GraphicsEnvironment.cpp

+16 −3
Original line number Diff line number Diff line
@@ -50,7 +50,7 @@ void setGpuStats_native(JNIEnv* env, jobject clazz, jstring driverPackageName, 
}



void setAngleInfo_native(JNIEnv* env, jobject clazz, jstring path, jstring appName,

                         jstring devOptIn, jobjectArray featuresObj) {

                         jboolean angleIsSystemDriver, jstring devOptIn, jobjectArray featuresObj) {

    ScopedUtfChars pathChars(env, path);

    ScopedUtfChars appNameChars(env, appName);

    ScopedUtfChars devOptInChars(env, devOptIn);
@@ -74,7 +74,18 @@ void setAngleInfo_native(JNIEnv* env, jobject clazz, jstring path, jstring appNa 
    }



    android::GraphicsEnv::getInstance().setAngleInfo(pathChars.c_str(), appNameChars.c_str(),

                                                     devOptInChars.c_str(), features);

                                                     angleIsSystemDriver, devOptInChars.c_str(),

                                                     features);

}



void setLegacyDriverInfo_native(JNIEnv* env, jobject clazz, jstring appName,

                                jboolean angleIsSystemDriver, jstring legacyDriverName) {

    ScopedUtfChars appNameChars(env, appName);

    ScopedUtfChars legacyDriverNameChars(env, legacyDriverName);



    android::GraphicsEnv::getInstance().setLegacyDriverInfo(appNameChars.c_str(),

                                                            angleIsSystemDriver,

                                                            legacyDriverNameChars.c_str());

}



bool shouldUseAngle_native(JNIEnv* env, jobject clazz, jstring appName) {
@@ -120,8 +131,10 @@ const JNINativeMethod g_methods[] = { 
        {"setInjectLayersPrSetDumpable", "()Z",

         reinterpret_cast<void*>(setInjectLayersPrSetDumpable_native)},

        {"setAngleInfo",

         "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;[Ljava/lang/String;)V",

         "(Ljava/lang/String;Ljava/lang/String;ZLjava/lang/String;[Ljava/lang/String;)V",

         reinterpret_cast<void*>(setAngleInfo_native)},

        {"setLegacyDriverInfo", "(Ljava/lang/String;ZLjava/lang/String;)V",

         reinterpret_cast<void*>(setLegacyDriverInfo_native)},

        {"getShouldUseAngle", "(Ljava/lang/String;)Z",

         reinterpret_cast<void*>(shouldUseAngle_native)},

        {"setLayerPaths", "(Ljava/lang/ClassLoader;Ljava/lang/String;)V",