Beranda
Android

Belajar Android : Mengenal Apa Itu Activity Pada Aplikasi Android

Apa itu Activity di Android? Pahami konsep layar aplikasi, back stack, daur hidup (lifecycle), Intent, plus catatan modern ViewModel.
Ilustrasi activity sebagai panggung teater dengan beberapa layar aplikasi

Definisi resminya begini: Activity adalah komponen aplikasi yang menyediakan layar untuk interaksi pengguna. Bahasa sederhananya: activity adalah satu layar penuh di aplikasimu. Layar login itu satu activity, layar daftar produk itu activity lain, layar detail produk activity lain lagi.

Setiap activity biasanya berpasangan dengan satu file layout XML yang mengatur tampilannya, dan satu file Kotlin (atau Java) yang mengatur perilakunya. File XML adalah wajahnya, file Kotlin adalah otaknya. Kalau kamu sudah membaca artikel tentang layout, kamu sudah memegang separuh konsepnya.

Satu Aplikasi Terdiri dari Banyak Activity

Satu aplikasi umumnya terdiri dari beberapa activity yang terikat secara longgar. Artinya tiap activity bisa berdiri sendiri, dan aplikasi berpindah dari satu activity ke activity lain mengikuti alur yang kamu rancang.

Satu activity ditetapkan sebagai pintu masuk utama (sering disebut main activity). Penetapannya ada di file AndroidManifest.xml:

<activity
    android:name=".MainActivity"
    android:exported="true">
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
</activity>

Kode MainActivity.kt yang paling sederhana terlihat seperti ini:

package com.example.latihanlayout

import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }
}

Untuk berpindah layar, kamu memakai Intent, semacam surat perintah pindah:

val intent = Intent(this, DetailActivity::class.java)
startActivity(intent)

Baris itu dibaca: buat perintah pindah dari activity ini (this) ke DetailActivity, lalu jalankan. DetailActivity tentu harus sudah kamu buat dan daftarkan di AndroidManifest.xml. Kalau proyekmu memakai Java, konsepnya sama persis, hanya sintaksnya yang berbeda.

Setiap activity tambahan wajib didaftarkan di manifest, kalau tidak aplikasi akan crash saat Intent dijalankan. Untungnya, kalau kamu membuat activity lewat menu New lalu Activity di Android Studio, pendaftarannya ditulis otomatis. Pendaftaran manualnya sederhana saja:

<activity android:name=".DetailActivity" android:exported="false" />

Mengirim Data Antar Activity

Pindah layar saja tidak cukup, biasanya kamu juga perlu menitipkan data. Misalnya dari layar daftar produk ke layar detail, kamu perlu memberitahu activity tujuan produk mana yang dipilih. Caranya dengan menempelkan data ke Intent:

val intent = Intent(this, DetailActivity::class.java)
intent.putExtra("id_produk", 42)
intent.putExtra("nama_produk", "Kopi Susu")
startActivity(intent)

Di activity tujuan, data itu diambil kembali di onCreate:

val idProduk = intent.getIntExtra("id_produk", 0)
val namaProduk = intent.getStringExtra("nama_produk")

Pola putExtra dan get...Extra ini dipakai di mana-mana, jadi hafalkan baik-baik. Kuncinya (seperti "id_produk") harus sama persis di kedua sisi, kalau beda satu huruf saja datanya tidak ketemu. Untuk data yang lebih kompleks seperti objek, kamu bisa memakai Parcelable, tapi itu topik lanjutan yang bisa dipelajari nanti.

Back Stack: Cara Android Mengingat Layar

Setiap kali activity baru dibuka, Android mendorongnya ke atas tumpukan yang disebut back stack. Prinsipnya LIFO: last in, first out. Yang terakhir masuk adalah yang pertama keluar, seperti tumpukan piring.

Saat pengguna menekan tombol kembali, activity teratas dikeluarkan dari tumpukan dan dihancurkan, lalu activity di bawahnya kembali tampil. Itu sebabnya tombol kembali selalu membawamu ke layar sebelumnya, bukan langsung menutup aplikasi.

Ilustrasi back stack: tumpukan layar aplikasi yang diambil dari atas saat tombol kembali ditekan

Kamu juga bisa menutup activity secara manual dari kode dengan memanggil finish(). Ini berguna misalnya setelah pengguna berhasil login: kamu tidak mau ia bisa kembali ke layar login hanya dengan menekan tombol kembali.

Daur Hidup Activity

Activity tidak hidup selamanya. Sistem Android memanggil serangkaian method callback saat activity dibuat, ditampilkan, dijeda, disembunyikan, dan dihancurkan. Rangkaian ini disebut lifecycle atau daur hidup. Enam callback utamanya:

  • onCreate: dipanggil sekali saat activity dibuat. Di sinilah kamu memanggil setContentView dan menyiapkan data awal.
  • onStart: activity mulai terlihat di layar.
  • onResume: activity siap menerima sentuhan pengguna. Ini kondisi sedang dipakai.
  • onPause: activity kehilangan fokus, misalnya muncul dialog atau pengguna pindah aplikasi.
  • onStop: activity tidak terlihat lagi.
  • onDestroy: activity dihancurkan sistem, waktunya bersih-bersih.
Ilustrasi daur hidup activity: layar aplikasi melewati tahapan hidup dan istirahat

Memahami daur hidup penting supaya aplikasimu tidak boros. Contohnya: kamera atau sensor sebaiknya dilepas di onPause, jangan dibiarkan menyala saat pengguna sudah pindah aplikasi. Data ringan yang belum disimpan sebaiknya diamankan di onPause atau onStop.

Agar lebih kebayang, ini skenario nyatanya. Pengguna membuka aplikasimu: onCreate, onStart, onResume dipanggil berurutan. Lalu ada telepon masuk dan layar panggilan menutupi aplikasimu: onPause lalu onStop dipanggil. Telepon selesai dan pengguna kembali: onStart dan onResume dipanggil lagi tanpa onCreate. Kalau sistem kehabisan memori saat aplikasimu di latar, activity dihancurkan lewat onDestroy. Contoh override di Kotlin:

override fun onStart() {
    super.onStart()
    // activity mulai terlihat
}

override fun onResume() {
    super.onResume()
    // activity siap menerima interaksi pengguna
}

override fun onPause() {
    super.onPause()
    // kehilangan fokus: simpan data ringan, lepas resource berat
}

override fun onStop() {
    super.onStop()
    // tidak terlihat lagi di layar
}

override fun onDestroy() {
    super.onDestroy()
    // dibersihkan oleh sistem
}

Layar Diputar, Datamu Hilang?

Ini jebakan klasik yang dialami hampir semua pemula. Kamu mengetik panjang di kolom input, lalu tanpa sengaja memutar HP, dan jreng, ketikanmu hilang. Penyebabnya: saat terjadi perubahan konfigurasi seperti rotasi layar, Android menghancurkan lalu membuat ulang activity-mu. Semua data yang disimpan di variabel biasa ikut lenyap.

Untuk data kecil, Android menyediakan mekanisme onSaveInstanceState. Kamu menyimpan data ke sebuah Bundle sebelum activity dihancurkan, lalu membacanya kembali di onCreate:

override fun onSaveInstanceState(outState: Bundle) {
    super.onSaveInstanceState(outState)
    outState.putString("nama", inputNama.text.toString())
}

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    val namaTersimpan = savedInstanceState?.getString("nama")
    // pakai namaTersimpan untuk mengisi kembali tampilan
}

Perhatikan tanda tanya pada Bundle?: parameter savedInstanceState bisa bernilai null saat activity dibuka pertama kali, dan baru berisi data saat activity dibuat ulang setelah dihancurkan. Mekanisme ini cukup untuk data ringan, tapi untuk data yang lebih besar dan kompleks, cara modernnya memakai ViewModel seperti dibahas di bagian berikutnya.

Catatan Modern: ViewModel dan Era Single-Activity

Ada satu perilaku yang wajib kamu tahu: saat layar HP diputar, Android menghancurkan lalu membuat ulang activity-mu. Semua data yang disimpan di variabel biasa ikut hilang begitu saja. Solusi modernnya adalah ViewModel, komponen arsitektur Jetpack yang tetap hidup melewati penghancuran tersebut. Aturannya sederhana: data penting simpan di ViewModel, activity hanya bertugas menampilkan.

Tren arsitektur pun bergeser. Dulu satu layar berarti satu activity (multi-activity). Sekarang banyak aplikasi memakai single-activity: satu activity menampung banyak layar yang dipecah menjadi fragment atau composable, dengan Navigation Component atau Jetpack Compose yang mengatur perpindahannya. Jangan khawatir, konsep activity, back stack, dan daur hidup di artikel ini tetap menjadi fondasi semuanya, jadi waktu yang kamu habiskan memahaminya tidak akan sia-sia.

Sebagai pemula, kamu tidak perlu langsung terjun ke single-activity. Mulailah dengan pola klasik multi-activity seperti di artikel ini: buat dua atau tiga activity, pindah dengan Intent, rasakan cara kerja back stack-nya. Setelah nyaman, barulah pelajari fragment, Navigation Component, dan Compose satu per satu. Fondasi yang kuat membuat semua teknologi lanjutan terasa jauh lebih mudah.

Penutup

Ringkasnya: activity adalah satu layar interaktif, aplikasi adalah kumpulan activity yang berpindah lewat Intent, dan Android mengatur tumpukan serta daur hidupnya untukmu. Pahami tiga hal ini baik-baik: cara pindah layar, cara kerja back stack, dan kapan tiap callback daur hidup dipanggil. Tiga hal itu muncul di hampir setiap aplikasi Android yang akan kamu buat, jadi anggap saja ini bekal wajib sebelum melangkah lebih jauh.

Di artikel berikutnya, kita praktik membuat aplikasi dengan dua activity dan tombol untuk berpindah di antaranya, supaya semua teori di artikel ini langsung terasa di tangan. Sampai jumpa di dapur berikutnya.