Questa pagina è stata tradotta dall'API Cloud Translation.

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 delle prestazioni

I dispositivi configurati con dimensioni di pagina di 16 KB in media utilizzano un po' più di memoria, ma ottengono anche vari miglioramenti delle prestazioni sia per il sistema sia per le app:

Tempi di avvio delle app più ridotti quando il sistema è sotto pressione di memoria: in media il 3,16% meno, con miglioramenti più significativi (fino al 30%) per alcune app che abbiamo testato
Assorbimento di corrente ridotto durante l'avvio dell'app: riduzione media del 4,56%
Avvio più rapido della fotocamera: in media gli avvii a caldo più veloci del 4,48% e degli avvii a freddo del 6,60% più velocemente
Tempo di avvio del sistema migliorato: miglioramento medio dell'8% (circa 950 millisecondi)

Questi miglioramenti si basano sui nostri test iniziali e i risultati sui dispositivi effettivi potrebbero essere diversi. Forniremo ulteriori analisi dei potenziali guadagni per le app man mano che continuiamo i test.

Verificare 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 sai con certezza se la tua app utilizza codice nativo, puoi utilizzare APK Analyzer per identificare se è presente codice nativo e poi controllare l'allineamento dei segmenti ELF per eventuali librerie condivise che trovi.

Se la tua app utilizza solo codice scritto nel linguaggio di programmazione Java o in Kotlin, incluse tutte le librerie o gli SDK, supporta già i dispositivi da 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 codice nativo se si applica una delle seguenti condizioni:

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 eventuali librerie native o dipendenze di terze parti (come gli SDK) che le utilizzano.
La tua app è stata creata da un'app builder di terze parti che utilizza librerie native sul dispositivo.

Identificare le librerie native utilizzando APK Analyzer

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

Apri Android Studio, poi fai clic su File > Apri e scegli un progetto.
Nella barra dei menu, fai clic su Build > Analizza APK….
Scegli l'APK da analizzare.
Controlla la cartella lib, che ospita i file degli oggetti condivisi (.so), se presenti. Se sono presenti file di oggetti condivisi, l'app utilizza codice nativo. Se non sono presenti file di oggetti condivisi o non è presente la cartella lib, l'app non utilizza il codice nativo.

Controlla l'allineamento dei segmenti ELF per le librerie condivise

Per tutte le librerie condivise, verifica che i segmenti ELF delle librerie condivise siano aliniati correttamente utilizzando l'allineamento ELF di 16 KB. Se esegui lo sviluppo su Linux o macOS, puoi utilizzare lo script check_elf_alignment.sh come descritto nella sezione seguente. Puoi anche utilizzare direttamente gli strumenti a riga di comando.

Utilizza lo script check_elf_alignment.sh (Linux o macOS)

Per controllare l'allineamento dei segmenti ELF utilizzando lo scriptcheck_elf_alignment.sh:

Salva lo script check_elf_alignment.sh in un file.
Esegui lo script sul file APK della tua app:
```
check_elf_alignment.sh APK_NAME.apk
```
Lo script restituisce ALIGNED o UNALIGNED per tutte le librerie condivise arm64-v8a.
Se le librerie condivise arm64-v8a o x86_64 sono UNALIGNED, dovrai aggiornare il pacchettizzazione di queste librerie, quindi ricompilare l'app e ripetere il test seguendo i passaggi descritti in questa sezione.

Utilizzare direttamente gli strumenti a riga di comando

Per verificare l'allineamento dei segmenti ELF utilizzando direttamente gli strumenti a riga di comando:

Assicurati che sia la versione 35.0.0 o successiva di Android SDK Build-Tools sia Android NDK siano installati utilizzando SDK Manager in Android Studio o lo strumento a riga di comando sdkmanager.

Estrai il file APK dell'app:

Linux o macOS

unzip APK_NAME.apk -d /tmp/my_apk_out

Windows (PowerShell)

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

Nella directory temporanea in cui hai estratto il file APK, controlla i contenuti della directory lib per verificare la presenza di file di oggetti condivisi (.so). Si tratta degli stessi file di oggetti condivisi che avresti visto durante l'identificazione delle librerie native utilizzando APK Analyzer. Esegui il seguente comando su ogni file oggetto condiviso:
Linux o 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"
```
dove SDK_ROOT_LOCATION è il percorso della directory in cui hai installato l'SDK Android, SHARED_OBJECT_FILE è il nome del file oggetto condiviso che stai controllando e NDK_VERSION è la versione dell'Android NDK che hai installato (ad esempio 28.0.12433566). L'output sarà simile al seguente per ogni file controllato:
```
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
```
Controlla le righe di output per assicurarti che i segmenti di carico non abbiano valori inferiori a 2**14. Se alcuni segmenti di caricamento sono valori 2**13, 2**12 o inferiori, devi aggiornare il pacchettizzazione per queste librerie, quindi ricompilare l'app e ripetere il test seguendo i passaggi descritti in questa sezione.
Quindi, esegui lo strumento a riga di comando zipalign sul file APK della tua app:
Linux o 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
```
dove SDK_ROOT_LOCATION è il percorso della directory in cui hai installato l'SDK Android e APK_NAME è il nome del file APK dell'app. L'ultima riga dell'output sarà "Verifica riuscita" se tutte le librerie condivise sono allineate correttamente.

Se la verifica non è riuscita, alcune librerie condivise devono essere riallineate, quindi dovrai aggiornare il pacchettizzazione di queste librerie, poi ricompilare l'app e ripetere il test seguendo i passaggi descritti in questa sezione.

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 il packaging delle librerie condivise

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

AGP versione 8.5.1 o successive

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

AGP versione 8.5 o precedenti

Se non riesci a eseguire l'upgrade di AGP alla versione 8.5.1 o successiva, l'alternativa è passare all'utilizzo delle librerie condivise compresse. Aggiorna la configurazione di Gradle in modo che Gradle comprima le librerie condivise durante il packaging dell'app per evitare problemi di installazione con le librerie condivise non allineate.

Groovy

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 l'app utilizzando l'allineamento ELF di 16 KB

I dispositivi da 16 KB richiedono che i segmenti ELF delle librerie condivise siano allineati correttamente utilizzando l'allineamento ELF da 16 KB per l'esecuzione dell'app.

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:

ndk-build

In Application.mk:

APP_SUPPORT_FLEXIBLE_PAGE_SIZES := true

Groovy

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

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:

ndk-build

Aggiorna Android.mk per attivare l'allineamento ELF a 16 KB:

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

CMake

Aggiorna CMakeLists.txt per attivare l'allineamento ELF a 16 KB:

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

Importante: anche se la tua app si collega dinamicamente alla libreria standard C++ (libc++_shared.so) dalle versioni NDK r26 e precedenti, alcune delle quali non sono allineate a 16 KB, devi comunque aggiornare l'allineamento di tutte le altre librerie qui e devi aggiornare il codice per evitare di dipendere da PAGE_SIZE. Per eseguire test su queste versioni precedenti dell'NDK su dispositivi da 16 KB, sono disponibili release canarie delle versioni LTS NDK r23 e r25 su Android CI con librerie libc++_shared.so allineate a 16 KB. In ogni caso, è consigliabile passare ad Android NDK r27 o versioni successive per eseguire l'aggiornamento alla versione della libreria standard C++ allineata a ELF di 16 KB. In caso contrario, la tua app non potrà essere installata sui dispositivi da 16 KB oggi.

Se non puoi passare alla versione più recente di Android NDK, potresti essere in grado di aggiornare la tua app in modo da compilare in modo statico la libreria standard C++ nella tua libreria condivisa. Consulta la sezione Supporto della libreria C++ per informazioni dettagliate sul collegamento statico alla libreria standard C++ e assicurati di leggere la sezione Considerazioni importanti.

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 pagina specifica. Per evitare questo problema, segui questi passaggi:

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).
Cerca gli utilizzi di mmap() e di altre API che richiedono argomenti allineati alla pagina e, se necessario, sostituiscili con alternative.

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 conmmap senza MAP_FIXED, il kernel utilizza comunque un'intera pagina, il che comporta un dispendio di memoria. Per questi motivi, PAGE_SIZE non è definito quando la modalità 16 KB è attivata 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.

Verificare il supporto di 16 KB per gli SDK

Molti SDK sono compatibili con dimensioni delle pagine di 16 KB, soprattutto se li crei autonomamente o se li scarichi precompilati di recente. Tuttavia, poiché alcune versioni precompilate o dell'SDK non sono compatibili con 16 KB, devi controllare il sito web di ciascun provider di SDK per determinare quale versione utilizzare con 16 KB.

Testa la tua app in un ambiente di 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:

Configura l'SDK Android 15.
Configura uno dei seguenti ambienti di test:
Avvia il dispositivo di test, quindi esegui il seguente comando per verificare che utilizzi un ambiente di 16 KB:
```
adb shell getconf PAGE_SIZE
```
Il comando deve restituire un valore 16384.
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
```
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.

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

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 un'esperienza ottimale quando lavori con la versione beta di Android 15, scarica l'ultima versione di anteprima di Android Studio.

Ricorda che puoi mantenere installata la versione esistente di Android Studio, poiché puoi installare più versioni affiancate.
In Android Studio, fai clic su Strumenti > Gestore SDK.
Nella scheda Piattaforme SDK, seleziona Mostra dettagli del pacchetto, poi espandi la sezione Android VanillaIceCream Preview 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 delle API di Google sperimentali con dimensioni pagina di 16 KB
- Immagine di sistema Atom Intel x86_64 per API Google sperimentali con dimensioni pagina di 16 KB
Nota: se prevedi di emulare un dispositivo Google Pixel supportato, ti servirà solo l'immagine di sistema ARM 64 v8a.
Fai clic su Applica > OK per scaricare le immagini di sistema che hai selezionato.
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 consigliata automaticamente, puoi trovare l'immagine di sistema di 16 KB nella scheda Altre immagini.

In Gestione dispositivi, fai clic sui tre puntini accanto all'immagine di 16 KB, quindi su Mostra sul disco.
In questa cartella, individua il file config.ini.
Aggiungi la seguente riga al file config.ini e salva le modifiche:
```
kernel.parameters = androidboot.page_shift=14
```
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)

Indietro

Supporto per 64 bit