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 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:

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

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

   

3. Scegli l'APK che vuoi analizzare.

4. 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 cartella lib, 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.

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

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:

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

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:

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

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:

1. 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() o sysconf(_SC_PAGESIZE).

2. 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:

1. Configura l'SDK Android 15.

2. Configura uno dei seguenti ambienti di test:

   • Configurare l'emulatore Android con un sistema Android 15 basato su 16 kB immagine
   • Utilizzare seppia con dimensione pagina di 16 kB su ARM64
   • Simula seppia con dimensione pagina di 16 kB su x86-64

3. 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.

4. 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
   

   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
      

   3. 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 o UNALIGNED per tutte le arm64-v8a raccolte condivise.

   4. 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.

5. 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
   

6. 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:

1. 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.

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

3. 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
   di Gemini Advanced.

   

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 viene consigliato automaticamente, puoi trovare Immagine di sistema da 16 kB nella scheda Altre immagini.