16 केबी वाले पेज साइज़ का इस्तेमाल करें

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

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

ज़्यादा जानें →

从历史上看，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 环境中测试应用。

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

配置为使用 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 Analyzer एक ऐसा टूल है जिसकी मदद से, बनाए गए APK के अलग-अलग पहलुओं का आकलन किया जा सकता है. यह देखने के लिए कि आपका ऐप्लिकेशन नेटिव कोड का इस्तेमाल करता है या नहीं (इससे कोई फ़र्क़ नहीं पड़ता कि यह 16 केबी के साथ काम करता है या नहीं):

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

2. मेन्यू बार में जाकर, बनाएं > APK का विश्लेषण करें... पर क्लिक करें

   

3. वह APK चुनें जिसकी आपको जांच करनी है.

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

   

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

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

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 NDK, दोनों को Android Studio में SDK Manager या 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 Analyzer का इस्तेमाल करके नेटिव लाइब्रेरी की पहचान करने के दौरान दिखती हैं. शेयर की गई हर ऑब्जेक्ट फ़ाइल पर, यह कमांड चलाएं:

   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 फ़ाइल का नाम है. अगर सभी शेयर की गई लाइब्रेरी सही तरीके से अलाइन की गई हैं, तो आउटपुट की आखिरी लाइन में "पुष्टि हो गई" लिखा होगा.

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

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

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

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

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

हमारा सुझाव है कि आप AGP को 8.5.1 या इसके बाद के वर्शन पर अपग्रेड करें. साथ ही, बिना कंप्रेस की गई शेयर की गई लाइब्रेरी का इस्तेमाल करें.

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

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

AGP का 8.5 या इससे पहले का वर्शन

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

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

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

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

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

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

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

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

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

Android NDK r27

Android NDK के r27 और इससे ऊपर के वर्शन के साथ, 16 केबी अलाइन की गई शेयर की गई लाइब्रेरी को कंपाइल करने के लिए, आपको अपने ndk-build, build.gradle, build.gradle.kts या लिंकर फ़्लैग को इस तरह अपडेट करना होगा:

APP_SUPPORT_FLEXIBLE_PAGE_SIZES := true

android {
  ...
  defaultConfig {
    ...
    // This block is different from the one you use to link Gradle
    // to your CMake or ndk-build script.
    externalNativeBuild {
      // For ndk-build, instead use the ndkBuild block.
      cmake {
        // Passes optional arguments to CMake.
        arguments "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
      }
    }
  }
}

android {
  ...
  defaultConfig {
    ...
    // This block is different from the one you use to link Gradle
    // to your CMake or ndk-build script.
    externalNativeBuild {
      // For ndk-build, instead use the ndkBuild block.
      cmake {
        // Passes optional arguments to CMake.
        arguments += listOf("-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON")
      }
    }
  }
}

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

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

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

Android NDK के r26 या इससे पुराने वर्शन के साथ, 16 केबी अलाइनमेंट वाली शेयर की गई लाइब्रेरी को कंपाइल करने के लिए, आपको ndk-build या cmake कॉन्फ़िगरेशन को इस तरह अपडेट करना होगा:

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

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

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

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

NDK r26 और इससे पहले के वर्शन के लिए बताए गए चरण के अलावा, अगर NDK r22 या इससे पहले के वर्शन का इस्तेमाल किया जा रहा है, तो आपको common-page-size=16384 सेट करना होगा. GNU ld और LLVM lld लिंक करने वाले प्रोग्राम के पुराने वर्शन में मौजूद गड़बड़ियों की वजह से, common-page-size=16384 सेटिंग ज़रूरी है. पेज के साइज़ को कम करने का यह तरीका सिर्फ़ तब काम करता है, जब ईएलएफ़ में .relro_padding सेक्शन भी मौजूद हो (LLD 18 और इसके बाद के वर्शन).

Android NDK के r22 या इससे पहले के वर्शन के साथ, 16 केबी के साथ काम करने वाली शेयर की जा सकने वाली लाइब्रेरी कंपाइल करने के लिए, अपने ndk-build या cmake कॉन्फ़िगरेशन को इस तरह अपडेट करें:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   adb shell getconf PAGE_SIZE
   

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

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

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

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

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

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

1. 16 केबी पर आधारित, Android 15 के एम्युलेटर सिस्टम इमेज, Android Studio Jellyfish | 2023.3.1 या इसके बाद के वर्शन के साथ काम करती हैं. हालांकि, 16 केबी वाले डिवाइसों के साथ काम करने का सबसे अच्छा अनुभव पाने के लिए, Android Studio Ladybug | 2024.2.1 या इसके बाद के वर्शन का इस्तेमाल करें.

   हम नई सुविधाओं पर हमेशा काम करते रहते हैं. इसलिए, जब Android Studio के नए वर्शन या प्रीव्यू वर्शन उपलब्ध हों, तब उन्हें डाउनलोड करें.

   याद रखें कि Android Studio के मौजूदा वर्शन को इंस्टॉल रखा जा सकता है, क्योंकि एक साथ कई वर्शन इंस्टॉल किए जा सकते हैं.

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

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

   • Google APIs Experimental 16 केबी पेज साइज़ ARM 64 v8a सिस्टम इमेज
   • Google APIs Experimental 16 KB Page Size Intel x86_64 Atom System Image

   

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

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

   

कुछ एम्युलेटर वर्शन और सिस्टम इमेज के लिए अतिरिक्त चरण

Android Emulator के 35.1.5 से 35.1.20 वर्शन के लिए, और SDK Manager में उपलब्ध Android 15.0 16 केबी पेज साइज़ वाली सिस्टम इमेज के चौथे वर्शन से पहले, x86_64 सिस्टम पर 16 केबी वाले एनवायरमेंट को सिम्युलेट करने के लिए, आपको ये चरण भी पूरे करने होंगे. ये चरण, 35.1.21 और Android 15.0 16 केबी पेज साइज़ सिस्टम इमेज के चौथे या उसके बाद के वर्शन के लिए ज़रूरी नहीं हैं.

1. डिवाइस मैनेजर में, 16 केबी वाली इमेज के बगल में मौजूद तीन बिंदुओं पर क्लिक करें. इसके बाद, डिस्क पर दिखाएं पर क्लिक करें.
2. इस फ़ोल्डर में, config.ini फ़ाइल ढूंढें.

3. config.ini फ़ाइल में यह लाइन जोड़ें और अपने बदलाव सेव करें:

   kernel.parameters = androidboot.page_shift=14
   

4. अपने बदलावों की पुष्टि करने के लिए, यह निर्देश चलाएं. इससे 16384 दिखना चाहिए:

   adb shell getconf PAGE_SIZE
   

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

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

डेवलपर के लिए सेटिंग और टूल का इस्तेमाल करके, किसी डिवाइस पर 16 केबी मोड चालू करना

डिवाइस को 16 केबी मोड में बूट करने के लिए, डेवलपर विकल्प में जाकर 16 केबी पेज साइज़ के साथ बूट करें को टॉगल करें.

Android 15 QPR1 से, डेवलपर विकल्प का इस्तेमाल किया जा सकता है. यह विकल्प, कुछ डिवाइसों पर उपलब्ध होता है. इसकी मदद से, डिवाइस को 16 केबी मोड में बूट किया जा सकता है और डिवाइस पर टेस्टिंग की जा सकती है. डेवलपर के लिए सेटिंग और टूल का इस्तेमाल करने से पहले, सेटिंग > सिस्टम > सॉफ़्टवेयर अपडेट पर जाएं और उपलब्ध अपडेट लागू करें.

डेवलपर के लिए उपलब्ध यह विकल्प, इन डिवाइसों पर उपलब्ध है:

• Pixel 8 और 8 Pro (Android 15 QPR1 या उसके बाद के वर्शन के साथ)

• Pixel 8a (Android 15 QPR1 या इसके बाद के वर्शन के साथ)

• Pixel 9, 9 Pro, और 9 Pro XL (Android 15 QPR2 Beta 2 या इसके बाद के वर्शन के साथ)

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

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

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

• अगर ऐप्लिकेशन में 4 केबी के LOAD सेगमेंट अलाइनमेंट वाली ELF फ़ाइलें (.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

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

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

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

इस बारे में ज़्यादा जानने के लिए, यह ब्लॉग पोस्ट देखें.