Sui dispositivi con Android 10 (livello API 29) e versioni successive, è disponibile il layering OpenGL ES (GLES). Un'app di cui è possibile eseguire il debug può caricare i livelli GLES dal proprio APK, dalla relativa directory di base o da un APK del livello selezionato.
L'utilizzo del livello GLES è simile all'utilizzo del livello di convalida Vulkan.
Requisiti
I livelli GLES sono supportati solo nelle versioni GLES 2.0 e successive.
Inizializzazione del livello
Dopo aver compilato i punti di contatto standard, EGL Loader esegue l'inizializzazione di un GLESLayerLoader. Se i livelli di debug sono attivati, LayerLoader esegue la scansione delle directory specificate per i livelli, come fa il caricatore Vulkan.
Se la stratificazione è attiva, LayerLoader cerca ed enumera un elenco di livelli specificato. L'elenco dei livelli è specificato da nomi file separati da due punti.
LayerLoader attraversa i livelli nell'ordine specificato, quindi il primo livello si trova direttamente sotto l'applicazione. Per ogni livello, LayerLoader monitora i punti di contatto AndroidGLESLayer_Initialize e AndroidGLESLayer_GetProcAddress. Affinché i livelli siano caricabili, devono fornire queste interfacce.
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 contatto che può essere chiamato per cercare le funzioni al di sotto
del livello. Il punto di ingresso può essere utilizzato come mostrato nell'esempio di codice seguente:
const char* func = "eglFoo"; void* gpa = get_next_layer_proc_address(layer_id, func);
AndroidGLESLayer_GetProcAddress prende l'indirizzo della chiamata successiva nella catena che il livello deve chiamare al termine. Se è presente un solo livello,next punta direttamente al driver per la maggior parte delle funzioni.
typedef __eglMustCastToProperFunctionPointerType EGLFuncPointer; void* AndroidGLESLayer_GetProcAddress(const char *funcName, EGLFuncPointer next)
Per ogni livello trovato da GLES LayerLoader, viene chiamata
AndroidGLESLayer_Initialize, vengono esaminati gli elenchi di funzioni di libEGL e viene chiamata
AndroidGLESLayer_GetProcAddress per tutte le funzioni conosciute. Spetta al livello determinare come monitorare l'indirizzo successivo. Se il livello intercetta una funzione, monitora l'indirizzo della funzione. Se il livello non intercetta una funzione,
AndroidGLESLayer_GetProcAddress restituisce lo stesso indirizzo della funzione che gli è stato
tramesso. LayerLoader aggiorna quindi l'elenco degli hook delle funzioni in modo che indichi il punto di ingresso del livello.
I livelli non sono tenuti a fare nulla con le informazioni fornite da AndroidGLESLayer_Initialize e get_next_layer_proc_address, ma fornire i dati semplifica il supporto di Android da parte dei livelli esistenti, come Android GPU Inspector e RenderDoc. Con questi dati, un livello può cercare le funzioni in modo indipendente anziché
aspettare le chiamate a AndroidGLESLayer_GetProcAddress. Se i livelli scelgono di inizializzarsi prima che il caricatore abbia eseguito query su tutti i punti di contatto, devono utilizzare get_next_layer_proc_address. eglGetProcAddress deve essere trasmesso lungo la catena alla piattaforma.
Livelli di posizionamento
GLES LayerLoader cerca i livelli nelle seguenti posizioni, in ordine di priorità:
1. Posizione del sistema per l'utente root
È richiesto l'accesso come utente 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 di base dell'applicazione
L'applicazione di destinazione deve essere di tipo debug o devi disporre dell'accesso come utente 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 della tua 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 inserire 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
Attivare i livelli
Puoi attivare i livelli GLES per app o a livello globale. Le impostazioni per app rimangono invariate tra un riavvio e l'altro, mentre le proprietà globali vengono cancellate al riavvio.
Il modello e i criteri di sicurezza di Android differiscono in modo significativo da altre piattaforme. Per caricare i livelli esterni, deve essere vera una delle seguenti condizioni:
Il file manifest dell'app di destinazione include il seguente elemento meta-data (si applica solo alle app che hanno come target Android 11 (livello API 30) o versioni successive):
<meta-data android:name="com.android.graphics.injectLayers.enable" android:value="true" />Ti consigliamo di utilizzare questa opzione per creare il profilo della tua applicazione.
L'app di destinazione sia di tipo debuggable. Questa opzione fornisce più informazioni di debug, ma potrebbe influire negativamente sulle prestazioni dell'app.
L'app di destinazione viene eseguita su una build userdebug del sistema operativo che grants 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>
Creare un livello
I livelli devono esporre le due funzioni descritte di seguito nell'inizializzazione di EGL Loader:
AndroidGLESLayer_Initialize AndroidGLESLayer_GetProcAddress
Livelli passivi
Per uno strato che intercetta solo alcune funzioni, è ottimale un
strato inizializzato passivamente. Il livello inizializzato passivamente attende
che GLES LayerLoader inizili la funzione di cui ha bisogno.
Il seguente esempio di codice mostra come creare un livello 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 i livelli più formalizzati che devono essere inizializzati completamente in anticipo o per i livelli
che devono cercare estensioni non conosciute dal caricatore EGL, è necessaria l'inizializzazione
del livello attivo. Il livello utilizza
get_next_layer_proc_address fornito da AndroidGLESLayer_Initialize per
cercare una funzione. Il livello deve comunque rispondere alle richieste AndroidGLESLayer_GetProcAddress del caricatore in modo che la piattaforma sappia dove instradare le chiamate. Il seguente esempio di codice mostra come creare un livello attivo.
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);
}
}