16 केबी वाले पेज साइज़ के साथ काम करना

从历史上看，Android 仅支持 4 KB 内存页面大小，这优化了系统内存性能，以适应 Android 设备通常拥有的平均总内存量。从 Android 15 开始，AOSP 支持配置为使用 16 KB 页面大小的设备（16 KB 设备）。如果您的应用直接或通过 SDK 间接使用任何 NDK 库，则需要重新构建应用，才能在这些 16 KB 设备上运行。

随着设备制造商不断制造出具有更大物理内存 (RAM) 的设备，许多此类设备将采用 16 KB（最终甚至更大）的页面大小来优化设备性能。添加对 16 KB 页面大小设备的支持，可让您的应用在这些设备上运行，并帮助您的应用受益于相关的性能改进。如果不重新编译，应用将无法在未来 Android 版本的 16 KB 设备上运行。

为帮助您为应用添加支持，我们提供了相关指南，介绍了如何检查应用是否受到影响、如何重新构建应用（如果适用），以及如何使用模拟器（包括 Android 模拟器的 Android 15 系统映像）在 16 KB 环境中测试应用。

Google Play के साथ काम करने की ज़रूरी शर्तें

Google Play पर मौजूद, Android 15 (एपीआई लेवल 35) और इसके बाद के वर्शन को टारगेट करने वाले सभी ऐप्लिकेशन को 64-बिट वाले डिवाइसों पर 16 केबी मेमोरी वाले पेज साइज़ के साथ काम करना होगा. ऐसा इसलिए, ताकि Android के नए वर्शन पर आपका ऐप्लिकेशन ठीक से काम करे. अगर 1 फ़रवरी, 2027 से आपके ऐप्लिकेशन के अपडेट, 16 केबी मेमोरी वाले पेज साइज़ के साथ काम नहीं करते हैं, तो इन अपडेट को रिलीज़ नहीं किया जा सकेगा.

पहली इमेज. Google Play Console के साथ काम करने से जुड़ी चेतावनी.

फ़ायदे और परफ़ॉर्मेंस में सुधार

配置为使用 16 KB 页面大小的设备平均会使用略多一些的内存，但系统和应用的性能也会得到各种提升：

• 缩短了系统内存压力时的应用启动时间：平均降低了 3.16%；对于我们测试的某些应用而言，改进幅度更大（最高可达 30%）
• 应用启动期间的功耗降低：平均降低了 4.56%
• 相机启动更快：热启动速度平均提高了 4.48%，冷启动速度平均提高了 6.60%
• 缩短了系统启动时间：平均缩短了 8%（约 950 毫秒）

这些改进基于我们的初始测试，实际设备上的结果可能会有所不同。随着测试的继续进行，我们将进一步分析应用的潜在收益。

यह देखना कि आपके ऐप्लिकेशन पर असर पड़ा है या नहीं

如果您的应用使用了任何原生代码，则应重新构建应用，使其支持 16 KB 设备。如果您不确定自己的应用是否使用了原生代码，可以使用 APK 分析器来确定是否存在任何原生代码，然后检查您找到的任何共享库的 ELF 段对齐情况。Android Studio 还提供了一些功能，可帮助您自动检测对齐问题。

如果您的应用仅使用以 Java 或 Kotlin 编程语言编写的代码（包括所有库或 SDK），则该应用已支持 16 KB 设备。不过，我们建议您在 16 KB 环境中测试应用，以验证应用行为是否出现意外的回归。

क्या आपका ऐप्लिकेशन नेटिव कोड का इस्तेमाल करता है?

अगर इनमें से कोई भी स्थिति लागू होती है, तो आपका ऐप्लिकेशन नेटिव कोड का इस्तेमाल करता है:

• आपका ऐप्लिकेशन, C/C++ (नेटिव) कोड का इस्तेमाल करता है. अगर आपका ऐप्लिकेशन Android NDK का इस्तेमाल करता है, तो इसका मतलब है कि वह नेटिव कोड का इस्तेमाल करता है.
• आपका ऐप्लिकेशन, तीसरे पक्ष की किसी ऐसी नेटिव लाइब्रेरी या डिपेंडेंसी (जैसे, एसडीके) से लिंक है जो इनका इस्तेमाल करती है.
• आपका ऐप्लिकेशन, तीसरे पक्ष के किसी ऐसे ऐप्लिकेशन बिल्डर ने बनाया है जो डिवाइस पर नेटिव लाइब्रेरी का इस्तेमाल करता है.

APK ऐनालाइज़र का इस्तेमाल करके नेटिव लाइब्रेरी की पहचान करना

APK ऐनालाइज़र एक ऐसा टूल है जिसकी मदद से, APK के अलग-अलग पहलुओं का आकलन किया जा सकता है. यह देखने के लिए कि आपका ऐप्लिकेशन नेटिव कोड का इस्तेमाल करता है या नहीं (चाहे वह 16 केबी वाले पेज साइज़ के साथ काम करता हो या नहीं):

1. Android Studio खोलें. इसके बाद, File > Open पर क्लिक करें और कोई प्रोजेक्ट चुनें.

2. मेन्यू बार में जाकर, Build > Analyze APK... पर क्लिक करें

   

3. वह APK चुनें जिसका विश्लेषण करना है.

4. lib फ़ोल्डर में देखें. इसमें शेयर की गई ऑब्जेक्ट (.so) फ़ाइलें होती हैं, अगर कोई फ़ाइल मौजूद हो. अगर शेयर की गई कोई ऑब्जेक्ट फ़ाइल मौजूद है, तो आपका ऐप्लिकेशन नेटिव कोड का इस्तेमाल करता है. अलाइनमेंट कॉलम में, उन सभी फ़ाइलों के लिए चेतावनी वाले मैसेज दिखते हैं जिनमें अलाइनमेंट से जुड़ी समस्याएं हैं. अगर शेयर की गई कोई ऑब्जेक्ट फ़ाइल मौजूद नहीं है या कोई lib फ़ोल्डर नहीं है, तो इसका मतलब है कि आपका ऐप्लिकेशन नेटिव कोड का इस्तेमाल नहीं करता है.

   

अपने-आप होने वाली जांचों से, अलाइनमेंट से जुड़ी समस्याओं का पता लगाना

अगर आपकी पहले से बनाई गई लाइब्रेरी या APK, 16 केबी के साथ काम नहीं करते हैं, तो Android Studio आपको पहले से ही चेतावनी देता है. APK ऐनालाइज़र टूल का इस्तेमाल करके देखें कि किन लाइब्रेरी को अपडेट करने की ज़रूरत है या कोड में कोई बदलाव करने की ज़रूरत है या नहीं.

Android Studio में Lint, उन नेटिव लाइब्रेरी को भी हाइलाइट करता है जो 16 केबी पेज साइज़ के साथ अलाइन नहीं हैं.

शेयर की गई लाइब्रेरी के लिए, ईएलएफ़ सेगमेंट के अलाइनमेंट की जांच करना

शेयर की गई किसी भी लाइब्रेरी के लिए, पुष्टि करें कि शेयर की गई लाइब्रेरी के ईएलएफ़ सेगमेंट, 16 केबी ईएलएफ़ अलाइनमेंट का इस्तेमाल करके सही तरीके से अलाइन किए गए हों. अगर Linux या macOS पर ऐप्लिकेशन डेवलप किया जा रहा है, तो check_elf_alignment.sh स्क्रिप्ट का इस्तेमाल किया जा सकता है. इसके बारे में यहां बताया गया है. कमांड-लाइन टूल का सीधे तौर पर भी इस्तेमाल किया जा सकता है.

check_elf_alignment.sh स्क्रिप्ट (Linux या macOS) का इस्तेमाल करना

check_elf_alignment.sh स्क्रिप्ट का इस्तेमाल करके, ईएलएफ़ सेगमेंट के अलाइनमेंट की जांच करने के लिए, यह तरीका अपनाएं:

1. check_elf_alignment.sh स्क्रिप्ट को किसी फ़ाइल में सेव करें.

2. अपने ऐप्लिकेशन की APK फ़ाइल पर स्क्रिप्ट चलाएं:

   check_elf_alignment.sh APK_NAME.apk
   

   स्क्रिप्ट, शेयर की गई सभी arm64-v8a लाइब्रेरी के लिए, ALIGNED या UNALIGNED आउटपुट देती है.

3. अगर शेयर की गई कोई arm64-v8a या x86_64 लाइब्रेरी UNALIGNED है, तो आपको उन लाइब्रेरी के पैकेजिंग को अपडेट करना होगा. इसके बाद, अपने ऐप्लिकेशन को फिर से कंपाइल करें और इस सेक्शन में दिए गए चरणों का पालन करके, फिर से जांच करें.

कमांड-लाइन टूल का सीधे तौर पर इस्तेमाल करना

कमांड-लाइन टूल का इस्तेमाल करके, ईएलएफ़ सेगमेंट के अलाइनमेंट की जांच करने के लिए, यह तरीका अपनाएं:

1. पक्का करें कि Android SDK बिल्ड-टूल का वर्शन 35.0.0 या इसके बाद का वर्शन और Android एनडीके, दोनों इंस्टॉल हों. इसके लिए, Android Studio में एसडीके मैनेजर या sdkmanager कमांड-लाइन टूल का इस्तेमाल करें.

2. अपने ऐप्लिकेशन की APK फ़ाइल एक्सट्रैक्ट करें:

   Linux या macOS

   unzip APK_NAME.apk -d /tmp/my_apk_out
   

   Windows (PowerShell)

   Expand-Archive -Path .\APK_NAME.apk -DestinationPath ~\tmp\my_apk_out
   

3. आपने जिस अस्थायी डायरेक्ट्री में अपनी APK फ़ाइल को एक्सट्रैक्ट किया है उसमें, शेयर किए गए ऑब्जेक्ट (.so) फ़ाइलों के लिए lib डायरेक्ट्री का कॉन्टेंट देखें. ये वही शेयर की गई ऑब्जेक्ट फ़ाइलें हैं जो आपको APK ऐनालाइज़र का इस्तेमाल करके नेटिव लाइब्रेरी की पहचान करने के दौरान दिखती हैं. शेयर की गई हर ऑब्जेक्ट फ़ाइल पर यह कमांड चलाएं:

   Linux या macOS

   SDK_ROOT_LOCATION/Android/sdk/ndk/NDK_VERSION/toolchains/llvm/prebuilt/darwin-x86_64/bin/llvm-objdump -p SHARED_OBJECT_FILE.so | grep LOAD
   

   Windows (PowerShell)

   SDK_ROOT_LOCATION\Android\sdk\ndk\NDK_VERSION\toolchains\llvm\prebuilt\windows-x86_64\bin\llvm-objdump.exe -p SHARED_OBJECT_FILE.so | Select-String -Pattern "LOAD"
   

   यहां SDK_ROOT_LOCATION उस डायरेक्ट्री का पाथ है जहां आपने Android SDK टूल इंस्टॉल किया है. SHARED_OBJECT_FILE, शेयर की गई उस ऑब्जेक्ट फ़ाइल का नाम है जिसकी जांच की जा रही है. साथ ही, NDK_VERSION, इंस्टॉल किए गए Android NDK का वर्शन है. उदाहरण के लिए, 28.0.12433566. जांच की जाने वाली हर फ़ाइल के लिए, आउटपुट कुछ इस तरह दिखेगा:

   LOAD off    0x0000000000000000 vaddr 0x0000000000000000 paddr 0x0000000000000000 align 2**14
   LOAD off    0x0000000000042a90 vaddr 0x0000000000043a90 paddr 0x0000000000043a90 align 2**14
   LOAD off    0x0000000000046230 vaddr 0x0000000000048230 paddr 0x0000000000048230 align 2**14
   

4. आउटपुट लाइनें देखकर पक्का करें कि लोड सेगमेंट की वैल्यू 2**14 से कम न हो. अगर लोड सेगमेंट की वैल्यू 2**13, 2**12 या इससे कम है, तो आपको उन लाइब्रेरी की पैकेजिंग अपडेट करनी होगी. इसके बाद, अपने ऐप्लिकेशन को फिर से कंपाइल करें और इस सेक्शन में दिया गया तरीका अपनाकर, फिर से जांच करें.

5. इसके बाद, अपने ऐप्लिकेशन की APK फ़ाइल पर zipalign कमांड-लाइन टूल चलाएं:

   Linux या macOS

   SDK_ROOT_LOCATION/Android/sdk/build-tools/35.0.0/zipalign -v -c -P 16 4 APK_NAME.apk
   

   Windows (PowerShell)

   SDK_ROOT_LOCATION\Android\sdk\build-tools\35.0.0\zipalign.exe -v -c -P 16 4 APK_NAME.apk
   

   जहां SDK_ROOT_LOCATION उस डायरेक्ट्री का पाथ है जहां आपने Android SDK इंस्टॉल किया है और APK_NAME आपके ऐप्लिकेशन की APK फ़ाइल का नाम है. अगर शेयर की गई सभी लाइब्रेरी सही तरीके से अलाइन की गई हैं, तो आउटपुट की आखिरी लाइन में "पुष्टि हो गई" लिखा होगा.

   अगर पुष्टि नहीं हो पाती है, तो शेयर की गई कुछ लाइब्रेरी को फिर से अलाइन करना होगा. इसलिए, आपको उन लाइब्रेरी के लिए पैकेजिंग अपडेट करनी होगी. इसके बाद, अपने ऐप्लिकेशन को फिर से कंपाइल करें और इस सेक्शन में दिए गए तरीके का पालन करके, फिर से जांच करें.

RELRO के सुरक्षा फ़्लैग की जांच करना

सुरक्षा से जुड़े जोखिमों को कम करने के लिए, आधुनिक लिंकर रीलोकेशन रीड-ओनली (RELRO) फ़्लैग का इस्तेमाल करते हैं. इससे शेयर की गई ऑब्जेक्ट फ़ाइल के रीलोकेशन सेक्शन को लोड होने के बाद, रीड-ओनली बनाया जा सकता है. अपने बिल्ड में RELRO फ़्लैग चालू करें.

अगर किसी RELRO सेक्शन में स्टार्ट अड्रेस और सेगमेंट साइज़ (MemSize) की वैल्यू 16 केबी के अलाइनमेंट के मुताबिक नहीं है, तो रनटाइम के दौरान ऐप्लिकेशन क्रैश हो जाता है. साथ ही, सेगमेंटेशन फ़ॉल्ट की गड़बड़ी दिखती है. ऐसा तब होता है, जब .so फ़ाइल को एनडीके टूल चेन r27 और इससे पहले के वर्शन का इस्तेमाल करके बनाया गया हो. साथ ही, काम के फ़्लैग चालू न किए गए हों.

शेयर की गई हर ऑब्जेक्ट फ़ाइल (Linux या macOS) पर यह कमांड चलाएं:

SDK_ROOT_LOCATION/Android/sdk/ndk/NDK_VERSION/toolchains/llvm/prebuilt/darwin-x86_64/bin/llvm-readelf -Wl SHARED_OBJECT_FILE.so | grep 'RELRO\|Type'

अगर कोई RELRO सेगमेंट मौजूद है, तो GNU_RELRO स्ट्रिंग प्रिंट की जाती है.

इसके बाद, RELRO सेगमेंट के अलाइनमेंट की जांच करें. इसके लिए, इसके वर्चुअल ऑफ़सेट पते (VirtAddr) को सेगमेंट की मेमोरी साइज़ (MemSiz) के साथ जोड़ें और 16 केबी (0x4000) से भाग दें. अगर रिमाइंडर (मॉड्यूलो) शून्य है, तो RELRO सेगमेंट 16 केबी के साथ अलाइन है.

यहां अलाइन न की गई .so फ़ाइल का एक उदाहरण दिया गया है:

Type           Offset   VirtAddr           PhysAddr           FileSiz MemSiz  Flg Align  
GNU_RELRO      0x0cfaf0 0x00000000000dfaf0 0x00000000000dfaf0 0x01510 0x01510 R   0x1

फ़ॉर्मूला: (VirtAddr + MemSiz) % 0x4000 == 0

नतीजा: (0xdfaf0 + 0x01510) % 0x4000 = 0xE1000 % 0x4000 == 0x1000

0x1000 शून्य नहीं है. इसलिए, यह .so फ़ाइल 16 केबी के मुताबिक नहीं है. RELRO प्रोटेक्शन रेंज, DC000 (पिछला पेज ब्रेक) से E4000 तक सिर्फ़ पढ़ने के लिए होती है. हालांकि, Android Linker को E1000 से E4000 तक की सब-रेंज में लिखने की अनुमति चाहिए. इससे सेगमेंटेशन फ़ॉल्ट होता है. इस मामले में, .so फ़ाइल को फिर से बनाएं. इसके लिए, 16 केबी ईएलएफ़ अलाइनमेंट का इस्तेमाल करके अपना ऐप्लिकेशन कंपाइल करें सेक्शन में दिया गया तरीका अपनाएं.

यहां RELRO सेगमेंट वाली अलाइन की गई .so फ़ाइल का उदाहरण दिया गया है:

Type           Offset   VirtAddr           PhysAddr           FileSiz MemSiz  Flg Align
GNU_RELRO      0x0cfaf0 0x00000000000dfaf0 0x00000000000dfaf0 0x01510 0x00510 R   0x1  

यहां ऐसी .so फ़ाइल का उदाहरण दिया गया है जिसमें RELRO सेगमेंट नहीं है:

Type           Offset   VirtAddr           PhysAddr           FileSiz MemSiz  Flg Align

यह 16 केबी वाले पेज साइज़ के साथ काम करने वाली .so फ़ाइल है. इसमें कोई RELRO सेगमेंट नहीं है.

यहां अलाइन की गई .so फ़ाइल का एक उदाहरण दिया गया है, जिसमें GNU_RELRO अपने LOAD सेगमेंट में है:

Type           Offset   VirtAddr           PhysAddr           FileSiz  MemSiz   Flg Align
LOAD           0x000000 0x0000000000000000 0x0000000000000000 0x000680 0x000680 R E 0x4000
LOAD           0x000680 0x0000000000004680 0x0000000000004680 0x0001d8 0x000980 RW  0x4000
GNU_RELRO      0x000680 0x0000000000004680 0x0000000000004680 0x0001d8 0x000980 R   0x1

फ़ॉर्मूला: (VirtAddr + MemSiz) % 0x4000 == 0

नतीजा: (0x4680 + 0x0980) % 0x4000 = 0x5000 % 0x4000 == 0x1000

हालांकि, 0x1000 शून्य नहीं है, लेकिन यह .so फ़ाइल अब भी 16 केबी वाले पेज साइज़ के साथ काम करती है.

मॉड्यूलो फ़ॉर्मूला तब लागू होता है, जब GNU_RELRO, LOAD सेगमेंट को बाद के राइटेबल डेटा (जैसे, .data या .bss) के साथ शेयर करता है.

यह देखने के लिए कि GNU_RELRO अपने LOAD सेगमेंट में है या नहीं, प्रोग्राम हेडर की जांच करें. इसके लिए, llvm-readelf -Wl चलाएं और grep 'LOAD\|RELRO\|Type' से फ़िल्टर करें. GNU_RELRO के VirtAddr और MemSiz की तुलना, LOAD सेगमेंट से करें. इस उदाहरण में, दोनों के पास VirtAddr 0x4680 और MemSiz 0x0980 हैं.

पूरे LOAD सेगमेंट में सिर्फ़ RELRO डेटा होता है. इसलिए, 0x5000 से 0x8000 तक की सब-रेंज में, ऐसा डेटा नहीं होता जिसमें बदलाव किया जा सके. इसके अलावा, इसके बाद आने वाला कोई भी राइटेबल LOAD सेगमेंट, 16 केबी वाले पेज की अलग बाउंड्री (0x8000 या इसके बाद) पर शुरू होता है. लिंकर की रीड-ओनली सुरक्षा, किसी भी ऐसे डेटा के साथ ओवरलैप नहीं होगी जिसे लिखा जा सकता है. इसलिए, कोई सेगमेंटेशन फ़ॉल्ट नहीं होगा.

अपने ऐप्लिकेशन को 16 केबी मेमोरी वाले डिवाइसों के साथ काम करने के लिए बनाएं

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

1. शेयर की गई लाइब्रेरी की पैकेजिंग अपडेट करना
2. अपने ऐप्लिकेशन को 16 केबी ईएलएफ़ अलाइनमेंट का इस्तेमाल करके कंपाइल करें
3. कोड को ठीक करना और रनटाइम से जुड़ी समस्याएं हल करना
4. कस्टम मेमोरी एलोकेटर को ऑप्टिमाइज़ करना (अगर लागू हो)
5. एसडीके टूल की जांच करके पता लगाएं कि वे 16 केबी वाले पेज साइज़ के साथ काम करते हैं या नहीं

अहम जानकारी: अगर आपने अपने टूल को नए वर्शन (एजीपी वर्शन 8.5.1 या इसके बाद के वर्शन और एनडीके वर्शन r28 या इसके बाद के वर्शन) पर अपडेट किया है और 16 केबी के साथ काम करने वाली पहले से बनी डिपेंडेंसी का इस्तेमाल किया है, तो आपका ऐप्लिकेशन डिफ़ॉल्ट रूप से 16 केबी के साथ काम करता है. ऐसे में, कोड को ठीक करने और रनटाइम से जुड़ी समस्याओं को हल करने के चरण पर जाएं.

शेयर की गई लाइब्रेरी के पैकेजिंग को अपडेट करना

Android Gradle प्लगिन के वर्शन 8.5.1 या इसके बाद वाले वर्शन पर अपग्रेड करें और कंप्रेस नहीं की गई शेयर की गई लाइब्रेरी का इस्तेमाल करें.

ज़िप अलाइनमेंट की पुष्टि करने के लिए, bundletool का इस्तेमाल करना

अपने बंडल का अलाइनमेंट देखने के लिए, इसका इस्तेमाल करें:

bundletool dump config --bundle=<my .aab>  | grep alignment

अगर आपको PAGE_ALIGNMENT_16K दिखता है, तो इसका मतलब है कि आपका बंडल 16 केबी ज़िप अलाइनमेंट का अनुरोध करता है. अगर आपको PAGE_ALIGNMENT_4K दिखता है, तो इसका मतलब है कि इस एएबी से बने APK की zip फ़ाइल में, 4 केबी अलाइन की गई .so फ़ाइलें होनी चाहिए.

AGP का वर्शन 8.5.1 या इसके बाद का वर्शन

16 केबी वाले डिवाइसों पर, कंप्रेस न की गई शेयर की गई लाइब्रेरी वाले ऐप्लिकेशन को 16 केबी वाले ज़िप-अलाइन किए गए पेज साइज़ के मुताबिक अलाइन करना ज़रूरी है. इसके लिए, आपको Android Gradle प्लगिन (एजीपी) को 8.5.1 या इसके बाद के वर्शन पर अपग्रेड करना होगा. अपग्रेड की प्रोसेस के बारे में जानकारी पाने के लिए, Android Gradle प्लग इन अपग्रेड असिस्टेंट सेक्शन देखें.

एजीपी का वर्शन 8.5 या इससे पहले का वर्शन

ध्यान दें: AGP के वर्शन 8.3 से 8.5 में, ऐप्लिकेशन डिफ़ॉल्ट रूप से 16 केबी अलाइन होते हैं. हालांकि, bundletool डिफ़ॉल्ट रूप से APK को ज़िपअलाइन नहीं करता. इसलिए, हो सकता है कि ऐप्लिकेशन काम करता हुआ दिखे. हालांकि, Play में बंडल से बनाए जाने पर, यह इंस्टॉल नहीं होगा.

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

Groovy

अपनी build.gradle फ़ाइल में, यह विकल्प जोड़ें:

android {
  ...
  packagingOptions {
      jniLibs {
        useLegacyPackaging true
      }
  }
}

Kotlin

अपनी build.gradle.kts फ़ाइल में, यह विकल्प जोड़ें:

android {
  ...
  packagingOptions {
      jniLibs {
        useLegacyPackaging = true
      }
  }
}

Android Gradle प्लगिन का वर्शन 8.0 या इससे पहले का वर्शन

अगर एजीपी के 8.0 या इससे पहले के वर्शन का इस्तेमाल किया जा रहा है, तो आपको अपनी gradle.properties फ़ाइल में, ऐप्लिकेशन बंडल के लिए कंप्रेस न की गई नेटिव लाइब्रेरी का विकल्प भी बंद करना होगा:

android.bundle.enableUncompressedNativeLibs=false

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

16 केबी वाले ईएलएफ़ अलाइनमेंट का इस्तेमाल करके, अपने ऐप्लिकेशन को कंपाइल करें

16 केबी वाले डिवाइसों पर, आपके ऐप्लिकेशन को चलाने के लिए, शेयर की गई लाइब्रेरी के ईएलएफ़ सेगमेंट को 16 केबी ईएलएफ़ अलाइनमेंट का इस्तेमाल करके सही तरीके से अलाइन करना ज़रूरी है.

अगर आपका गेम Unity गेम इंजन पर चलता है, तो Unity गाइड देखें. अगर आपका गेम Unreal गेम इंजन पर चलता है, तो Unreal गाइड देखें.नेटिव गेम इंजन के लिए, इस गाइड को पढ़ना जारी रखें.

ध्यान दें: अगर आपका ऐप्लिकेशन, नेटिव लाइब्रेरी को फ़ाइल सिस्टम में एक्सट्रैक्ट नहीं करता है (extractNativeLibs को false पर सेट किया गया है), तो आपको 16 केबी ईएलएफ़ अलाइनमेंट का इस्तेमाल करके कंपाइल करने के बाद, अपने ऐप्लिकेशन के बाइनरी साइज़ में थोड़ी बढ़ोतरी दिख सकती है. Android 15 में पैकेज मैनेजर को ऑप्टिमाइज़ करने से, रनटाइम की लागत में होने वाली बढ़ोतरी को कम किया जा सकता है.

16 केबी ईएलएफ़ अलाइनमेंट का इस्तेमाल करके अपने ऐप्लिकेशन को कंपाइल करने के लिए, यहां दिए गए सेक्शन में से किसी एक में दिया गया तरीका अपनाएं. यह तरीका, Android एनडीके के उस वर्शन पर निर्भर करता है जिसका इस्तेमाल किया जा रहा है.

अहम जानकारी: अगर आपका ऐप्लिकेशन पहले से बनी शेयर की गई लाइब्रेरी का इस्तेमाल करता है, तो आपको उन्हें भी इसी तरह से फिर से कंपाइल करना होगा. साथ ही, 16 केबी पेज साइज़ के साथ अलाइन की गई लाइब्रेरी को अपने ऐप्लिकेशन में फिर से इंपोर्ट करना होगा.

Android NDK r28 और इसके बाद के वर्शन

एनडीके के r28 और इसके बाद के वर्शन, डिफ़ॉल्ट रूप से 16 केबी के हिसाब से अलाइन किए जाते हैं.

Android NDK r27 और इससे पहले के वर्शन

Android एनडीके (NDK) के r27 या इससे पहले के वर्शन के साथ, 16 केबी पेज साइज़ के हिसाब से अलाइन की गई शेयर की गई लाइब्रेरी को कंपाइल करने के लिए, इन लिंकर फ़्लैग का इस्तेमाल करें:

-Wl,-z,max-page-size=16384
-Wl,-z,common-page-size=16384

अपनी बिल्ड सिस्टम कॉन्फ़िगरेशन फ़ाइलों को अपडेट करने का तरीका यहां बताया गया है:

ndk-build

अगर ndk-build का इस्तेमाल किया जा रहा है, तो 16 केबी ईएलएफ़ अलाइनमेंट को चालू करने के लिए, अपने Android.mk को अपडेट करें:

LOCAL_LDFLAGS += -Wl,-z,max-page-size=16384 -Wl,-z,common-page-size=16384

CMake

अगर CMake का इस्तेमाल किया जा रहा है, तो 16 केबी ईएलएफ़ अलाइनमेंट चालू करने के लिए, CMakeLists.txt को अपडेट करें:

target_link_options(${CMAKE_PROJECT_NAME} PRIVATE
    "-Wl,-z,max-page-size=16384"
    "-Wl,-z,common-page-size=16384"
)

ध्यान दें: अगर आपका ऐप्लिकेशन, NDK के r26 और इससे पुराने वर्शन से C++ स्टैंडर्ड लाइब्रेरी (libc++_shared.so) के साथ डाइनैमिक तरीके से लिंक होता है, तो आपको यहां अन्य सभी लाइब्रेरी के अलाइनमेंट को अपडेट करना होगा. साथ ही, आपको अपने कोड को अपडेट करना होगा, ताकि वह PAGE_SIZE पर निर्भर न रहे. हालांकि, इनमें से कुछ लाइब्रेरी में 16 केबी अलाइन किया गया libc++_shared.so नहीं होता है. एनडीके के पुराने वर्शन को 16 केबी वाले डिवाइसों पर टेस्ट करने के लिए, एलटीएस एनडीके के वर्शन r23 और r25 के कैनरी रिलीज़, Android सीआई पर उपलब्ध हैं. इनमें 16 केबी वाले पेज साइज़ के साथ काम करने वाली libc++_shared.so लाइब्रेरी शामिल हैं.

ध्यान दें: अगर Android एनडीके के नए वर्शन पर स्विच नहीं किया जा सकता, तो C++ स्टैंडर्ड लाइब्रेरी को शेयर की गई लाइब्रेरी में स्टैटिक तौर पर कंपाइल करने के लिए, अपने ऐप्लिकेशन को अपडेट किया जा सकता है. C++ स्टैंडर्ड लाइब्रेरी को स्टैटिक तौर पर लिंक करने के बारे में जानकारी पाने के लिए, C++ लाइब्रेरी के लिए सहायता सेक्शन देखें. साथ ही, ज़रूरी बातें सेक्शन को ज़रूर पढ़ें.

कोड को ठीक करना और रनटाइम से जुड़ी समस्याएं हल करना

अगर आपका ऐप्लिकेशन 16 केबी वाले पेज साइज़ के साथ काम करता है, तो भी उसमें गड़बड़ियां हो सकती हैं. ऐसा तब होता है, जब आपके कोड में यह अनुमान लगाया गया हो कि डिवाइस में किसी खास साइज़ का पेज इस्तेमाल किया जा रहा है. इससे बचने के लिए, यह तरीका अपनाएं:

1. हार्ड-कोड की गई ऐसी सभी डिपेंडेंसी हटाएं जो आपके कोड लॉजिक में PAGE_SIZE कॉन्सटेंट या इंस्टेंस को रेफ़र करती हैं. साथ ही, यह मानती हैं कि डिवाइस का पेज साइज़ 4 केबी (4096) है.

   इसके बजाय, getpagesize() या sysconf(_SC_PAGESIZE) का इस्तेमाल करें.

2. mmap() और अन्य एपीआई के इस्तेमाल का पता लगाएं जिनके लिए पेज-अलाइन किए गए आर्ग्युमेंट की ज़रूरत होती है. साथ ही, ज़रूरत पड़ने पर उन्हें अन्य विकल्पों से बदलें.

कुछ मामलों में, अगर आपका ऐप्लिकेशन PAGE_SIZE का इस्तेमाल ऐसी वैल्यू के तौर पर करता है जो पेज साइज़ से जुड़ी नहीं है, तो 16 केबी मोड में इस्तेमाल करने पर, आपका ऐप्लिकेशन काम करना बंद नहीं करेगा. हालांकि, अगर इस वैल्यू को कर्नल को mmap के साथ MAP_FIXED के बिना पास किया जाता है, तो कर्नल अब भी पूरे पेज का इस्तेमाल करता है. इससे कुछ मेमोरी बर्बाद हो जाती है. इन वजहों से, एनडीके r27 और इसके बाद के वर्शन पर 16 केबी मोड चालू होने पर, PAGE_SIZE को तय नहीं किया जाता.

अगर आपका ऐप्लिकेशन PAGE_SIZE का इस्तेमाल इस तरह करता है और इस वैल्यू को कभी भी सीधे तौर पर कर्नेल को पास नहीं करता है, तो PAGE_SIZE का इस्तेमाल करने के बजाय, नए नाम के साथ एक नया वैरिएबल बनाएं. इससे यह पता चलेगा कि इसका इस्तेमाल अन्य कामों के लिए किया जाता है और यह असल मेमोरी पेज को नहीं दिखाता है.

कस्टम मेमोरी ऐलोकेटर को ऑप्टिमाइज़ करना

ध्यान दें: यह सेक्शन सिर्फ़ तब लागू होता है, जब आपके ऐप्लिकेशन, गेम इंजन या नेटिव लाइब्रेरी में कस्टम मेमोरी मैनेजर, हीप या स्लैब ऐलोकेटर लागू किया गया हो. जैसे, कस्टम गेम इंजन, एम्बेड किए गए डेटाबेस या jemalloc या mimalloc को एम्बेड करने वाले रनटाइम. अगर आपका ऐप्लिकेशन, Android के स्टैंडर्ड मेमोरी ऐलोकेटर (scudo) का इस्तेमाल करता है, तो इस सेक्शन को छोड़ा जा सकता है.

16 केबी सिस्टम पर, ऑपरेटिंग सिस्टम जिस फ़िज़िकल मेमोरी को सबसे छोटी यूनिट के तौर पर असाइन करता है वह 4 केबी सिस्टम की तुलना में चार गुना बड़ी होती है. अगर कस्टम ऐलोकेटर को 4 केबी के हिसाब से डिज़ाइन किया गया है, तो यह छोटे ऑब्जेक्ट को कई 16 केबी पेजों में बिखेर सकता है. साथ ही, बेवजह खाली मेमोरी को बनाए रख सकता है. इससे, फ़िज़िकल मेमोरी के इस्तेमाल (आरएसएस) में काफ़ी बढ़ोतरी हो सकती है. साथ ही, कंप्रेस की गई स्वैप मेमोरी (ज़ेडआरएएम) की परफ़ॉर्मेंस में गिरावट आ सकती है.

अगर आपका कोड अपने मेमोरी पूल को मैनेज करता है, तो ये सुझाव अपनाएं:

1. मेमोरी खाली करने के लिए, हार्ड-कोड की गई बाइट थ्रेशोल्ड से बचें

कई ऐलोकेटर, बाइट की तय सीमा का इस्तेमाल करके यह तय करते हैं कि madvise(MADV_DONTNEED) का इस्तेमाल करके, ओएस को मेमोरी कब वापस करनी है. उदाहरण के लिए, मेमोरी सिर्फ़ तब वापस करें, जब ऐक्टिव ऑब्जेक्ट 8 केबी से कम जगह लेते हों.

16 केबी वाले सिस्टम पर, 16 बाइट का एक लाइव ऑब्जेक्ट भी पूरे 16 केबी वाले पेज को पिन कर देता है. यह पेज 8 केबी से बड़ा होता है. इस वजह से, रिलीज़ थ्रेशोल्ड कभी पूरा नहीं होता और ऐलोकेटर, आस-पास की इस्तेमाल न की गई मेमोरी को कर्नेल को कभी वापस नहीं करता.

क्या करें: पेज-रिलीज़ ह्यूरिस्टिक के लिए, हार्ड-कोड किए गए बाइट कॉन्सटेंट का इस्तेमाल कभी न करें. sysconf(_SC_PAGESIZE) का इस्तेमाल करके, पेज के असल साइज़ के आधार पर रनटाइम के दौरान, रिलीज़ थ्रेशोल्ड को डाइनैमिक तौर पर स्केल करें.

2. पहले से इस्तेमाल किए जा रहे पेजों को पहले भरें (डेंस-फ़र्स्ट ऐलोकेशन)

अगर कोई ऐलोकेटर, फ़र्स्ट-इन-फ़र्स्ट-आउट (एफ़आईएफ़ओ) या राउंड-रॉबिन ऑर्डर में मेमोरी देता है, तो नए ऐलोकेशन, 16 केबी के कई पेजों पर बिखर जाते हैं. पेज पर मौजूद एक ऑब्जेक्ट, फ़िज़िकल रैम में मौजूद सभी 16 केबी को सेव रखता है.

क्या करें: खाली या कम इस्तेमाल किए गए पेजों को ऐक्सेस करने से पहले, हमेशा सबसे ज़्यादा भरे हुए (सबसे ज़्यादा डेंसिटी वाले) पेज या स्लैब से नए ऑब्जेक्ट असाइन करें. पहले से इस्तेमाल किए जा रहे पेजों पर नए ऐलोकेशन को कंसंट्रेट करने से, कम इस्तेमाल किए जा रहे पेजों को नैचुरल तरीके से ड्रेन किया जा सकता है. इससे, उन पेजों पर मौजूद ऐक्टिव ऑब्जेक्ट की संख्या शून्य हो जाती है. इस तरह, पूरे 16 केबी पेज को ओएस के लिए रिलीज़ किया जा सकता है.

3. मेमोरी पूल को 16 केबी पर अलाइन करें और पूल के साइज़ को मॉडरेट रखें

4 केबी वाले सिस्टम के लिए डिज़ाइन किए गए मल्टी-पेज स्पैन, 16 केबी वाले कर्नेल पर ज़्यादा मेमोरी इस्तेमाल कर सकते हैं. इसके अलावा, 16 केबी में बराबर न बंटने वाले साइज़ क्लास की वजह से, हर पेज के आखिर में फ़्रैगमेंटेशन होता है.

क्या करें:

• पक्का करें कि सभी मेमोरी पूल, स्लैब बाउंड्री, और बफ़र अलाइनमेंट, रनटाइम पेज के साइज़ के सटीक मल्टीपल हों.
• छोटे ऑब्जेक्ट क्लास के लिए, एक से ज़्यादा पेजों वाले स्पैन के साइज़ का फिर से आकलन करें, ताकि ऐसे बहुत बड़े स्लैब असाइन न किए जाएं जो खाली मेमोरी को ट्रैप करते हैं.

4. कैश किए गए बड़े बफ़र के लिए, फ़िज़िकल मेमोरी को तुरंत रिलीज़ करें

कस्टम ऐलोकेटर अक्सर इन-मेमोरी पूल में बड़े बफ़र (> 64 केबी) को कैश मेमोरी में सेव करते हैं, ताकि उन्हें mmap या munmap सिस्टम कॉल के ओवरहेड का भुगतान किए बिना फिर से इस्तेमाल किया जा सके. हालांकि, मेमोरी में इन गंदे बफ़र को बनाए रखने से, इविक्शन टाइमर के इंतज़ार के दौरान कई मेगाबाइट फ़िज़िकल रैम बर्बाद हो जाती है.

क्या करें: वर्चुअल मेमोरी के अड्रेस की रेंज को रिज़र्व रखें, ताकि उसे तुरंत फिर से इस्तेमाल किया जा सके. हालांकि, कैश मेमोरी में बफ़र को वापस भेजते समय, madvise(..., MADV_DONTNEED) या madvise(..., MADV_FREE) को तुरंत कॉल करें. ऑपरेटिंग सिस्टम, फ़िज़िकल रैम को तुरंत वापस ले लेता है. हालांकि, आपका ऐप्लिकेशन वर्चुअल पते को फिर से असाइन किए बिना, तुरंत फिर से इस्तेमाल कर सकता है.

5. ZRAM कंप्रेशन के लिए मेमोरी को असाइन करने के बजाय, उसे खाली करें

Android, बैकग्राउंड में चल रहे ऐप्लिकेशन को मेमोरी में रखने के लिए, कंप्रेस किए गए स्वैप (ZRAM) का इस्तेमाल करता है. 16 केबी वाले डिवाइसों पर, अगर किसी पेज में एक भी लाइव ऑब्जेक्ट मौजूद है, तो पूरा 16 केबी वाला पेज, मेमोरी में बना रहता है या उसे ZRAM में स्वैप कर दिया जाता है. उस पेज के पहले से खाली किए गए हिस्सों पर बचा हुआ गारबेज डेटा (जैसे, पुराने पॉइंटर और स्ट्रिंग) खराब तरीके से कंप्रेस होता है.

अगर आपका ऐलोकेटर मेमोरी को शून्य पर सेट करता है (जैसे, सुरक्षा या शून्य पर सेट की गई शुरुआती वैल्यू के लिए), तो ऐलोकेशन के बजाय डीऐलोकेशन (free()) पर शून्य पर सेट करने पर विचार करें:

• पिन किए गए पेजों पर कम खर्च होता है: 16 केबी के आंशिक रूप से भरे हुए पेजों पर मौजूद खाली मेमोरी, ZRAM में लगभग पूरी तरह से कंप्रेस हो जाती है. इसलिए, पिन किए गए पेज फ़िज़िकल स्वैप स्पेस को बर्बाद नहीं करते.
• कैश मेमोरी का कम से कम ओवरहेड: free() को कॉल किए जाने के समय, सीपीयू कैश मेमोरी में पहले से ही मेमोरी मौजूद होती है. इससे, बाद में कैश मेमोरी में डेटा न मिलने की समस्या से बचा जा सकता है.

सुझावों की खास जानकारी

जगह	सुझाव	अनुमानित असर
डेटा मिटाने के थ्रेशोल्ड	sysconf(_SC_PAGESIZE) का इस्तेमाल करके, रिलीज़ के थ्रेशोल्ड को डाइनैमिक तरीके से बढ़ाएं.	रिलीज़ लॉजिक को हमेशा के लिए डेडलॉक होने से रोकता है.
एलोकेशन ऑर्डर	सबसे पहले, सबसे ज़्यादा (लगभग पूरा) पेज या स्लैब असाइन करें.	इससे ऐक्टिव ऑब्जेक्ट को एक साथ पैक करके, रेज़िडेंट मेमोरी (आरएसएस) को कम किया जाता है.
स्पैन साइज़िंग	साइज़ क्लास को 16 केबी के मल्टीपल के साथ अलाइन करें और बड़े साइज़ के स्लैब से बचें.	इससे टेल-पेज फ़्रैगमेंटेशन की समस्या खत्म होती है और मेमोरी स्लैक कम होता है.
बफ़र कैश मेमोरी	बड़े बफ़र को कैश मेमोरी में सेव करते समय, madvise(MADV_DONTNEED) को तुरंत कॉल करें.	इससे, इस्तेमाल न की जा रही रैम का इस्तेमाल कम हो जाता है. साथ ही, वर्चुअल रैम को तेज़ी से फिर से इस्तेमाल किया जा सकता है.
स्वैप / ज़ेडआरएएम	मेमोरी को असाइन करने के बजाय, free() पर मेमोरी को शून्य करें.	ZRAM के कंप्रेस करने के अनुपात को बेहतर बनाता है, ताकि पिन किए गए पेजों पर कम खर्च हो.

देखें कि एसडीके, 16 केबी वाले पेज साइज़ के साथ काम करते हैं या नहीं

कई एसडीके, 16 केबी वाले पेज साइज़ के साथ काम करते हैं. खास तौर पर, तब जब उन्हें खुद बनाया गया हो या हाल ही में पहले से बने एसडीके इस्तेमाल किए गए हों. हालांकि, एसडीके के कुछ प्रीबिल्ट या वर्शन, 16 केबी के साथ काम नहीं करते. इसलिए, आपको एसडीके बनाने वाली हर कंपनी की वेबसाइट पर जाकर देखना चाहिए कि 16 केबी के साथ कौनसा वर्शन इस्तेमाल करना चाहिए.

अपने ऐप्लिकेशन को उन डिवाइसों पर टेस्ट करें जो 16 केबी वाले पेज साइज़ पर काम करते हों

अपने ऐप्लिकेशन को 16 केबी मेमोरी वाले डिवाइसों के साथ काम करने के लिए बनाने के बाद, आपको उसे 16 केबी मेमोरी वाले डिवाइसों पर टेस्ट करना होगा. इससे यह पता चलेगा कि आपके ऐप्लिकेशन इस्तेमाल करने के अनुभव में कोई समस्या तो नहीं है. ऐसा करने के लिए, इन चरणों का अनुसरण करें:

1. Android 15 SDK या इसके बाद का वर्शन सेट अप करें.

2. इनमें से कोई एक टेस्टिंग एनवायरमेंट सेट अप करें:

   • Android Emulator को 16 केबी वाले, Android 15 सिस्टम इमेज के साथ सेट अप करना
   • ARM64 पर 16 केबी वाले पेज साइज़ के साथ Cuttlefish का इस्तेमाल करना
   • x86-64 पर 16 केबी वाले पेज साइज़ के साथ Cuttlefish को सिम्युलेट करना
   • डेवलपर के लिए सेटिंग और टूल का इस्तेमाल करके, किसी डिवाइस पर 16 केबी मोड चालू करना
   • Samsung Remote Test Lab का इस्तेमाल करें. यह 16 केबी वाले पेज साइज़ के साथ काम करने वाले डिवाइसों पर उपलब्ध है

3. अपने टेस्ट डिवाइस को चालू करें. इसके बाद, यह पुष्टि करने के लिए कि यह 16 केबी वाले पेज साइज़ पर काम कर रहा है, यह निर्देश चलाएं:

   adb shell getconf PAGE_SIZE
   

   कमांड से 16384 वैल्यू मिलनी चाहिए.

4. यह पुष्टि करने के लिए कि आपका ऐप्लिकेशन 16 केबी के साथ अलाइन है, यहां दिया गया zipalign कमांड चलाएं. यहां APK_NAME, आपके ऐप्लिकेशन की APK फ़ाइल का नाम है:

   zipalign -c -P 16 -v 4 APK_NAME.apk
   

5. अपने ऐप्लिकेशन की अच्छी तरह से जांच करें. खास तौर पर, उन हिस्सों पर ध्यान दें जिन पर खास पेज के साइज़ का रेफ़रंस देने वाले कोड इंस्टेंस बदलने का असर पड़ सकता है.

16 केबी की सिस्टम इमेज के साथ Android Emulator को सेट अप करना

Android Emulator का इस्तेमाल करके 16 केबी वाला एनवायरमेंट सेट अप करने के लिए, यह तरीका अपनाएं:

1. Android Studio में, Tools > SDK Manager पर क्लिक करें.

2. एसडीके प्लैटफ़ॉर्म टैब में, पैकेज की जानकारी दिखाएं को चुनें. इसके बाद, Android VanillaIceCream या इसके बाद के वर्शन वाले सेक्शन को बड़ा करें. इसके बाद, आपको जो वर्चुअल डिवाइस बनाने हैं उनके हिसाब से, यहां दी गई एक या दोनों एम्युलेटर सिस्टम इमेज चुनें:

   • Google APIs Experimental 16 KB Page Size ARM 64 v8a System Image
   • Google APIs Experimental 16 KB Page Size Intel x86_64 Atom System Image
   ध्यान दें: अगर आपको इस्तेमाल किए जा सकने वाले Google Pixel डिवाइस को एम्युलेट करना है, तो आपको सिर्फ़ ARM 64 v8a सिस्टम इमेज की ज़रूरत होगी.

   

3. आपने जो भी सिस्टम इमेज चुनी हैं उन्हें डाउनलोड करने के लिए, लागू करें > ठीक है पर क्लिक करें.

4. Android 15 के लिए वर्चुअल डिवाइस सेट अप करने का तरीका अपनाएं. इसके बाद, सिस्टम इमेज चुनने के लिए कहा जाने पर, डाउनलोड की गई 16 केबी वाली सिस्टम इमेज चुनें. अगर यह अपने-आप नहीं दिखता है, तो अन्य इमेज टैब में जाकर, 16 केबी वाली सिस्टम इमेज को ढूंढा जा सकता है.

   

एम्युलेटर लॉन्च करना

Android Emulator और वर्चुअल डिवाइसों को सेट अप करने के बाद, टारगेट डिवाइस के मेन्यू से या कमांड लाइन से एम्युलेटर लॉन्च करें.

使用开发者选项在设备上启用 16 KB 模式

切换以 16KB 页面大小启动设备开发者选项，以在 16 KB 模式下启动设备。

在 Android 15 的 QPR 版本中，您可以使用某些设备上提供的开发者选项，以 16 KB 模式启动设备并执行设备端测试。在使用开发者选项之前，请依次前往设置 > 系统 > 软件更新，并应用所有可用的更新。

此开发者选项适用于以下设备：

• Pixel 8 和 Pixel 8 Pro（搭载 Android 15 QPR1 或更高版本）

• Pixel 8a（搭载 Android 15 QPR1 或更高版本）

• Pixel 9、9 Pro 和 9 Pro XL（搭载 Android 15 QPR2 或更高版本）

• Pixel 9a（搭载 Android 16 或更高版本）

16 केबी बैककॉम्पैट मोड

पेज साइज़ कंपैटबिलिटी मोड में चेतावनी

16 केबी कर्नेल पर चल रहे डिवाइस के लिए, 16 केबी बैककंपैट विकल्प उपलब्ध होता है. पैकेज मैनेजर, किसी ऐप्लिकेशन को 16 केबी वाले बैकवर्ड कंपैटबिलिटी मोड में तब चलाता है, जब ये शर्तें पूरी होती हैं:

• अगर ऐप्लिकेशन में 4 केबी के लोड सेगमेंट अलाइनमेंट वाली ईएलएफ़ फ़ाइलें (.so एक्सटेंशन वाली) हैं.
• अगर ज़िप किए गए APK में, कंप्रेस नहीं की गई ऐसी ELF फ़ाइलें हैं जो 4 केबी की हैं और ZIP अलाइन की गई हैं.

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

16 केबी वाले बैककंपैट मोड की मदद से, कुछ ऐप्लिकेशन काम कर सकते हैं. हालांकि, बेहतर तरीके से काम करने और स्टेबल रहने के लिए, ऐप्लिकेशन को 16 केबी के हिसाब से अलाइन किया जाना चाहिए.

ऐप्लिकेशन की जानकारी वाले पेज पर, ऐडवांस में जाकर, ऐप्लिकेशन को पेज साइज़ कंपैटबिलिटी मोड में चलाएं सेटिंग को टॉगल करें. इससे किसी ऐप्लिकेशन के लिए, 16 केबी बैककंपैट मोड को चालू या बंद किया जा सकता है. यह सेटिंग सिर्फ़ तब दिखती है, जब डिवाइस 16 केबी वाले पेज साइज़ पर चल रहा हो.

पेज साइज़ कंपैटबिलिटी मोड की सेटिंग

डिवाइस पर मौजूद हर ऐप्लिकेशन के लिए, 16 केबी वाले पेज साइज़ के साथ बैकवर्ड कंपैटबिलिटी की सुविधा को ज़बरदस्ती चालू करने के लिए:

adb shell setprop bionic.linker.16kb.app_compat.enabled true
adb shell setprop pm.16kb.app_compat.disabled false

डिवाइस पर मौजूद हर ऐप्लिकेशन के लिए, 16 केबी वाले पेज साइज़ के साथ काम करने की सुविधा को ज़बरदस्ती बंद करने के लिए:

adb shell setprop bionic.linker.16kb.app_compat.enabled false
adb shell setprop pm.16kb.app_compat.disabled true

Android 17 में, हर ऐप्लिकेशन के लिए 16 केबी बैककॉम्पैट को बंद किया जा सकता है. साथ ही, इससे किसी भी बाइनरी को तुरंत बंद किया जा सकता है जो काम नहीं करती:

    adb shell setprop bionic.linker.16kb.app_compat.enabled fatal
    adb shell setprop pm.16kb.app_compat.disabled true

किसी ऐप्लिकेशन के AndroidManifest.xml में, बैककंपैट मोड को चालू या बंद करने के लिए, android:pageSizeCompat प्रॉपर्टी को चालू या बंद पर सेट करें. इस प्रॉपर्टी को सेट करने पर, ऐप्लिकेशन लॉन्च होने पर बैककंपैट मोड की चेतावनियां नहीं दिखाएगा.