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

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

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

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

ในอดีต Android รองรับเฉพาะหน้าหน่วยความจำขนาด 4 KB ซึ่งได้ เพิ่มประสิทธิภาพหน่วยความจำของระบบสำหรับปริมาณหน่วยความจำทั้งหมดโดยเฉลี่ยที่ อุปกรณ์ Android มักจะมี ตั้งแต่ Android 15 เป็นต้นไป AOSP จะรองรับ อุปกรณ์ที่กำหนดค่าให้ใช้หน้าขนาด 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 Analyzer เพื่อระบุว่ามีโค้ดเนทีฟหรือไม่ จากนั้นตรวจสอบการจัดแนวของส่วน ELF สำหรับไลบรารีที่ใช้ร่วมกันที่คุณพบ Android Studio ยังมีฟีเจอร์ที่จะช่วยให้คุณตรวจหาปัญหาการจัดแนวโดยอัตโนมัติได้ด้วย

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

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

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

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

ระบุไลบรารีแบบเนทีฟโดยใช้ตัววิเคราะห์ APK

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

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

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

   

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

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

   

ตรวจหาปัญหาการจัดแนวด้วยการตรวจสอบอัตโนมัติ

Android Studio จะแจ้งเตือนคุณล่วงหน้าหากไลบรารีหรือ APK ที่สร้างไว้ล่วงหน้าไม่เป็นไปตามข้อกำหนด 16 KB ใช้เครื่องมือ APK Analyzer เพื่อตรวจสอบว่าต้องอัปเดตไลบรารีใด หรือต้องเปลี่ยนแปลงโค้ดหรือไม่

Lint ใน Android Studio ยังไฮไลต์ไลบรารีแบบเนทีฟที่ไม่ได้จัดเรียงตามรูปแบบความจำขนาด 16 KB ด้วย

ตรวจสอบการจัดแนวของกลุ่ม 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 Manager ใน 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 ขึ้นไป) และใช้ทรัพยากร Dependency ที่สร้างไว้ล่วงหน้าซึ่งเข้ากันได้กับ 16 KB แสดงว่าแอปของคุณเข้ากันได้กับ 16 KB โดยค่าเริ่มต้น และคุณสามารถ ข้ามไปยังขั้นตอนสำหรับแก้ไขโค้ดและแก้ไขปัญหาขณะรันไทม์ได้

อัปเดตการแพ็กเกจไลบรารีที่ใช้ร่วมกัน

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

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

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

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

หมายเหตุ: ใน AGP เวอร์ชัน 8.3 ถึง 8.5 แอปจะได้รับการจัดแนว 16 KB โดยค่าเริ่มต้น อย่างไรก็ตาม bundletool จะไม่ zipalign 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 หรือแฟล็กของ 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")
      }
    }
  }
}

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

ระบุแฟล็กของ 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 ของ NDK เวอร์ชัน LTS r23 และ r25 จะพร้อมใช้งานใน Android CI ที่มีไลบรารี libc++_shared.so ขนาด 16 KB ที่จัดแนว อย่างไรก็ตาม เราขอแนะนำให้เปลี่ยนไปใช้ Android NDK r27 ขึ้นไปเพื่ออัปเดตเป็นเวอร์ชันที่สอดคล้องกับ ELF ขนาด 16 KB ของไลบรารีมาตรฐาน C++ ไม่เช่นนั้น แอปจะติดตั้งในอุปกรณ์ 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 ที่สร้างไว้ล่วงหน้าบางรายการไม่รองรับ 16 KB คุณจึงควรตรวจสอบเว็บไซต์ของผู้ให้บริการ SDK แต่ละรายเพื่อดูว่าควรใช้เวอร์ชันใดกับ 16 KB

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

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

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

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

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

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 Feature Drop | 2024.1.2 Canary 5

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

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 Manager

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

   • อิมเมจระบบ ARM 64 v8a ขนาดหน้า 16 KB ของ Google APIs Experimental
   • Google APIs Experimental 16 KB Page Size Intel x86_64 Atom System รูปภาพ
   หมายเหตุ: หากคุณวางแผนที่จะจำลองอุปกรณ์ 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 และเมื่อใช้ระบบ อิมเมจของ Android 15.0 ขนาดหน้า 16 KB ฉบับแก้ไขที่ 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 ในอุปกรณ์โดยใช้ตัวเลือกสำหรับนักพัฒนาแอป

สลับตัวเลือกสำหรับนักพัฒนาแอปบูตโดยใช้หน้าหน่วยความจำขนาด 16 KB เพื่อบูตอุปกรณ์ในโหมด 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 จึงขอแนะนำข้อกำหนดใหม่ด้านความเข้ากันได้เพื่อเตรียมพร้อมสำหรับการเปิดตัวอุปกรณ์ที่กำลังจะมาถึงเหล่านี้ โดยตั้งแต่วันที่ 1 พฤศจิกายน 2025 เป็นต้นไป แอปใหม่ทั้งหมดและการอัปเดตแอปที่มีอยู่ซึ่งส่งไปยัง Google Play และกำหนดเป้าหมายเป็นอุปกรณ์ที่ใช้ Android 15 (API ระดับ 35) ขึ้นไปจะต้องรองรับขนาดหน้า 16 KB

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