Membangun aplikasi dari command line

Anda dapat menjalankan semua tugas build yang tersedia untuk project Android Anda menggunakan alat command line Gradle wrapper. Alat ini tersedia sebagai file batch untuk Windows (gradlew.bat) dan skrip shell untuk Linux dan Mac (gradlew.sh), serta dapat diakses dari root masing-masing 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 cara mem-build dan menjalankan aplikasi Anda dengan Gradle wrapper. Untuk informasi selengkapnya mengenai cara mempersiapkan build Android Anda, baca Mengonfigurasi build Anda.

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

Tentang jenis build

Secara default, ada dua jenis build yang tersedia untuk setiap aplikasi Android: satu untuk proses debug aplikasi Anda, yaitu build debug, dan satu untuk merilis aplikasi Anda kepada pengguna, yaitu build release. Hasil output dari masing-masing build harus ditandatangani dengan sebuah sertifikat sebelum Anda dapat men-deploy aplikasi ke perangkat. Build debug otomatis ditandatangani dengan kunci debug yang disediakan oleh SDK Tools (ini tidak aman dan Anda tidak dapat menggunakannya untuk publikasi ke Google Play Store), dan build rilis harus ditandatangani dengan kunci pribadi Anda sendiri.

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

Anda juga dapat mendefinisikan jenis build kustom dalam file build.gradle.kts dan mengonfigurasinya untuk 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 merupakan cara terbaik untuk memaketkan aplikasi Anda dan menguploadnya ke Konsol Play, mem-build APK akan lebih cocok jika Anda ingin menguji build debug atau membagikan aplikasi Anda kepada orang lain sebagai artefak yang dapat di-deploy.

Mem-build APK debug

Untuk pengujian dan proses debug aplikasi langsung, Anda dapat mem-build APK debug. APK debug ditandatangani menggunakan 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 pada emulator yang sedang berjalan atau perangkat yang terhubung, panggil installDebug:

gradlew installDebug

Bagian "Debug" dalam nama tugas di atas hanyalah versi camel-case dari nama varian build, sehingga dapat diganti dengan jenis atau varian build mana pun yang ingin Anda buat 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. Pada command line, buka android_sdk/tools/ dan jalankan emulator dengan menetapkan AVD:

   emulator -avd avd_name

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

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

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

   adb 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 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. Kembali ke layar sebelumnya untuk menemukan Opsi developer.

Setelah perangkat Anda siap dan terhubung melalui USB, Anda dapat menginstal aplikasi menggunakan tugas instal Gradle yang telah dijelaskan di bagian 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 dengan menggunakan Gradle atau bundletool, seperti yang dijelaskan di bawah.

Mem-build app bundle dengan Gradle

Jika Anda lebih ingin 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 paket yang ditandatangani untuk diupload ke Konsol Play, Anda perlu 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 paket aplikasi adalah:

jarsigner -keystore pathToKeystore app-release.aab keyAlias

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 versi AAPT2 terbaru dari repositori Maven Google.

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/

Selama fase penautan, ketika 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 di bawah ini:

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

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:

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 di bawah ini:

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

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

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.

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 tidak perlu dikompresi saat memaketkan APK menggunakan pola glob, sebagai berikut:

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

Ingatlah bahwa secara default, bundletool tidak mengompresi library native aplikasi Anda (di Android 6.0 atau yang lebih baru) dan tabel resource (resources.arsc). Untuk penjelasan selengkapnya tentang apa yang dapat Anda konfigurasi di BundleConfig.json, periksa file bundletool config.proto, 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

Android Studio tidak diperlukan untuk penandatanganan aplikasi. Anda dapat menandatangani aplikasi dari command line, menggunakan apksigner untuk APK atau jarsigner untuk app bundle, atau mengonfigurasi Gradle untuk menandatanganinya selama proses build. Apa pun cara yang digunakan, pertama-tama Anda harus membuat kunci pribadi menggunakan keytool, seperti di bawah ini:

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

Contoh di atas meminta sandi Anda untuk keystore dan kunci, dan untuk kolom "Nama yang Dibedakan" 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 maupun app bundle secara manual, atau mengonfigurasi Gradle untuk menandatangani aplikasi selama proses build, seperti yang dijelaskan di bagian berikut ini.

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 seperti yang dijelaskan di bawah.

1. Buka command line dari Android Studio, pilih View > Tool Windows > Terminal, lalu buka direktori lokasi APK Anda yang belum ditandatangani.

2. Sesuaikan APK yang belum ditandatangani menggunakan zipalign:

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

   zipalign memastikan semua data yang tidak dikompresi dimulai dengan penyelarasan byte tertentu secara relatif terhadap awal file, yang dapat mengurangi jumlah RAM yang digunakan oleh suatu 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 bertanda tangan pada 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 lain, termasuk menandatangani file APK menggunakan kunci pribadi dan file sertifikat yang terpisah, serta menandatangani APK menggunakan beberapa penanda tangan. Untuk detail selengkapnya, lihat referensi apksigner.

   Catatan: Agar dapat menggunakan alat apksigner, Anda harus menginstal Android SDK Build Tools versi revisi 24.0.3 atau yang lebih baru. 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:

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

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

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 sebaiknya Anda membaca terlebih dahulu cara memublikasikan aplikasi dan meninjau checklist peluncuran Google Play.