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

ข้อกำหนดความเข้ากันได้ของ Google Play ขนาด 16 KB

ตั้งแต่วันที่ 1 พฤศจิกายน 2025 เป็นต้นไป แอปใหม่ทั้งหมดและการอัปเดตแอปที่มีอยู่ซึ่งส่งไปยัง Google Play และกำหนดเป้าหมายเป็นอุปกรณ์ Android 15 ขึ้นไปต้องรองรับหน้าขนาด 16 KB ในอุปกรณ์ 64 บิต

อ่านเพิ่มเติม →

ที่ผ่านมา Android รองรับหน้าหน่วยความจำขนาด 4 KB เท่านั้น ซึ่งมี เพิ่มประสิทธิภาพหน่วยความจำของระบบสำหรับปริมาณหน่วยความจำทั้งหมดโดยเฉลี่ย อุปกรณ์ Android ที่มักมีในระบบ AOSP รองรับตั้งแต่ Android 15 เป็นต้นไป อุปกรณ์ที่มีการกำหนดค่าให้ใช้หน้าขนาด 16 KB (16 KB) อุปกรณ์) หากแอปใช้ไลบรารี NDK โดยตรงอย่างใดอย่างหนึ่ง หรือโดยอ้อมผ่าน SDK คุณจะต้องสร้างแอปใหม่เพื่อ ใช้ได้กับอุปกรณ์ขนาด 16 KB เหล่านี้

เนื่องจากผู้ผลิตอุปกรณ์ยังคงผลิตอุปกรณ์จำนวนมาก หน่วยความจำกายภาพ (RAM) อุปกรณ์จำนวนมากจะใช้ 16 KB (และ และใหญ่ขึ้น) เพื่อเพิ่มประสิทธิภาพของอุปกรณ์ กำลังเพิ่ม การรองรับอุปกรณ์ขนาดหน้า 16 KB จะช่วยให้แอปของคุณทํางานบนอุปกรณ์เหล่านี้ได้ อุปกรณ์และช่วยให้แอปของคุณได้รับประโยชน์จากประสิทธิภาพที่เกี่ยวข้อง เพิ่มขึ้น หากไม่ทำการคอมไพล์ซ้ำ แอปอาจไม่ทำงานในอุปกรณ์ขนาด 16 KB เมื่อเวอร์ชันที่ใช้งานจริงใน Android รุ่นต่อๆ ไป

เราได้ให้คำแนะนำเกี่ยวกับวิธีตรวจสอบ หากแอปได้รับผลกระทบ วิธีการ สร้างแอปอีกครั้ง (หากมี) และวิธีทดสอบแอปใน สภาพแวดล้อมขนาด 16 KB โดยใช้เครื่องมือจำลอง (รวมถึง Android 15 อิมเมจระบบสำหรับ Android Emulator)

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

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

• เวลาเปิดแอปลดลงขณะที่ระบบมีภาระเกี่ยวกับหน่วยความจำ: ลดลงโดยเฉลี่ย 3.16% โดยการปรับปรุงที่เห็นได้ชัดมากขึ้น (สูงสุด 30%) สำหรับบางแอปที่เราทดสอบ
• การลดพลังงานในระหว่างการเปิดแอป: ลดลง 4.56% โดยเฉลี่ย
• การเปิดตัวกล้องเร็วขึ้น: Hot Start เร็วขึ้น 4.48% โดยเฉลี่ย และ Cold Start เร็วขึ้น 6.60% โดยเฉลี่ย
• ปรับปรุงเวลาในการบูตระบบ: เร็วขึ้น 8% (ประมาณ 950 มิลลิวินาที) โดยเฉลี่ย

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

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

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

หากแอปใช้เฉพาะโค้ดที่เขียนด้วยภาษาโปรแกรม Java หรือ Kotlin รวมถึงไลบรารีหรือ SDK ทั้งหมด แอปของคุณรองรับอุปกรณ์ขนาด 16 KB อยู่แล้ว อย่างไรก็ตาม เราขอแนะนำให้คุณทดสอบแอปในสภาพแวดล้อม 16 KB เพื่อยืนยันว่าไม่มีการแสดงลักษณะการทำงานที่แย่ลงอย่างฉับพลันของแอป

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

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

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

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

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

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

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

   

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

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

   

ตรวจสอบการจัดตำแหน่งของกลุ่ม 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

1. อัปเดตการบรรจุของไลบรารีที่ใช้ร่วมกัน
2. คอมไพล์แอปโดยใช้การจัดวาง ELF ขนาด 16 KB
3. แก้ไขโค้ดและแก้ปัญหารันไทม์
4. ตรวจสอบ SDK สำหรับการรองรับขนาด 16 KB

เคล็ดลับ: หากคุณอัปเดตเครื่องมือเป็นเวอร์ชันล่าสุด (AGP เวอร์ชัน 8.5.1 ขึ้นไปและ NDK เวอร์ชัน r28 ขึ้นไป) และใช้ทรัพยากร 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.3 ถึง 8.5 แอปจะได้รับการจัดแนวขนาด 16 KB โดยค่าเริ่มต้น อย่างไรก็ตาม 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
      }
  }
}

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

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

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

สำหรับนักพัฒนาเกม หากเกมของคุณทำงานบนเกมเอนจิน Unity โปรดดูคู่มือ Unity หากเกมของคุณทำงานบนเครื่องมือสร้างเกม Unreal ให้ดูคู่มือ Unreal สำหรับเครื่องมือสร้างเกมแบบเนทีฟ ให้ทำตามคำแนะนำนี้

หมายเหตุ: หากแอปไม่แตกไฟล์ไลบรารีแบบเนทีฟไปยังระบบไฟล์ (extractNativeLibs ตั้งค่าเป็น false) คุณอาจเห็นว่าขนาดไบนารีของแอปเพิ่มขึ้นเล็กน้อยหลังจากคอมไพล์โดยใช้การจัดแนว ELF 16 KB การเพิ่มประสิทธิภาพเครื่องมือจัดการแพ็กเกจใน Android 15 จะช่วยลดต้นทุนรันไทม์ที่เพิ่มขึ้นนี้

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

สำคัญ: หากแอปใช้ไลบรารีที่แชร์ซึ่งสร้างไว้ล่วงหน้า คุณต้องคอมไพล์ไลบรารีเหล่านั้นอีกครั้งด้วยวิธีเดียวกัน และนำเข้าไลบรารีที่จัดวางขนาด 16 KB กลับไปยังแอป

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")

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

นอกเหนือจากขั้นตอนที่ระบุไว้สำหรับ NDK r26 และต่ำกว่าแล้ว คุณต้องตั้งค่า common-page-size=16384 หากคุณใช้ NDK r22 หรือต่ำกว่า การตั้งค่า common-page-size=16384เป็นสิ่งจําเป็นเนื่องจากข้อบกพร่องในโปรแกรมลิงก์ GNU ld และ LLVM lld เวอร์ชันเก่า อย่างไรก็ตาม เราขอแนะนําอย่างยิ่งให้คุณอัปเดตเครื่องมือเป็นเวอร์ชันล่าสุดเพื่อหลีกเลี่ยงข้อบกพร่องเหล่านี้โดยสิ้นเชิง

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

ndk-build

อัปเดต Android.mk เพื่อสร้าง ELF ที่เข้ากันได้กับขนาด 16 KB โดยทำดังนี้

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

CMake

อัปเดต CMakeLists.txt เพื่อสร้าง ELF ที่เข้ากันได้กับขนาด 16 KB โดยทำดังนี้

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")

สำคัญ: แม้ว่าแอปจะลิงก์กับไลบรารีมาตรฐาน C++ (libc++_shared.so) จาก NDK r26 และต่ำกว่าแบบไดนามิก ซึ่งบางรายการไม่ได้จัดแนวขนาด 16 KB คุณก็ควรอัปเดตการจัดแนวของไลบรารีอื่นๆ ทั้งหมดที่นี่ และควรอัปเดตโค้ดเพื่อหลีกเลี่ยงการพึ่งพา PAGE_SIZE หากต้องการทดสอบ NDK เวอร์ชันที่ต่ำกว่าเหล่านั้นในอุปกรณ์ 16 KB คุณสามารถใช้งานรุ่น Canary ของ LTS NDK เวอร์ชัน r23 และ r25 ใน Android CI ที่มีไลบรารี libc++_shared.so ที่ปรับขนาดเป็น 16 KB อย่างไรก็ตาม เราขอแนะนำให้เปลี่ยนไปใช้ Android NDK r27 ขึ้นไปเพื่ออัปเดตเป็นไลบรารีมาตรฐาน C++ เวอร์ชัน 16 KB ที่สอดคล้องกับ ELF ไม่เช่นนั้นแอปของคุณจะติดตั้งในอุปกรณ์ขนาด 16 KB ไม่ได้ในปัจจุบัน

หากย้ายไปใช้ Android NDK เวอร์ชันใหม่ไม่ได้ คุณอาจอัปเดตแอปให้คอมไพล์ไลบรารีมาตรฐาน C++ แบบคงที่ลงในไลบรารีที่แชร์ได้ โปรดดูรายละเอียดเกี่ยวกับการลิงก์แบบคงที่กับไลบรารีมาตรฐาน C++ ในส่วนการรองรับไลบรารี C++ และอย่าลืมอ่านส่วนข้อควรพิจารณาที่สำคัญ

แก้ไขโค้ดและแก้ปัญหารันไทม์

แม้ว่าแอปจะปรับขนาดเป็น 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. ตั้งค่าสภาพแวดล้อมการทดสอบอย่างใดอย่างหนึ่งต่อไปนี้

   • ตั้งค่าโปรแกรมจำลอง Android ด้วยระบบภาพ Android 15 แบบ 16 KB
   • เปิดใช้โหมด 16 KB ในอุปกรณ์โดยใช้ตัวเลือกสำหรับนักพัฒนาแอป
   • ใช้ Cuttlefish กับหน้าขนาด 16 KB ใน ARM64
   • จำลอง Cuttlefish ด้วยขนาดหน้า 16 KB ใน x86-64

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

สำคัญ: ปัญหาที่ทราบกันคือการป้องกันการแก้ไขข้อบกพร่องด้วย LLDB ด้วยภาพระบบโปรแกรมจำลองขนาด 16 KB การแก้ไขสำหรับปัญหานี้รวมอยู่ใน NDK r27 RC 1 และการอัปเดตฟีเจอร์ใหม่ของ Android Studio Koala | 2024.1.2 Canary 5

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

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

   เราพัฒนาฟีเจอร์ใหม่ๆ อยู่เสมอ ดังนั้นโปรดดาวน์โหลดเวอร์ชันที่ใหม่กว่าหรือเวอร์ชันตัวอย่างล่าสุดของ Android Studio เมื่อพร้อมให้บริการ

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

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

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

   • อิมเมจระบบ ARM 64 v8a ขนาดหน้า 16 KB ของ Google APIs รุ่นทดลอง
   • ระบบ Intel x86_64 Atom ที่ใช้ขนาดหน้า 16 KB ของ Google APIs แบบทดลอง รูปภาพ
   หมายเหตุ: หากวางแผนที่จะจําลองอุปกรณ์ Google Pixel ที่รองรับ คุณจะใช้ได้เฉพาะภาพระบบ ARM 64 v8a

   

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

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

   

ขั้นตอนเพิ่มเติมสำหรับโปรแกรมจำลองบางเวอร์ชันและภาพระบบ

สำหรับ Android Emulator เวอร์ชัน 35.1.5 ถึง 35.1.20 และก่อนการแก้ไขที่ 4 ของภาพระบบขนาดหน้า 16 KB ของ Android 15.0 ที่เสนอใน SDK Manager หากต้องการจำลองสภาพแวดล้อมขนาด 16 KB ในระบบ x86_64 คุณจะต้องทําตามขั้นตอนต่อไปนี้ด้วย คุณไม่จำเป็นต้องทำตามขั้นตอนเหล่านี้หลังจากเวอร์ชัน 35.1.21 และกับภาพระบบขนาดหน้า 16 KB ของ Android 15.0 ฉบับแก้ไขที่ 4 ขึ้นไป

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

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

   kernel.parameters = androidboot.page_shift=14
   

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

   adb shell getconf PAGE_SIZE
   

เปิดโปรแกรมจำลอง

หลังจากตั้งค่า Android Emulator และอุปกรณ์เสมือนเสร็จแล้ว ให้เปิดโปรแกรมจำลองจากเมนูอุปกรณ์เป้าหมาย หรือจากบรรทัดคำสั่ง

เปิดใช้โหมด 16 KB ในอุปกรณ์โดยใช้ตัวเลือกสำหรับนักพัฒนาแอป

สลับตัวเลือกบูตโดยใช้หน้าขนาด 16KB สำหรับนักพัฒนาแอปเพื่อบูตอุปกรณ์ในโหมด 16 KB

ตั้งแต่ Android 15 QPR1 เป็นต้นไป คุณสามารถใช้ตัวเลือกสำหรับนักพัฒนาแอปที่มีให้ในอุปกรณ์บางรุ่นเพื่อบูตอุปกรณ์ในโหมด 16 KB และทำการทดสอบในอุปกรณ์ ก่อนใช้ตัวเลือกสำหรับนักพัฒนาซอฟต์แวร์ ให้ไปที่การตั้งค่า -> ระบบ -> การอัปเดตซอฟต์แวร์ แล้วใช้การอัปเดตที่มี

ตัวเลือกสำหรับนักพัฒนาแอปนี้พร้อมใช้งานในอุปกรณ์ต่อไปนี้

• Pixel 8 และ 8 Pro (ที่ใช้ Android 15 QPR1 ขึ้นไป)

  คำเตือน: เนื่องจากปัญหาที่ทราบเกี่ยวกับ Android 15 QPR2 เบต้า 3 หน้าจอสัมผัสจึงใช้งานไม่ได้ในอุปกรณ์ Pixel 8 หลังจากติดตั้ง Android 15 QPR2 เบต้า 3 และบูตอุปกรณ์ในโหมด 16 KB ปัญหานี้ไม่ส่งผลต่ออุปกรณ์ Pixel 8 Pro

• Pixel 8a (ที่ใช้ Android 15 QPR1 ขึ้นไป)

  คำเตือน: เนื่องจากปัญหาที่ทราบเกี่ยวกับ Android 15 QPR2 เบต้า 3 หน้าจอสัมผัสจึงไม่ทำงานในอุปกรณ์ Pixel 8a หลังจากติดตั้ง Android 15 QPR2 เบต้า 3 และบูตอุปกรณ์ในโหมด 16 KB

• Pixel 9, 9 Pro และ 9 Pro XL (ที่ใช้ Android 15 QPR2 Beta 2 ขึ้นไป)

หมายเหตุ: Android 15 QPR2 อยู่ในเวอร์ชันเบต้า ดูข้อมูลเพิ่มเติมเกี่ยวกับการรับ QPR2 ในอุปกรณ์ที่มีสิทธิ์ได้ที่รับ Android 15 QPR เวอร์ชันเบต้า

ข้อกำหนดความเข้ากันได้ของ Google Play

เนื่องจากผู้ผลิตอุปกรณ์ติดตั้ง RAM มากขึ้นในอุปกรณ์เพื่อเพิ่มประสิทธิภาพ อุปกรณ์จำนวนมากจึงใช้หน้าขนาดที่ใหญ่ขึ้น เช่น 16 KB Google Play เปิดตัวข้อกำหนดความเข้ากันได้สำหรับแอปใหม่ทั้งหมดและการอัปเดตแอปที่มีอยู่ รวมถึงการกำหนดเป้าหมายอุปกรณ์ Android 15 ขึ้นไปให้รองรับหน้าขนาด 16 KB ตั้งแต่วันที่ 1 พฤศจิกายน 2025 เพื่อเตรียมพร้อมสำหรับการเปิดตัวอุปกรณ์เหล่านี้

อ่านข้อมูลเพิ่มเติมเกี่ยวกับข้อกำหนดด้านความเข้ากันได้นี้ได้ในบล็อกโพสต์นี้