Sui dispositivi con Android 10 (livello API 29) e versioni successive, viene applicato il livello OpenGL ES (GLES) disponibili. Un'app di cui è possibile eseguire il debug può caricare livelli GLES dal proprio APK, dalla relativa base o da un APK di livello selezionato.
L'utilizzo dei livelli GLES è simile Utilizzo del livello di convalida Vulkan.
Requisiti
I livelli GLES sono supportati solo sulle versioni GLES 2.0 e successive.
Inizializzazione dei livelli
Dopo aver compilato i punti di ingresso standard, il caricatore EGL crea un'istanza per un GLES
LayerLoader
. Se i livelli di debug sono abilitati, LayerLoader
analisi specificate
per gli strati, ad esempio
Vulkan loader sì.
Se la disposizione su livelli è abilitata, LayerLoader
cerca ed enumera un elemento
dell'elenco di livelli. L'elenco dei livelli è specificato da nomi file separati da due punti.
LayerLoader
attraversa i livelli nell'ordine da te specificato, quindi il primo
si trova direttamente sotto l'applicazione. Per ogni livello, il valore LayerLoader
monitora AndroidGLESLayer_Initialize
e
AndroidGLESLayer_GetProcAddress
punti di ingresso. I livelli devono fornire questi
diverse interfacce per essere caricabili.
typedef void* (*PFNEGLGETNEXTLAYERPROCADDRESSPROC)(void*, const char*); void* AndroidGLESLayer_Initialize(void* layer_id, PFNEGLGETNEXTLAYERPROCADDRESSPROC get_next_layer_proc_address))
AndroidGLESLayer_Initialize()
fornisce un identificatore per il livello da utilizzare
(layer_id
) e un punto di ingresso che può essere chiamato per cercare le funzioni riportate di seguito
livello. Il punto di ingresso può essere utilizzato come mostrato nel seguente esempio di codice:
const char* func = "eglFoo"; void* gpa = get_next_layer_proc_address(layer_id, func);
AndroidGLESLayer_GetProcAddress
accetta l'indirizzo della prossima chiamata nel
che il livello deve chiamare al termine. Se è presente un solo livello,
next
punta direttamente al conducente per la maggior parte delle operazioni.
typedef __eglMustCastToProperFunctionPointerType EGLFuncPointer; void* AndroidGLESLayer_GetProcAddress(const char *funcName, EGLFuncPointer next)
Per ogni livello trovato dal GLES LayerLoader
, chiama
AndroidGLESLayer_Initialize
, gestisce gli elenchi di funzioni di libEGL
e chiama
AndroidGLESLayer_GetProcAddress
per tutte le funzioni note. Dipende dal livello
per stabilire come monitorare l'indirizzo successivo. Se il livello intercetta una funzione,
tiene traccia dell'indirizzo della funzione. Se il livello non intercetta una funzione,
AndroidGLESLayer_GetProcAddress
restituisce lo stesso indirizzo di funzione che era
superato. LayerLoader
aggiorna quindi l'elenco di hook di funzione in modo che punti alla
del livello di accesso.
I livelli non devono fare nulla con le informazioni
AndroidGLESLayer_Initialize
e get_next_layer_proc_address
forniscono, ma
fornire i dati semplifica la gestione dei livelli esistenti, come
GPU Inspector per Android e
RenderDoc, per supportare
Android. Con questi dati, un livello può cercare funzioni in modo indipendente
in attesa di chiamate al numero AndroidGLESLayer_GetProcAddress
. Se i livelli scelgono
si inizializzano prima che il caricatore abbia eseguito una query su tutti i punti di ingresso,
deve usare get_next_layer_proc_address
. eglGetProcAddress
deve
della catena alla piattaforma.
Posiziona i livelli
Il LayerLoader
GLES cerca i livelli nelle seguenti posizioni, in ordine
priorità:
1. Posizione di sistema per il root
È richiesto l'accesso root
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. Directory base dell'applicazione
L'applicazione di destinazione deve essere di cui è possibile eseguire il debug oppure devi disporre dell'accesso root:
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 esterno
Determina l'ABI dell'applicazione di destinazione, quindi installa un APK contenente i livelli che vuoi caricare:
adb install --abi armeabi-v7a layers.apk
4. Nell'APK dell'applicazione di destinazione
L'esempio seguente mostra come posizionare i livelli nell'APK dell'applicazione:
$ 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
Abilita i livelli
Puoi attivare i livelli GLES per app o a livello globale. Le impostazioni per app vengono mantenute tra i riavvii, mentre le proprietà globali vengono cancellate al riavvio.
Il modello di sicurezza e i criteri di Android sono diversi in modo significativo da altre piattaforme. Per caricare i livelli esterni, uno dei deve essere vero:
Il file manifest dell'app di destinazione include quanto segue elemento meta-data (si applica solo per le app destinate ad Android 11 (livello API 30) o versioni successive:
<meta-data android:name="com.android.graphics.injectLayers.enable" android:value="true" />
Dovresti utilizzare questa opzione per profilare la tua applicazione.
È possibile eseguire il debug dell'app di destinazione. Questa opzione offre maggiori informazioni di debug, ma potrebbero influire negativamente sulle prestazioni della tua app.
L'app di destinazione viene eseguita su una build userdebug del sistema operativo che concede l'accesso root.
Per attivare i livelli per 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>
Per disattivare i livelli per 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
Per attivare i livelli a livello globale:
# This attempts to load layers for all applications, including native # executables adb shell setprop debug.gles.layers <layer1:layer2:layerN>
Crea un livello
I livelli devono mostrare le due funzioni seguenti descritte in Inizializzazione del caricatore EGL:
AndroidGLESLayer_Initialize AndroidGLESLayer_GetProcAddress
Strati passivi
Per uno strato che intercetta solo poche funzioni,
strato inizializzato passivamente è ottimale. Lo strato inizializzato passivamente attende
per GLES LayerLoader
per inizializzare la funzione di cui ha bisogno.
Il seguente esempio di codice mostra come creare uno strato passivo.
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); } }
Livelli attivi
Per strati più formalizzati che devono essere completamente inizializzati in anticipo, oppure per strati
che richiedono la ricerca di estensioni sconosciute all'EGL Loader, livello attivo
l'inizializzazione è obbligatoria. Il livello utilizza
il valore get_next_layer_proc_address
fornito da AndroidGLESLayer_Initialize
per cercare una funzione. Il livello deve comunque rispondere
AndroidGLESLayer_GetProcAddress
richieste dal caricatore in modo che la piattaforma sappia
dove indirizzare le chiamate. Il seguente esempio di codice mostra come creare un modello
livello di sicurezza.
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); } }