In passato, Android supportava solo le dimensioni delle pagine in memoria da 4 kB, che sono le prestazioni della memoria di sistema ottimizzate per la quantità media di memoria totale In genere i dispositivi Android hanno avuto. A partire da Android 15, AOSP supporta dispositivi configurati per l'utilizzo di dimensioni pagina di 16 kB (16 kB) dispositivi). Se la tua app utilizza librerie NDK, direttamente o indirettamente tramite un SDK, dovrai ricreare l'app funzionano su questi dispositivi da 16 kB.
I produttori di dispositivi continuano a realizzare dispositivi con memoria fisica (RAM), molti di questi dispositivi adotteranno 16 kB (e alla fine aumentano) le dimensioni delle pagine per ottimizzare le prestazioni del dispositivo. Aggiunta in corso... per dispositivi con dimensione pagina di 16 kB consente di eseguire l'app su questi dispositivi e consente alla tua app di trarre vantaggio dalle prestazioni associate miglioramenti. Senza la ricompilazione, le app potrebbero non funzionare sui dispositivi da 16 kB quando vengono messe in produzione nelle release future di Android.
Per aiutarti ad aggiungere il supporto della tua app, abbiamo fornito indicazioni su come controllare se la tua app è interessata, come ricreare l'app (se applicabile) e come testare l'app in In un ambiente da 16 kB con emulatori (tra cui Android 15 immagini di sistema per l'emulatore Android).
Vantaggi e miglioramenti del rendimento
I dispositivi configurati con dimensioni pagina di 16 kB utilizzano in media una quantità di memoria leggermente maggiore, ma ottengono anche diversi miglioramenti delle prestazioni sia per il sistema sia per le app:
- Tempi di avvio delle app inferiori quando il sistema è sotto pressione: in media, il 3,16% è in meno, con miglioramenti più significativi (fino al 30%) per alcune app che abbiamo testato
- Consumo energetico ridotto durante il lancio dell'app: in media una riduzione del 4,56%
- Lancio più rapido delle fotocamere: in media avvii a caldo più rapidi del 4,48% e avvii a freddo in media del 6,60%
- Miglioramento del tempo di avvio del sistema: miglioramento dell'1,5% (circa 0,8 secondi) in media
Questi miglioramenti si basano sui nostri test iniziali e i risultati sui dispositivi effettivi saranno probabilmente diversi. Forniremo ulteriori analisi dei potenziali guadagni per le app man mano che procediamo con i nostri test.
Controllare se la tua app è interessata
Se la tua app utilizza qualsiasi codice nativo, devi ricreare l'app supportando i dispositivi da 16 kB. Se non hai la certezza che la tua app utilizzi codice nativo, puoi utilizzare lo strumento di analisi APK per identificare la presenza di codice nativo.
Se la tua app utilizza solo codice scritto nel linguaggio di programmazione Java o in Kotlin, incluse tutte le librerie o tutti gli SDK, l'app supporta già i dispositivi da 16 kB. Tuttavia, ti consigliamo di testare la tua app in un ambiente da 16 kB per verificare che non ci siano regressioni impreviste nel comportamento dell'app.
La tua app utilizza codice nativo?
La tua app utilizza il codice nativo nei seguenti casi:
- La tua app utilizza qualsiasi codice C/C++ (nativo). Se la tua app utilizza il sistema operativo Android NDK, la tua app utilizza il codice nativo.
- L'app si collega a eventuali librerie o dipendenze native di terze parti che per utilizzarli.
- La tua app è creata da uno strumento per la creazione di app di terze parti che utilizza librerie native su dispositivo.
Identificare le librerie native usando l'Analizzatore APK
Lo Strumento di analisi APK consente di valutare vari aspetti di un . Per capire se la tua app utilizza librerie o codice nativo, segui questi passaggi: passaggi:
- Apri Android Studio, quindi fai clic su File > Apri e scegli un progetto.
Nella barra dei menu, fai clic su Crea > Analizza l'APK...
Scegli l'APK che vuoi analizzare.
Cerca all'interno della cartella
lib
che ospita eventuali file dell'oggetto condiviso (.so
) sono presenti. Se sono presenti file di oggetti condivisi, la tua app utilizza le API nel tuo codice. Se non sono presenti file di oggetti condivisi o se non è presente una cartellalib
, significa che la tua app non usa codice nativo.
Crea la tua app con supporto per dispositivi da 16 kB
Per supportare i dispositivi da 16 kB, le app che utilizzano codice nativo devono completare la procedura i passaggi descritti nelle sezioni seguenti.
Aggiorna la pacchettizzazione delle tue librerie condivise
Ti consigliamo di eseguire l'upgrade ad AGP versione 8.3 o successiva e di utilizzare raccolte condivise.
AGP 8.3 o versioni successive
I dispositivi da 16 kB richiedono app fornite con librerie condivise non compresse per e allinearle a un limite allineato al file zip di 16 kB. Per farlo, devi eseguire l'upgrade al plug-in Android Gradle (AGP) 8.3 o versioni successive. Fai riferimento al Sezione Assistente per l'upgrade del plug-in Gradle per maggiori dettagli sulla procedura di upgrade.
AGP 8.2 o versioni precedenti
Se non riesci a eseguire l'upgrade di AGP alla versione 8.3 o successive, l'alternativa è l'opzione per usare librerie condivise compresse. Aggiorna la configurazione Gradle in fare in modo che Gradle comprima le librerie condivise durante la pacchettizzazione dell'app per evitare di installazione con librerie condivise non allineate.
Alla moda
Nel file build.gradle
, aggiungi la seguente opzione:
android {
...
packagingOptions {
jniLibs {
useLegacyPackaging true
}
}
}
Kotlin
Nel file build.gradle.kts
, aggiungi la seguente opzione:
android {
...
packagingOptions {
jniLibs {
useLegacyPackaging = true
}
}
}
Compila la tua app utilizzando l'allineamento ELF di 16 kB
I dispositivi da 16 kB richiedono le librerie condivise Segmenti ELF da allineare correttamente utilizzando l'allineamento ELF a 16 kB per consentire l'esecuzione dell'app.
Per compilare la tua app utilizzando l'allineamento ELF a 16 kB, completa i passaggi in uno dei le sezioni seguenti, a seconda della versione dell'Android NDK di cui disponi che utilizzano.
Android NDK r26 e versioni precedenti
Per supportare la compilazione di librerie condivise allineate a 16 KB con Android NDK
Versione r26 o precedente, devi aggiornare ndk-build
o cmake
configurazione come segue:
build-ndk
Aggiorna Android.mk
per attivare l'allineamento ELF a 16 kB:
LOCAL_LDFLAGS += "-Wl,-z,max-page-size=16384"
Marca
Aggiorna CMakeLists.txt
per attivare l'allineamento ELF a 16 kB:
target_link_options(${CMAKE_PROJECT_NAME} PRIVATE "-Wl,-z,max-page-size=16384")
Android NDK r27 e versioni successive
Per supportare la compilazione di librerie condivise allineate a 16 KB con Android NDK
versione r27 e successive, devi aggiornare ndk-build
, build.gradle
,
build.gradle.kts
o il linker segnala come segue:
build-ndk
In Application.mk
:
APP_SUPPORT_FLEXIBLE_PAGE_SIZES := true
Alla moda
Nel file build.gradle
, imposta l'argomento
-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
Nel file build.gradle.kts
, imposta l'argomento
-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")
}
}
}
}
Altri sistemi di compilazione
Specifica i seguenti flag del linker:
-Wl,-z,max-page-size=16384
Verifica la presenza di istanze di codice che fanno riferimento a dimensioni di pagina specifiche
Anche se l'app è allineata a 16 kB, può riscontrare errori in alcune posizioni nel codice presupporre che un dispositivo utilizzi una dimensione di pagina specifica. Per evitare che ciò accada, completa i seguenti passaggi:
Rimuovi tutte le dipendenze hardcoded che fanno riferimento a
PAGE_SIZE
o istanze nella logica del codice che presuppongono che la pagina di un dispositivo è di 4 kB (4096
).Usa invece
getpagesize()
osysconf(_SC_PAGESIZE)
.Cerca gli utilizzi di
mmap()
e di altre API che richiedono l'allineamento alla pagina e sostituirli con altre, se necessario.
In alcuni casi, se la tua app utilizza PAGE_SIZE
come valore pratico che non è
sono vincolati alle dimensioni della pagina
sottostante, questo non causerà l'interruzione dell'app
se utilizzato in modalità da 16 kB. Tuttavia, se questo valore viene passato al kernel
con mmap
senza MAP_FIXED
, il kernel utilizza comunque un'intera pagina, che
spreca un po' di memoria. Per questi motivi, PAGE_SIZE
non è definito quando 16 kB
è abilitata su NDK r27 e versioni successive.
Se la tua app utilizza PAGE_SIZE
in questo modo e non trasmette mai direttamente questo valore a
del kernel, quindi invece di usare PAGE_SIZE
, crea una nuova variabile con un
di Google Cloud per indicare che è utilizzato per altri scopi e non riflette una reale
della memoria.
Testa la tua app in un ambiente da 16 kB
Dopo aver creato l'app che supporta i dispositivi da 16 kB, ti consigliamo di testa la tua app in un ambiente da 16 kB per vedere se è disponibile di regressione lineare. A tale scopo, procedi nel seguente modo:
Configura uno dei seguenti ambienti di test:
Avvia il dispositivo di test ed esegui questo comando per verificare che in un ambiente da 16 kB:
adb shell getconf PAGE_SIZE
Il comando dovrebbe restituire il valore
16384
.Per le librerie condivise, verifica che I segmenti ELF allineata correttamente con un allineamento ELF di 16 kB. Puoi utilizzare questo script per assistenza in questa procedura:
#!/bin/bash # usage: alignment.sh path to search for *.so files dir="$1" RED="\e[31m" GREEN="\e[32m" ENDCOLOR="\e[0m" matches="$(find $dir -name "*.so" -type f)" IFS=$'\n' for match in $matches; do res="$(objdump -p ${match} | grep LOAD | awk '{ print $NF }' | head -1)" if [[ $res =~ "2**14" ]] || [[ $res =~ "2**16" ]]; then echo -e "${match}: ${GREEN}ALIGNED${ENDCOLOR} ($res)" else echo -e "${match}: ${RED}UNALIGNED${ENDCOLOR} ($res)" fi done
Salva lo script in un file, ad esempio
alignment.sh
.Estrai il file APK dell'app:
unzip APK_NAME.apk -d /tmp/my_apk_out
Esegui lo script sui file estratti in
/tmp/my_apk_out
directory:alignment.sh /tmp/my_apk_out | grep "arm64-v8a"
Lo script restituisce
ALIGNED
oUNALIGNED
per tutte learm64-v8a
raccolte condivise.Se una delle
arm64-v8a
raccolte condivise èUNALIGNED
, dovrai: aggiornare la pacchettizzazione per le librerie in questione, quindi ricompilare app e riprova seguendo i passaggi in questa sezione.
Esegui questo comando
zipalign
per verificare che la tua app sia Allineato a KB, dove APK_NAME è il nome il file APK della tua app:zipalign -c -P 16 -v 4 APK_NAME.apk
Testa a fondo l'app, concentrandoti sulle aree che potrebbero essere interessate modifica di istanze di codice che fanno riferimento a dimensioni di pagina specifiche.
Configura l'emulatore Android con un'immagine di sistema Android 15 basata su 16 kB
Per configurare un ambiente da 16 kB utilizzando Android Emulator: passaggi:
Le immagini di sistema dell'emulatore Android 15 basate su 16 KB sono compatibili con Android Studio Jellyfish | 2023.3.1 o versioni successive. Tuttavia, per quando si lavora con Android 15 Beta, scarica la versione più recente l'anteprima di Android Studio.
Ricorda che puoi mantenere la tua versione attuale di Android Studio perché puoi installare più versioni una accanto all'altra.
In Android Studio, fai clic su Strumenti > SDK Manager.
Nella scheda SDK Platforms (Piattaforme SDK), seleziona Mostra dettagli pacchetto, quindi espandi nella sezione Anteprima di Android VanillaIceCream e seleziona una o entrambe le opzioni le seguenti immagini di sistema dell'emulatore, a seconda dei dispositivi virtuali vuoi creare:
- Immagine di sistema ARM 64 v8a sperimentale per le API di Google, dimensioni pagina 16k
- Immagine del sistema Atom Intel x86_64 sperimentale per le API di Google, dimensioni della pagina di 16.000
Fai clic su Applica > OK per scaricare le immagini di sistema selezionate.
Segui i passaggi per configurare un dispositivo virtuale per Android 15 e quando ti viene chiesto di selezionare un'immagine di sistema, seleziona l'immagine di sistema da 16 kB che hai scaricato. Se non viene consigliato automaticamente, puoi trovare Immagine di sistema da 16 kB nella scheda Altre immagini.