Supporta dimensioni di pagina da 16 kB.

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 codice nativo, devi ricostruirla con il supporto per 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 verificare se è presente del codice nativo e poi controllare l'allineamento dei segmenti ELF per eventuali librerie condivise individuate.

Se la tua app utilizza soltanto codice scritto nel linguaggio di programmazione Java o in Kotlin, incluse tutte le librerie o tutti gli SDK, significa che supporta già i dispositivi a 16 kB. Tuttavia, ti consigliamo di testare l'app in un ambiente di 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 NDK Android, utilizza il codice nativo.
• La tua app si collega a librerie native o dipendenze di terze parti che le utilizzano.
• La tua app è creata da uno strumento per la creazione di app di terze parti che utilizza librerie native sul dispositivo.

Identificare le librerie native usando lo strumento di analisi APK

APK Analyzer è uno strumento che consente di valutare vari aspetti di un APK compilato. Per capire se la tua app utilizza librerie o codice nativo, segui questi passaggi:

1. Apri Android Studio, poi fai clic su File > Apri e scegli un progetto.

2. Nella barra dei menu, fai clic su Crea > Analizza APK...

   

3. Scegli l'APK da analizzare.

4. Controlla la cartella lib, che ospita i file degli oggetti condivisi (.so), se presenti. Se sono presenti file di oggetti condivisi, l'app utilizza il codice nativo. Se non sono presenti file di oggetti condivisi o non è presente la cartella lib, l'app non utilizza il codice nativo.

   

Creare l'app con il supporto per i dispositivi da 16 KB

Per supportare i dispositivi da 16 kB, le app che utilizzano codice nativo devono completare i passaggi descritti nelle sezioni seguenti. Se esegui l'aggiornamento alla versione AGP 8.5.1 o successiva e alla versione NDK r28 o successiva e utilizzi dipendenze predefinite compatibili con 16 KB, le app sono compatibili con 16 KB per impostazione predefinita.

Aggiorna la pacchettizzazione delle tue librerie condivise

Ti consigliamo di eseguire l'upgrade ad AGP 8.5.1 o versioni successive e di utilizzare librerie condivise non compresse.

AGP versione 8.5.1 o successiva

I dispositivi da 16 KB richiedono che le app fornite con librerie condivise non compresse siano allineate a un confine zip di 16 KB. Per farlo, devi eseguire l'upgrade al plug-in Android per Gradle (AGP) versione 8.5.1 o successive. Per maggiori dettagli sul processo di upgrade, consulta la sezione Assistente per l'upgrade del plug-in Android Gradle.

AGP versione 8.5 o precedenti

Se non puoi eseguire l'upgrade di AGP alla versione 8.5.1 o successive, l'alternativa è utilizzare le librerie condivise compresse. Aggiorna la configurazione di Gradle in modo che Gradle comprima le librerie condivise durante la pacchettizzazione dell'app per evitare problemi di installazione dell'app con librerie condivise non allineate.

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

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

Compila l'app utilizzando l'allineamento ELF a 16 KB

Per poter eseguire l'app, i dispositivi da 16 kB richiedono che i segmenti ELF delle librerie condivise siano allineati correttamente mediante un allineamento ELF da 16 kB.

Per compilare l'app utilizzando l'allineamento ELF di 16 KB, completa i passaggi in una delle seguenti sezioni, a seconda della versione di Android NDK in uso.

Android NDK r28 e versioni successive

La versione NDK r28 e successive compilano per impostazione predefinita con allineamento a 16 KB.

Android NDK r27

Per supportare la compilazione di librerie condivise allineate a 16 KB con Android NDK nella versione r27 e successive, devi aggiornare i flag ndk-build, build.gradle, build.gradle.kts o del linker come segue:

APP_SUPPORT_FLEXIBLE_PAGE_SIZES := true

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

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

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

Android NDK r26 e versioni precedenti

Per supportare la compilazione di librerie condivise allineate a 16 KB con la versione r26 o precedente di Android NDK, devi aggiornare la configurazione ndk-build o cmake come segue:

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

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

Verificare se le istanze di codice fanno riferimento a dimensioni di pagina specifiche

Anche se l'app è allineata a 16 KB, può verificarsi un errore se nel codice si presume che un dispositivo utilizzi una dimensione di pagina specifica. Per evitare questo problema, segui questi passaggi:

1. Rimuovi eventuali dipendenze predefinite che fanno riferimento alla costante PAGE_SIZE o alle istanze nella logica del codice che presuppongono che le dimensioni della pagina di un dispositivo siano pari a 4 KB (4096).

   Utilizza invece getpagesize() o sysconf(_SC_PAGESIZE).

2. Cerca gli utilizzi di mmap() e di altre API che richiedono argomenti allineati alla pagina e sostituiscili con alternative se necessario.

In alcuni casi, se la tua app utilizza PAGE_SIZE come valore pratico non correlato alle dimensioni della pagina sottostanti, l'app non si arresta in modo anomalo se utilizzata in modalità 16 KB. Tuttavia, se questo valore viene passato al kernel con mmap senza MAP_FIXED, il kernel utilizza comunque un'intera pagina, con conseguente spreco di memoria. Per questi motivi, PAGE_SIZE non è definito quando è abilitata la modalità da 16 kB su NDK r27 e versioni successive.

Se la tua app utilizza PAGE_SIZE in questo modo e non passa mai direttamente questo valore al kernel, anziché utilizzare PAGE_SIZE, crea una nuova variabile con un nuovo nome per indicare che viene utilizzata per altri scopi e non riflette una pagina di memoria reale.

Testa la tua app in un ambiente da 16 kB

Dopo aver creato l'app con il supporto per i dispositivi da 16 KB, ti consigliamo di testarla in un ambiente da 16 KB per verificare se si verificano eventuali regressioni. A tale scopo, procedi nel seguente modo:

1. Configura l'SDK Android 15.

2. Configura uno dei seguenti ambienti di test:

   • Configurare l'emulatore Android con un'immagine di sistema Android 15 basata su 16 kB
   • Attivare la modalità a 16 kB su un dispositivo utilizzando le opzioni sviluppatore
   • Utilizzare seppia con dimensione pagina di 16 kB su ARM64
   • Simulare Cuttlefish con dimensione pagina di 16 KB su x86-64

3. Avvia il dispositivo di test, quindi esegui questo comando per verificare che utilizzi un ambiente da 16 kB:

   adb shell getconf PAGE_SIZE
   

   Il comando deve restituire un valore 16384.

4. Per eventuali librerie condivise, verifica che i segmenti ELF delle librerie condivise siano allineati correttamente utilizzando un allineamento ELF da 16 kB. Puoi utilizzare questo script per facilitare 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
   

   1. Salva lo script in un file, ad esempio alignment.sh.

   2. Estrai il file APK dell'app:

       unzip APK_NAME.apk -d /tmp/my_apk_out
       ```
   
   1.  Run the script on the extracted files in the `/tmp/my_apk_out`
       directory:
   
   ```none {: .devsite-terminal .devsite-click-to-copy }
       alignment.sh /tmp/my_apk_out | grep "arm64-v8a"
       ```
   
   The script outputs either `ALIGNED` or `UNALIGNED` for all the `arm64-v8a`
       shared libraries.
   
   1.  If any `arm64-v8a` shared libraries are `UNALIGNED`, you'll need to
       [update the packaging for those libraries][20], then [recompile your
       app][21] and retest by following the steps in this section.
   

5. Esegui il seguente comando zipalign per verificare che la tua app sia allineata a 16 KB, dove APK_NAME è il nome del file APK della tua app:

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

6. Testa a fondo l'app, concentrandoti sulle aree che potrebbero essere interessate dalla modifica delle istanze di codice che fanno riferimento a dimensioni di pagine specifiche.

Configura l'emulatore Android con un'immagine di sistema Android 15 basata su 16 kB

Per configurare un ambiente di 16 KB utilizzando l'emulatore Android:

1. Le immagini di sistema dell'emulatore Android 15 e basate su 16 kB sono compatibili con Android Studio Jellyfish | 2023.3.1 o versioni successive. Tuttavia, per un'esperienza ottimale con Android 15 beta, scarica la versione di anteprima più recente di Android Studio.

   Ricorda che puoi mantenere installata la versione esistente di Android Studio, poiché puoi installare più versioni affiancate.

2. In Android Studio, fai clic su Strumenti > SDK Manager.

3. Nella scheda SDK Platforms, seleziona Show Package Details (Mostra dettagli pacchetto), quindi espandi la sezione Android VanillaIceCream Preview (Anteprima Android VanillaIceCream) e seleziona una o entrambe le seguenti immagini di sistema dell'emulatore, a seconda dei dispositivi virtuali che vuoi creare:

   • Immagine di sistema ARM 64 v8a sperimentale delle API di Google con dimensioni pagina di 16 KB
   • Immagine del sistema Atom Intel x86_64 sperimentale per le API di Google, dimensioni della pagina di 16.000

   

4. Fai clic su Applica > OK per scaricare le immagini di sistema selezionate.

5. 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 è consigliata automaticamente, potrai trovare l'immagine di sistema da 16 kB nella scheda Altre immagini.

   

1. In Gestione dispositivi, fai clic sui tre puntini accanto all'immagine da 16 kB, quindi fai clic su Mostra su disco.
2. In questa cartella, individua il file config.ini.

3. Aggiungi la riga seguente al file config.ini e salva le modifiche:

   kernel.parameters = androidboot.page_shift=14
   

4. Per verificare le modifiche, esegui il seguente comando, che dovrebbe restituire16384:

   adb shell getconf PAGE_SIZE
   

Attivare la modalità da 16 kB su un dispositivo utilizzando le opzioni sviluppatore

Attiva/disattiva lo sviluppatore Avvia con dimensione pagina di 16 KB per avviare un dispositivo in modalità da 16 kB.

A partire da Android 15 QPR1, puoi usare l'opzione sviluppatore disponibile su alcuni per avviarli in modalità da 16 kB ed eseguire test sul dispositivo.

Questa opzione sviluppatore è disponibile sui seguenti dispositivi:

• Pixel 8 e 8 Pro (con Android 15 QPR1 Beta 1 o versioni successive)