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

Controlla 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 codice nativo se si applica una delle seguenti condizioni:

• La tua app utilizza qualsiasi codice C/C++ (nativo). Se l'app utilizza l'NDK di Android, allora utilizza il codice nativo.
• L'app si collega a eventuali librerie o dipendenze native 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

Lo Strumento di analisi APK è uno strumento che consente di valutare diversi aspetti di un APK creato. Per identificare se la tua app utilizza codice nativo o librerie, segui questi passaggi:

1. Apri Android Studio, 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 desideri analizzare.

4. Cerca all'interno della cartella lib, che ospita i file degli oggetti condivisi (.so), se sono presenti. Se sono presenti file di oggetti condivisi, la tua app utilizza il codice nativo. Se non sono presenti file di oggetti condivisi o se non è presente una cartella lib, la tua app non utilizza codice nativo.

   

Crea la tua app con il supporto per i dispositivi da 16 kB

Per supportare dispositivi da 16 kB, le app che utilizzano codice nativo devono completare i passaggi descritti nelle sezioni seguenti.

Aggiorna ad AGP versione 8.3 o successive

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

Ti consigliamo di utilizzare le librerie condivise non compresse, ma se non puoi eseguire l'upgrade di AGP alla versione 8.3 o successive, l'alternativa è passare all'utilizzo delle librerie condivise compresse. Aggiorna la configurazione di Gradle per fare in modo che Gradle comprimi le librerie condivise durante la pacchettizzazione dell'app per evitare problemi di installazione delle app con librerie condivise non allineate.

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

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

Compila la tua app utilizzando l'allineamento ELF da 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 consentire l'esecuzione dell'app.

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

Android NDK r26 e versioni precedenti

Per supportare la compilazione di 16 librerie condivise allineate alla KB con Android NDK versione r26 o precedente, devi aggiornare la configurazione di 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")

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

Verifica la presenza di istanze di codice che fanno riferimento a dimensioni di pagina specifiche

Anche se l'app è allineata a 16 kB, può verificarsi errori se le parti del codice presuppongono 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 alla costante PAGE_SIZE o le istanze dalla logica del codice che presuppongono che le dimensioni delle pagine di un dispositivo siano pari a 4 kB (4096).

   Usa invece getpagesize() o sysconf(_SC_PAGESIZE).

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

Testa la tua app in un ambiente da 16 kB

Dopo aver creato la tua app con il supporto per dispositivi da 16 kB, ti consigliamo di testarla in un ambiente di 16 kB per verificare se la tua app ha subito regressioni. Per farlo, configura uno degli ambienti di test riportati di seguito, quindi testa accuratamente l'app, 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
• Usare seppia con dimensioni pagina da 16 kB su ARM64
• Simulazione di seppie con dimensioni pagina da 16 kB su x86-64

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, procedi nel seguente modo:

1. Le immagini di sistema di emulatori Android 15 basate su 16 kB sono compatibili con Android Studio Jellyfish | 2023.3.1 o versioni successive. Tuttavia, per un'esperienza ottimale quando si lavora 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, in quanto puoi installare più versioni affiancate.

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

3. Nella scheda SDK Platforms (Piattaforme SDK), espandi la sezione Android VanillaIceCream Preview (Anteprima Android VanillaIceCream) e seleziona una o entrambe le seguenti immagini del sistema di emulatore, a seconda dei dispositivi virtuali che vuoi creare:

   • API di Google Sperimentale API Dimensioni pagina 16 kB ARM 64 v8a immagine di sistema
   • API di Google Sperimentale 16 kB Dimensioni pagina Intel x86_64 Atom System Image

   

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

5. Segui la procedura 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 è consigliato automaticamente, puoi trovare l'immagine di sistema da 16 kB nella scheda Altre immagini.