Crea la tua app dalla riga di comando

Puoi eseguire tutte le attività di build disponibili per il tuo progetto Android utilizzando lo strumento a riga di comando Gradle Wrapper. È disponibile come file batch per Windows (gradlew.bat) e come script shell per Linux e Mac (gradlew.sh) ed è accessibile dalla directory principale di ogni progetto creato con Android Studio.

Per eseguire un'attività con il wrapper, utilizza uno dei seguenti comandi da una finestra del terminale (da Android Studio, seleziona Visualizza > Finestre degli strumenti > Terminale):

• Nella shell dei comandi Windows:

  gradlew task-name
  

• Su Mac, Linux o Windows PowerShell:

  ./gradlew task-name
  

Per visualizzare un elenco di tutte le attività di build disponibili per il tuo progetto, esegui tasks:

gradlew tasks

Il resto di questa pagina descrive le nozioni di base per creare ed eseguire l'app con il wrapper Gradle. Per saperne di più su come configurare la build Android, consulta Configura la build.

Se preferisci utilizzare gli strumenti di Android Studio anziché quelli da riga di comando, consulta Crea ed esegui l'app.

Informazioni sui tipi di build

Per impostazione predefinita, sono disponibili due tipi di build per ogni app per Android: una per il debug dell'app, la build di debug, e una per il rilascio dell'app agli utenti, la build di release. L'output risultante da ogni build deve essere firmato con un certificato prima di poter eseguire il deployment dell'app su un dispositivo. La build di debug viene firmata automaticamente con una chiave di debug fornita dagli Strumenti SDK (non è sicura e non puoi utilizzarla per la pubblicazione sul Google Play Store), mentre la build di release deve essere firmata con la tua chiave privata.

Se vuoi creare la tua app per il rilascio, è importante anche firmarla con la chiave di firma appropriata. Tuttavia, se hai appena iniziato, puoi eseguire rapidamente le tue app su un emulatore o un dispositivo connesso creando un APK di debug.

Puoi anche definire un tipo di build personalizzato nel file build.gradle.kts e configurarlo in modo che venga firmato come build di debug includendo debuggable true. Per saperne di più, consulta Configura le varianti di compilazione.

Crea ed esegui il deployment di un APK

Sebbene la creazione di un app bundle sia il modo migliore per pacchettizzare l'app e caricarla su Play Console, la creazione di un APK è più adatta se vuoi testare rapidamente una build di debug o condividere l'app con altri utenti come artefatto di cui è possibile eseguire il deployment.

Crea un APK di debug

Per testare ed eseguire il debug dell'app immediatamente, puoi creare un APK di debug. L'APK di debug è firmato con una chiave di debug fornita dagli Strumenti SDK e consente il debug tramite adb.

Per creare un APK di debug, apri una riga di comando e vai alla directory principale del progetto. Per avviare una build di debug, richiama l'attività assembleDebug:

gradlew assembleDebug

Viene creato un APK denominato module_name-debug.apk in project_name/module_name/build/outputs/apk/. Il file è già firmato con la chiave di debug e allineato con zipalign, quindi puoi installarlo immediatamente su un dispositivo.

In alternativa, per creare l'APK e installarlo immediatamente su un emulatore in esecuzione o su un dispositivo connesso, richiama installDebug:

gradlew installDebug

La parte "Debug" nei nomi delle attività è solo una versione in notazione a cammello del nome della variante di compilazione, quindi può essere sostituita con qualsiasi tipo o variante di compilazione che vuoi assemblare o installare. Ad esempio, se hai una versione prodotto "demo", puoi creare la versione di debug con l'attività assembleDemoDebug.

Per visualizzare tutte le attività di build e installazione disponibili per ogni variante (incluse le attività di disinstallazione), esegui l'attività tasks.

Consulta anche la sezione su come eseguire l'app sull'emulatore ed eseguire l'app su un dispositivo.

Crea un bundle o un APK di release

Quando è tutto pronto per rilasciare e distribuire l'app, devi creare un bundle o un APK di release firmato con la tua chiave privata. Per maggiori informazioni, consulta la sezione su come firmare l'app dalla riga di comando.

Esegui il deployment dell'app nell'emulatore

Per utilizzare l'emulatore Android, devi creare un Android Virtual Device (AVD) utilizzando Android Studio.

Una volta ottenuto un AVD, avvia l'emulatore Android e installa la tua app nel seguente modo:

1. In una riga di comando, vai a android_sdk/tools/ e avvia l'emulatore specificando il tuo AVD:

   emulator -avd <var>avd_name</var>
   

   Se non conosci il nome dell'AVD, esegui emulator -list-avds.

2. Ora puoi installare l'app utilizzando una delle attività di installazione di Gradle menzionate nella sezione su come creare un APK di debug o lo strumento adb.

   Se l'APK è stato creato utilizzando un SDK Anteprima per gli sviluppatori (se targetSdkVersion è una lettera anziché un numero), devi includere l'opzione -t con il comando install per installare un APK di test.

   adb install <var>path/to/your_app</var>.apk
   

   Tutti gli APK che crei vengono salvati in project_name/module_name/build/outputs/apk/.

Per saperne di più, consulta Esegui app sull'emulatore Android.

Esegui il deployment dell'app su un dispositivo fisico

Prima di poter eseguire l'app su un dispositivo, devi attivare il debug USB sul dispositivo. Puoi trovare l'opzione in Impostazioni > Opzioni sviluppatore.

Nota: su Android 4.2 e versioni successive, Opzioni sviluppatore è nascosto per impostazione predefinita. Per renderla disponibile, vai a Impostazioni > Informazioni sullo smartphone e tocca Numero build sette volte. Torna alla schermata precedente per trovare Opzioni sviluppatore.

Una volta configurato e connesso il dispositivo tramite USB, puoi installare l'app utilizzando le attività di installazione di Gradle menzionate nella sezione su come creare un APK di debug o lo strumento adb:

adb -d install path/to/your_app.apk

Tutti gli APK che crei vengono salvati in project_name/module_name/build/outputs/apk/.

Per saperne di più, consulta Esegui app su un dispositivo hardware.

Crea un app bundle

Gli Android App Bundle includono tutto il codice e le risorse compilati della tua app, ma rimandano la generazione e la firma dell'APK a Google Play. A differenza di un APK, non puoi eseguire il deployment di un app bundle direttamente su un dispositivo. Pertanto, se vuoi testare o condividere rapidamente un APK con un'altra persona, devi creare un APK.

Il modo più semplice per creare un app bundle è utilizzare Android Studio. Tuttavia, se devi creare un app bundle dalla riga di comando, puoi farlo utilizzando Gradle o bundletool, come descritto nelle sezioni seguenti.

Crea un app bundle con Gradle

Se preferisci generare un app bundle dalla riga di comando, esegui l'attività Gradle bundleVariant sul modulo di base della tua app. Ad esempio, il comando seguente crea un app bundle per la versione di debug del modulo di base:

./gradlew :base:bundleDebug

Se vuoi creare un bundle firmato da caricare su Play Console, devi prima configurare il file build.gradle.kts del modulo di base con le informazioni di firma dell'app. Per scoprire di più, vai alla sezione su come configurare Gradle per firmare l'app. In seguito, puoi ad esempio creare la versione di release dell'app e Gradle genera automaticamente un app bundle e lo firma con le informazioni di firma fornite nel file build.gradle.kts.

Se invece vuoi firmare un app bundle come passaggio separato, puoi utilizzare jarsigner per firmare l'app bundle dalla riga di comando. Il comando per creare un app bundle è:

jarsigner -keystore pathToKeystore app-release.aab keyAlias

Nota: non puoi utilizzare apksigner per firmare l'app bundle.

Crea un app bundle utilizzando bundletool

bundletool è uno strumento a riga di comando utilizzato da Android Studio, dal plug-in Android Gradle e da Google Play per convertire il codice compilato e le risorse della tua app in app bundle e generare APK di cui è possibile eseguire il deployment da questi bundle.

Pertanto, sebbene sia utile testare gli app bundle con bundletool e ricreare localmente il modo in cui Google Play genera gli APK, in genere non è necessario richiamare bundletool per creare l'app bundle stesso. Dovresti invece utilizzare le attività di Android Studio o Gradle, come descritto nelle sezioni precedenti.

Tuttavia, se non vuoi utilizzare Android Studio o le attività Gradle per creare bundle, ad esempio se utilizzi una toolchain di build personalizzata, puoi utilizzare bundletool dalla riga di comando per creare un app bundle da codice e risorse precompilati. Se non l'hai ancora fatto, scarica bundletool dal repository GitHub.

Questa sezione descrive come pacchettizzare il codice e le risorse compilati della tua app e come utilizzare bundletool dalla riga di comando per convertirli in un Android App Bundle.

Genera il manifest e le risorse in formato proto

bundletool richiede che alcune informazioni sul progetto dell'app, ad esempio il manifest e le risorse dell'app, siano nel formato buffer di protocollo di Google, noto anche come "protobuf", che utilizza l'estensione del file *.pb. I protobuf forniscono un meccanismo indipendente dal linguaggio, indipendente dalla piattaforma ed estensibile per la serializzazione dei dati strutturati, simile a XML, ma più piccolo, più veloce e più semplice.

Scarica AAPT2

Puoi generare il file manifest e la tabella delle risorse della tua app in formato protobuf utilizzando l'ultima versione di AAPT2 dal repository Maven di Google.

Attenzione: non utilizzare la versione di AAPT2 inclusa nel pacchetto di strumenti di build di Android, in quanto non supporta bundletool.

Per scaricare AAPT2 dal repository Maven di Google, procedi nel seguente modo:

1. Vai a com.android.tools.build > aapt2 nell'indice del repository.
2. Copia il nome dell'ultima versione di AAPT2.

3. Inserisci il nome della versione che hai copiato nel seguente URL e specifica il sistema operativo di destinazione: https://dl.google.com/dl/android/maven2/com/android/tools/build/aapt2/ aapt2-version/aapt2-aapt2-version- [windows | linux | osx].jar

   Ad esempio, per scaricare la versione 3.2.0-alpha18-4804415 per Windows, devi utilizzare: https://dl.google.com/dl/android/maven2/com/android/tools/build/aapt2/3.2.0-alpha18-4804415/aapt2-3.2.0-alpha18-4804415-windows.jar

4. Vai all'URL in un browser. Il download di AAPT2 dovrebbe iniziare a breve.

5. Decomprimi il file JAR appena scaricato.

Compila e collega le risorse della tua app

Utilizza AAPT2 per compilare le risorse della tua app con il seguente comando:

aapt2 compile \
project_root/module_root/src/main/res/drawable/Image1.png \
project_root/module_root/src/main/res/drawable/Image2.png \
-o compiled_resources/

Nota: anche se puoi passare le directory delle risorse ad AAPT2 utilizzando il flag --dir, in questo modo vengono ricompilati tutti i file nella directory, indipendentemente dal numero di file effettivamente modificati.

Durante la fase di collegamento, in cui AAPT2 collega le varie risorse compilate in un singolo APK, indica ad AAPT2 di convertire il manifest e le risorse compilate dell'app nel formato protobuf includendo il flag --proto-format, come mostrato nell'esempio seguente:

aapt2 link --proto-format -o output.apk \
-I android_sdk/platforms/android_version/android.jar \
--manifest project_root/module_root/src/main/AndroidManifest.xml \
-R compiled_resources/*.flat \
--auto-add-overlay

Nota: in alternativa, quando specifichi le risorse compilate con il flag -R, puoi specificare un file di testo che includa il percorso assoluto di ciascuna delle risorse compilate, con ogni percorso separato da un singolo spazio. Puoi quindi passare il file di testo ad AAPT2 come segue: aapt2 link ... -R @compiled_resources.txt.

Puoi quindi estrarre i contenuti dall'APK di output, ad esempio i file AndroidManifest.xml, resources.pb e altri file di risorse della tua app, ora nel formato protobuf. Questi file sono necessari per preparare l'input richiesto da bundletool per creare l'app bundle, come descritto nella sezione seguente.

Pacchetto di codice e risorse precompilati

Prima di utilizzare bundletool per generare un app bundle per la tua app, devi fornire i file ZIP che contengono il codice e le risorse compilati per un determinato modulo dell'app. I contenuti e l'organizzazione del file ZIP di ogni modulo sono molto simili a quelli del formato Android App Bundle. Ad esempio, devi creare un file base.zip per il modulo di base della tua app e organizzarne i contenuti come segue:

File o directory	Descrizione
manifest/AndroidManifest.xml	Il manifest del modulo in formato protobuf.
dex/...	Una directory con uno o più file DEX compilati della tua app. Questi file devono essere denominati come segue: classes.dex, classes2.dex, classes3.dex e così via.
res/...	Contiene le risorse del modulo in formato protobuf per tutte le configurazioni del dispositivo. Le sottodirectory e i file devono essere organizzati in modo simile a un APK tipico.
root/..., assets/... e lib/...	Queste directory sono identiche a quelle descritte nella sezione relativa al formato Android App Bundle.
resources.pb	La tabella delle risorse della tua app in formato protobuf.

Dopo aver preparato il file ZIP per ogni modulo della tua app, puoi passarlo a bundletool per creare l'app bundle, come descritto nella sezione seguente.

Crea l'app bundle utilizzando bundletool

Per creare l'app bundle, utilizza il comando bundletool build-bundle, come mostrato nell'esempio seguente:

bundletool build-bundle --modules=base.zip --output=mybundle.aab

Nota: se prevedi di pubblicare l'app bundle, devi firmarlo utilizzando jarsigner. Non puoi utilizzare apksigner per firmare l'app bundle.

La tabella seguente descrive in modo più dettagliato i flag per il comando build-bundle:

Flag	Descrizione
--modules=path-to-base.zip, path-to-module2.zip,path-to-module3.zip	Specifica l'elenco di file ZIP dei moduli che bundletool deve utilizzare per creare l'app bundle.
--output=path-to-output.aab	Specifica il percorso e il nome file del file *.aab di output.
--config=path-to-BundleConfig.json	Specifica il percorso di un file di configurazione facoltativo che puoi utilizzare per personalizzare il processo di build. Per scoprire di più, consulta la sezione relativa alla personalizzazione della generazione di APK downstream.
--metadata-file=target-bundle-path:local-file-path	Indica a bundletool di pacchettizzare un file di metadati facoltativo all'interno dell'app bundle. Puoi utilizzare questo file per includere dati, ad esempio le mappature ProGuard o l'elenco completo dei file DEX della tua app, che potrebbero essere utili per altri passaggi della tua toolchain o di uno store. target-bundle-path specifica un percorso relativo alla radice dell'app bundle in cui vuoi pacchettizzare il file di metadati e local-file-path specifica il percorso del file di metadati locale stesso.

Personalizza la generazione di APK downstream

Gli app bundle includono un file BundleConfig.pb che fornisce i metadati richiesti dagli store, come Google Play, durante la generazione degli APK dal bundle. Sebbene bundletool crei questo file per te, puoi configurare alcuni aspetti dei metadati in un file BundleConfig.json e passarlo al comando bundletool build-bundle. bundletool converte e unisce questo file con la versione protobuf inclusa in ogni app bundle.

Nota: per scoprire di più su come il formato JSON viene mappato al formato protobuf, leggi Mappatura JSON. Tuttavia, queste informazioni sono più avanzate di quelle richieste per questa pagina.

Ad esempio, puoi controllare quali categorie di APK di configurazione attivare o disattivare. L'esempio seguente di un file BundleConfig.json disattiva gli APK di configurazione, ciascuno dei quali ha come target una lingua diversa (ovvero le risorse per tutte le lingue sono incluse nei rispettivi APK di base o delle funzionalità):

{
  "optimizations": {
    "splitsConfig": {
      "splitDimension": [{
        "value": "LANGUAGE",
        "negate": true
      }]
    }
  }
}

Nel file BundleConfig.json, puoi anche specificare quali tipi di file lasciare non compressi durante la pacchettizzazione degli APK utilizzando i pattern glob, come segue:

{
  "compression": {
    "uncompressedGlob": ["res/raw/**", "assets/**.uncompressed"]
  }
}

Tieni presente che, per impostazione predefinita, bundletool non comprime le librerie native dell'app (su Android 6.0 o versioni successive) e la tabella delle risorse (resources.arsc). Per una descrizione completa di ciò che puoi configurare nel tuo BundleConfig.json, controlla il file bundletool config.proto, scritto utilizzando la sintassi Proto3.

Esegui il deployment dell'app da un app bundle

Se hai creato e firmato un app bundle, utilizza bundletool per generare gli APK ed eseguirne il deployment su un dispositivo.

Firma l'app dalla riga di comando

Non è necessario Android Studio per firmare l'app. Puoi firmarla dalla riga di comando utilizzando apksigner per gli APK o jarsigner per gli app bundle oppure configurare Gradle in modo che la firmi durante la build. In entrambi i casi, devi prima generare una chiave privata utilizzando keytool, come mostrato nell'esempio seguente:

keytool -genkey -v -keystore my-release-key.jks -keyalg RSA -keysize 2048 -validity 10000 -alias my-alias

Questo esempio ti chiede le password per l'archivio chiavi e la chiave, nonché i campi "Nome distinto" per la chiave. Quindi genera il keystore come file denominato my-release-key.jks, salvandolo nella directory corrente (puoi spostarlo dove preferisci). Il keystore contiene una singola chiave valida per 10.000 giorni.

Ora puoi firmare manualmente l'APK o l'app bundle oppure configurare Gradle per firmare l'app durante il processo di build, come descritto nelle sezioni seguenti.

Firma l'app manualmente dalla riga di comando

Se vuoi firmare un app bundle dalla riga di comando, puoi utilizzare jarsigner. Se invece vuoi firmare un APK, devi utilizzare zipalign e apksigner:

1. Apri una riga di comando: da Android Studio, seleziona Visualizza > Finestre degli strumenti > Terminale e vai alla directory in cui si trova l'APK non firmato.

2. Allinea l'APK non firmato utilizzando zipalign:

   zipalign -v -p 4 my-app-unsigned.apk my-app-unsigned-aligned.apk
   

   zipalign garantisce che tutti i dati non compressi inizino con un particolare allineamento dei byte rispetto all'inizio del file, il che potrebbe ridurre la quantità di RAM utilizzata da un'app.

3. Firma l'APK con la tua chiave privata utilizzando apksigner:

   apksigner sign --ks my-release-key.jks --out my-app-release.apk my-app-unsigned-aligned.apk
   

   Questo esempio genera l'APK firmato in my-app-release.apk dopo averlo firmato con una chiave privata e un certificato archiviati in un singolo file KeyStore: my-release-key.jks.

   Lo strumento apksigner supporta altre opzioni di firma, tra cui la firma di un file APK utilizzando file di chiave privata e certificato separati e la firma di un APK utilizzando più firmatari. Per maggiori dettagli, consulta il riferimento apksigner.

   Nota: per utilizzare lo strumento apksigner, devi aver installato la revisione 24.0.3 o una versione successiva degli strumenti di build dell'SDK Android. Puoi aggiornare questo pacchetto utilizzando SDK Manager.

4. Verifica che l'APK sia firmato:

   apksigner verify my-app-release.apk
   

Configura Gradle per firmare l'app

Apri il file build.gradle.kts a livello di modulo e aggiungi il blocco signingConfigs {} con le voci per storeFile, storePassword, keyAlias e keyPassword, quindi passa l'oggetto alla proprietà signingConfig nel tipo di build. Ad esempio:

Kotlin

android {
    ...
    defaultConfig { ... }
    signingConfigs {
        create("release") {
            // You need to specify either an absolute path or include the
            // keystore file in the same directory as the build.gradle file.
            storeFile = file("my-release-key.jks")
            storePassword = "password"
            keyAlias = "my-alias"
            keyPassword = "password"
        }
    }
    buildTypes {
        getByName("release") {
            signingConfig = signingConfigs.getByName("release")
            ...
        }
    }
}

Alla moda

android {
    ...
    defaultConfig { ... }
    signingConfigs {
        release {
            // You need to specify either an absolute path or include the
            // keystore file in the same directory as the build.gradle file.
            storeFile file("my-release-key.jks")
            storePassword "password"
            keyAlias "my-alias"
            keyPassword "password"
        }
    }
    buildTypes {
        release {
            signingConfig signingConfigs.release
            ...
        }
    }
}

Nota: in questo caso, il keystore e la password della chiave sono visibili direttamente nel file build.gradle. Per una maggiore sicurezza, devi rimuovere le informazioni di firma dal file di build.

Ora, quando crei la tua app richiamando un'attività Gradle, Gradle firma l'app (ed esegue zipalign) per te.

Inoltre, poiché hai configurato la build di release con la tua chiave di firma, l'attività "install" è disponibile per quel tipo di build. In questo modo, puoi creare, allineare, firmare e installare l'APK di release su un emulatore o un dispositivo, il tutto con l'attività installRelease.

Un'app firmata con la tua chiave privata è pronta per la distribuzione, ma prima dovresti leggere ulteriori informazioni su come pubblicare la tua app ed esaminare l'elenco di controllo per il lancio su Google Play.