Supporta dimensioni di pagina da 16 kB.

Requisito di compatibilità con Google Play di 16 kB

A partire dal 1° novembre 2025, tutte le nuove app e gli aggiornamenti delle app esistenti inviati a Google Play e destinati a dispositivi Android 15+ devono supportare dimensioni delle pagine di 16 KB sui dispositivi a 64 bit.

Scopri di più →

Storicamente, Android ha supportato solo dimensioni delle pagine di memoria di 4 KB, il che ha ottimizzato le prestazioni della memoria di sistema per la quantità media di memoria totale che i dispositivi Android hanno in genere avuto. A partire da Android 15, AOSP supporta i dispositivi configurati per utilizzare una dimensione pagina di 16 KB (dispositivi da 16 KB). Se la tua app utilizza librerie NDK, direttamente o indirettamente tramite un SDK, dovrai ricompilare l'app per farla funzionare su questi dispositivi da 16 KB.

Man mano che i produttori di dispositivi continuano a creare dispositivi con quantità maggiori di memoria fisica (RAM), molti di questi dispositivi adotteranno dimensioni delle pagine di 16 KB (e alla fine maggiori) per ottimizzare le prestazioni del dispositivo. L'aggiunta del supporto per i dispositivi con dimensioni di pagina di 16 kB consente alla tua app di essere eseguita su questi dispositivi e di sfruttare i miglioramenti delle prestazioni associati. Senza ricompilazione, le app non funzioneranno sui dispositivi da 16 KB nelle versioni future di Android.

Per aiutarti ad aggiungere il supporto per la tua app, abbiamo fornito indicazioni su come verificare se la tua app è interessata, su come ricompilare l'app (se applicabile) e su come testarla in un ambiente da 16 kB utilizzando emulatori (incluse le immagini di sistema Android 15 per Android Emulator).

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.

Controllare se la tua app è interessata

Se la tua app utilizza codice nativo, devi ricompilarla 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 le librerie condivise che trovi. Android Studio offre anche funzionalità che ti aiutano a rilevare automaticamente i problemi di allineamento.

Se la tua app utilizza solo codice scritto nel linguaggio di programmazione Java o in Kotlin, incluse tutte le librerie o gli SDK, allora la tua app supporta già dispositivi da 16 KB. Tuttavia, ti consigliamo di testare l'app in un ambiente da 16 KB per verificare che non si verifichino regressioni impreviste nel comportamento dell'app.

La tua app utilizza codice nativo?

La tua app utilizza codice nativo se si verifica una delle seguenti condizioni:

• La tua app utilizza codice C/C++ (nativo). Se la tua app utilizza l'NDK Android, utilizza codice nativo.
• La tua app si collega a librerie o dipendenze native di terze parti (ad esempio SDK) che le utilizzano.
• La tua app è creata da un builder di app di terze parti che utilizza librerie native sul dispositivo.

Identificare le librerie native utilizzando APK Analyzer

APK Analyzer è uno strumento che ti consente di valutare vari aspetti di un APK creato. Per verificare se la tua app utilizza codice nativo (indipendentemente dalla compatibilità con 16 KB):

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

2. Nella barra dei menu, fai clic su Build > Analyze APK…

   

3. Scegli l'APK da analizzare.

4. Cerca all'interno della cartella lib, che ospita i file degli oggetti condivisi (.so), se presenti. Se sono presenti file oggetto condivisi, la tua app utilizza codice nativo. La colonna Allineamento mostra messaggi di avviso per tutti i file che presentano problemi di allineamento. Se non sono presenti file oggetto condivisi o non è presente la cartella lib, la tua app non utilizza codice nativo.

   

Rilevare problemi di allineamento con controlli automatici

Android Studio ti avvisa in modo proattivo se le tue librerie o i tuoi APK precompilati non sono conformi a 16 KB. Utilizza lo strumento APK Analyzer per esaminare quali librerie devono essere aggiornate o se sono necessarie modifiche al codice.

Lint in Android Studio evidenzia anche le librerie native che non sono allineate a 16 kB.

Controllare l'allineamento dei segmenti ELF per le librerie condivise

Per tutte le librerie condivise, verifica che i segmenti ELF delle librerie condivise siano allineati correttamente utilizzando l'allineamento ELF a 16 KB. Se sviluppi 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)

Segui questi passaggi per controllare l'allineamento dei segmenti ELF utilizzando lo script check_elf_alignment.sh:

1. Salva lo script check_elf_alignment.sh in un file.

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

3. Se una delle librerie condivise arm64-v8a o x86_64 è UNALIGNED, devi aggiornare il packaging di queste librerie, poi ricompilare la tua app e ripetere il test seguendo i passaggi descritti in questa sezione.

Utilizzare direttamente gli strumenti a riga di comando

Segui questi passaggi per controllare l'allineamento dei segmenti ELF utilizzando direttamente gli strumenti da riga di comando:

1. Assicurati che sia installata la versione 35.0.0 o successive di Android SDK Build-Tools e l'NDK Android utilizzando SDK Manager in Android Studio o lo strumento da riga di comando sdkmanager.

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

3. Nella directory temporanea in cui hai estratto il file APK, controlla i contenuti della directory lib per i file di oggetti condivisi (.so). Si tratta degli stessi file oggetto condivisi che avresti visto durante l'identificazione delle librerie native utilizzando APK Analyzer. Esegui questo 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'NDK Android che hai installato (ad esempio, 28.0.12433566). L'output sarà simile al seguente per ogni file che controlli:

   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
   

4. Controlla le righe di output per assicurarti che i segmenti di caricamento non abbiano valori inferiori a 2**14. Se uno dei segmenti di caricamento ha valori 2**13, 2**12 o inferiori, devi aggiornare il packaging di queste librerie, quindi ricompilare l'app e ripetere il test seguendo i passaggi descritti in questa sezione.

5. Successivamente, esegui lo strumento a riga di comando zipalign sul file APK dell'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 della tua app. L'ultima riga dell'output indicherà "Verifica riuscita" se tutte le librerie condivise sono allineate correttamente.

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

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

Se la tua app utilizza codice nativo, completa i passaggi descritti nelle sezioni seguenti per assicurarti che supporti i dispositivi da 16 KB:

1. Aggiornare il packaging delle librerie condivise
2. Compila l'app utilizzando l'allineamento ELF a 16 KB
3. Correggere il codice e risolvere i problemi di runtime
4. Controllare gli SDK per il supporto di 16 kB

Aggiornare il packaging delle librerie condivise

Ti consigliamo di eseguire l'upgrade ad AGP versione 8.5.1 o successive e di utilizzare 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 le allineino a un limite 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 all'upgrade del plug-in Gradle per Android.

AGP versione 8.5 o precedenti

Se non riesci a eseguire l'upgrade di AGP alla versione 8.5.1 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 il packaging 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 l'esecuzione dell'app, i dispositivi a 16 KB richiedono che i segmenti ELF delle librerie condivise siano allineati correttamente utilizzando l'allineamento ELF a 16 KB.

Per gli sviluppatori di giochi, se il tuo gioco viene eseguito sul motore di gioco Unity, consulta la guida di Unity. Se il tuo gioco viene eseguito su Unreal Engine, consulta la guida di Unreal. Per i motori di gioco nativi, continua con questa guida.

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

Android NDK r28 e versioni successive

NDK versione r28 e successive vengono compilate con allineamento a 16 KB per impostazione predefinita.

Android NDK r27

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

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 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 r22 e versioni precedenti

Oltre al passaggio descritto per NDK r26 e versioni precedenti, devi impostare common-page-size=16384 se utilizzi NDK r22 o versioni precedenti. L'impostazione common-page-size=16384 è obbligatoria a causa di bug nelle versioni precedenti dei linker GNU ld e LLVM lld. Tuttavia, ti consigliamo vivamente di aggiornare gli strumenti a una versione più recente per evitare completamente questi bug.

Per compilare librerie condivise compatibili con 16 kB con Android NDK versione r22 o precedenti, aggiorna la configurazione di ndk-build o cmake come segue:

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

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

Correggere il codice e risolvere i problemi di runtime

Anche se la tua app è allineata a 16 KB, può riscontrare errori se in alcuni punti del codice si presuppone che un dispositivo utilizzi dimensioni di pagina specifiche. Per evitare questo problema, completa i seguenti passaggi:

1. Rimuovi tutte le dipendenze hardcoded che fanno riferimento alla costante PAGE_SIZE o alle istanze nella logica del codice che presuppongono che la dimensione della pagina di un dispositivo sia 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 associato alle dimensioni della pagina sottostante, l'app non smetterà di funzionare quando viene utilizzata in modalità a 16 KB. Tuttavia, se questo valore viene passato al kernel con mmap senza MAP_FIXED, il kernel utilizza comunque un'intera pagina, il che spreca un po' di memoria. Per questi motivi, PAGE_SIZE non è definito quando la modalità a 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.

Controlla gli SDK per il supporto di 16 kB

Molti SDK sono compatibili con le dimensioni delle pagine di 16 KB, soprattutto se li crei tu o se utilizzi versioni precompilate recenti. Tuttavia, poiché alcuni SDK precompilati o versioni dell'SDK non sono compatibili con 16 KB, devi controllare il sito web di ogni provider di SDK per determinare quale versione utilizzare con 16 KB.

Testare l'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 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
     • Utilizzare Cuttlefish con dimensioni pagina di 16 KB su ARM64
     • Simulare Cuttlefish con dimensioni pagina di 16 KB su x86-64
   • Attivare la modalità a 16 kB su un dispositivo utilizzando le opzioni sviluppatore

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

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

5. Testa a fondo la tua app, concentrandoti su tutte le aree che potrebbero essere interessate dalla modifica delle istanze di codice che fanno riferimento a dimensioni specifiche delle pagine.

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:

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 un'esperienza ottimale quando lavori con dispositivi da 16 KB, utilizza Android Studio Ladybug | 2024.2.1 o versioni successive.

   Lavoriamo sempre su nuove funzionalità, quindi ti consigliamo di scaricare le versioni più recenti o l'ultima versione di anteprima di Android Studio non appena sono disponibili.

   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), seleziona Show Package Details (Mostra dettagli pacchetto), poi espandi la sezione Android VanillaIceCream o versioni successive e seleziona una o entrambe le seguenti immagini di sistema dell'emulatore, a seconda dei dispositivi virtuali che vuoi creare:

   • Immagine di sistema sperimentale API Google 16 KB Dimensioni pagina ARM 64 v8a
   • API Google sperimentali con dimensioni pagina di 16 KB, sistema Intel x86_64 Atom Immagine

   

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

   

Passaggi aggiuntivi per alcune versioni dell'emulatore e immagini di sistema

Per le versioni di Android Emulator dalla 35.1.5 alla 35.1.20 e prima della revisione 4 delle immagini di sistema di Android 15.0 con dimensioni di pagina di 16 KB offerte in SDK Manager, per simulare un ambiente da 16 KB sui sistemi x86_64, devi anche completare i seguenti passaggi. Questi passaggi non sono necessari dopo la versione 35.1.21 e con la revisione 4 delle immagini di sistema Android 15.0 16 KB o versioni successive.

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, trova il file config.ini.

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

   kernel.parameters = androidboot.page_shift=14
   

4. Per verificare le modifiche, esegui questo comando, che dovrebbe restituire 16384:

   adb shell getconf PAGE_SIZE
   

Avviare l'emulatore

Dopo aver completato la configurazione di Android Emulator e dei dispositivi virtuali, avvia l'emulatore dal menu del dispositivo di destinazione o dalla riga di comando.

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

Attiva l'opzione sviluppatore Avvia con dimensione pagina 16 kB per avviare un dispositivo in modalità a 16 kB.

A partire da Android 15 QPR1, puoi utilizzare l'opzione sviluppatore disponibile su alcuni dispositivi per avviare il dispositivo in modalità 16 KB ed eseguire test sul dispositivo. Prima di utilizzare l'opzione sviluppatore, vai a Impostazioni > Sistema > Aggiornamenti software e applica gli aggiornamenti disponibili.

Questa opzione sviluppatore è disponibile sui seguenti dispositivi:

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

  Avviso: a causa di un problema noto con Android 15 QPR2 Beta 3, il touchscreen non funziona sui Pixel 8 dopo l'installazione di Android 15 QPR2 Beta 3 e l'avvio del dispositivo in modalità 16 KB. Questo problema non riguarda i Pixel 8 Pro.

• Pixel 8a (con Android 15 QPR1 o versioni successive)

  Avviso: a causa di un problema noto con Android 15 QPR2 Beta 3, il touchscreen non funziona sui Pixel 8a dopo l'installazione di Android 15 QPR2 Beta 3 e l'avvio del dispositivo in modalità 16 KB.

• Pixel 9, 9 Pro e 9 Pro XL (con Android 15 QPR2 Beta 2 o versioni successive)

Requisito di compatibilità di Google Play

Man mano che i produttori di dispositivi dotano i dispositivi di più RAM per ottimizzare le prestazioni, molti adotteranno dimensioni di pagina più grandi, come 16 KB. Per prepararsi al lancio di questi dispositivi in arrivo, Google Play introduce un nuovo requisito di compatibilità: a partire dal 1° novembre 2025, tutte le nuove app e gli aggiornamenti delle app esistenti inviati a Google Play e destinati a dispositivi con Android 15 (livello API 35) e versioni successive devono supportare dimensioni di pagina di 16 KB.

Per saperne di più su questo requisito di compatibilità, consulta questo post del blog.