Obsługa rozmiaru stron 16 KB

Wymaganie dotyczące zgodności z Google Play w przypadku rozmiaru 16 KB

Od 1 listopada 2025 roku wszystkie nowe aplikacje i aktualizacje istniejących aplikacji przesyłane do Google Play i kierowane na urządzenia z Androidem 15 lub nowszym muszą obsługiwać rozmiary stron 16 KB na urządzeniach 64-bitowych.

Więcej informacji →

W przeszłości Android obsługiwał tylko strony pamięci o rozmiarze 4 KB, co optymalizowało wydajność pamięci systemowej pod kątem średniej ilości pamięci całkowitej, jaką zwykle miały urządzenia z Androidem. Od Androida 15 AOSP obsługuje urządzenia skonfigurowane do używania rozmiaru strony 16 KB (urządzenia 16 KB). Jeśli Twoja aplikacja używa bibliotek NDK bezpośrednio lub pośrednio za pomocą pakietu SDK, musisz ją przebudować, aby działała na urządzeniach o rozmiarze strony 16 KB.

Producenci urządzeń nadal tworzą urządzenia z większą ilością pamięci fizycznej (RAM). Wiele z nich będzie korzystać ze stron o rozmiarze 16 KB (a w przyszłości większych), aby zoptymalizować wydajność urządzenia. Dodanie obsługi urządzeń ze stronami o rozmiarze 16 KB umożliwia uruchamianie aplikacji na tych urządzeniach i korzystanie z powiązanych z tym ulepszeń wydajności. Bez ponownej kompilacji aplikacje nie będą działać na urządzeniach 16 KB w przyszłych wersjach Androida.

Aby pomóc Ci dodać obsługę w aplikacji, przygotowaliśmy wskazówki dotyczące sprawdzania, czy zmiana ma wpływ na Twoją aplikację, ponownego jej kompilowania (w odpowiednich przypadkach) oraz testowania aplikacji w środowisku 16 KB przy użyciu emulatorów (w tym obrazów systemu Android 15 dla emulatora Androida).

Korzyści i wzrost wydajności

配置为使用 16 KB 页面大小的设备平均会使用略多一些的内存，但系统和应用的性能也会得到各种提升：

• 缩短了系统内存压力时的应用启动时间：平均降低了 3.16%；对于我们测试的某些应用而言，改进幅度更大（最高可达 30%）
• 应用启动期间的功耗降低：平均降低了 4.56%
• 相机启动更快：热启动速度平均提高了 4.48%，冷启动速度平均提高了 6.60%
• 缩短了系统启动时间：平均缩短了 8%（约 950 毫秒）

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

Sprawdzanie, czy zmiana wpłynie na Twoją aplikację

如果您的应用使用了任何原生代码，则应重新构建应用，使其支持 16 KB 设备。如果您不确定自己的应用是否使用了原生代码，可以使用 APK 分析器来确定是否存在任何原生代码，然后检查您找到的任何共享库的 ELF 段对齐情况。Android Studio 还提供了一些功能，可帮助您自动检测对齐问题。

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

Czy Twoja aplikacja korzysta z kodu natywnego?

Aplikacja korzysta z kodu natywnego, jeśli spełnia któreś z tych kryteriów:

• Aplikacja używa kodu C/C++ (natywnego). Jeśli aplikacja korzysta z Androida NDK, używa kodu natywnego.
• Twoja aplikacja jest połączona z bibliotekami natywnymi lub zależnościami innych firm (np. pakietami SDK), które ich używają.
• Twoja aplikacja została utworzona przez narzędzie do tworzenia aplikacji innych firm, które korzysta z bibliotek natywnych na urządzeniu.

Identyfikowanie bibliotek natywnych za pomocą narzędzia APK Analyzer

Analizator APK to narzędzie, które umożliwia ocenę różnych aspektów skompilowanego pliku APK. Aby sprawdzić, czy Twoja aplikacja używa kodu natywnego (niezależnie od tego, czy jest zgodna z trybem 16 KB):

1. Otwórz Android Studio, a następnie kliknij Plik > Otwórz i wybierz dowolny projekt.

2. Na pasku menu kliknij Build > Analyze APK... (Kompilacja > Analizuj APK...).

   

3. Wybierz plik APK, który chcesz przeanalizować.

4. Sprawdź folder lib, w którym znajdują się pliki udostępnionych obiektów (.so), jeśli takie istnieją. Jeśli są obecne jakiekolwiek udostępnione pliki obiektowe, aplikacja używa kodu natywnego. W kolumnie Wyrównanie wyświetlają się komunikaty ostrzegawcze dotyczące plików, w których występują problemy z wyrównaniem. Jeśli nie ma plików obiektów współdzielonych lub nie ma folderu lib, aplikacja nie używa kodu natywnego.

   

Wykrywanie problemów z wyrównaniem za pomocą automatycznych kontroli

Android Studio z wyprzedzeniem ostrzega, jeśli wstępnie skompilowane biblioteki lub pliki APK nie są zgodne z wymaganiem 16 KB. Użyj analizatora APK, aby sprawdzić, które biblioteki wymagają aktualizacji lub czy konieczne są zmiany w kodzie.

Lint w Android Studio wyróżnia też biblioteki natywne, które nie są zgodne z trybem 16 KB.

Sprawdzanie wyrównania segmentów ELF w przypadku bibliotek współdzielonych

W przypadku wszystkich bibliotek udostępnionych sprawdź, czy segmenty ELF bibliotek udostępnionych są prawidłowo wyrównane przy użyciu wyrównania ELF 16 KB. Jeśli tworzysz aplikację w systemie Linux lub macOS, możesz użyć skryptu check_elf_alignment.sh w sposób opisany w następnej sekcji. Możesz też bezpośrednio używać narzędzi wiersza poleceń.

Użyj skryptu check_elf_alignment.sh (Linux lub macOS)

Aby sprawdzić wyrównanie segmentów ELF za pomocą skryptu check_elf_alignment.sh:

1. Zapisz skrypt check_elf_alignment.sh w pliku.

2. Uruchom skrypt na pliku APK aplikacji:

   check_elf_alignment.sh APK_NAME.apk
   

   Skrypt zwraca wartość ALIGNED lub UNALIGNED dla wszystkich arm64-v8azasobów wspólnych.

3. Jeśli którekolwiek biblioteki współdzielone arm64-v8a lub x86_64 są UNALIGNED, musisz zaktualizować pakiet tych bibliotek, a następnie ponownie skompilować aplikację i przeprowadzić test, wykonując czynności opisane w tej sekcji.

Bezpośrednie używanie narzędzi wiersza poleceń

Aby sprawdzić wyrównanie segmentów ELF bezpośrednio za pomocą narzędzi wiersza poleceń, wykonaj te czynności:

1. Upewnij się, że zarówno narzędzia Android SDK Build-Tools w wersji 35.0.0 lub nowszej, jak i Android NDK są zainstalowane za pomocą Menedżera SDK w Android Studio lub narzędzia wiersza poleceń sdkmanager.

2. Wyodrębnij plik APK aplikacji:

   Linux lub macOS

   unzip APK_NAME.apk -d /tmp/my_apk_out
   

   Windows (PowerShell)

   Expand-Archive -Path .\APK_NAME.apk -DestinationPath ~\tmp\my_apk_out
   

3. W katalogu tymczasowym, do którego został wyodrębniony plik APK, sprawdź zawartość katalogu lib pod kątem plików obiektów współdzielonych (.so). Są to te same pliki obiektów współdzielonych, które można było zobaczyć podczas identyfikowania bibliotek natywnych za pomocą narzędzia APK Analyzer. Uruchom to polecenie w przypadku każdego pliku obiektu współdzielonego:

   Linux lub 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"
   

   gdzie SDK_ROOT_LOCATION to ścieżka do katalogu, w którym zainstalowano pakiet Android SDK, SHARED_OBJECT_FILE to nazwa sprawdzanego pliku obiektu współdzielonego, a NDK_VERSION to zainstalowana wersja pakietu Android NDK (np. 28.0.12433566). Dane wyjściowe będą wyglądać podobnie do tych poniżej w przypadku każdego sprawdzanego pliku:

   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. Sprawdź wiersze wyjściowe, aby upewnić się, że segmenty ładowania nie mają wartości mniejszych niż 2**14. Jeśli którykolwiek z segmentów ładowania ma wartość 2**13, 2**12 lub niższą, musisz zaktualizować pakiet tych bibliotek, a następnie ponownie skompilować aplikację i przeprowadzić test, wykonując czynności opisane w tej sekcji.

5. Następnie uruchom narzędzie wiersza poleceń zipalign na pliku APK aplikacji:

   Linux lub 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
   

   gdzie SDK_ROOT_LOCATION to ścieżka do katalogu, w którym zainstalowano pakiet SDK Androida, a APK_NAME to nazwa pliku APK aplikacji. Jeśli wszystkie biblioteki współdzielone są prawidłowo dopasowane, w ostatnim wierszu danych wyjściowych pojawi się komunikat „Verification successful” (Weryfikacja zakończona).

   Jeśli weryfikacja się nie powiodła, niektóre biblioteki współdzielone wymagają ponownego wyrównania, więc musisz zaktualizować pakiet tych bibliotek, a następnie ponownie skompilować aplikację i ponownie przetestować ją, wykonując czynności opisane w tej sekcji.

Tworzenie aplikacji z obsługą urządzeń 16 KB

Jeśli Twoja aplikacja używa kodu natywnego, wykonaj czynności opisane w poniższych sekcjach, aby mieć pewność, że obsługuje urządzenia o rozmiarze 16 KB:

1. Aktualizowanie pakietów bibliotek udostępnionych
2. Skompiluj aplikację z wyrównaniem ELF 16 KB
3. Poprawianie kodu i rozwiązywanie problemów z czasem działania
4. Sprawdzanie, czy pakiety SDK obsługują strony pamięci o rozmiarze 16 KB

Wskazówka: jeśli zaktualizujesz narzędzia do najnowszych wersji (AGP w wersji 8.5.1 lub nowszej i NDK w wersji r28 lub nowszej) i użyjesz wstępnie skompilowanych zależności zgodnych z 16 KB, Twoja aplikacja będzie domyślnie zgodna z 16 KB i możesz przejść do kroku naprawiania kodu i rozwiązywania problemów z czasem działania.

Aktualizowanie pakietów bibliotek wspólnych

Zalecamy przejście na AGP w wersji 8.5.1 lub nowszej i używanie nieskompresowanych bibliotek wspólnych.

AGP w wersji 8.5.1 lub nowszej.

Urządzenia 16 KB wymagają, aby aplikacje dostarczane z nieskompresowanymi bibliotekami współużytkowanymi były wyrównane do granicy 16 KB. Aby to zrobić, musisz przejść na wtyczkę Androida do obsługi Gradle (AGP) w wersji 8.5.1 lub nowszej. Szczegółowe informacje o procesie uaktualniania znajdziesz w sekcji Asystent uaktualniania wtyczki Gradle do Androida.

AGP w wersji 8.5 lub starszej

Uwaga: w AGP w wersjach od 8.3 do 8.5 aplikacje są domyślnie wyrównane do 16 KB. Jednak bundletool domyślnie nie wyrównuje bajtów w plikach APK. Dlatego aplikacja może wydawać się działająca, ale po utworzeniu z pakietu w Google Play nie będzie można jej zainstalować.

Jeśli nie możesz uaktualnić AGP do wersji 8.5.1 lub nowszej, możesz używać skompresowanych bibliotek współdzielonych. Zaktualizuj konfigurację Gradle, aby Gradle kompresował biblioteki udostępnione podczas pakowania aplikacji. Pozwoli to uniknąć problemów z instalacją aplikacji z bibliotekami udostępnionymi, które nie są zgodne z trybem 16 KB.

Groovy

W pliku build.gradle dodaj tę opcję:

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

Kotlin

W pliku build.gradle.kts dodaj tę opcję:

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

Ostrzeżenie: gdy używasz skompresowanych bibliotek współdzielonych, aplikacja zajmuje więcej miejsca po zainstalowaniu, ponieważ biblioteki są wyodrębniane z pliku APK i kopiowane na dysk. Aplikacja może być częściej instalowana nieprawidłowo, ponieważ zwiększone zużycie miejsca na dysku oznacza, że na urządzeniu jest mniej miejsca. Aby tego uniknąć, uaktualnij AGP do wersji 8.5.1 lub nowszej.

Skompiluj aplikację pod kątem obsługi stron 16 KB przez format ELF

Aby aplikacja działała na urządzeniach 16 KB, segmenty ELF bibliotek współdzielonych muszą być prawidłowo wyrównane przy użyciu wyrównania ELF 16 KB.

Jeśli jesteś deweloperem gier, a Twoja gra działa na silniku Unity, zapoznaj się z przewodnikiem po Unity. Jeśli Twoja gra działa na silniku Unreal Engine, zapoznaj się z przewodnikiem po Unreal. Jeśli używasz natywnych silników gier, postępuj zgodnie z instrukcjami w tym przewodniku.

Uwaga: jeśli Twoja aplikacja nie wyodrębnia bibliotek natywnych do systemu plików (extractNativeLibs ustawione na false), po skompilowaniu z wyrównaniem ELF o rozmiarze 16 KB prawdopodobnie zauważysz niewielki wzrost rozmiaru pliku binarnego aplikacji. Optymalizacje menedżera pakietów w Androidzie 15 niwelują koszty czasu działania wynikające z tego wzrostu.

Aby skompilować aplikację z użyciem wyrównania ELF 16 KB, wykonaj czynności opisane w jednej z tych sekcji w zależności od używanej wersji Android NDK.

Ważne: jeśli Twoja aplikacja korzysta z gotowych bibliotek współdzielonych, musisz je również zrekompilować w ten sam sposób i ponownie zaimportować do aplikacji biblioteki dostosowane do stron 16 KB.

Android NDK w wersji r28 lub nowszej

NDK w wersji r28 i nowszych domyślnie kompiluje kod z wyrównaniem do 16 KB.

Android NDK r27

Aby obsługiwać kompilowanie bibliotek współdzielonych wyrównanych do 16 KB za pomocą Android NDK w wersji r27 lub nowszej, musisz zaktualizować flagi ndk-build, build.gradle, build.gradle.kts lub linkera w ten sposób:

ndk-build

Na Application.mk:

APP_SUPPORT_FLEXIBLE_PAGE_SIZES := true

Groovy

W pliku build.gradle ustaw argument -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

W pliku build.gradle.kts ustaw argument -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")
      }
    }
  }
}

Inne systemy kompilacji

Określ te flagi linkera:

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

Android NDK r26 i starsze

Zawsze aktualizuj NDK. Należy z niej korzystać tylko w ostateczności. Nie gwarantujemy pomocy w tym zakresie.

Aby obsługiwać kompilowanie bibliotek współdzielonych wyrównanych do 16 KB za pomocą Android NDK w wersji r26 lub starszej, musisz zaktualizować konfigurację ndk-build lub cmake w ten sposób:

ndk-build

Zaktualizuj Android.mk, aby włączyć wyrównanie ELF do 16 KB:

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

CMake

Zaktualizuj CMakeLists.txt, aby włączyć wyrównanie ELF do 16 KB:

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

Android NDK w wersji r22 lub starszej

Zawsze aktualizuj NDK. Należy z niej korzystać tylko w ostateczności. Nie gwarantujemy pomocy w tym zakresie.

Jeśli używasz NDK w wersji 22 lub starszej, oprócz czynności opisanej w przypadku NDK w wersji 26 i starszych musisz ustawić common-page-size=16384. Ustawienie common-page-size=16384 jest wymagane ze względu na błędy w starszych wersjach linkerów GNU ld i LLVM lld. To obejście problemu z rozmiarem strony działa tylko wtedy, gdy plik ELF zawiera też sekcję .relro_padding (LLD w wersji 18 i nowszej).

Aby skompilować biblioteki współdzielone zgodne ze stronami 16 KB za pomocą Android NDK w wersji r22 lub starszej, zaktualizuj konfigurację ndk-build lub cmake w ten sposób:

ndk-build

Zaktualizuj Android.mk, aby utworzyć plik ELF zgodny ze stronami 16 KB:

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

CMake

Zaktualizuj CMakeLists.txt, aby utworzyć plik ELF zgodny ze stronami 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")

Ważne: nawet jeśli Twoja aplikacja dynamicznie łączy się z biblioteką standardową C++ (libc++_shared.so) z pakietów NDK w wersji r26 i starszych, z których niektóre nie są wyrównane do 16 KB, nadal musisz zaktualizować wyrównanie wszystkich innych bibliotek, a także zaktualizować kod, aby uniknąć zależności od PAGE_SIZE. Aby przetestować te starsze wersje NDK na urządzeniach o pamięci 16 KB, w Android CI są dostępne wersje testowe LTS NDK r23 i r25 z bibliotekami libc++_shared.so o rozmiarze 16 KB. Niezależnie od tego zalecamy przejście na Android NDK w wersji r27 lub nowszej, aby zaktualizować bibliotekę standardową C++ do wersji wyrównanej do 16 KB ELF. W przeciwnym razie aplikacja nie będzie się dziś instalować na urządzeniach 16 KB.

Jeśli nie możesz przejść na nowszy pakiet Android NDK, możesz zaktualizować aplikację, aby statycznie skompilować bibliotekę standardową C++ w bibliotece współdzielonej. Więcej informacji o statycznym linkowaniu do standardowej biblioteki C++ znajdziesz w sekcji Obsługa biblioteki C++. Pamiętaj też, aby przeczytać sekcję Ważne uwagi.

Poprawianie kodu i rozwiązywanie problemów z czasem działania

Nawet jeśli aplikacja jest dostosowana do 16 KB, mogą w niej występować błędy, jeśli w niektórych miejscach w kodzie zakłada się, że urządzenie używa określonego rozmiaru strony. Aby tego uniknąć, wykonaj te czynności:

1. Usuń z logiki kodu wszystkie zależności zakodowane na stałe, które odwołują się do stałej PAGE_SIZE lub instancji, które zakładają, że rozmiar strony urządzenia wynosi 4 KB (4096).

   Zamiast tego użyj getpagesize() lub sysconf(_SC_PAGESIZE).

2. Wyszukaj użycia funkcji mmap() i innych interfejsów API, które wymagają argumentów wyrównanych do strony, i w razie potrzeby zastąp je alternatywnymi rozwiązaniami.

W niektórych przypadkach, jeśli Twoja aplikacja używa wartości PAGE_SIZE jako wygodnej wartości, która nie jest powiązana z rozmiarem strony, nie spowoduje to nieprawidłowego działania aplikacji w trybie 16 KB. Jeśli jednak ta wartość zostanie przekazana do jądra z parametrem mmap bez parametru MAP_FIXED, jądro nadal używa całej strony, co powoduje marnowanie pamięci. Z tych powodów wartość PAGE_SIZE jest nieokreślona, gdy w NDK w wersji r27 i nowszych włączony jest tryb 16 KB.

Jeśli Twoja aplikacja używa w ten sposób wartości PAGE_SIZE i nigdy nie przekazuje jej bezpośrednio do jądra, zamiast PAGE_SIZE utwórz nową zmienną o nowej nazwie, aby odzwierciedlić fakt, że jest ona używana do innych celów i nie odzwierciedla rzeczywistej strony pamięci.

Sprawdzanie, czy pakiety SDK obsługują strony pamięci o rozmiarze 16 KB

Wiele pakietów SDK jest zgodnych ze stronami o rozmiarze 16 KB, zwłaszcza jeśli tworzysz je samodzielnie lub korzystasz z najnowszych gotowych pakietów. Niektóre wstępnie skompilowane pakiety SDK lub ich wersje nie są jednak zgodne z limitem 16 KB. Dlatego na stronie każdego dostawcy pakietu SDK sprawdź, której wersji możesz używać w przypadku tego limitu.

Testowanie aplikacji w środowisku 16 KB

Po utworzeniu aplikacji z obsługą urządzeń 16 KB warto ją przetestować w środowisku 16 KB, aby sprawdzić, czy nie występują w niej żadne regresje. W tym celu należy wykonać następujące czynności:

1. Skonfiguruj pakiet SDK na Androida 15 lub nowszy.

2. Skonfiguruj jedno z tych środowisk testowych:

   • Konfigurowanie emulatora Androida z systemem Android 15 opartym na stronach 16 KB
     • Używanie Cuttlefish ze stronami o rozmiarze 16 KB na urządzeniach ARM64
     • Symulowanie Cuttlefish ze stronami o rozmiarze 16 KB na platformie x86-64
   • Włączanie trybu 16 KB na urządzeniu za pomocą opcji programisty
   • Korzystanie z Samsung Remote Test Lab na obsługiwanych urządzeniach o pojemności 16 KB

3. Uruchom urządzenie testowe, a następnie wykonaj to polecenie, aby sprawdzić, czy korzysta ono ze środowiska o rozmiarze 16 KB:

   adb shell getconf PAGE_SIZE
   

   Polecenie powinno zwrócić wartość 16384.

4. Aby sprawdzić, czy aplikacja jest wyrównana do 16 KB, uruchom to polecenie zipalign, gdzie APK_NAME to nazwa pliku APK aplikacji:

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

5. Dokładnie przetestuj aplikację, zwracając szczególną uwagę na obszary, na które mogą mieć wpływ zmiany instancji kodu odwołujących się do określonych rozmiarów stron.

Konfigurowanie narzędzia Android Emulator za pomocą obrazu systemu o rozmiarze 16 KB

Aby skonfigurować środowisko 16 KB za pomocą emulatora Androida, wykonaj te czynności:

1. W Android Studio kliknij Narzędzia > Menedżer SDK.

2. Na karcie Platformy pakietu SDK zaznacz Pokaż szczegóły pakietu, a następnie rozwiń sekcję Android VanillaIceCream lub nowszą i wybierz 1 lub 2 z tych obrazów systemu emulatora, w zależności od tego, jakie urządzenia wirtualne chcesz utworzyć:

   • Obraz systemu Google APIs Experimental 16 KB Page Size ARM 64 v8a
   • Google APIs Experimental 16 KB Page Size Intel x86_64 Atom System Image
   Uwaga: jeśli planujesz emulować obsługiwane urządzenie Google Pixel, wystarczy Ci obraz systemu ARM 64 v8a.

   

3. Kliknij Zastosuj > OK, aby pobrać wybrane obrazy systemu.

4. Wykonaj czynności, aby skonfigurować urządzenie wirtualne z Androidem 15, a gdy pojawi się prośba o wybranie obrazu systemu, wybierz pobrany obraz systemu 16 KB. Jeśli nie jest zalecany automatycznie, obraz systemu o rozmiarze 16 KB znajdziesz na karcie Inne obrazy.

   

Uruchamianie emulatora

Po skonfigurowaniu emulatora Androida i urządzeń wirtualnych uruchom emulator z menu urządzenia docelowego lub z wiersza poleceń.

Włączanie trybu 16 KB na urządzeniu za pomocą opcji programisty

Włącz opcję programisty Uruchom ze stroną 16 KB, aby uruchomić urządzenie w trybie 16 KB.

W wersjach QPR Androida 15 możesz skorzystać z opcji dla programistów dostępnej na niektórych urządzeniach, aby uruchomić urządzenie w trybie 16 KB i przeprowadzić testowanie na urządzeniu. Zanim skorzystasz z opcji programisty, otwórz Ustawienia > System > Aktualizacje oprogramowania i zastosuj dostępne aktualizacje.

Ta opcja dla deweloperów jest dostępna na tych urządzeniach:

• Pixel 8 i 8 Pro (z Androidem 15 QPR1 lub nowszym)

• Pixel 8a (z Androidem 15 QPR1 lub nowszym)

• Pixel 9, 9 Pro i 9 Pro XL (z Androidem 15 QPR2 Beta 2 lub nowszym)

Tryb zgodności wstecznej 16 KB

Ostrzeżenie w trybie zgodności z rozmiarem strony

Opcja zgodności wstecznej 16 KB jest dostępna, gdy urządzenie działa z jądrem systemu 16 KB. Menedżer pakietów uruchamia aplikację w trybie zgodności wstecznej 16 KB, gdy zostaną spełnione te warunki:

• Jeśli aplikacja zawiera pliki ELF (z rozszerzeniem .so) z segmentem LOAD o wyrównaniu 4 KB.
• Jeśli spakowany plik APK zawiera nieskompresowane pliki ELF wyrównane do 4 KB.

Jeśli menedżer pakietów włączył tryb zgodności wstecznej 16 KB w przypadku aplikacji, przy pierwszym uruchomieniu wyświetli ona ostrzeżenie o tym, że działa w trybie zgodności wstecznej 16 KB.

Tryb zgodności wstecznej 16 KB umożliwia działanie niektórych aplikacji, ale aby zapewnić najlepszą niezawodność i stabilność, aplikacje powinny być nadal dostosowane do rozmiaru 16 KB.

Na stronie informacji o aplikacji w sekcji Zaawansowane włącz lub wyłącz ustawienie Uruchamiaj aplikację w trybie zgodności z rozmiarem strony, aby włączyć lub wyłączyć tryb zgodności wstecznej 16 KB w przypadku konkretnej aplikacji. To ustawienie jest widoczne tylko wtedy, gdy urządzenie działa ze stronami o rozmiarze 16 KB.

Ustawienie trybu zgodności z rozmiarem strony

Aby wymusić zgodność wsteczną z trybem 16 KB w przypadku wszystkich aplikacji na urządzeniu:

adb shell setprop bionic.linker.16kb.app_compat.enabled true
adb shell setprop pm.16kb.app_compat.disabled false

Aby wyłączyć zgodność wsteczną z trybem 16 KB w przypadku wszystkich aplikacji na urządzeniu:

adb shell setprop bionic.linker.16kb.app_compat.enabled false
adb shell setprop pm.16kb.app_compat.disabled true

Ustaw właściwość android:pageSizeCompat na włączoną lub wyłączoną, aby włączyć lub wyłączyć tryb zgodności wstecznej w przypadku określonej aplikacji w jej AndroidManifest.xml. Gdy ta właściwość jest ustawiona, aplikacja nie wyświetla ostrzeżeń o trybie zgodności wstecznej podczas uruchamiania.

Wymagania dotyczące zgodności z Google Play

Producenci urządzeń wyposażają je w większą ilość pamięci RAM, aby zoptymalizować wydajność. Wiele z nich będzie stosować większe rozmiary stron, np. 16 KB. W ramach przygotowań do wprowadzenia tych urządzeń Google Play wprowadza nowe wymaganie dotyczące zgodności: od 1 listopada 2025 r. wszystkie nowe aplikacje i aktualizacje istniejących aplikacji przesyłane do Google Play i kierowane na urządzenia z Androidem 15 (poziom interfejsu API 35) lub nowszym muszą obsługiwać strony o rozmiarze 16 KB.

Więcej informacji o tym wymaganiu dotyczącym zgodności znajdziesz w tym poście na blogu.