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

Android 过去仅支持 4 KB 内存页面大小， 优化了系统内存性能，以针对 Android 设备通常具备的功能。从 Android 15 开始，AOSP 支持 配置为使用 16 KB (16 KB) 页面大小的设备 设备）。如果您的应用使用任何 NDK 库，请直接使用 或者通过 SDK 间接创建，那么，您需要重新构建自己的应用 支持这些 16KB 设备。

随着设备制造商不断打造出 物理内存 (RAM)，许多此类设备都会采用 16KB（以及 页面大小以优化设备的性能。正在添加 支持 16 KB 页面大小的设备，可使您的应用在这些设备上运行 并有助于您的应用从相关的广告效果中获益 改进。如果不重新编译，应用可能无法在 16KB 设备上运行 在未来的 Android 版本中正式推出。

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

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

配置为 16 KB 页面的设备平均使用的内存会略多，但系统和应用性能也会有所提升：

  • 在系统面临内存压力时缩短应用启动时间：平均降低了 3.16%，对于我们测试过的一些应用而言，改进幅度更显著（提升幅度高达 30%）
  • 降低应用启动时的功耗：平均降低 4.56%
  • 相机启动速度更快：平均热启动速度加快 4.48%，冷启动速度平均加快 6.60%
  • 缩短了系统启动时间：平均缩短了 1.5%（约 0.8 秒）

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

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

如果您的应用使用任何原生代码，则您应重新构建支持 16 KB 设备的应用。如果您不确定自己的应用是否使用了原生代码，可以使用 APK 分析器来确定是否存在任何原生代码。

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

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

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

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

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

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

  1. Android Studio खोलें. इसके बाद, फ़ाइल > खोलें और कोई भी प्रोजेक्ट चुनें.

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

    APK लॉन्च करने के लिए, Studio Build के मेन्यू का विकल्प ऐनालाइज़र

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

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

    APK ऐनालाइज़र व्यू दिखाता है कि शेयर की गई ऑब्जेक्ट फ़ाइलें उपस्थित

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

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

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

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

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

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

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

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

ग्रूवी

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

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

Kotlin

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

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

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

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

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

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

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

एनडीके-बिल्ड

16 केबी ईएलएफ़ अलाइनमेंट को चालू करने के लिए अपना Android.mk अपडेट करें:

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

CMake

16 केबी ईएलएफ़ अलाइनमेंट को चालू करने के लिए अपना CMakeLists.txt अपडेट करें:

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

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

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

एनडीके-बिल्ड

आपके Application.mk में:

APP_SUPPORT_FLEXIBLE_PAGE_SIZES := true

ग्रूवी

अपनी build.gradle फ़ाइल में, तर्क सेट करें -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 "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
      }
    }
  }
}

Kotlin

अपनी build.gradle.kts फ़ाइल में, तर्क सेट करें -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

किसी पेज के साइज़ से जुड़े कोड इंस्टेंस की जांच करें

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

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

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

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

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

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

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

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

  1. Android 15 SDK टूल सेट अप करें.

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

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

    adb shell getconf PAGE_SIZE

    निर्देश से 16384 की वैल्यू मिलनी चाहिए.

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

    #!/bin/bash

# usage: alignment.sh path to search for *.so files

dir="$1"

RED="\e[31m"
GREEN="\e[32m"
ENDCOLOR="\e[0m"

matches="$(find $dir -name "*.so" -type f)"
IFS=$'\n'
for match in $matches; do
  res="$(objdump -p ${match} | grep LOAD | awk '{ print $NF }' | head -1)"
  if [[ $res =~ "2**14" ]] || [[ $res =~ "2**16" ]]; then
    echo -e "${match}: ${GREEN}ALIGNED${ENDCOLOR} ($res)"
  else
    echo -e "${match}: ${RED}UNALIGNED${ENDCOLOR} ($res)"
  fi
done

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

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

      unzip APK_NAME.apk -d /tmp/my_apk_out

    3. /tmp/my_apk_out में निकाली गई फ़ाइलों पर स्क्रिप्ट चलाएं डायरेक्ट्री:

      alignment.sh /tmp/my_apk_out | grep "arm64-v8a"

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

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

  5. यह पुष्टि करने के लिए कि आपका ऐप्लिकेशनzipalign 16 केबी- अलाइन किया गया है, जहां APK_NAME का नाम है आपके ऐप्लिकेशन की APK फ़ाइल:

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

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

16 केबी-आधारित, Android 15 वाली सिस्टम इमेज के साथ Android Emulator सेट अप करें

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

  1. 16 केबी पर आधारित, Android 15 के एम्युलेटर सिस्टम की इमेज, इमेज के साथ काम करती हैं Android Studio जेलीफ़िश | 2023.3.1 या इसके बाद. हालांकि, सर्वोत्तम Android 15 के बीटा वर्शन के साथ काम करने का बेहतरीन अनुभव पाने के लिए, Google Play Store पर मौजूद सबसे नया वर्शन Android Studio के वर्शन की झलक देखें.

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

  2. Android Studio में, टूल > पर क्लिक करें एसडीके मैनेजर.

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

    • Google API प्रयोगात्मक 16k पेज आकार ARM 64 v8a सिस्टम इमेज
    • Google API एक्सपेरिमेंटल 16k पेज साइज़ Intel x86_64 ऐटम सिस्टम इमेज

    Android में SDK Manager का इस्तेमाल करके, एम्युलेटर सिस्टम की 16 केबी की इमेज डाउनलोड करें स्टूडियो

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

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

    अन्य इमेज में 16 केबी की एम्युलेटर इमेज ढूंढें टैब

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

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

    kernel.parameters = androidboot.page_shift=14

  4. अपने बदलावों की पुष्टि करने के लिए, नीचे दिए गए निर्देश को चलाएं, जो कि 16384:

    adb shell getconf PAGE_SIZE
पीछे जाएं
64-बिट सहायता