Membuat aplikasi dari command line

Anda dapat menjalankan semua tugas build yang tersedia untuk project Android Anda menggunakan fitur command line Gradle Wrapper. Fitur ini tersedia sebagai kumpulan file 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 Lihat > Jendela Fitur > Terminal):

  • Di Windows:
    gradlew task-name
  • Di Mac atau Linux:
    ./gradlew task-name

Untuk melihat daftar semua tugas pembuatan yang tersedia bagi project Anda, jalankan tasks:

    gradlew tasks
    

Bagian halaman selanjutnya menjelaskan dasar-dasar tentang cara membuat dan menjalankan aplikasi Anda dengan Gradle wrapper. Untuk informasi selengkapnya mengenai cara mempersiapkan Android build Anda, lihat Mengonfigurasi build Anda.

Jika Anda lebih suka menggunakan fitur Android Studio daripada fitur command-line, lihat Membuat 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. Versi debug secara otomatis ditandatangani dengan kunci debug yang disediakan oleh fitur SDK (tidak aman dan Anda tidak dapat memublikasikan APK ke Google Play Store), dan versi rilis harus ditandatangani dengan kunci pribadi Anda sendiri.

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

Anda juga dapat mendefinisikan jenis build khusus dalam file build.gradle Anda dan mengonfigurasinya untuk ditandatangani sebagai build debug dengan menyertakan debuggable true. Untuk informasi selengkapnya, lihat Mengonfigurasi Varian Build.

Membuat dan men-deploy APK

Meskipun membuat app bundle merupakan cara terbaik untuk mengemas aplikasi Anda dan menguploadnya ke Konsol Play, membuat APK akan lebih cocok jika Anda ingin menguji build debug atau membagikan aplikasi Anda kepada orang lain sebagai artefak yang dapat di-deploy.

Membuat APK debug

Untuk pengujian dan proses debug aplikasi dengan seketika, Anda dapat membuat APK debug. APK debug ditandatangani menggunakan kunci debug yang disediakan oleh fitur SDK dan memungkinkan proses debug melalui adb.

Untuk membuat 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 dengan nama module_name-debug.apk di project_name/module_name/build/outputs/apk/. File ini sudah ditandatangani dengan kunci debug dan diselaraskan dengan zipalign, sehingga Anda dapat langsung menginstalnya di perangkat.

Atau, untuk membuat APK dan langsung menginstalnya pada emulator yang sedang berjalan atau perangkat yang terhubung, gunakan installDebug:

gradlew installDebug

Bagian "Debug" dalam nama tugas di atas hanyalah versi camel-case dari nama varian build, sehingga dapat diganti dengan varian build mana pun yang ingin Anda buat atau instal. Misalnya, jika Anda memiliki ragam produk "demo", Anda dapat membuat 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.

Membuat APK rilis

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

Men-deploy aplikasi Anda ke emulator

Untuk menggunakan Android Emulator, Anda harus membuat Android Virtual Device (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, jalankan emulator -list-avds.

  2. Sekarang Anda dapat menginstal aplikasi menggunakan salah satu dari tugas instal Gradle yang telah dijelaskan di bagian Membuat APK debug atau fitur adb.

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

        adb install path/to/your_app.apk
        

    Semua APK yang Anda buat akan 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 di Setelan > Opsi developer.

Catatan: Di Android 4.2 dan yang lebih baru, opsi developer disembunyikan secara default. Agar terlihat, buka Setelan > Tentang telepon lalu ketuk Nomor build sebanyak 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 Membuat APK debug atau fitur adb:

    adb -d install path/to/your_app.apk
    

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

Untuk informasi selengkapnya, lihat Menjalankan Aplikasi di Perangkat Hardware.

Membuat app bundle

Android App Bundle menyertakan semua kode dan resource yang dikompilasi aplikasi Anda, tetapi menangguhkan pembuatan dan penandatangan 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 buat APK.

Cara termudah untuk mebuat app bundle adalah dengan menggunakan Android Studio. Namun, jika Anda harus membuat app bundle dari command line, Anda dapat melakukannya menggunakan Gradle atau bundletool, seperti yang dijelaskan pada bagian di bawah.

Membuat 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 membuat app bundle untuk versi debug modul dasar:

./gradlew :base:bundleDebug
    

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

Jika ingin menandatangani app bundle secara terpisah, Anda dapat menggunakan jarsigner untuk menandatangani app bundle dari command line.

Membuat app bundle menggunakan bundletool

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

Jadi, meskipun disarankan untuk menguji app bundle dengan bundletool dan mengkreasi kembali secara lokal bagaimana Google Play menghasilkan APK secara lokal, biasanya Anda tidak perlu memanggil bundletool untuk membuat app bundle—sebaiknya Anda menggunakan Android Studio atau tugas Gradle, seperti dijelaskan di bagian sebelumnya.

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

Bagian ini menjelaskan cara mengemas kode dan resource yang dikompilasi oleh aplikasi Anda, dan cara menggunakan bundletool dari command line untuk mengubahnya menjadi Android App Bundle.

Membuat manifes dan resource dalam format proto

bundletool memerlukan informasi tertentu tentang project aplikasi 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 Google Maven.

Untuk mendownload AAPT2 dari repositori Google Maven, 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 telah 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- alfa18-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.

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, di mana AAPT2 menautkan berbagai resource yang dikompilasi ke dalam satu APK, instruksikan AAPT2 untuk mengubah resource Anda dan mengompilasinya ke dalam format protobuf dengan memasukkan flag --proto-format, seperti yang ditunjukkan 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
    

Anda kemudian dapat mengekstraksi konten dari APK output, seperti AndroidManifest.xml dan resources.pb aplikasi Anda beserta file resource lainnya, kini dalam format protobuf. Anda memerlukan file-file ini saat mempersiapkan input yang diperlukan bundletool untuk membuat app bundle, seperti yang dijelaskan di bagian berikut.

Paket resource dan paket yang telah dikompilasi sebelumnya

Sebelum Anda menggunakan bundletool untuk menghasilkan app bundle untuk aplikasi, Anda harus terlebih dahulu menyediakan file ZIP yang masing-masing berisi kode dan resource yang telah dikompilasi untuk modul aplikasi yang diberikan. Konten dan organisasi file ZIP setiap modul sangat mirip dengan format Android App Bundle. Misalnya, Anda harus membuat file base.zip untuk modul dasar aplikasi Anda dan mengatur kontennya sebagai 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-file tersebut harus diberi nama sebagai berikut: classes.dex , classes2.dex , classes3.dex , dan lain-lain.
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 membuat app bundle, seperti yang dijelaskan di bagian berikut.

Membuat app bundle Anda menggunakan bundletool

Untuk membuat app bundle, gunakan perintah bundletool build-bundle seperti yang ditampilkan di bawah:

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

Tabel berikut menjelaskan tanda untuk perintah build-bundle secara lebih detail:

Tanda Deskripsi
--modules=path-to-base.zip, path-to-module2.zip,path-to-module3.zip Menentukan daftar file ZIP modul yang harus digunakan bundletool untuk membuat app bundle Anda.
--output=path-to-output.aab Menentukan lokasi dan nama file untuk file *.aab output.
--config=path-to-BundleConfig.json Menentukan lokasi 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 Instruksikan bundletool untuk mengemas 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 lokasi relatif ke root dari app bundle yang ingin Anda gunakan untuk mengemas file metadata, dan local-file path menentukan lokasi ke file metadata lokal itu sendiri.

Menyesuaikan pembuatan APK downstream

App bundle mencakup file BundleConfig.pb yang menyediakan metadata yang dibutuhkan oleh app store, seperti Google Play, saat membuat APK dari bundle. Meskipun bundletool membuatkan file ini untuk Anda, Anda dapat mengonfigurasi beberapa aspek metadata dalam file BundleConfig.json dan meneruskannya ke perintah bundletool build-bundle. Kemudian bundletool 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 akan menonaktifkan APK konfigurasi yang masing-masing menargetkan bahasa yang berbeda (yaitu, resource untuk semua bahasa yang disertakan dalam setiap APK dasar atau dinamis):

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

Dalam file BundleConfig.json, Anda juga dapat menentukan jenis file mana yang tidak perlu dikompresi saat mengemas APK menggunakan pola glob, sebagai berikut:

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

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

Men-deploy aplikasi Anda dari app bundle

Jika Anda telah membuat dan menandatangani app bundle, gunakan bundletool untuk menghasilkan APK dan men-deploy-nya 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 menandatangani aplikasi selama proses build. Apa pun cara yang digunakan, pertama-tama Anda harus membuat kunci pribadi menggunakan keytool seperti ditunjukkan 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 bidang "Nama yang Dibedakan" untuk kunci Anda. Itu kemudian menghasilkan keystore sebagai file yang bernama my-release-key.jks, lalu menyimpannya di direktori saat ini (Anda dapat memindahkannya ke mana pun yang Anda mau). 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 pembuatan seperti yang dijelaskan di bagian di bawah 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 ini.

  1. Buka command line dari Android Studio, pilih Tampilan > Jendela Fitur > Terminal, lalu arahkan ke direktori lokasi APK Anda yang belum ditandatangani.
  2. Selaraskan 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 dikonsumsi oleh sebuah 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.

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

    Catatan: Untuk menggunakan fitur apksigner, Anda harus menginstal Android SDK Build Tools versi 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 level modul, lalu tambahkan blok signingConfigs {} dengan entri untuk storeFile, storePassword, keyAlias, dan keyPassword, kemudian teruskan objek tersebut ke properti signingConfig dalam tipe build Anda. Contoh:

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 membuat aplikasi dengan mengaktifkan 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 membuat, menyelaraskan, menandatangani, dan menginstal APK rilis di emulator atau perangkat menggunakan installRelease.

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