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 shell script 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 un Finestra Terminale (da Android Studio, seleziona Visualizza > Finestre strumenti > Terminale):

• Su Command Shell di 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 del tuo progetto, esegui tasks:

gradlew tasks

Il resto di questa pagina descrive le nozioni di base per creare ed eseguire la tua app con il wrapper Gradle. Per ulteriori informazioni su come configurare Build Android, consulta Configurare la tua build.

Se preferisci utilizzare gli strumenti di Android Studio anziché la riga di comando consulta Creare ed eseguire l'app.

Informazioni sui tipi di build

Per impostazione predefinita, sono disponibili due tipi di build per ogni app per Android: per il debug dell'app, la build debug, e una per il rilascio dell'app per gli utenti: la build di release. L'output risultante da ogni la build deve essere firmata con un certificato prima di poter eseguire il deployment dell'app in un dispositivo. La build di debug viene firmata automaticamente con una chiave di debug fornita dalla Strumenti SDK (non sono sicuri e non possono essere pubblicati su Google Play) Store) e la build della release deve essere firmata con la tua chiave privata.

Se vuoi sviluppare l'app per il rilascio, è importante che Firma l'app con la chiave di firma appropriata. Se hai appena iniziato, tuttavia, puoi eseguire rapidamente le tue app su un emulatore o un dispositivo connesso creare un APK di debug.

Puoi anche definire un tipo di build personalizzato in build.gradle.kts e configurarlo affinché venga firmato come build di debug includendo debuggable true. Per ulteriori informazioni, consulta Configurare le varianti della build.

Crea ed esegui il deployment di un APK

Sebbene creare un app bundle sia il modo migliore pacchettizzare la tua app e caricarla su Play Console; è meglio creare un APK. adatto a quando vuoi testare rapidamente una build di debug o condividere la tua app come artefatto di cui è possibile eseguire il deployment con gli altri.

Creare un APK di debug

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

Per creare un APK di debug, apri una riga di comando e vai alla directory radice del tuo della directory di un progetto. Per avviare una build di debug, richiama il metodo assembleDebug attività:

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, in modo da poter installarlo immediatamente su un dispositivo.

Oppure creare l'APK e installarlo immediatamente su un emulatore in esecuzione o dispositivo connesso, richiama invece installDebug:

gradlew installDebug

La sezione "Debug" dei nomi delle attività qui sopra è solo un versione camel-case del nome della variante build, quindi può essere sostituita con qualsiasi tipo di build o che vuoi assemblare o installare. Ad esempio, se hai una "demo" versione di prodotto, puoi creare la versione di debug con assembleDemoDebug attività.

Per visualizzare tutte le attività di creazione e installazione disponibili per ogni variante (tra cui disinstallare le attività), esegui l'attività tasks.

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

Creare un APK o bundle di release

Quando è tutto pronto per rilasciare e distribuire la tua app, devi creare un un bundle di release o un APK firmato con la tua chiave privata. Per ulteriori informazioni, vai alla sezione su come firmare l'app dal dall'interfaccia a riga di comando.

Esegui il deployment dell'app nell'emulatore

Per utilizzare l'emulatore Android, devi creare un'istanza virtuale Android Dispositivo (AVD) che utilizza Android Studio.

Una volta che disponi di una durata di visualizzazione media, avvia l'emulatore Android e installa il tuo dell'app nel modo seguente:

1. In una riga di comando, passa android_sdk/tools/ e avvia l'emulatore che specifica la durata di visualizzazione media:

   emulator -avd avd_name

   Se hai dubbi sul nome della durata di visualizzazione media, esegui emulator -list-avds.

2. Ora puoi installare la tua app utilizzando una delle attività di installazione di Gradle menzionata nella sezione su come creare un APK di debug o il Strumento adb.

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

   adb install path/to/your_app.apk
   

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

Per ulteriori informazioni, vedi Eseguire app sull'emulatore Android.

Esegui il deployment dell'app su un dispositivo fisico

Per poter eseguire l'app su un dispositivo, devi prima attivare l'opzione USB debug sul tuo dispositivo. Puoi trovare l'opzione in Impostazioni > Opzioni sviluppatore.

Nota:su Android 4.2 e versioni successive, Le Opzioni sviluppatore sono nascoste per impostazione predefinita. Per renderla disponibile, vai a Impostazioni > Informazioni sullo smartphone e tocca Crea numero sette volte. Torna alla schermata precedente per trovare Opzioni sviluppatore.

Dopo aver configurato e collegato il dispositivo tramite USB, puoi installare l'app utilizzando le attività di installazione Gradle menzionate nella sezione su come creare un APK di debug o 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 ulteriori informazioni, vedi Esecuzione di app su un dispositivo hardware.

Creare un app bundle

Gli Android App Bundle includono tutte le funzioni della tua app il codice compilato e le risorse, ma rimanda la generazione e la firma degli APK a Google Gioca. A differenza di un APK, non puoi implementare un app bundle direttamente su un dispositivo. Quindi, se vuoi testare o condividere rapidamente un APK con qualcuno in caso contrario, dovresti creare un APK.

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

Creare un app bundle con Gradle

Se preferisci generare un app bundle dalla riga di comando, esegui bundleVariant attività Gradle nel 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: per configurare prima il file build.gradle.kts del modulo di base con il informazioni sulla firma. Per saperne di più, vai alla sezione su come Configura Gradle per firmare la tua app. Quindi, ad esempio, puoi creare la versione di release della tua app e Gradle genera automaticamente un app bundle e lo firma con il 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 gruppo è:

jarsigner -keystore pathToKeystore app-release.aab keyAlias

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

Creare un app bundle utilizzando bundletool

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

Quindi, sebbene sia utile testare app bundle con bundletool e ricreare localmente la modalità di generazione degli APK da parte di Google Play, di solito non c'è richiamare bundletool per creare l'app bundle stesso; dovresti invece usare le attività di Android Studio o Gradle, come descritto nelle sezioni precedenti.

Tuttavia, se non vuoi utilizzare le attività Android Studio o 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 a partire da codice precompilato Google Cloud. Se non l'hai ancora fatto, scarica bundletool dal repository GitHub.

Questa sezione descrive come pacchettizzare il codice compilato dell'app e le risorse, e come utilizzare bundletool dalla riga di comando per convertirli in un Android App Bundle.

Genera il manifest e le risorse in formato protocollo

bundletool richiede determinate informazioni sul progetto dell'app, ad esempio al file manifest e alle risorse dell'app, in modo che formato buffer di protocollo di Google, che è anche noto come "protobuf" e utilizza l'estensione del file *.pb. Protobuf forniscono un meccanismo neutrale dal linguaggio, dalla piattaforma ed estensibile per serializzare i dati strutturati: è simile a XML, ma più piccolo, più veloce più semplice.

Scarica AAPT2

Puoi generare il file manifest e la tabella delle risorse dell'app in utilizzando l'ultima versione di AAPT2 del Repository Maven di Google.

Attenzione :non utilizzare la versione di AAPT2 inclusa nella build Android di terze parti, la versione di AAPT2 non supporta bundletool.

Per scaricare AAPT2 dal Repository Maven di Google, procedi come segue:

1. Vai a com.android.tools.build > aapt2 del indice del repository.
2. Copia il nome della versione più recente di AAPT2.

3. Inserisci il nome della versione che hai copiato nell'URL seguente e specifica sistema operativo target: 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 userebbe: 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. Rimuovi il pacchetto del file JAR che hai appena scaricato.

Compila e collega le risorse dell'app

Usa 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 da quanti è cambiato.

Durante la fase di collegamento, in cui AAPT2 collega le varie risorse compilate in un singolo APK, indica ad AAPT2 di convertire il file manifest e le risorse compilate della tua app nel formato protobuf includendo il flag --proto-format, come mostrato di seguito:

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, specificare un file di testo che includa il percorso assoluto per le risorse compilate, con ogni percorso separato da un singolo spazio. Puoi quindi passa quel file di testo ad AAPT2 nel seguente modo: aapt2 link ... -R @compiled_resources.txt.

Puoi quindi estrarre i contenuti dall'APK di output, ad esempio AndroidManifest.xml, resources.pb e altri file di risorse, ora nel formato protobuf. Questi file ti servono durante la preparazione dell'input bundletool richiede la creazione dell'app bundle, come descritto di seguito .

Pacchettizzazione di codice e risorse precompilati

Prima di utilizzare bundletool per generare un app bundle per la tua app, devi: fornire innanzitutto file ZIP contenenti il codice compilato e le risorse per un un determinato modulo dell'app. I contenuti e l'organizzazione del file ZIP di ogni modulo sono molto simile a quello del formato Android App Bundle. Ad esempio, devi creare un file base.zip per il modulo di base dell'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 dell'app. Questi file deve essere nominato come segue: classes.dex, classes2.dex, classes3.dex e così via.
res/...	Contiene le risorse del modulo in formato protobuf per tutti i dispositivi configurazioni. Le sottodirectory e i file devono essere organizzati in modo simile di un APK tipico.
root/..., assets/... e lib/...	Queste directory sono identiche a quelle descritte nella sezione il formato Android App Bundle.
resources.pb	La tabella delle risorse dell'app in formato protobuf.

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

Creare l'app bundle utilizzando bundletool

Per creare l'app bundle, utilizza il comando bundletool build-bundle, come come mostrato di seguito:

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

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

La seguente tabella descrive i flag per il comando build-bundle in dettaglio:

Segnala	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 per creare l'app bundle.
--output=path-to-output.aab	Specifica il percorso e il nome file per il file *.aab di output.
--config=path-to-BundleConfig.json	Specifica il percorso di un file di configurazione facoltativo che puoi utilizzare per per personalizzare il processo di compilazione. Per saperne di più, consulta la sezione su personalizzando la generazione degli 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 usare questo file per includere dati come le mappature ProGuard o l'elenco completo dei file DEX dell'app, che potrebbero essere utile per altri passaggi nella catena di strumenti o in uno store. target-bundle-path specifica un percorso relativo alla radice di all'app bundle in cui vuoi pacchettizzare il file di metadati, e local-file-path specifica il percorso dei metadati locali .

Personalizza la generazione di APK downstream

Gli app bundle includono un file BundleConfig.pb che fornisce i metadati dell'app come Google Play, richiedono la generazione di APK dal bundle. Anche se bundletool crea questo file per te, puoi configurare alcuni aspetti dei metadati in un file BundleConfig.json e passarli alla Comando bundletool build-bundle: in seguito, bundletool converte e unisce questo con la versione protobuf inclusa in ogni app bundle.

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

Ad esempio, puoi controllare quali categorie di APK di configurazione attivare o disattivare. Il seguente esempio di disattivazione di un file BundleConfig.json di configurazione che hanno come target una lingua diversa (vale a dire di risorse in tutte le lingue sono incluse nelle rispettive base APK in primo piano):

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

Nel file BundleConfig.json, puoi anche specificare i tipi di file da abbandonare non compresso quando pacchettizza gli APK utilizzando pattern glob, come segue:

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

Tieni presente che, per impostazione predefinita, bundletool non comprime lo spazio librerie (su Android 6.0 o versioni successive) e risorse (resources.arsc). Per una descrizione completa di ciò che puoi configurare il tuo BundleConfig.json, controlla bundletool config.proto , scritto utilizzando Proto3 a riga di comando.

Eseguire il deployment dell'app da un app bundle

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

Firma la tua app dalla riga di comando

Non è necessario Android Studio per firmare l'app. Puoi firmare la tua app da la riga di comando, utilizzando apksigner per gli APK o jarsigner per gli app bundle, o configurare Gradle in modo che lo firmi per te durante la creazione. In ogni caso, devi generi prima una chiave privata keytool, come mostrato di seguito:

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

Nell'esempio precedente vengono richieste le password per l'archivio chiavi e la chiave, nonché per il "Nome distinto" campi per la chiave. Genera quindi dell'archivio chiavi in un file denominato my-release-key.jks, che viene salvato nel directory corrente (puoi spostarla dove vuoi). Archivio chiavi contiene una singola chiave valida per 10.000 giorni.

Ora puoi firmare manualmente l'APK o l'app bundle oppure configurare Gradle per la firma durante il processo di creazione dell'app, come descritto nelle sezioni che seguono.

Firma manuale l'app dalla riga di comando

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

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

2. Allinea l'APK non firmato utilizzando zipalign:

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

   zipalign assicura che tutti i dati non compressi inizino con un un particolare allineamento byte rispetto all'inizio del file, ridurre la quantità di RAM consumata 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 restituisce l'APK firmato in my-app-release.apk dopo averlo firmato con una chiave privata e un certificato memorizzati singolo file KeyStore: my-release-key.jks.

   Lo strumento apksigner supporta altre opzioni di firma, tra cui firmare un file APK usando file di certificati e chiave privata separati; e firmare un APK usando più firmatari. Per maggiori dettagli, consulta apksigner riferimento.

   Nota: per utilizzare lo strumento apksigner, devi Avere installato la versione 24.0.3 o successiva di Android SDK Build Tools. Puoi aggiornare questo pacchetto utilizzando SDK Manager.

4. Verifica che l'APK sia firmato:

   apksigner verify my-app-release.apk
   

Configura Gradle per firmare la tua app

Apri il file build.gradle.kts a livello di modulo e aggiungi il Blocco signingConfigs {} con voci per storeFile, storePassword, keyAlias e keyPassword, quindi passa quell'oggetto al signingConfig nel tuo 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, l'archivio chiavi e la password della chiave sono visibili direttamente nel file build.gradle. Per una maggiore sicurezza, devi rimuovere le informazioni sulla firma dal file di build.

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

Inoltre, poiché hai configurato la build della release con la chiave di firma, il comando "install" è disponibile un'attività per quel tipo di build. Quindi puoi creare, allineare e installa l'APK di release su un emulatore o un dispositivo, il tutto con installRelease attività.

Un'app firmata con la tua chiave privata è pronta per la distribuzione, ma dovresti scopri innanzitutto come pubblicare l'app ed esamina l'elenco di controllo per il lancio di Google Play.