Membangun aplikasi dari command line

Anda dapat menjalankan semua tugas build yang tersedia untuk project Android menggunakan alat command line Gradle wrapper. Gradle tersedia sebagai file batch untuk Windows (gradlew.bat) dan skrip shell untuk Linux dan Mac (gradlew.sh), serta dapat diakses dari root setiap project yang Anda buat dengan Android Studio.

Untuk menjalankan tugas dengan wrapper, gunakan salah satu perintah berikut dari jendela Terminal (dari Android Studio, pilih View > Tool Windows > Terminal):

• Di Windows Command Shell:

  gradlew task-name
  

• Di Mac, Linux, atau Windows PowerShell:

  ./gradlew task-name
  

Untuk melihat daftar semua tugas build yang tersedia untuk project Anda, eksekusi tasks:

gradlew tasks

Bagian selanjutnya dari halaman ini menjelaskan dasar-dasar untuk mem-build dan menjalankan aplikasi Anda dengan wrapper Gradle. Untuk mengetahui informasi selengkapnya tentang cara menyiapkan build Android, lihat Mengonfigurasi build.

Jika Anda lebih suka menggunakan alat Android Studio daripada alat command line, lihat Mem-build dan menjalankan aplikasi.

Tentang jenis build

Secara default, ada dua jenis build yang tersedia untuk setiap aplikasi Android: satu untuk men-debug aplikasi—build debug—dan satu untuk merilis aplikasi kepada pengguna—build rilis. Output yang dihasilkan dari setiap build harus ditandatangani dengan sertifikat sebelum Anda dapat men-deploy aplikasi ke perangkat. Build debug otomatis ditandatangani dengan kunci debug yang disediakan oleh SDK Tools (tidak aman dan Anda tidak dapat memublikasikannya ke Google Play Store), dan build rilis harus ditandatangani dengan kunci pribadi Anda sendiri.

Jika ingin mem-build aplikasi untuk rilis, Anda juga harus menandatangani aplikasi dengan kunci penandatanganan yang sesuai. Namun, jika Anda baru memulai, Anda dapat menjalankan aplikasi dengan cepat di emulator atau perangkat terhubung dengan mem-build APK debug.

Anda juga dapat menentukan jenis build kustom dalam file build.gradle.kts dan mengonfigurasinya agar ditandatangani sebagai build debug dengan menyertakan debuggable true. Untuk informasi selengkapnya, lihat Mengonfigurasi Varian Build.

Mem-build dan men-deploy APK

Meskipun mem-build app bundle adalah cara terbaik untuk memaketkan aplikasi dan menguploadnya ke Konsol Play, mem-build APK lebih cocok jika Anda ingin menguji build debug dengan cepat atau membagikan aplikasi sebagai artefak yang dapat di-deploy kepada orang lain.

Mem-build APK debug

Untuk pengujian dan proses debug aplikasi langsung, Anda dapat mem-build APK debug. APK debug ditandatangani dengan kunci debug yang disediakan oleh SDK Tools dan memungkinkan proses debug melalui adb.

Untuk mem-build APK debug, buka command line dan arahkan ke root direktori project Anda. Untuk memulai build debug, panggil tugas assembleDebug:

gradlew assembleDebug

Tindakan ini akan membuat APK yang disebut module_name-debug.apk di project_name/module_name/build/outputs/apk/. File ini telah ditandatangani dengan kunci debug dan disesuaikan dengan zipalign, sehingga Anda dapat langsung menginstalnya di perangkat.

Atau, untuk mem-build APK dan langsung menginstalnya di emulator yang sedang berjalan atau perangkat terhubung, panggil installDebug:

gradlew installDebug

Bagian "Debug" dalam nama tugas hanyalah versi camel-case dari nama varian build, sehingga dapat diganti dengan jenis atau varian build mana pun yang ingin Anda rakit atau instal. Misalnya, jika Anda memiliki ragam produk "demo", Anda dapat mem-build versi debug dengan tugas assembleDemoDebug.

Untuk melihat semua tugas build dan instal yang tersedia bagi masing-masing varian (termasuk tugas uninstal), jalankan tugas tasks.

Lihat juga bagian tentang cara menjalankan aplikasi di emulator dan menjalankan aplikasi di perangkat.

Mem-build APK atau paket rilis

Jika sudah siap merilis dan mendistribusikan aplikasi, Anda harus mem-build APK atau paket rilis yang ditandatangani dengan kunci pribadi. Untuk mengetahui informasi selengkapnya, buka bagian tentang cara menandatangani aplikasi dari command line.

Men-deploy aplikasi Anda ke emulator

Untuk menggunakan Android Emulator, Anda harus membuat Perangkat Virtual Android (AVD) menggunakan Android Studio.

Setelah memiliki AVD, jalankan Android Emulator dan instal aplikasi Anda seperti berikut:

1. Di command line, buka android_sdk/tools/ dan mulai emulator dengan menentukan AVD Anda:

   emulator -avd <var>avd_name</var>
   

   Jika Anda tidak yakin dengan nama AVD, jalankan emulator -list-avds.

2. Sekarang Anda dapat menginstal aplikasi menggunakan salah satu tugas penginstalan Gradle yang disebutkan di bagian cara mem-build APK debug atau alat adb.

   Jika APK dibuat menggunakan SDK pratinjau developer (jika targetSdkVersion adalah huruf, bukan angka), Anda harus menyertakan opsi -t dengan perintah install untuk menginstal APK pengujian.

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

   Semua APK yang Anda build disimpan di project_name/module_name/build/outputs/apk/.

Untuk informasi selengkapnya, lihat Menjalankan Aplikasi pada Android Emulator.

Men-deploy aplikasi ke perangkat fisik

Sebelum dapat menjalankan aplikasi pada perangkat, Anda harus mengaktifkan proses debug USB di perangkat. Anda dapat menemukan opsi ini pada bagian Setelan > Opsi developer.

Catatan: Di Android 4.2 dan yang lebih baru, Opsi developer disembunyikan secara default. Agar opsi itu tersedia, buka Setelan > Tentang ponsel lalu ketuk Nomor build tujuh kali. Kembalilah ke layar sebelumnya untuk menemukan Opsi developer.

Setelah perangkat disiapkan dan terhubung menggunakan USB, Anda dapat menginstal aplikasi menggunakan tugas penginstalan Gradle yang disebutkan di bagian tentang cara mem-build APK debug atau alat adb:

adb -d install path/to/your_app.apk

Semua APK yang Anda build akan disimpan dalam project_name/module_name/build/outputs/apk/.

Untuk informasi selengkapnya, lihat Menjalankan Aplikasi di Perangkat Hardware.

Mem-build app bundle

Android App Bundle menyertakan semua kode dan resource yang dikompilasi aplikasi Anda, tetapi menangguhkan pembuatan dan penandatanganan APK ke Google Play. Tidak seperti APK, Anda tidak dapat men-deploy app bundle langsung ke perangkat. Jadi, jika Anda ingin menguji atau membagikan APK kepada orang lain dengan cepat, sebaiknya build APK.

Cara termudah untuk mem-build app bundle adalah dengan menggunakan Android Studio. Namun, jika perlu mem-build app bundle dari command line, Anda dapat melakukannya menggunakan Gradle atau bundletool, seperti yang dijelaskan di bagian berikut.

Mem-build app bundle dengan Gradle

Jika Anda lebih suka membuat app bundle dari command line, jalankan tugas Gradle bundleVariant pada modul dasar aplikasi Anda. Contohnya, perintah berikut akan mem-build app bundle untuk versi debug modul dasar:

./gradlew :base:bundleDebug

Jika ingin mem-build app bundle yang ditandatangani untuk diupload ke Konsol Play, Anda harus mengonfigurasi file build.gradle.kts modul dasar terlebih dahulu dengan informasi penandatanganan aplikasi Anda. Untuk mengetahui selengkapnya, buka bagian tentang cara Mengonfigurasi Gradle untuk menandatangani aplikasi. Setelah itu, Anda dapat, misalnya, mem-build versi rilis aplikasi, dan Gradle akan secara otomatis membuat app bundle dan menandatanganinya dengan informasi penandatanganan yang Anda berikan dalam file build.gradle.kts.

Jika ingin menandatangani app bundle secara terpisah, Anda dapat menggunakan jarsigner untuk menandatangani app bundle dari command line. Perintah untuk mem-build app bundle adalah:

jarsigner -keystore pathToKeystore app-release.aab keyAlias

Catatan: Anda tidak dapat menggunakan apksigner untuk menandatangani app bundle.

Mem-build app bundle menggunakan bundletool

bundletool adalah alat command line yang digunakan oleh Android Studio, plugin Android Gradle, dan Google Play untuk mengonversi kode dan resource yang dikompilasi aplikasi Anda menjadi app bundle, dan membuat APK yang dapat di-deploy dari paket tersebut.

Jadi, meskipun disarankan untuk menguji app bundle dengan bundletool dan membuat ulang secara lokal cara Google Play membuat APK, biasanya Anda tidak perlu memanggil bundletool untuk mem-build app bundle. Sebaiknya Anda menggunakan tugas Gradle atau Android Studio, seperti yang dijelaskan di bagian sebelumnya.

Namun, jika tidak ingin menggunakan tugas Gradle atau Android Studio untuk mem-build paket, misalnya jika menggunakan toolchain build kustom, Anda dapat menggunakan bundletool dari command line untuk mem-build app bundle dari kode dan resource yang telah dikompilasi sebelumnya. Jika Anda belum melakukannya, download bundletool dari repositori GitHub.

Bagian ini menjelaskan cara memaketkan kode dan resource yang dikompilasi aplikasi Anda, serta cara menggunakan bundletool dari command line untuk mengonversinya menjadi Android App Bundle.

Membuat manifes dan resource dalam format proto

bundletool memerlukan informasi tertentu tentang project Anda, seperti manifes dan resource aplikasi, untuk mematuhi format Buffering Protokol Google yang disebut juga sebagai "protobuf" dan menggunakan ekstensi file *.pb. Protobuf menyediakan mekanisme bahasa netral, platform netral, dan dapat diperluas untuk serialisasi data terstruktur, mirip dengan XML, tetapi lebih kecil, lebih cepat, dan lebih sederhana.

Mendownload AAPT2

Anda dapat membuat file manifes dan tabel resource aplikasi dalam format protobuf menggunakan AAPT2 versi terbaru dari repositori Maven Google.

Perhatian: Jangan gunakan versi AAPT2 yang disertakan dalam paket alat build Android—versi AAPT2 tersebut tidak mendukung bundletool.

Untuk mendownload AAPT2 dari repositori Maven Google, ikuti langkah-langkah berikut:

1. Buka com.android.tools.build > aapt2 dalam indeks repositori.
2. Salin nama versi terbaru AAPT2.

3. Masukkan nama versi yang Anda salin ke URL berikut dan tentukan sistem operasi target Anda: https://dl.google.com/dl/android/maven2/com/android/tools/build/aapt2/ aapt2-version/aapt2-aapt2-version- [windows | linux | osx].jar

   Misalnya, untuk mendownload versi 3.2.0-alpha18-4804415 untuk Windows, Anda dapat menggunakan: 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. Buka URL di browser. AAPT2 akan segera didownload.

5. Buka paket file JAR yang baru saja didownload.

Mengompilasi dan menautkan resource aplikasi Anda

Gunakan AAPT2 untuk mengompilasi resource aplikasi Anda dengan perintah berikut:

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/

Catatan: Meskipun Anda dapat meneruskan direktori resource ke AAPT2 menggunakan flag --dir, melakukannya akan mengompilasi ulang semua file dalam direktori, terlepas dari berapa banyak file yang sebenarnya berubah.

Selama fase penautan, saat AAPT2 menautkan berbagai resource yang dikompilasi ke dalam satu APK, instruksikan AAPT2 untuk mengonversi manifes dan resource yang dikompilasi aplikasi Anda ke dalam format protobuf dengan menyertakan flag --proto-format, seperti yang ditunjukkan dalam contoh berikut:

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

Catatan: Atau, saat menentukan resource yang dikompilasi dengan flag -R, Anda dapat menentukan file teks yang menyertakan jalur absolut untuk setiap resource yang dikompilasi—dengan setiap jalur dipisahkan oleh satu spasi. Kemudian, Anda dapat meneruskan file teks tersebut ke AAPT2 seperti berikut: aapt2 link ... -R @compiled_resources.txt.

Setelah itu, Anda dapat mengekstrak konten APK output, seperti AndroidManifest.xml, resources.pb, dan file resource aplikasi Anda lainnya, yang sekarang memiliki format protobuf. File ini diperlukan saat menyiapkan input bundletool yang diperlukan untuk mem-build app bundle, seperti yang dijelaskan di bagian berikut.

Memaketkan resource dan kode yang telah dikompilasi sebelumnya

Sebelum menggunakan bundletool untuk membuat app bundle bagi aplikasi, Anda harus menyediakan file ZIP terlebih dahulu, yang masing-masing berisi resource dan kode terkompilasi untuk modul aplikasi tertentu. Konten dan penyusunan setiap file ZIP modul sangat mirip dengan format Android App Bundle. Misalnya, Anda harus membuat file base.zip untuk modul dasar aplikasi dan menyusun kontennya seperti berikut:

File atau direktori	Deskripsi
manifest/AndroidManifest.xml	Manifes modul dalam format protobuf.
dex/...	Direktori dengan satu atau beberapa file DEX yang telah dikompilasi aplikasi Anda. File ini harus diberi nama sebagai berikut: classes.dex, classes2.dex, classes3.dex, etc.
res/...	Berisi resource modul dalam format protobuf untuk semua konfigurasi perangkat. Subdirektori dan file harus disusun mirip dengan APK biasa.
root/..., assets/..., dan lib/...	Direktori ini identik dengan direktori yang dijelaskan di bagian format Android app bundle.
resources.pb	Tabel resource aplikasi Anda dalam format protobuf.

Setelah menyiapkan file ZIP untuk setiap modul aplikasi, Anda dapat meneruskannya ke bundletool untuk mem-build app bundle, seperti yang dijelaskan di bagian berikut.

Mem-build app bundle menggunakan bundletool

Untuk mem-build app bundle, gunakan perintah bundletool build-bundle, seperti yang ditunjukkan dalam contoh berikut:

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

Catatan: Jika Anda berencana memublikasikan app bundle, Anda harus menandatanganinya menggunakan jarsigner. Anda tidak dapat menggunakan apksigner untuk menandatangani app bundle.

Tabel berikut menjelaskan flag untuk perintah build-bundle secara lebih mendetail:

Flag	Deskripsi
--modules=path-to-base.zip, path-to-module2.zip,path-to-module3.zip	Menentukan daftar file ZIP modul yang harus digunakan bundletool untuk mem-build app bundle Anda.
--output=path-to-output.aab	Menentukan jalur dan nama file untuk file *.aab output.
--config=path-to-BundleConfig.json	Menentukan jalur ke file konfigurasi opsional yang dapat Anda gunakan untuk menyesuaikan proses build. Untuk mempelajari lebih lanjut, lihat bagian menyesuaikan pembuatan APK downstream.
--metadata-file=target-bundle-path:local-file-path	Menginstruksikan bundletool untuk memaketkan file metadata opsional di dalam app bundle Anda. Anda dapat menggunakan file ini untuk memasukkan data, seperti pemetaan ProGuard atau daftar lengkap file DEX aplikasi, yang mungkin berguna untuk langkah-langkah lain di toolchain atau app store Anda. target-bundle-path menentukan jalur relatif ke root dari app bundle yang ingin Anda gunakan untuk mengemas file metadata, dan local-file-path menentukan jalur ke file metadata lokal itu sendiri.

Menyesuaikan pembuatan APK downstream

App bundle berisi file BundleConfig.pb yang menyediakan metadata yang dibutuhkan oleh app store, seperti Google Play, saat membuat APK dari paket tersebut. Meskipun bundletool membuat file ini secara otomatis, Anda dapat mengonfigurasi beberapa aspek metadata dalam file BundleConfig.json dan meneruskannya ke perintah bundletool build-bundle—bundletool kemudian akan mengonversi dan menggabungkan file ini dengan versi protobuf yang disertakan dalam setiap app bundle.

Catatan: Untuk mempelajari lebih lanjut cara JSON melakukan pemetaan ke format protobuf, baca Pemetaan JSON. Namun, informasi tersebut lebih kompleks daripada informasi yang diperlukan untuk halaman ini.

Misalnya, Anda dapat mengontrol kategori APK konfigurasi mana yang akan diaktifkan atau dinonaktifkan. Contoh file BundleConfig.json berikut akan menonaktifkan APK konfigurasi yang masing-masing menargetkan bahasa yang berbeda (yaitu, resource untuk semua bahasa yang disertakan dalam setiap APK dasar atau fiturnya masing-masing):

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

Dalam file BundleConfig.json, Anda juga dapat menentukan jenis file yang akan dibiarkan tidak dikompresi saat memaketkan APK menggunakan pola glob, seperti berikut:

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

Perlu diingat, secara default, bundletool tidak mengompresi library native aplikasi Anda (di Android 6.0 atau yang lebih tinggi) dan tabel resource (resources.arsc). Untuk deskripsi lengkap tentang hal yang dapat Anda konfigurasi di BundleConfig.json, periksa file config.proto bundletool, yang ditulis menggunakan sintaksis Proto3.

Men-deploy aplikasi Anda dari app bundle

Jika Anda telah mem-build dan menandatangani app bundle, gunakan bundletool untuk membuat dan men-deploy APK ke perangkat.

Menandatangani aplikasi Anda dari command line

Anda tidak memerlukan Android Studio untuk menandatangani aplikasi. Anda dapat menandatangani aplikasi dari command line, menggunakan apksigner untuk APK atau jarsigner untuk app bundle, atau mengonfigurasi Gradle untuk menandatanganinya selama build. Apa pun caranya, Anda harus membuat kunci pribadi terlebih dahulu menggunakan keytool, seperti yang ditunjukkan dalam contoh berikut:

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

Contoh ini akan meminta sandi untuk keystore dan kunci, serta untuk kolom "Nama Khusus" untuk kunci Anda. Kemudian, keystore akan dibuat sebagai file yang bernama my-release-key.jks, dan disimpan di direktori saat ini (Anda dapat memindahkannya ke mana saja). Keystore berisi satu kunci yang berlaku selama 10.000 hari.

Sekarang Anda dapat menandatangani APK atau app bundle secara manual, atau mengonfigurasi Gradle untuk menandatangani aplikasi selama proses build, seperti yang dijelaskan di bagian berikut.

Menandatangani aplikasi Anda secara manual dari command line

Jika ingin menandatangani app bundle dari command line, Anda dapat menggunakan jarsigner. Jika ingin menandatangani APK, Anda harus menggunakan zipalign dan apksigner:

1. Buka command line—dari Android Studio, pilih View > Tool Windows > Terminal—lalu buka direktori tempat APK yang tidak ditandatangani berada.

2. Sejajarkan APK yang tidak ditandatangani menggunakan zipalign:

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

   zipalign memastikan bahwa semua data yang tidak dikompresi dimulai dengan penyelarasan byte tertentu yang relatif terhadap awal file, yang dapat mengurangi jumlah RAM yang digunakan oleh aplikasi.

3. Tanda tangani APK Anda dengan kunci pribadi menggunakan apksigner:

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

   Contoh ini menghasilkan APK yang ditandatangani di my-app-release.apk setelah menandatanganinya dengan kunci pribadi dan sertifikat yang disimpan dalam satu file KeyStore: my-release-key.jks.

   Alat apksigner mendukung opsi penandatanganan lainnya, termasuk menandatangani file APK menggunakan file kunci pribadi dan sertifikat terpisah, serta menandatangani APK menggunakan beberapa penanda tangan. Untuk mengetahui detail selengkapnya, lihat referensi apksigner.

   Catatan: Untuk menggunakan alat apksigner, Anda harus menginstal Android SDK Build Tools revisi 24.0.3 atau yang lebih tinggi. Anda dapat mengupdate paket ini menggunakan SDK Manager.

4. Pastikan APK Anda telah ditandatangani:

   apksigner verify my-app-release.apk
   

Mengonfigurasi Gradle untuk menandatangani aplikasi Anda

Buka file build.gradle.kts level modul dan tambahkan blok signingConfigs {} dengan entri untuk storeFile, storePassword, keyAlias dan keyPassword, lalu teruskan objek tersebut ke properti signingConfig dalam jenis build Anda. Contoh:

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")
            ...
        }
    }
}

Groovy

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

Catatan: Dalam hal ini, sandi kunci dan keystore terlihat langsung dalam file build.gradle. Untuk meningkatkan keamanan, Anda harus menghapus informasi penandatanganan dari file build.

Sekarang, saat Anda mem-build aplikasi dengan memanggil tugas Gradle. Gradle akan menandatangani aplikasi Anda (dan menjalankan zipalign).

Selain itu, karena Anda telah mengonfigurasi build rilis dengan kunci penandatanganan, tugas "instal" akan tersedia untuk jenis build tersebut. Jadi, Anda dapat mem-build, menyesuaikan, menandatangani, dan menginstal APK rilis pada emulator atau perangkat menggunakan tugas installRelease.

Aplikasi yang ditandatangani dengan kunci pribadi Anda siap didistribusikan, tetapi Anda harus membaca lebih lanjut cara memublikasikan aplikasi dan meninjau checklist peluncuran Google Play terlebih dahulu.