Obsługa rozmiaru stron 16 KB

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

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 lub nowszym muszą obsługiwać strony o rozmiarze 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

Urządzenia skonfigurowane z użyciem stron o rozmiarze 16 KB zużywają średnio nieco więcej pamięci, ale zyskują też różne ulepszenia wydajności zarówno systemu, jak i aplikacji:

• Krótszy czas uruchamiania aplikacji, gdy system jest pod presją pamięci: średnio o 3,16% krótszy, a w przypadku niektórych testowanych aplikacji o znacznie więcej (do 30%).
• Zmniejszone zużycie energii podczas uruchamiania aplikacji: średnio o 4,56%
• Szybsze uruchamianie aparatu: średnio o 4,48% szybsze uruchomienia z pamięci i o 6,60% szybsze uruchomienia „na zimno”
• Skrócony czas uruchamiania systemu: skrócenie o 8% (około 950 milisekund)

Te ulepszenia bazują na naszych wstępnych testach. Wyniki na rzeczywistych urządzeniach mogą się różnić. W miarę kontynuowania testów będziemy przeprowadzać dodatkową analizę potencjalnych zysków w przypadku aplikacji.

Sprawdzanie, czy Twoja aplikacja jest objęta tym wymaganiem

Jeśli Twoja aplikacja używa kodu natywnego, zrekompiluj ją, aby obsługiwała urządzenia 16-kilobajtowe. Jeśli nie masz pewności, czy Twoja aplikacja używa kodu natywnego, możesz za pomocą narzędzia APK Analyzer sprawdzić, czy zawiera ona kod natywny, a następnie sprawdzić wyrównanie segmentów ELF w przypadku znalezionych bibliotek współdzielonych. Android Studio udostępnia też funkcje, które pomagają automatycznie wykrywać problemy z wyrównaniem.

Jeśli Twoja aplikacja używa tylko kodu napisanego w języku programowania Java lub Kotlin, w tym wszystkich bibliotek i pakietów SDK, to już obsługuje urządzenia 16-bitowe. Zalecamy jednak przetestowanie aplikacji w środowisku 16 KB, aby sprawdzić, czy nie występują nieoczekiwane regresje w jej działaniu.

Czy Twoja aplikacja korzysta z kodu natywnego?

Twoja aplikacja korzysta z kodu natywnego, jeśli spełnia którykolwiek z tych warunków:

• Aplikacja używa kodu w języku C lub C++ (natywnego). Jeśli Twoja aplikacja korzysta z Android NDK, oznacza to, że używa kodu natywnego.
• Aplikacja łączy się z bibliotekami natywnymi lub zależnościami innych firm (np. pakietami SDK), które z nich korzystają.
• Aplikacja została utworzona za pomocą narzędzia do tworzenia aplikacji innej firmy, które używa bibliotek natywnych na urządzeniu.

Identyfikowanie bibliotek natywnych za pomocą narzędzia APK Analyzer

APK Analyzer to narzędzie, które umożliwia ocenę różnych aspektów utworzonego 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 (Kompilacja) > Analyze APK... (Analizuj APK...).

   

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

4. Sprawdź folder lib, w którym znajdują się pliki obiektów współdzielonych (.so). Jeśli są tam pliki obiektów współdzielonych, Twoja aplikacja używa kodu natywnego. W kolumnie Alignment (Wyrównanie) wyświetlają się ostrzeżenia dotyczące plików, w których występują problemy z wyrównaniem. Jeśli nie ma plików obiektów współdzielonych lub folderu lib, Twoja aplikacja nie używa kodu natywnego.

   

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

Android Studio wyświetla ostrzeżenie, jeśli Twoje wstępnie skompilowane biblioteki lub pliki APK nie są zgodne z trybem 16 KB. Za pomocą narzędzia APK Analyzer możesz 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ą wyrównane do trybu 16 KB.

Sprawdzanie wyrównania segmentów ELF w bibliotekach współdzielonych

W przypadku bibliotek współdzielonych sprawdź, czy ich segmenty ELF są prawidłowo wyrównane za pomocą wyrównania ELF 16 KB. Jeśli programujesz w systemie Linux lub macOS, możesz użyć skryptu check_elf_alignment.sh zgodnie z opisem w następnej sekcji. Możesz też bezpośrednio używać narzędzi wiersza poleceń.

Używanie 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 w pliku APK aplikacji:

   check_elf_alignment.sh APK_NAME.apk
   

   Skrypt wyświetla ALIGNED lub UNALIGNED w przypadku wszystkich arm64-v8a bibliotek współdzielonych.

3. Jeśli któreś biblioteki współdzielone arm64-v8a lub x86_64 są UNALIGNED, musisz zaktualizować ich pakowanie, a następnie ponownie skompilować aplikację i przetestować ją, wykonując czynności opisane w tej sekcji.

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

Aby sprawdzić wyrównanie segmentów ELF za pomocą narzędzi wiersza poleceń:

1. Upewnij się, że za pomocą narzędzia SDK Manager w Android Studio lub sdkmanager narzędzia wiersza poleceń masz zainstalowane narzędzia Android SDK Build-Tools w wersji 35.0.0 lub nowszej oraz the Android NDK.

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 zostały wykryte podczas identyfikowania bibliotek natywnych za pomocą narzędzia APK Analyzer. W przypadku każdego pliku obiektów współdzielonych uruchom to polecenie:

   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 Android SDK, SHARED_OBJECT_FILE to nazwa sprawdzanego pliku obiektów współdzielonych, a NDK_VERSION to zainstalowana wersja Android NDK (np. 28.0.12433566). Wynik będzie wyglądać mniej więcej tak jak 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óryś z segmentów ładowania ma wartość 2**13, 2**12 lub niższą, musisz zaktualizować pakowanie tych bibliotek, a następnie ponownie skompilować aplikację i przetestować ją, wykonując czynności opisane w tej sekcji.

5. Następnie uruchom narzędzie wiersza poleceń zipalign w 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 Android SDK, a APK_NAME to nazwa pliku APK aplikacji. Jeśli wszystkie biblioteki współdzielone są prawidłowo wyrównane, w ostatnim wierszu wyniku pojawi się komunikat „Verification successful” (Weryfikacja zakończona pomyślnie).

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

Sprawdzanie flagi zabezpieczeń RELRO

Aby ograniczyć wykorzystywanie luk w zabezpieczeniach, nowoczesne linkery używają flagi Relocation Read-Only (RELRO), która po załadowaniu ustawia sekcje relokacji pliku obiektów współdzielonych jako tylko do odczytu. Połączenie sekcji z włączoną flagą RELRO z sekcją bez tej flagi (z innego pliku obiektów) na tej samej stronie powoduje awarię aplikacji.

W przypadku każdego pliku obiektów współdzielonych uruchom to polecenie (Linux lub macOS):

SDK_ROOT_LOCATION/Android/sdk/ndk/NDK_VERSION/toolchains/llvm/prebuilt/darwin-x86_64/bin/llvm-readelf -l SHARED_OBJECT_FILE.so | grep RELRO

Sprawdź wynik polecenia, aby upewnić się, że wyświetla się ciąg znaków GNU_RELRO. Potwierdza to, że plik .so ma włączoną flagę RELRO.

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

Jeśli Twoja aplikacja używa kodu natywnego, wykonaj czynności opisane w tych sekcjach, aby upewnić się, że obsługuje ona urządzenia 16 KB:

1. Zaktualizuj pakowanie bibliotek współdzielonych
2. Skompiluj aplikację za pomocą wyrównania ELF 16 KB
3. Popraw kod i rozwiąż problemy z czasem działania
4. Sprawdź, czy pakiety SDK obsługują tryb 16 KB

Aktualizowanie pakowania bibliotek współdzielonych

Uaktualnij AGP do wersji 8.5.1 lub nowszej i używaj nieskompresowanych bibliotek współdzielonych.

Sprawdzanie wyrównania ZIP za pomocą narzędzia bundletool

Aby sprawdzić wyrównanie pakietu, użyj tego polecenia:

bundletool dump config --bundle=<my .aab>  | grep alignment

Jeśli widzisz PAGE_ALIGNMENT_16K, oznacza to, że Twój pakiet wymaga wyrównania ZIP 16 KB. Jeśli widzisz PAGE_ALIGNMENT_4K, oznacza to, że plik APK utworzony na podstawie tego pakietu AAB ma w pliku ZIP pliki ` .so` wyrównane do 4 KB.

AGP w wersji 8.5.1 lub nowszej

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

AGP w wersji 8.5 lub starszej

Jeśli nie możesz uaktualnić AGP do wersji 8.5.1 lub nowszej, możesz przejść na skompresowane biblioteki współdzielone. Zaktualizuj konfigurację Gradle, aby Gradle kompresował biblioteki współdzielone podczas pakowania aplikacji. Pozwoli to uniknąć problemów z instalacją aplikacji z powodu niewyrównanych bibliotek współdzielonych.

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

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

AGP w wersji 8.0 lub starszej

Jeśli używasz AGP w wersji 8.0 lub starszej, musisz też wyłączyć opcję nieskompresowanych bibliotek natywnych w przypadku pakietów aplikacji w pliku gradle.properties:

android.bundle.enableUncompressedNativeLibs=false

Kompilowanie aplikacji za pomocą wyrównania ELF 16 KB

Aby aplikacja mogła działać na urządzeniach 16 KB, segmenty ELF bibliotek współdzielonych muszą być prawidłowo wyrównane za pomocą wyrównania ELF 16 KB.

Jeśli tworzysz grę, która działa na silniku Unity, zapoznaj się z przewodnikiem Unity. Jeśli Twoja gra działa na silniku Unreal, zapoznaj się z przewodnikiem Unreal. W przypadku natywnych silników gier postępuj zgodnie z tym przewodnikiem.

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

Android NDK r28 lub nowszy

NDK w wersji r28 lub nowszej domyślnie kompiluje się z wyrównaniem 16 KB.

Android NDK r27 lub starszy

Aby obsługiwać kompilowanie bibliotek współdzielonych wyrównanych do trybu 16 KB za pomocą Android NDK w wersji r27 lub starszej, użyj tych flag linkera:

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

Aby zaktualizować pliki konfiguracyjne systemu kompilacji:

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

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

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

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

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

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

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

W niektórych przypadkach, jeśli Twoja aplikacja używa PAGE_SIZE jako wygodnej wartości, która nie jest powiązana z rozmiarem strony, nie spowoduje to awarii aplikacji w trybie 16 KB. Jeśli jednak ta wartość jest przekazywana do jądra za pomocą mmap bez MAP_FIXED, jądro nadal używa całej strony, co powoduje marnowanie pamięci. Z tych powodów PAGE_SIZE jest niezdefiniowany, gdy w NDK r27 lub nowszym włączony jest tryb 16 KB.

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

Sprawdzanie, czy pakiety SDK obsługują tryb 16 KB

Wiele pakietów SDK jest zgodnych z rozmiarem strony 16 KB, zwłaszcza jeśli samodzielnie je skompilujesz lub uzyskasz najnowsze wstępnie skompilowane wersje. Niektóre wstępnie skompilowane pakiety SDK lub ich wersje nie są jednak zgodne z trybem 16 KB. Aby sprawdzić, której wersji używać w trybie 16 KB, zajrzyj na stronę każdego dostawcy pakietu SDK.

Testowanie aplikacji w środowisku 16 KB

Po skompilowaniu aplikacji z obsługą urządzeń 16 KB warto ją przetestować w środowisku 16 KB, aby sprawdzić, czy nie występują regresje. W tym celu wykonaj te czynności:

1. Skonfiguruj Android SDK w wersji 15 lub nowszej.

2. Skonfiguruj jedno z tych środowisk testowych:

   • Skonfiguruj Android Emulator z obrazem systemu Android 15 opartym na trybie 16 KB.
     • Używaj Cuttlefish z rozmiarem strony 16 KB na ARM64.
     • Symuluj Cuttlefish z rozmiarem strony 16 KB na x86-64.
   • Włącz tryb 16 KB na urządzeniu za pomocą opcji programisty.
   • Używaj Samsung Remote Test Lab na urządzeniach obsługujących tryb 16 KB.

3. Uruchom urządzenie testowe, a następnie uruchom to polecenie, aby sprawdzić, czy używa ono środowiska 16 KB:

   adb shell getconf PAGE_SIZE
   

   Polecenie powinno zwrócić wartość 16384.

4. Uruchom to polecenie zipalign, aby sprawdzić, czy Twoja aplikacja jest wyrównana do trybu 16 KB. Zastąp APK_NAME nazwą pliku APK aplikacji:

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

5. Dokładnie przetestuj aplikację, skupiając się na obszarach, na które może mieć wpływ zmiana instancji kodu odwołujących się do określonych rozmiarów stron.

Konfigurowanie Android Emulator z obrazem systemu opartym na trybie 16 KB

Aby skonfigurować środowisko 16 KB za pomocą Android Emulator:

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

2. Na karcie SDK Platforms zaznacz Show Package Details, a następnie rozwiń sekcję Android VanillaIceCream lub nowszą i wybierz jeden lub oba te obrazy systemu emulatora w zależności od tego, jakie urządzenia wirtualne chcesz utworzyć:

   • Google APIs Experimental 16 KB Page Size ARM 64 v8a System Image (Obraz systemu Google APIs Experimental z rozmiarem strony 16 KB dla ARM 64 v8a)
   • Google APIs Experimental 16 KB Page Size Intel x86_64 Atom System Image (Obraz systemu Google APIs Experimental z rozmiarem strony 16 KB dla Intel x86_64 Atom)

   

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

4. Wykonaj czynności, aby skonfigurować urządzenie wirtualne dla Androida 15, a gdy pojawi się prośba o wybranie obrazu systemu, wybierz pobrany obraz systemu 16 KB. Jeśli nie jest on automatycznie zalecany, znajdziesz go na karcie Other Images (Inne obrazy).

   

Uruchamianie emulatora

Po skonfigurowaniu Android Emulator 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 wszystkie dostępne aktualizacje.

Ta opcja dla programistó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 lub nowszym)

• Pixel 9a (z Androidem 16 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 16 KB. System zarządzania pakietami uruchamia aplikację w trybie zgodności wstecznej 16 KB, gdy spełnione są te warunki:

• Aplikacja ma pliki ELF (z rozszerzeniem .so) z wyrównaniem segmentu LOAD 4 KB.
• Skompresowany plik APK zawiera nieskompresowane pliki ELF wyrównane do ZIP 4 KB.

Jeśli system zarządzania pakietami włączy tryb zgodności wstecznej 16 KB w przypadku aplikacji, przy pierwszym uruchomieniu aplikacji wyświetli się ostrzeżenie, że działa ona 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ć wyrównane do trybu 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 z rozmiarem strony 16 KB.

Ustawienie trybu zgodności z rozmiarem strony

Aby wymusić włączenie trybu zgodności wstecznej 16 KB w przypadku każdej aplikacji na urządzeniu:

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

Aby wymusić wyłączenie trybu zgodności wstecznej 16 KB w przypadku każdej aplikacji na urządzeniu:

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

W Androidzie 17 możesz też wymusić wyłączenie trybu zgodności wstecznej 16 KB w przypadku każdej aplikacji i spowodować natychmiastowe przerwanie działania niezgodnego pliku binarnego:

    adb shell setprop bionic.linker.16kb.app_compat.enabled fatal
    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 konkretnej aplikacji w pliku AndroidManifest.xml. Gdy ta właściwość jest ustawiona, aplikacja nie wyświetla ostrzeżeń o trybie zgodności wstecznej podczas uruchamiania.

Wymaganie dotyczące zgodności z Google Play

Producenci urządzeń wyposażają je w coraz więcej pamięci RAM, aby zoptymalizować wydajność. Wielu z nich będzie stosować większe rozmiary stron, np. 16 KB. Aby przygotować się na wprowadzenie tych urządzeń na rynek, 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 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.