Supporta dimensioni di pagina da 16 kB.

In passato, Android supportava solo dimensioni pagina di memoria di 4 kB, il che ottimizza le prestazioni della memoria di sistema per la quantità media di memoria totale solitamente occupata dai dispositivi Android. A partire da Android 15, Android supporta i dispositivi configurati per utilizzare una dimensione di pagina di 16 kB (dispositivi da 16 kB).

Poiché i produttori di dispositivi continuano a sviluppare dispositivi con quantità maggiori di memoria fisica (RAM), molti di questi dispositivi probabilmente verranno configurati con dimensioni delle pagine di 16 kB (fino a un massimo di) per ottimizzare le prestazioni del dispositivo. L'aggiunta del supporto per dispositivi da 16 kB consente di eseguire l'app su questi dispositivi e di trarre vantaggio dai miglioramenti delle prestazioni associati. Per aiutarti, ti forniamo indicazioni su come verificare se la tua app è interessata, come ricreare l'app (se applicabile) e come testare l'app in un ambiente di 16 kB utilizzando sia emulatori sia dispositivi fisici.

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 Android NDK, l'app utilizza il codice nativo.
• L'app si collega a eventuali librerie o dipendenze native di terze parti che li 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 l'Analizzatore APK

Strumento di analisi APK consente di valutare vari aspetti di un APK creato. Per capire se la tua app utilizza librerie o codice nativo, segui questi 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 APK...

   

3. Scegli l'APK che vuoi analizzare.

4. Cerca all'interno della cartella lib che ospita file di oggetti condivisi (.so) se presenti. Se sono presenti file di oggetti condivisi, l'app utilizza il codice nativo. Se non sono presenti file oggetto condivisi o se non è presente una cartella lib, la tua app non utilizza 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 i passaggi descritti nelle sezioni seguenti.

Aggiorna la pacchettizzazione delle librerie condivise

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

AGP 8.3 o versioni successive

I dispositivi da 16 kB richiedono app fornite con librerie condivise non compresse per allinearle su un confine allineato al file zip di 16 kB. Per farlo, devi eseguire l'upgrade al plug-in Android Gradle (AGP) 8.3 o versioni successive. Per maggiori dettagli sul processo di upgrade, consulta la sezione Assistente per l'upgrade del plug-in Android Gradle.

AGP 8.2 o versioni precedenti

Se non puoi eseguire l'upgrade di AGP alla versione 8.3 o successive, l'alternativa è passare all'utilizzo di 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.

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

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.

Nota: se l'app non estrae librerie native dal file system (extractNativeLibs impostato su false), potresti notare un leggero aumento delle dimensioni binarie dell'app dopo la compilazione utilizzando un allineamento ELF da 16 kB. Le ottimizzazioni per il gestore di pacchetti in Android 15 annullano i costi di runtime di questo aumento.

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

Importante: se la tua app utilizza librerie condivise predefinite, devi anche ricompilarle nello stesso modo e reimportare le librerie allineate a 16 kB nella tua app.

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 la configurazione ndk-build o cmake 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")

Importante: se la tua app si collega in modo dinamico alla libreria standard C++ (libc++_shared.so) da Android NDK r26 o versioni precedenti, ti consigliamo di passare ad Android NDK r27 o versioni successive per eseguire l'aggiornamento alla versione allineata in ELF da 16 kB della libreria standard C++. In caso contrario, l'app non verrà installata su dispositivi da 16 KB.

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

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 i flag ndk-build, build.gradle, build.gradle.kts o linker 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 se alcune parti del codice presuppongono che un dispositivo utilizzi una dimensione di pagina specifica. Per evitare che ciò accada, completa questi passaggi:

1. Rimuovi tutte le dipendenze hardcoded che fanno riferimento alla costante PAGE_SIZE o le istanze nella logica del codice che presuppongono che la dimensione della pagina di un dispositivo sia pari a 4 kB (4096).

   Usa 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 l'app utilizza PAGE_SIZE come valore pratico che non è legato alle dimensioni della pagina sottostante, ciò non causerà l'interruzione dell'app se utilizzata 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, con conseguente spreco di memoria. Per questi motivi, PAGE_SIZE non è definito quando è abilitata la modalità a 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, invece di utilizzare PAGE_SIZE, crea una nuova variabile con un nuovo nome per indicare che viene utilizzato 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 che supporta dispositivi da 16 kB, ti consigliamo di testarla in un ambiente da 16 kB per vedere se si verificano regressioni. A questo scopo, configura uno dei seguenti ambienti di test, poi testa l'app in modo approfondito, concentrandoti sulle aree che potrebbero essere interessate dalla modifica di istanze di codice che fanno riferimento a dimensioni di pagina specifiche.

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

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

Importante: a causa di un problema noto in Android 15 Beta 2, il debug con LLDB non funziona ancora con le immagini di sistema dell'emulatore da 16 kB.

Per configurare un ambiente da 16 kB utilizzando Android Emulator, segui questi passaggi:

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 perché puoi installare più versioni una accanto all'altra.

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 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
   Nota: se prevedi di emulare un dispositivo Google Pixel supportato, avrai bisogno solo dell'immagine di sistema ARM 64 v8a.

   

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.