Diese Seite wurde von der Cloud Translation API übersetzt.

GLES-Ebenen
Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Auf Geräten mit Android 10 (API-Level 29) und höher ist die OpenGL ES-Stapelung (GLES) verfügbar. Eine Debug-fähige App kann GLES-Ebenen aus ihrem APK von der Basis aus laden. oder aus einem ausgewählten Ebenen-APK.

Die Nutzung der GLES-Schicht ähnelt der Verwendung der Vulkan-Validierungsebene

Voraussetzungen

GLES-Ebenen werden nur von GLES-Versionen 2.0 und höher unterstützt.

Ebeneninitialisierung

Nachdem die Standard-Einstiegspunkte ausgefüllt wurden, instanziiert der EGL-Ladeprogramm eine GLESLayerLoader. Wenn Debug-Ebenen aktiviert sind, durchsucht LayerLoader die angegebenen Verzeichnisse nach Ebenen, ähnlich wie der Vulkan-Ladeprogramm.

Wenn die Ebenenfunktion aktiviert ist, sucht LayerLoader nach einer angegebenen Ebenenliste und zählt sie auf. Die Ebenenliste wird durch Dateinamen angegeben, die durch einen Doppelpunkt getrennt sind.

Der LayerLoader durchläuft die Ebenen in der von Ihnen angegebenen Reihenfolge, sodass die erste befindet sich direkt unter der Anwendung. Für jede Ebene wird mit dem LayerLoader verfolgt AndroidGLESLayer_Initialize und AndroidGLESLayer_GetProcAddress Einstiegspunkte. Die Layer müssen diese als ladebar sein.

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

AndroidGLESLayer_Initialize() stellt eine Kennung für die zu verwendende Ebene bereit. (layer_id) und einen Einstiegspunkt, der zum Nachschlagen von Funktionen unten aufgerufen werden kann auf der Ebene. Der Einstiegspunkt kann wie im folgenden Codebeispiel gezeigt verwendet werden:

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

AndroidGLESLayer_GetProcAddress nimmt die Adresse des nächsten Aufrufs in der Kette an, den die Schicht nach Abschluss aufrufen soll. Wenn es nur eine Ebene gibt, verweist next für die meisten Funktionen direkt auf den Treiber.

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

Für jede Ebene, die GLES LayerLoader findet, wird AndroidGLESLayer_Initialize aufgerufen, die Funktionslisten von libEGL werden durchgegangen und AndroidGLESLayer_GetProcAddress wird für alle bekannten Funktionen aufgerufen. Es liegt an der Schicht, zu bestimmen, wie die nächste Adresse ermittelt wird. Wenn die Schicht eine Funktion abfängt, wird die Adresse der Funktion verfolgt. Wenn die Schicht keine Funktion abfängt, AndroidGLESLayer_GetProcAddress gibt dieselbe Funktionsadresse zurück. bestanden. Die LayerLoader aktualisiert dann die Funktion-Hook-Liste, sodass sie auf den Einstiegspunkt der Ebene verweist.

Die Ebenen müssen nichts mit den Informationen tun, die AndroidGLESLayer_Initialize und get_next_layer_proc_address bereitstellen. Die Bereitstellung der Daten erleichtert es jedoch bestehenden Ebenen wie Android GPU Inspector und RenderDoc, Android zu unterstützen. Mit diesen Daten kann eine Ebene Funktionen unabhängig aufrufen, anstatt auf Aufrufe von AndroidGLESLayer_GetProcAddress zu warten. Wenn die Ebenen initialisieren, bevor der Loader alle Einstiegspunkte abgefragt hat, muss get_next_layer_proc_address verwenden. eglGetProcAddress muss an die Plattform weitergeleitet werden.

Ebenen platzieren

Das GLES-LayerLoader sucht nach Ebenen an den folgenden Orten in der angegebenen Reihenfolge der Priorität:

1. Systemspeicherort für Root

Dazu ist Root-Zugriff erforderlich.

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. Basisverzeichnis der Anwendung

Die Zielanwendung muss debug-fähig sein oder Sie benötigen Root-Zugriff:

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. Externes APK

Ermitteln Sie die ABI Ihrer Zielanwendung und installieren Sie dann ein APK mit den Ebenen, die Sie laden möchten:

adb install --abi armeabi-v7a layers.apk

4. Im APK der Ziel-App

Das folgende Beispiel zeigt, wie Ebenen im APK der Anwendung platziert werden:

$ 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

Ebenen aktivieren

Sie können GLES-Ebenen entweder pro App oder global aktivieren. Einstellungen für einzelne Apps bleiben erhalten während globale Properties beim Neustart gelöscht werden.

Das Sicherheitsmodell und die Richtlinien von Android unterscheiden sich erheblich von denen anderer Plattformen. Um externe Layers zu laden, muss eine der muss Folgendes zutreffen:

Die Manifestdatei der Ziel-App enthält Folgendes: meta-data element (gilt nur für für Apps, die auf Android 11 (API-Level 30) oder höher ausgerichtet sind:

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

Sie sollten diese Option verwenden, um Ihr Anwendungsprofil zu erstellen.
Die Ziel-App ist debugfähig. Mit dieser Option erhalten Sie weitere Informationen zur Fehlerbehebung, aber die Leistung Ihrer App beeinträchtigen könnte.
Die Ziel-App wird auf einem Userdebug-Build des Betriebssystems ausgeführt, der Root-Zugriff gewährt.

So aktivieren Sie Ebenen pro App:

# 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>

So deaktivieren Sie Ebenen pro App:

# 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

So aktivieren Sie Ebenen global:

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

Ebene erstellen

Ebenen müssen die folgenden beiden Funktionen bereitstellen, die unter EGL-Loader-Initialisierung:

AndroidGLESLayer_Initialize
AndroidGLESLayer_GetProcAddress

Passive Ebenen

Für einen Layer, der nur eine Handvoll Funktionen abfängt, wird ein ist die passiv initialisierte Ebene optimal. Der passiv initialisierte Layer wartet damit GLES LayerLoader die benötigte Funktion initialisieren kann.

Das folgende Codebeispiel zeigt, wie eine passive Ebene erstellt wird.

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

Aktive Ebenen

Für formalisiertere Layer, die im Voraus vollständig initialisiert werden müssen, oder Layers die nach Erweiterungen suchen müssen, die dem EGL Loader nicht bekannt sind, aktiver Layer Initialisierung ist erforderlich. Die Ebene verwendet die get_next_layer_proc_address, die AndroidGLESLayer_Initialize für nach einer Funktion suchen. Die Schicht muss weiterhin auf AndroidGLESLayer_GetProcAddress-Anfragen vom Loader reagieren, damit die Plattform weiß, wohin Aufrufe weitergeleitet werden sollen. Das folgende Codebeispiel zeigt, wie eine aktive Ebene erstellt wird.

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