Capas de GLES

En dispositivos con Android 10 (API nivel 29) y versiones posteriores, están disponibles las capas de OpenGL ES (GLES). Una app depurable puede cargar capas de GLES desde su APK, desde su directorio base o desde un APK de capas seleccionado.

El uso de capas de GLES es similar al uso de la capa de validación de Vulkan.

Requisitos

Las capas de GLES son solo compatibles con la versión de GLES 2.0 y versiones posteriores.

Inicialización de la capa

Después de propagar los puntos de entrada estándar, EGL Loader instancia un objeto LayerLoader de GLES. Si las capas de depuración están habilitadas, el objeto LayerLoader analiza los directorios especificados en busca de capas, como lo hace el cargador de Vulkan.

Si las capas están habilitadas, LayerLoader busca las capas especificadas y las enumera en una lista con nombres de archivos separados por dos puntos.

LayerLoader desvía las capas en el orden que tú especifiques, por lo que la primera capa aparece directamente debajo de la aplicación. Por cada capa, LayerLoader hace un seguimiento de los puntos de entrada AndroidGLESLayer_Initialize y AndroidGLESLayer_GetProcAddress. Las capas deben proporcionar esas interfaces para que puedan cargarse.

typedef void* (*PFNEGLGETNEXTLAYERPROCADDRESSPROC)(void*, const char*);
void* AndroidGLESLayer_Initialize(void* layer_id, PFNEGLGETNEXTLAYERPROCADDRESSPROC get_next_layer_proc_address))

AndroidGLESLayer_Initialize() proporciona un identificador para que lo utilice la capa (layer_id) y un punto de entrada que puede llamarse para buscar las funciones que se encuentran debajo de la capa. El punto de entrada se puede usar en la siguiente muestra de código:

const char* func = "eglFoo";
void* gpa = get_next_layer_proc_address(layer_id, func);

AndroidGLESLayer_GetProcAddress toma la dirección de la próxima llamada en la cadena a la que la capa debería llamar al finalizar. Si existe solo una capa, next apunta directamente al controlador de la mayoría de las funciones.

typedef __eglMustCastToProperFunctionPointerType EGLFuncPointer;
void* AndroidGLESLayer_GetProcAddress(const char *funcName, EGLFuncPointer next)

Por cada capa que LayerLoader de GLES encuentra, llama a AndroidGLESLayer_Initialize, recorre la lista de funciones de libEGL y llama a AndroidGLESLayer_GetProcAddress para todas las funciones conocidas. La capa es la que debe determinar cómo hacer un seguimiento de la próxima dirección. Si la capa intercepta una función, hace un seguimiento de la dirección de la función. Si la capa no intercepta una función, AndroidGLESLayer_GetProcAddress muestra la misma dirección de función que le pasaron. Luego, LayerLoader actualiza la lista de hooks de funciones para que apunte al punto de entrada de la capa.

No es necesario que las capas realicen una acción con la información que AndroidGLESLayer_Initialize y get_next_layer_proc_address proporcionan, pero proporcionar los datos facilita que las capas existentes, como GAPID y RenderDoc, admitan Android. Con esos datos, una capa puede buscar funciones independientemente, en lugar de esperar llamadas a AndroidGLESLayer_GetProcAddress. Si las capas eligen inicializarse antes de que el cargador haya consultado todos los puntos de entrada, deben usar get_next_layer_proc_address. eglGetProcAddress debe pasar por la cadena hacia la plataforma.

Coloca las capas

LayerLoader de GLES busca capas en las siguientes ubicaciones, en orden de prioridad:

1. Ubicación del sistema para la raíz

Requiere acceso de raíz:

adb root
adb disable-verity
adb reboot
adb root
adb shell setenforce 0
adb shell mkdir -p /data/local/debug/gles
adb push <layer>.so /data/local/debug/gles/

2. Directorio base de la aplicación

La aplicación de destino debe poder depurarse, o bien debes tener acceso a la raíz:

adb push libGLTrace.so /data/local/tmp
adb shell run-as com.android.gl2jni cp /data/local/tmp/libGLTrace.so .
adb shell run-as com.android.gl2jni ls | grep libGLTrace
libGLTrace.so

3. APK externo

Determina la ABI de tu aplicación objetivo, luego instala un APK que contiene las capas que quieres cargar:

adb install --abi armeabi-v7a layers.apk

4. En el APK de la aplicación objetivo

En el siguiente ejemplo, se muestra cómo colocar capas en el APK de la aplicación:

$ jar tf GLES_layers.apk
lib/arm64-v8a/libGLES_glesLayer1.so
lib/arm64-v8a/libGLES_glesLayer2.so
lib/arm64-v8a/libGLES_glesLayer3.so
lib/armeabi-v7a/libGLES_glesLayer1.so
lib/armeabi-v7a/libGLES_glesLayer2.so
lib/armeabi-v7a/libGLES_glesLayer3.so
resources.arsc
AndroidManifest.xml
META-INF/CERT.SF
META-INF/CERT.RSA
META-INF/MANIFEST.MF

Cómo habilitar las capas

Puedes habilitar esas capas por app o de forma global. La configuración por app persiste después de los reinicios, mientras que las propiedades globales se borran.

El modelo de seguridad y las políticas de Android difieren significativamente de los de otras plataformas. Para cargar capas externas, una de las siguientes opciones debe ser verdadera:

  • El archivo de manifiesto de la app de destino incluye el siguiente elemento de metadatos (solo se aplica a apps que se orientan a Android 11 (API nivel “R”) o versiones posteriores:

    <meta-data android:name="com.android.graphics.injectLayers.enable" android:value="true" />

    Debes usar esta opción para generar el perfil de tu aplicación.

  • La app de destino es depurable. Esta opción te brinda más información de depuración, pero puede afectar negativamente el rendimiento de tu app.

  • La app de destino se ejecuta en una compilación userdebug del sistema operativo que otorga acceso de raíz.

Para habilitar las capas por app, haz lo siguiente:

# Enable layers
adb shell settings put global enable_gpu_debug_layers 1

# Specify target application
adb shell settings put global gpu_debug_app <package_name>

# Specify layer list (from top to bottom)
# Layers are identified by their filenames, such as "libGLLayer.so"
adb shell settings put global gpu_debug_layers_gles <layer1:layer2:layerN>

# Specify packages to search for layers
adb shell settings put global gpu_debug_layer_app <package1:package2:packageN>

Para inhabilitar las capas por app, haz lo siguiente:

# Delete the global setting that enables layers
adb shell settings delete global enable_gpu_debug_layers

# Delete the global setting that selects target application
adb shell settings delete global gpu_debug_app

# Delete the global setting that specifies layer list
adb shell settings delete global gpu_debug_layers_gles

# Delete the global setting that specifies layer packages
adb shell settings delete global gpu_debug_layer_app

Para habilitar las capas globalmente, haz lo siguiente:

# This attempts to load layers for all applications, including native
# executables
adb shell setprop debug.gles.layers <layer1:layer2:layerN>

Cómo crear una capa

Las capas deben exponer las siguientes dos funciones descritas en Inicialización de EGL Loader:

AndroidGLESLayer_Initialize
AndroidGLESLayer_GetProcAddress

Capas pasivas

Para una capa que solo intercepta algunas funciones, una capa inicializada en forma pasiva resulta óptima. La capa inicializada en forma pasiva espera a que LayerLoader de GLES inicialice la función que necesita.

En la siguiente muestra de código, verás cómo crear una capa pasiva.

namespace {

std::unordered_map<std::string, EGLFuncPointer> funcMap;

EGLAPI EGLBoolean EGLAPIENTRY glesLayer_eglChooseConfig (
  EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size,
  EGLint *num_config) {

  EGLFuncPointer entry = funcMap["eglChooseConfig"];

  typedef EGLBoolean (*PFNEGLCHOOSECONFIGPROC)(
    EGLDisplay, const EGLint*, EGLConfig*, EGLint, EGLint*);

  PFNEGLCHOOSECONFIGPROC next = reinterpret_cast<PFNEGLCHOOSECONFIGPROC>(entry);

  return next(dpy, attrib_list, configs, config_size, num_config);
}

EGLAPI EGLFuncPointer EGLAPIENTRY eglGPA(const char* funcName) {

  #define GETPROCADDR(func) if(!strcmp(funcName, #func)) { \
    return (EGLFuncPointer)glesLayer_##func; }

  GETPROCADDR(eglChooseConfig);

  // Don't return anything for unrecognized functions
  return nullptr;
}

EGLAPI void EGLAPIENTRY glesLayer_InitializeLayer(
  void* layer_id, PFNEGLGETNEXTLAYERPROCADDRESSPROC get_next_layer_proc_address) {
     // This function is purposefully empty, since this layer does not proactively
     // look up any entrypoints
  }

EGLAPI EGLFuncPointer EGLAPIENTRY glesLayer_GetLayerProcAddress(
  const char* funcName, EGLFuncPointer next) {
  EGLFuncPointer entry = eglGPA(funcName);
  if (entry != nullptr) {
    funcMap[std::string(funcName)] = next;
    return entry;
  }
  return next;
}

}  // namespace

extern "C" {
  __attribute((visibility("default"))) EGLAPI void AndroidGLESLayer_Initialize(
    void* layer_id, PFNEGLGETNEXTLAYERPROCADDRESSPROC get_next_layer_proc_address) {
    return (void)glesLayer_InitializeLayer(layer_id, get_next_layer_proc_address);
  }
  __attribute((visibility("default"))) EGLAPI void* AndroidGLESLayer_GetProcAddress(
    const char *funcName, EGLFuncPointer next) {
    return (void*)glesLayer_GetLayerProcAddress(funcName, next);
  }
}

Capas activas

Es necesario utilizar la inicialización de capas activas si se requieren capas más formalizadas que tienen que inicializarse directamente o capas que tienen que buscar extensiones no conocidas para EGL Loader. La capa usa el objeto get_next_layer_proc_address que AndroidGLESLayer_Initialize proporciona para buscar una función. La capa debe responder a las solicitudes de AndroidGLESLayer_GetProcAddress desde el cargador, de manera que la plataforma sepa dónde se enrutarán las llamadas. En la siguiente muestra de código, verás cómo crear una capa activa.

namespace {

std::unordered_map<std::string, EGLFuncPointer> funcMap;

EGLAPI EGLBoolean EGLAPIENTRY glesLayer_eglChooseConfig (
  EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size,
  EGLint *num_config) {

  EGLFuncPointer entry = funcMap["eglChooseConfig"];

  typedef EGLBoolean (*PFNEGLCHOOSECONFIGPROC)(
    EGLDisplay, const EGLint*, EGLConfig*, EGLint, EGLint*);

  PFNEGLCHOOSECONFIGPROC next = reinterpret_cast<PFNEGLCHOOSECONFIGPROC>(entry);

  return next(dpy, attrib_list, configs, config_size, num_config);
}

EGLAPI EGLFuncPointer EGLAPIENTRY eglGPA(const char* funcName) {

  #define GETPROCADDR(func) if(!strcmp(funcName, #func)) { \
    return (EGLFuncPointer)glesLayer_##func; }

  GETPROCADDR(eglChooseConfig);

  // Don't return anything for unrecognized functions
  return nullptr;
}

EGLAPI void EGLAPIENTRY glesLayer_InitializeLayer(
  void* layer_id, PFNEGLGETNEXTLAYERPROCADDRESSPROC get_next_layer_proc_address) {

  // Note: This is where the layer would populate its function map with all the
  // functions it cares about
  const char* func = “eglChooseConfig”;
  funcMap[func] = get_next_layer_proc_address(layer_id, func);
}

EGLAPI EGLFuncPointer EGLAPIENTRY glesLayer_GetLayerProcAddress(
  const char* funcName, EGLFuncPointer next) {
  EGLFuncPointer entry = eglGPA(funcName);
  if (entry != nullptr) {
    return entry;
  }

  return next;
}

}  // namespace

extern "C" {
  __attribute((visibility("default"))) EGLAPI void AndroidGLESLayer_Initialize(
    void* layer_id, PFNEGLGETNEXTLAYERPROCADDRESSPROC get_next_layer_proc_address) {
    return (void)glesLayer_InitializeLayer(layer_id, get_next_layer_proc_address);
  }
  __attribute((visibility("default"))) EGLAPI void* AndroidGLESLayer_GetProcAddress(
    const char *funcName, EGLFuncPointer next) {
    return (void*)glesLayer_GetLayerProcAddress(funcName, next);
  }
}