Menggunakan Kotlin tanpa GUI Development, CLI only, dengan USB Debugging

Iyan Zuli

5 January 2026 •

9 min read

https://images.unsplash.com/photo-1628277613967-6abca504d0ac?q=80&w=1170&auto=format&fit=crop&ixlib=rb-4.1.0&ixid=M3wxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHx8fA%3D%3D

Category: Tutorial

Tags:

kotlinandroid

Apa Itu Kotlin? Apa Maksudnya GUI Headless Development?

Apa itu Kotlin?

Kotlin adalah bahasa pemrograman modern yang berjalan di atas Java Virtual Machine (JVM) dan dikembangkan oleh JetBrains. Kotlin bersifat:

Statically typed
Interoperable penuh dengan Java
Lebih ringkas dan aman dibanding Java (null-safety, data class, dsb.)

Sejak 2017, Kotlin ditetapkan sebagai bahasa resmi pengembangan Android, dan saat ini menjadi standar utama dalam pengembangan aplikasi Android modern, termasuk dengan Jetpack Compose.

Apa maksudnya GUI Headless Development?

Dalam konteks artikel ini, GUI Headless Development berarti:

Pengembangan aplikasi Android tanpa menggunakan IDE GUI berat seperti Android Studio, emulator, atau tooling visual, dan dilakukan sepenuhnya melalui Command Line Interface (CLI).

Karakteristik pendekatan ini:

Tanpa Android Studio
Tanpa emulator
Build via Gradle CLI
Deploy langsung ke real device via USB Debugging
Editor bebas (VS Code, Neovim, Vim, dll)

Pendekatan ini bukan menggantikan Android Studio, tetapi menjadi alternatif yang lebih ringan, transparan, dan terkontrol, terutama untuk:

Mesin dengan spesifikasi terbatas
Developer yang terbiasa dengan workflow Linux/Unix
Pengembangan API client, tooling, atau project personal
Eksplorasi sistem build Android secara lebih “mentah”

Prerequisites

Sebelum memulai, pastikan kamu memenuhi beberapa prasyarat berikut:

Sistem Operasi
- Linux (Ubuntu, Linux Mint, Arch, Fedora, dll)
- Artikel ini ditulis dan diuji menggunakan Ubuntu-based distro, (apt) terutama Linux Mint dan Arch Linux, (pacman)
Bisa menggunakan non Linux seperti Windows maupun MacOS, namun terdapat sedikit perbedaan.
Pengetahuan Dasar

Disarankan sudah memahami:
- Dasar Kotlin
- Dasar terminal Linux
- Konsep build tool (Gradle)
- Sedikit konsep Android (Activity, package name, APK)
Perangkat Keras
- Laptop / PC
- Android device fisik
- Kabel USB data (bukan charge-only)
Akses Sistem
- Hak sudo untuk instalasi package
- Akses write ke $HOME

Langkah-langkah

Berikut ialah langkah-langkah konkret dalam implementasi development aplikasi berbasis platform Android tanpa emulator atau Android studio, murni CLI dan USB debugging. Sesuaikan dengan preferensi OS masing-masing.

FYI, langkah-langkah berikut juga bekerja pada framework lain seperti React Native dengan sedikit penyesuaian framework.

Install Tooling Wajib

Android modern butuh JDK 17.

Jika menggunakan distribusi apt:
```
sudo apt update
sudo apt install openjdk-17-jdk
```
Jika menggunakan arch:
```
sudo pacman -S jdk17-openjdk
```
Jika terdapat error terdapat dependency atau package yang hilang, cukup tambahkan flag --fix-missing.

Setelah sukses diinstal, cek dengan:
```
java --version
```
Pastikan muncul output versinya, contohnya seperti ini:
```
openjdk version "17.0.17" 2025-10-21
OpenJDK Runtime Environment (build 17.0.17+10-Ubuntu-124.04)
OpenJDK 64-Bit Server VM (build 17.0.17+10-Ubuntu-124.04, mixed mode, sharing)
```
Android SDK Command Line Tools

Download Command Line Tools only melalui official Android Developer.

https://developer.android.com/studio#command-tools

Pilih platform Linux. Ingat, unduh yang command line tools only.

Buat directory untuk tempat extract, biasanya di directory home:
```
mkdir -p $HOME/Android/Sdk/cmdline-tools
```
atau bisa juga seperti ini:
```
mkdir -p ~/Android/Sdk/cmdline-tools
```
Extract command line tools yang telah diunduh lalu pindahkan ke directory yang telah disiapkan sebelumnya:
```
unzip commandlinetools-linux-*.zip -d $HOME/Android/Sdk/cmdline-tools
```
```
mv $HOME/Android/Sdk/cmdline-tools/cmdline-tools \
   $HOME/Android/Sdk/cmdline-tools/latest
```
(Untuk unzip dan rename nya bisa dilakukan secara GUI jika mau)
Set Environment Variable

Edit ~/.bashrc atau ~/.zshrc (sesuaikan dengan script masing-masing). Cek shell nya terlebih dahulu dengan:
```
echo $SHELL
```
Jika outpputnya seperti:
```
/bin/bash
```
Maka gunakan bash. Edit file script bash nya dengan:
```
nano ~/.bashrc`
```
Tambahkan ini di paling bawah
```
# Android SDK
export ANDROID_HOME=$HOME/Android/Sdk
export PATH=$PATH:$ANDROID_HOME/cmdline-tools/latest/bin
export PATH=$PATH:$ANDROID_HOME/platform-tools
```
Reload environment variable dengan:
```
source ~/.bashrc
```
Setelah menambahkan environment variable, cek ADB dengan:
```
adb version
```
Pastikan muncul output versinya seperti:
```
Android Debug Bridge version 1.0.41
Version 36.0.2-14xxxxxx
Installed as /home/zul/Android/Sdk/platform-tools/adb
Running on Linux 6.x.x-xx-lowlatency (x86_64)
```
Jika tidak muncul, maka lanjutkan dulu di langkah ke 4 dan pastikan langkah 4 berhasil.
Install SDK Packages

Install SDK Package versi minimalis.
```
sdkmanager --licenses
```
```
sdkmanager \
 "platform-tools" \
 "platforms;android-34" \
 "build-tools;34.0.0"
```
Sesuaikan dengan versi Android yang dipakai. Android 14 = android.34.
Android Setup

Di perangkat Android,
1. Buka Setings, masuk ke About Phone
2. Tap Build Number atau sejenisnya sebanyak 7 kali hingga memasuki developer mode
3. Setelah itu, cari menu developer mode di Settings lalu aktifkan USB Debugging dan Install via USB
4. Jalankan adb devices dan jika ada notifikasi pada Android, maka accept
Cek Koneksi ADB

Sebelum itu, pastikan Android terhubung via usb dengan usb debugging aktif lalu cek koneksi adb dengan:
```
adb devices
```
Jika muncul device, maka bisa skip langkah ini. Namun jika muncul unauthorized, maka lanjutkan langkah ini:

Koneksi PC dengan Android memerlukan ADB, dalam ubuntu, buat Udev Rules supaya ADB stabil:
```
sudo apt install android-sdk-platform-tools-common
```
buat rule berikut:
```
sudo nano /etc/udev/rules.d/51-android.rules
```
Isi file tersebut dengan:
```
SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", MODE="0666", GROUP="plugdev"
```
Jika menggunakan arch, install udev dengan:
```
sudo pacman -S android-udev
```
Setelah selesai, reload rule dan udev dengan:
```
sudo udevadm control --reload-rules
sudo udevadm trigger
```
Cabut dan pasang lagi USB debugging nya, lalu cek device (perangkat Android harus sudah terhubung dengan USB) dan harus muncul output device:
```
adb devices
```
Jika menggunakan arch, bisa jadi adb devices tetap unauthorized, jadi jalankan:
```
sudo usermod -aG uucp $USER
```
Lalu logout dan login ulang dan cek dengan groups dan pastikan muncul uucp.

Setelah selesai, reload rule dan udev dengan:
```
sudo udevadm control --reload-rules
sudo udevadm trigger
```
Lalu tes lagi adb devices.

Jika sampai sini terdapat error, bisa menggunakan cara kedua dalam penggunaan ADB yaitu dengan menginstall ADB via package manger Ubuntu sehingga tidak bergantung pada SDK Android (namun tutorial ini berfokus pada cara yang pertama).
```
sudo apt install adb
```
Lalu cek ulang dengan:
```
adb version
adb devices
```
VS Code Setup

Terdapat beberapa extension yang wajib ada jika menggunakan VS Code, berikut ialah ekstensionya:
- Kotlin Language
- Java Extension Pack (atau pilih yang perlu)
- Gradle for Java (jika tidak ada di Java Extension Pack)
Sisanya bisa disesuaikan dengan prefrensi masing-masing jika diperlukan.
Buat Project Android

Dalam kasus ini, saya menggunakan starter buatan saya sendiri untuk Kotlin CLI only from scratch. Berikut repository nya:

https://github.com/catc0de1/kotlin-minimal-starter

Namun jika ingin menggunakan repository lain, kunjungi compose sample berikut (namun konfigurasinya mungkin agak berbeda dari tutorial ini):

https://github.com/android/compose-samples
Konfigurasi local.properties

Dalam root project, buat file local.properties yang berisi:
```
sdk.dir=/home/USERNAME/Android/Sdk
```
Dimana sesuaikan USERNAME dengan username OS masing-masing. Serta tiap preferensi OS memilki konfigurasi yang berbeda.
Batasi Gradle

Jika perlu, beri limit kosumsi resource seperti ram / cpu oleh gradle. Cukup berguna jika perangkat PC low spec.

Buat file gradle.properties dengan:
```
nano ~/.gradle/gradle.properties
```
lalu isi dengan:
```
org.gradle.jvmargs=-Xmx1024m -XX:MaxMetaspaceSize=512m -Dfile.encoding=UTF-8
org.gradle.daemon=true
org.gradle.parallel=false
```
Build & Install Project

Untuk Build project, jalankan berikut pada root project:
```
./gradlew assembleDebug
```
Jika proses build tetap berhenti karena masalah low spec meski sudah dibatasi di langkah 10, terpaksa mematikan daemon dengan langhka berikut:
1. Matikan gradlew jika masih ada
```
./gradlew --stop
```
2. Bersihkan cache gradlew jika perlu
```
./gradlew clean
```
3. Build project tanpa daemon
```
./gradlew assembleDebug --no-daemon
```
Setelah selesai dibuild, akan muncul hasil build di directory ./app/build/ (jika menggunakan starter buatan saya). Untuk menginstall nya di Android yang terhubung dengan USB, jalankan perintah berikut:
```
./gradlew installDebug
```
Setelah itu terima di perangkat Android. Jika sampai sini berhasil, selamat!!, tutorial project Android berbasis Kotlin CLI only dengan USB debugging tanpa GUI seperti Android Studio atau emulator selesai.

Development

Berikut ialah beberapa script atau command yang diperlukan untuk development. Tidak semuanya, sesuai kondisi saja.

Clean Gradle Config

Jika menggunakan Gradle dan ingin membersihkan cache serta daemon misalnya error konfigurasi, jalankan 2 perintah berikut (tenang saja, itu hanya menghapus cache jadi aman):
```
rm -rf ~/.gradle/daemon
rm -rf ~/.gradle/caches
```
Jalankan perintah berikut jika ingin membersihkan gradlew dalam project. Jalankan di root project:
```
./gradlew clean
```
Log Debugging

Jalankan perintah berikut untuk log debugging dengan USB Debugging secara manual CLI:
```
adb logcat
```
Bisa juga lebih spesifik seperti ini:
```
adb logcat | grep AndroidRuntime
```
Iterasi Development

Jalankan perintah berikut untuk mendapatkan fitur iterasi development layaknya daemon atau hot reload sehingga tidak perlu mondar mandir assemble debug dan install debug:
```
./gradlew installDebug --continuous
```
Namun hot reload tersebut membaca perubahan pada class, serta merestart app di Android.

Ada alternatif lain yang lebih advance, yaitu via Jetpack Compose. Jetpack Compose tidak perlu emulator untuk rapid iteration. Jalankan perintah berikut untuk fitur layaknya hot reload:
```
./gradlew installDebug
adb shell am start -n com.your.app/.MainActivity
```
Setiap perubahan akan build ulang lalu install ulang di device asli, performanya malah lebih real daripada menggunakan emulator atau studio.
Clean Scripts

Jika ingin rapi dalam menyalakan atau menghentikan server ADB, jalankan perintah berikut:
1. Mematikan ADB:
```
adb kill-server
```
2. Menyalakan ADB
```
adb start-server
```
Kedua itu tidak diwajibkan. Karena secara by default, jika server atau task ADB berhenti, maka sudah berhenti tanpa mematikan secara manual. Otomatis menyala juga jika digunakan. Tidak seperti flashdisk yang perlu reject, USB Debugging boleh langsung colok dan cabut.

Build with Gradle

Gradle hanya dibutuhkan untuk generate wrapper yang berisi konfigurasi gradle dan file .jar. Wrapper ini yang nantinya digunakan dalam pengembangan Android dengan gradle. Jadi setelah itu, wrapper yang akan dipakai sedangkan gradle sudah tidak perlu.

Sekedar informasi saja, jika ingin membuat project from scratch dengan gradle alih-alih menggunakan starter atau template orang lain, berikut langkah-langkahnya:

Install Gradle

Install gradle dengan:
```
sudo apt install gradle
```
Cek gradle dengan:
```
gradle -v
```
Pastikan muncul output versi nya.
Gunakan Gradle

Jalankan perintah berikut di root project Android:
```
gradle wrapper --gradle-version 8.4
```
Perintah tersebut akan menghasilkan wrapper untuk project. Sesuaikan versi yang dibutuhkan. Contohnya versi 8.4 compatible dengan AGP 8.2+.
Beri Permission

Jalankan perintah berikut untuk permission gradlew jika OS melarang permission. Jalankan sekali saja:
```
chmod +x gradlew
```

Kelebihan dan Kekurangan Pendekatan CLI Only

Berikut ialah kelebihan dan kekurangan pendekatan CLI only jika membandingkannya dengan pendekatan Android Studio atau emulator.

Kelebihan

Ringan & Cepat

Pendekatan CLI-only menghilangkan kebutuhan Android Studio yang terkenal berat, sehingga konsumsi RAM dan CPU jauh lebih rendah. Ini membuat pengembangan Android tetap memungkinkan bahkan di laptop low-spec tanpa mengorbankan stabilitas sistem. Terbukti ampuh dalam laptop dengan ram dibawah 8 GB dan diatas 4 GB, performa lebih cepat dalam Linux.
Kontrol Penuh

Seluruh proses seperti build, install, dan debugging dilakukan secara eksplisit melalui command line. Developer tahu persis apa yang dijalankan dan kapan dijalankan, tanpa bergantung pada otomatisasi tersembunyi dari IDE. Sehingga tidak ada “magic” IDE yang tersembunyi.
Workflow Linux-native

Pengembangan terasa lebih natural bagi pengguna Linux karena seluruh alur kerja berbasis shell, Git, dan editor ringan seperti Vim, Neovim, atau VS Code. Tidak ada ketergantungan pada GUI berat yang tidak sejalan dengan filosofi Unix.
Lebih Realistis

Aplikasi langsung dijalankan di perangkat Android fisik melalui USB Debugging, sehingga hasil pengujian lebih mendekati kondisi penggunaan nyata dibandingkan emulator. Hal ini menghilangkan ketergantungan terhadap emulator.
Edukasi Sistem Build

Developer dipaksa memahami struktur project Android, peran Gradle wrapper, SDK Manager, dan ADB, sehingga tidak hanya bisa menggunakan tools, tetapi juga mengerti cara kerjanya.

Kekurangan

Tidak Ada Hot Reload Seperti IDE

Setiap perubahan kode umumnya memerlukan proses build dan install ulang, sehingga iterasi UI menjadi lebih lambat dibandingkan workflow berbasis Android Studio. Walaupun bisa diakali dengan script shell, tetapi tetap tidak sebagus Android Studio.
Debugging Lebih Manual

Tanpa visual debugger, proses analisis error bergantung pada adb logcat dan stack trace teks, yang bisa memperlambat proses troubleshooting. Dapat ditambahkan plugin untuk visual debugging jika mau.
Setup Awal Lebih Panjang

Developer harus mengatur environment variable, Udev rules, SDK manager, dan konfigurasi sistem secara manual sebelum bisa mulai development, yang dapat menjadi hambatan di awal.
Kurang Cocok untuk Tim Besar

Android Studio masih lebih unggul dalam hal kolaborasi, integrasi tooling, dan standar kerja tim yang besar dan heterogen.
Kurva Belajar Lebih Curam

Pendekatan ini kurang ramah bagi pemula Android karena menuntut pemahaman teknis sejak awal tanpa banyak bantuan visual atau konfigurasi otomatis. Dan jujur saja, jika ingin yang lebih mudah dan pembuatan cepat, saya sarankan coba emulator atau Android Studio terlebih dahulu.

Kesimpulan

Pengembangan Android menggunakan Kotlin secara CLI-only dengan USB Debugging adalah pendekatan yang valid, stabil, dan profesional, selama developer memahami batasannya.

Pendekatan ini sangat cocok jika kamu:

Menginginkan workflow ringan
Tidak bergantung pada Android Studio
Mengembangkan project personal, tooling, atau eksperimen
Ingin memahami Android build system secara mendalam

Namun, pendekatan ini bukan pengganti mutlak Android Studio, melainkan alternatif. Untuk kebutuhan tertentu seperti UI complex, debugging visual, atau kolaborasi tim besar, IDE resmi tetap memiliki keunggulan.

Singkatnya:

CLI-only Android development bukan shortcut, tapi conscious engineering choice.