รองรับหน้าขนาด 16 KB

Historically, Android has only supported 4 KB memory page sizes, which has optimized system memory performance for the average amount of total memory that Android devices have typically had. Beginning with Android 15, AOSP supports devices that are configured to use a page size of 16 KB (16 KB devices). If your app uses any NDK libraries, either directly or indirectly through an SDK, then you will need to rebuild your app for it to work on these 16 KB devices.

As device manufacturers continue to build devices with larger amounts of physical memory (RAM), many of these devices will adopt 16 KB (and eventually greater) page sizes to optimize the device's performance. Adding support for 16 KB page size devices enables your app to run on these devices and helps your app benefit from the associated performance improvements. Without recompiling, apps might not work on 16 KB devices when they are productionized in future Android releases.

To help you add support for your app, we've provided guidance on how to check if your app is impacted, how to rebuild your app (if applicable), and how to test your app in a 16 KB environment using emulators (including Android 15 system images for the Android Emulator).

ประโยชน์และประสิทธิภาพที่เพิ่มขึ้น

Devices configured with 16 KB page sizes use slightly more memory on average, but also gain various performance improvements for both the system and apps:

  • Lower app launch times while the system is under memory pressure: 3.16% lower on average, with more significant improvements (up to 30%) for some apps that we tested
  • Reduced power draw during app launch: 4.56% reduction on average
  • Faster camera launch: 4.48% faster hot starts on average, and 6.60% faster cold starts on average
  • Improved system boot time: improved by 8% (approximately 950 milliseconds) on average

These improvements are based on our initial testing, and results on actual devices will likely differ. We'll provide additional analysis of potential gains for apps as we continue our testing.

ตรวจสอบว่าแอปของคุณได้รับผลกระทบหรือไม่

If your app uses any native code, then you should rebuild your app with support for 16 KB devices. If you are unsure if your app uses native code, you can use the APK Analyzer to identify whether any native code is present and then check the alignment of ELF segments for any shared libraries that you find.

If your app only uses code written in the Java programming language or in Kotlin, including all libraries or SDKs, then your app already supports 16 KB devices. Nevertheless, we recommend that you test your app in a 16 KB environment to verify that there are no unexpected regressions in app behavior.

แอปของคุณใช้โค้ดเนทีฟหรือไม่

แอปของคุณใช้โค้ดเนทีฟในกรณีต่อไปนี้

  • แอปของคุณใช้โค้ด C/C++ (เนทีฟ) หากแอปใช้ Android IDE แสดงว่าแอปใช้โค้ดเนทีฟ
  • แอปของคุณลิงก์กับไลบรารีหรือทรัพยากร Dependency ของบุคคลที่สาม (เช่น SDK) ที่ใช้ไลบรารีหรือทรัพยากร Dependency ดังกล่าว
  • แอปของคุณสร้างขึ้นโดยเครื่องมือสร้างแอปของบุคคลที่สามที่ใช้ไลบรารีเนทีฟในอุปกรณ์

ระบุไลบรารีแบบเนทีฟโดยใช้เครื่องมือวิเคราะห์ APK

เครื่องมือวิเคราะห์ APK เป็นเครื่องมือที่ช่วยให้คุณประเมินแง่มุมต่างๆ ของ APK ที่สร้างขึ้น หากต้องการตรวจสอบว่าแอปของคุณใช้โค้ดเนทีฟหรือไลบรารี ให้ทำตามขั้นตอนต่อไปนี้

  1. เปิด Android Studio แล้วคลิกไฟล์ > เปิด แล้วเลือกโปรเจ็กต์ที่ต้องการ

  2. จากแถบเมนู ให้คลิกสร้าง > วิเคราะห์ APK...

    ตัวเลือกเมนู "สร้าง" ของ Studio เพื่อเปิด APK Analyzer

  3. เลือก APK ที่ต้องการวิเคราะห์

  4. มองหาในโฟลเดอร์ lib ซึ่งโฮสต์ไฟล์ออบเจ็กต์ที่แชร์ (.so) หากมี หากมีไฟล์ออบเจ็กต์ที่แชร์อยู่ แอปของคุณจะใช้โค้ดเนทีฟ หากไม่มีไฟล์ออบเจ็กต์ที่แชร์หรือไม่มีโฟลเดอร์ lib แสดงว่าแอปไม่ได้ใช้โค้ดเนทีฟ

    มุมมองตัววิเคราะห์ APK ที่แสดงว่ามีไฟล์ออบเจ็กต์ที่แชร์อยู่

ตรวจสอบการจัดแนวของกลุ่ม ELF สําหรับไลบรารีที่ใช้ร่วมกัน

สำหรับไลบรารีที่ใช้ร่วมกัน ให้ตรวจสอบว่ามีการจัดแนว ELF ของไลบรารีที่ใช้ร่วมกันอย่างถูกต้องโดยใช้การจัดแนว ELF 16 KB หากพัฒนาบน Linux หรือ macOS คุณสามารถใช้สคริปต์ check_elf_alignment.sh ตามที่อธิบายไว้ในส่วนต่อไปนี้ นอกจากนี้ คุณยังใช้เครื่องมือบรรทัดคำสั่งโดยตรงได้ด้วย

ใช้สคริปต์ check_elf_alignment.sh (Linux หรือ macOS)

ทำตามขั้นตอนต่อไปนี้เพื่อตรวจสอบการจัดตำแหน่งของกลุ่ม ELF โดยใช้สคริปต์ check_elf_alignment.sh

  1. บันทึกสคริปต์ check_elf_alignment.sh ลงในไฟล์

  2. เรียกใช้สคริปต์ในไฟล์ APK ของแอปโดยทำดังนี้

    check_elf_alignment.sh APK_NAME.apk

    สคริปต์จะแสดงผลเป็น ALIGNED หรือ UNALIGNED สำหรับarm64-v8a ไลบรารีที่ใช้ร่วมกันทั้งหมด

  3. หากไลบรารีที่ใช้ร่วมกัน arm64-v8a หรือ x86_64 เป็น UNALIGNED คุณจะต้องอัปเดตการแพ็กเกจสำหรับไลบรารีเหล่านั้น จากนั้นคอมไพล์แอปอีกครั้งและทดสอบอีกครั้งโดยทำตามขั้นตอนในส่วนนี้

ใช้เครื่องมือบรรทัดคำสั่งโดยตรง

ทำตามขั้นตอนต่อไปนี้เพื่อตรวจสอบการจัดแนวของกลุ่ม ELF โดยใช้เครื่องมือบรรทัดคำสั่งโดยตรง

  1. ตรวจสอบว่าได้ติดตั้งทั้งเครื่องมือสร้าง Android SDK เวอร์ชัน 35.0.0 ขึ้นไปและ Android NDK โดยใช้เครื่องมือจัดการ SDK ใน 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 ให้ตรวจสอบเนื้อหาของไดเรกทอรี lib สำหรับไฟล์ออบเจ็กต์ที่แชร์ (.so) ไฟล์เหล่านี้คือไฟล์ออบเจ็กต์ที่แชร์เดียวกันกับที่คุณเห็นขณะระบุไฟล์ไลบรารีแบบเนทีฟโดยใช้ 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. ถัดไป ให้เรียกใช้เครื่องมือบรรทัดคำสั่ง zipalign ในไฟล์ APK ของแอป

    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 KB

หากต้องการรองรับอุปกรณ์ขนาด 16 KB แอปที่ใช้โค้ดเนทีฟควรทำตามขั้นตอนที่ระบุไว้ในส่วนต่อไปนี้ หากคุณอัปเดตเป็น AGP เวอร์ชัน 8.5.1 ขึ้นไปและ NDK เวอร์ชัน r28 ขึ้นไป และใช้ทรัพยากร Dependency ที่คอมไพล์ล่วงหน้าซึ่งเข้ากันได้กับ 16 KB แอปจะเข้ากันได้กับ 16 KB โดยค่าเริ่มต้น

อัปเดตการบรรจุของไลบรารีที่ใช้ร่วมกัน

เราขอแนะนำให้อัปเกรดเป็น AGP เวอร์ชัน 8.5.1 ขึ้นไปและใช้ไฟล์ที่แชร์แบบไม่บีบอัด

AGP เวอร์ชัน 8.5.1 ขึ้นไป

อุปกรณ์ขนาด 16 KB กำหนดให้แอปที่มาพร้อมกับไลบรารีที่ใช้ร่วมกันแบบไม่บีบอัดต้องจัดแนวให้อยู่ตรงขอบเขตขนาด 16 KB ที่สอดคล้องกับไฟล์ ZIP โดยคุณต้องอัปเกรดเป็น Android Gradle Plugin (AGP) เวอร์ชัน 8.5.1 ขึ้นไป ดูรายละเอียดเกี่ยวกับกระบวนการอัปเกรดได้ที่ส่วนAndroid ผู้ช่วยอัปเกรดปลั๊กอิน Gradle

AGP เวอร์ชัน 8.5 หรือต่ำกว่า

หากอัปเกรด AGP เป็นเวอร์ชัน 8.5.1 ขึ้นไปไม่ได้ คุณก็เปลี่ยนไปใช้ไลบรารีที่ใช้ร่วมกันแบบบีบอัดได้ อัปเดตการกำหนดค่า Gradle ให้ Gradle บีบอัดไลบรารีที่ใช้ร่วมกันเมื่อแพ็กเกจแอปเพื่อหลีกเลี่ยงปัญหาการติดตั้งแอปด้วยไลบรารีที่ใช้ร่วมกันซึ่งไม่ได้จัดแนว

Groovy

ในไฟล์ build.gradle ให้เพิ่มตัวเลือกต่อไปนี้

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

Kotlin

ในไฟล์ build.gradle.kts ให้เพิ่มตัวเลือกต่อไปนี้

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

คอมไพล์แอปโดยใช้การจัดแนว ELF ขนาด 16 KB

อุปกรณ์ 16 KB กำหนดให้ต้องจัดแนวกลุ่ม ELF ของไลบรารีที่ใช้ร่วมกันอย่างถูกต้องโดยใช้การจัดแนว ELF 16 KB เพื่อให้แอปทำงานได้

หากต้องการคอมไพล์แอปโดยใช้การจัดแนว ELF ขนาด 16 KB ให้ทำตามขั้นตอนในส่วนใดส่วนหนึ่งต่อไปนี้ โดยขึ้นอยู่กับเวอร์ชันของ Android NDK ที่คุณใช้

Android NDK r28 ขึ้นไป

NDK เวอร์ชัน r28 ขึ้นไปจะคอมไพล์แบบจัดแนว 16 KB โดยค่าเริ่มต้น

Android NDK r27

หากต้องการรองรับการคอมไพล์ไลบรารีที่แชร์แบบ 16 KB ที่สอดคล้องกับ Android NDK เวอร์ชัน r27 ขึ้นไป คุณต้องอัปเดต ndk-build, build.gradle, build.gradle.kts หรือ Flag ของ linker ดังนี้

ndk-build

ใน Application.mk

APP_SUPPORT_FLEXIBLE_PAGE_SIZES := true

Groovy

ในไฟล์ 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")
      }
    }
  }
}

ระบบบิลด์อื่นๆ

ระบุ Flag ของ linker ต่อไปนี้

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

Android NDK r26 และต่ำกว่า

หากต้องการรองรับการคอมไพล์ไลบรารีที่ใช้ร่วมกันแบบ 16 KB ที่สอดคล้องกับ Android NDK เวอร์ชัน r26 หรือต่ำกว่า คุณต้องอัปเดตการกำหนดค่า ndk-build หรือ cmake ดังนี้

ndk-build

อัปเดต Android.mk เพื่อเปิดใช้การจัดแนว ELF ขนาด 16 KB โดยทำดังนี้

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

CMake

อัปเดต CMakeLists.txt เพื่อเปิดใช้การจัดแนว ELF ขนาด 16 KB โดยทำดังนี้

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

ตรวจสอบอินสแตนซ์โค้ดที่อ้างอิงขนาดหน้าเว็บที่เจาะจง

แม้ว่าแอปจะปรับขนาดเป็น 16 KB แต่แอปก็อาจพบข้อผิดพลาดได้หากตำแหน่งในโค้ดของคุณถือว่าอุปกรณ์ใช้ขนาดหน้าเว็บที่เจาะจง หากต้องการหลีกเลี่ยงปัญหานี้ ให้ทําตามขั้นตอนต่อไปนี้

  1. นําการพึ่งพาแบบฮาร์ดโค้ดที่อ้างอิงค่าคงที่ PAGE_SIZE หรืออินสแตนซ์ในตรรกะโค้ดที่ถือว่าขนาดหน้าเว็บของอุปกรณ์คือ 4 KB (4096) ออก

    ให้ใช้ getpagesize() หรือ sysconf(_SC_PAGESIZE) แทน

  2. มองหาการใช้ mmap() และ API อื่นๆ ที่ต้องอาศัยอาร์กิวเมนต์ที่สอดคล้องกับหน้าเว็บ แล้วแทนที่ด้วยทางเลือกอื่นๆ ตามความจําเป็น

ในบางกรณี หากแอปใช้ PAGE_SIZE เป็นค่าที่สะดวกซึ่งไม่ได้เชื่อมโยงกับขนาดหน้าเว็บพื้นฐาน การดำเนินการนี้จะไม่ทําให้แอปขัดข้องเมื่อใช้ในโหมด 16 KB อย่างไรก็ตาม หากส่งค่านี้ไปยังเคอร์เนลด้วย mmap โดยไม่มี MAP_FIXED เคอร์เนลจะยังคงใช้ทั้งหน้า ซึ่งจะสิ้นเปลืองหน่วยความจำไปบ้าง ด้วยเหตุนี้ PAGE_SIZE จึงไม่มีการกำหนดค่าเมื่อเปิดใช้โหมด 16 KB ใน NDK r27 ขึ้นไป

หากแอปใช้ PAGE_SIZE ในลักษณะนี้และไม่เคยส่งค่านี้ไปยังเคอร์เนลโดยตรง ให้สร้างตัวแปรใหม่ที่มีชื่อใหม่แทนการใช้ PAGE_SIZE เพื่อระบุว่าตัวแปรดังกล่าวมีไว้เพื่อวัตถุประสงค์อื่นและไม่ได้แสดงถึงหน้าหน่วยความจำจริง

ตรวจสอบ SDK สำหรับการรองรับ 16 KB

SDK จํานวนมากเข้ากันได้กับหน้าขนาด 16 KB โดยเฉพาะอย่างยิ่งหากคุณสร้าง SDK เองหรือใช้ SDK ที่คอมไพล์ไว้ล่วงหน้าล่าสุด อย่างไรก็ตาม เนื่องจาก SDK ที่คอมไพล์ไว้ล่วงหน้าหรือ SDK บางเวอร์ชันใช้ร่วมกับ 16 KB ไม่ได้ คุณจึงควรตรวจสอบเว็บไซต์ของผู้ให้บริการ SDK แต่ละรายเพื่อดูว่าควรใช้เวอร์ชันใดกับ 16 KB

ทดสอบแอปในสภาพแวดล้อมขนาด 16 KB

หลังจากสร้างแอปที่รองรับอุปกรณ์ขนาด 16 KB แล้ว คุณควรทดสอบแอปในสภาพแวดล้อมขนาด 16 KB เพื่อดูว่าแอปมีอาการถดถอยหรือไม่ โดยคุณต้องทำตามขั้นตอนต่อไปนี้:

  1. ตั้งค่า SDK ของ Android 15

  2. ตั้งค่าสภาพแวดล้อมการทดสอบอย่างใดอย่างหนึ่งต่อไปนี้

  3. เริ่มอุปกรณ์ทดสอบ แล้วเรียกใช้คําสั่งต่อไปนี้เพื่อยืนยันว่าอุปกรณ์ใช้สภาพแวดล้อม 16 KB

    adb shell getconf PAGE_SIZE

    คำสั่งควรแสดงผลค่า 16384

  4. เรียกใช้คำสั่ง zipalign ต่อไปนี้เพื่อยืนยันว่าแอปของคุณจัดแนวเป็น 16 KB โดยที่ APK_NAME คือชื่อไฟล์ APK ของแอป

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

  5. ทดสอบแอปอย่างละเอียด โดยเน้นที่ส่วนต่างๆ ที่อาจได้รับผลกระทบจากการเปลี่ยนอินสแตนซ์โค้ดที่อ้างอิงขนาดหน้าเว็บที่เฉพาะเจาะจง

ตั้งค่าโปรแกรมจำลอง Android ด้วยอิมเมจระบบ Android 15 ขนาด 16 KB

หากต้องการตั้งค่าสภาพแวดล้อม 16 KB โดยใช้ Android Emulator ให้ทำตามขั้นตอนต่อไปนี้

  1. รูปภาพระบบที่ใช้โปรแกรมจำลอง Android 15 ขนาด 16 KB เข้ากันได้กับ Android Studio Jellyfish | 2023.3.1 ขึ้นไป อย่างไรก็ตาม หากต้องการประสบการณ์การใช้งาน Android 15 เบต้าที่ดีที่สุด ให้ดาวน์โหลด Android Studio เวอร์ชันตัวอย่างล่าสุด

    โปรดทราบว่าคุณสามารถติดตั้ง Android Studio เวอร์ชันที่มีอยู่ต่อไปได้ เนื่องจากคุณสามารถติดตั้งหลายเวอร์ชันควบคู่กันได้

  2. ใน Android Studio ให้คลิกเครื่องมือ > เครื่องมือจัดการ SDK

  3. ในแท็บแพลตฟอร์ม SDK ให้เลือกแสดงรายละเอียดแพ็กเกจ จากนั้นขยายส่วน Android VanillaIceCream Preview แล้วเลือกภาพระบบโปรแกรมจำลองต่อไปนี้อย่างน้อย 1 ภาพ โดยขึ้นอยู่กับอุปกรณ์เสมือนจริงที่คุณต้องการสร้าง

    • อิมเมจระบบ ARM 64 v8a ขนาดหน้า 16,000 รายการเวอร์ชันทดลองของ Google APIs
    • รูปภาพระบบ Intel x86_64 Atom ขนาดหน้า 16,000 รายการของ Google APIs รุ่นทดลอง

    ดาวน์โหลดภาพระบบโปรแกรมจำลองขนาด 16 KB โดยใช้เครื่องมือจัดการ SDK ใน Android Studio

  4. คลิกใช้ > ตกลงเพื่อดาวน์โหลดรูปภาพระบบที่คุณเลือก

  5. ทำตามขั้นตอนเพื่อตั้งค่าอุปกรณ์เสมือนสำหรับ Android 15 และเมื่อระบบแจ้งให้เลือกอิมเมจระบบ ให้เลือกอิมเมจระบบขนาด 16 KB ที่คุณดาวน์โหลด หากระบบไม่แนะนำโดยอัตโนมัติ คุณจะค้นหารูปภาพระบบขนาด 16 KB ได้ในแท็บรูปภาพอื่นๆ

    ค้นหารูปภาพโปรแกรมจำลองขนาด 16 KB ในแท็บรูปภาพอื่นๆ

  1. ในเครื่องมือจัดการอุปกรณ์ ให้คลิกจุด 3 จุดข้างรูปภาพขนาด 16 KB แล้วคลิกแสดงในดิสก์
  2. ค้นหาไฟล์ config.ini ในโฟลเดอร์นี้

  3. เพิ่มบรรทัดต่อไปนี้ลงในไฟล์ config.ini แล้วบันทึกการเปลี่ยนแปลง

    kernel.parameters = androidboot.page_shift=14

  4. หากต้องการยืนยันการเปลี่ยนแปลง ให้เรียกใช้คําสั่งต่อไปนี้ ซึ่งควรแสดงผลเป็น 16384

    adb shell getconf PAGE_SIZE

Enable 16 KB mode on a device using developer options

Toggle the Boot with 16KB page size developer option to boot a device into 16 KB mode.

Starting with Android 15 QPR1, you can use the developer option that's available on certain devices to boot the device in 16 KB mode and perform on-device testing.

This developer option is available on the following devices:

  • Pixel 8 and 8 Pro (with Android 15 QPR1 Beta 1 or higher)
  • Pixel 8a (with Android 15 QPR1 Beta 2 or higher)
ก่อนหน้า
การรองรับ 64 บิต