जीएलईएस लेयर

Android 10 (एपीआई लेवल 29) और उसके बाद के वर्शन वाले डिवाइसों पर, OpenGL ES (GLES) लेयरिंग उपलब्ध है. डीबग किया जा सकने वाला ऐप्लिकेशन, अपने APK, अपनी मुख्य डायरेक्ट्री या चुनी गई लेयर के APK से GLES लेयर लोड कर सकता है.

GLES लेयर का इस्तेमाल, Vulkan की पुष्टि करने वाली लेयर के इस्तेमाल से मिलता-जुलता है.

ज़रूरी शर्तें

GLES लेयर सिर्फ़ GLES के 2.0 और उसके बाद के वर्शन पर काम करती हैं.

चेतावनी: लेयरिंग की सुविधा चालू होने पर, GLES 1.x के खास फ़ंक्शन GLES 1.x ड्राइवर पर भेजे जाते रहेंगे. हालांकि, glGetString() जैसे GLES 2.0 और उसके बाद के वर्शन के साथ शेयर किए गए फ़ंक्शन, 2.0 और उसके बाद के वर्शन वाले ड्राइवर पर भेजे जाते हैं.

लेयर को शुरू करना

स्टैंडर्ड एंट्री पॉइंट भरने के बाद, EGL लोडर एक GLESLayerLoader इंस्टैंशिएट करता है. अगर डीबग लेयर चालू हैं, तो LayerLoader, लेयर के लिए तय की गई डायरेक्ट्री को स्कैन करता है, जैसे कि Vulkan लोडर करता है.

लेयरिंग की सुविधा चालू होने पर, LayerLoader किसी तय लेयर की सूची खोजता है और उसकी गिनती करता है. लेयर की सूची, कोलन से अलग किए गए फ़ाइल नामों से तय की जाती है.

LayerLoader, आपके तय किए गए क्रम में लेयर को ट्रैवर्स करता है, ताकि पहली लेयर सीधे ऐप्लिकेशन के नीचे हो. हर लेयर के लिए, LayerLoader AndroidGLESLayer_Initialize और AndroidGLESLayer_GetProcAddress एंट्री पॉइंट को ट्रैक करता है. लेयर को ये इंटरफ़ेस उपलब्ध कराने होंगे, ताकि इन्हें लोड किया जा सके.

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

AndroidGLESLayer_Initialize(), लेयर के लिए इस्तेमाल करने के लिए एक आइडेंटिफ़ायर (layer_id) और एक एंट्री पॉइंट उपलब्ध कराता है. इस एंट्री पॉइंट को लेयर के नीचे मौजूद फ़ंक्शन देखने के लिए कॉल किया जा सकता है. एंट्री पॉइंट का इस्तेमाल, नीचे दिए गए कोड सैंपल में दिखाए गए तरीके से किया जा सकता है:

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

AndroidGLESLayer_GetProcAddress, चेन में अगले कॉल का पता लेता है, जिसे लेयर को पूरा होने पर कॉल करना चाहिए. अगर सिर्फ़ एक लेयर है, तो next ज़्यादातर फ़ंक्शन के लिए, सीधे ड्राइवर पर ले जाता है.

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

GLES LayerLoader को जो भी लेयर मिलती है उसके लिए, वह AndroidGLESLayer_Initialize को कॉल करता है. साथ ही, libEGL की फ़ंक्शन सूचियों को देखता है और सभी ज्ञात फ़ंक्शन के लिए AndroidGLESLayer_GetProcAddress को कॉल करता है. अगले पते को ट्रैक करने का तरीका तय करना, लेयर के ऊपर निर्भर करता है. अगर लेयर किसी फ़ंक्शन को इंटरसेप्ट करती है, तो वह फ़ंक्शन के पते को ट्रैक करती है. अगर लेयर किसी फ़ंक्शन को इंटरसेप्ट नहीं करती है, तो AndroidGLESLayer_GetProcAddress वही फ़ंक्शन पता दिखाता है जो उसे पास किया गया था. इसके बाद, LayerLoader फ़ंक्शन हुक की सूची को अपडेट करता है, ताकि वह लेयर के एंट्री पॉइंट पर ले जाए.

लेयर को AndroidGLESLayer_Initialize और get_next_layer_proc_address से मिली जानकारी का इस्तेमाल करने की ज़रूरत नहीं होती. हालांकि, डेटा उपलब्ध कराने से, Android GPU Inspector और RenderDoc जैसी मौजूदा लेयर के लिए, Android के साथ काम करना आसान हो जाता है. उस डेटा की मदद से, कोई लेयर AndroidGLESLayer_GetProcAddress के कॉल के इंतज़ार करने के बजाय, स्वतंत्र रूप से फ़ंक्शन खोज सकती है. अगर लेयर, लोडर के सभी एंट्री पॉइंट से क्वेरी करने से पहले, खुद को शुरू करना चाहती हैं, तो उन्हें get_next_layer_proc_address का इस्तेमाल करना होगा. eglGetProcAddress को चैनल से प्लैटफ़ॉर्म पर भेजा जाना चाहिए.

लेयर डालना

GLES LayerLoader, प्राथमिकता के क्रम में इन जगहों पर लेयर खोजता है:

1. रूट के लिए सिस्टम की जगह

इसके लिए, रूट ऐक्सेस की ज़रूरत होती है

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. ऐप्लिकेशन की बुनियादी डायरेक्ट्री

टारगेट किए गए ऐप्लिकेशन को डीबग किया जा सकता हो या आपके पास रूट ऐक्सेस हो:

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

अपने टारगेट ऐप्लिकेशन के एबीआई का पता लगाएं. इसके बाद, ऐसी लेयर वाला APK इंस्टॉल करें जिन्हें आपको लोड करना है:

adb install --abi armeabi-v7a layers.apk

4. टारगेट किए गए ऐप्लिकेशन के APK में

यहां दिए गए उदाहरण में, ऐप्लिकेशन APK में लेयर डालने का तरीका बताया गया है:

$ 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

लेयर चालू करना

GLES लेयर को हर ऐप्लिकेशन के लिए या पूरी दुनिया के लिए चालू किया जा सकता है. हर ऐप्लिकेशन की सेटिंग, रीबूट होने के बाद भी बनी रहती हैं. वहीं, रीबूट होने पर ग्लोबल प्रॉपर्टी मिट जाती हैं.

Android का सुरक्षा मॉडल और नीतियां, दूसरे प्लैटफ़ॉर्म से काफ़ी अलग होती हैं. बाहरी लेयर लोड करने के लिए, इनमें से कोई एक शर्त पूरी होनी चाहिए:

• टारगेट किए गए ऐप्लिकेशन की मेनिफ़ेस्ट फ़ाइल में, यह मेटा-डेटा एलिमेंट शामिल होता है. यह सिर्फ़ उन ऐप्लिकेशन पर लागू होता है जो Android 11 (एपीआई लेवल 30) या उसके बाद के वर्शन को टारगेट करते हैं:

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

  आपको अपने ऐप्लिकेशन की प्रोफ़ाइल बनाने के लिए, इस विकल्प का इस्तेमाल करना चाहिए.

• टारगेट ऐप्लिकेशन को डीबग किया जा सकता है. इस विकल्प से, आपको डीबग करने के बारे में ज़्यादा जानकारी मिलती है. हालांकि, इससे आपके ऐप्लिकेशन की परफ़ॉर्मेंस पर बुरा असर पड़ सकता है.

• टारगेट ऐप्लिकेशन, ऑपरेटिंग सिस्टम के userdebug बिल्ड पर चलाया जाता है, जो रूट ऐक्सेस देता है.

हर ऐप्लिकेशन के लिए लेयर चालू करने के लिए:

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

हर ऐप्लिकेशन के लिए लेयर बंद करने के लिए:

# 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

दुनिया भर में लेयर की सुविधा चालू करने के लिए:

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

लेयर बनाना

लेयर को EGL लोडर को शुरू करने में बताए गए इन दो फ़ंक्शन को एक्सपोज़ करना होगा:

AndroidGLESLayer_Initialize
AndroidGLESLayer_GetProcAddress

पैसिव लेयर

अगर लेयर सिर्फ़ कुछ फ़ंक्शन को इंटरसेप्ट करती है, तो पैसिव तौर पर शुरू की गई लेयर सबसे सही होती है. पैसिव तौर पर शुरू की गई लेयर, GLES LayerLoader के उस फ़ंक्शन को शुरू करने का इंतज़ार करती है जिसकी उसे ज़रूरत होती है.

नीचे दिए गए कोड सैंपल में, पैसिव लेयर बनाने का तरीका बताया गया है.

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

ऐक्टिव लेयर

ज़्यादा औपचारिक लेयर के लिए, उन्हें शुरू में पूरी तरह से शुरू करना ज़रूरी है. इसके अलावा, उन लेयर के लिए भी ऐसा करना ज़रूरी है जिन्हें EGL लोडर के बारे में जानकारी नहीं है. लेयर, किसी फ़ंक्शन को खोजने के लिए, AndroidGLESLayer_Initialize से मिले get_next_layer_proc_address का इस्तेमाल करती है. लेयर को अब भी लोडर के AndroidGLESLayer_GetProcAddress अनुरोधों का जवाब देना होगा, ताकि प्लैटफ़ॉर्म को पता चले कि कॉल कहां भेजने हैं. यहां दिए गए कोड सैंपल में, ऐक्टिव लेयर बनाने का तरीका बताया गया है.

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