MODUL PRAKTIKUM

PEMROGRAMAN UNTUK
PERANGKAT BERGERAK 1

Indra Azimi, S.T., M.T.

Reza Budiawan, S.T., M.T., OCA
Rizza Indah Mega Mandasari, S.Kom., M.T.
Cahyana S.T., M.Kom.

D3 Rekayasa Perangkat Lunak Aplikasi

Telkom University
 Daftar Isi
Modul 13: Activity & Fragment Lifecycle ...................................................................................................... 2

1. Overview ........................................................................................................................................... 2

2. Getting Started.................................................................................................................................. 3

3. Task ................................................................................................................................................... 3

3.1. Mempelajari daur hidup Activity .............................................................................................. 3

3.2. Mempelajari daur hidup Fragment ........................................................................................... 7

3.3. Menggunakan Timer pada Lifecycle ......................................................................................... 8

4. Summary ......................................................................................................................................... 12
Modul 13: Activity & Fragment Lifecycle
1. Overview
Pada modul kali ini kita akan coba memahami siklus hidup (lifecycle) dari activity & fragment. Hal ini
penting, karena kita perlu mengetahui kapan komponen aplikasi seperti animasi, audio, atau sensor
harus dijalankan. Contoh, ketika seseorang sedang bermain game, lalu keluar sebentar dari aplikasi
dengan menekan tombol Home, musik latar game tersebut harus mati secara otomatis, baru
kemudian hidup lagi setelah orang tersebut kembali ke game-nya.

Pada kasus lain, ketika terjadi perubahan orientasi layar (rotate screen), state dari aplikasi secara
default akan kembali seperti saat aplikasi pertama kali dijalankan. Bayangkan dalam aplikasi simulasi
ujian yang sudah menampilkan nomor ke-10, dan pengguna harus mengulang kembali mengerjakan
dari nomor 1 ketika rotate screen terjadi secara tidak sengaja. Tentu ini akan membuat jengkel
pengguna aplikasi tersebut, dan ini tentunya tidak kita inginkan.

Oleh sebab itu sebagai seorang developer, penting bagi kita

untuk mengetahui sifat daur hidup dari activity/fragment aplikasi
Android. Karena setiap penempatan kode untuk menjalankan
komponen tertentu sangat bergantung pada method yang
mewakili lifecycle dari activity/fragment.

Di modul ini kita akan melanjutkan aplikasi Galeri Hewan yang

telah kita buat di modul 12 (Connect to the Internet), karena
kebetulan aplikasi tersebut memiliki satu activity, satu fragment
dan satu view model sehingga cukup lengkap untuk dijadikan
aplikasi percobaan lifecycle Android.

Kode lengkap aplikasi dapat diakses di repository Github pada

branch lifecycle: https://github.com/indraazimi/galeri-hewan
2. Getting Started
Buka project Galeri Hewan dari modul 12 (Connect to the Internet). Klik menu Git > New Branches…
Masukkan “lifecycle” sebagai nama branch yang baru, lalu klik tombol Create.

Akan tercipta sebuah branch baru di project kita. Task-task pada modul harus dikerjakan di branch ini.

Dilarang keras untuk copy – paste kode dari modul/sumber lain!

Ngoding pelan-pelan akan membuat kamu lebih jago di masa depan.

Lakukan commit setiap selesai 1 sub-task. Selamat ngoding!

3. Task
3.1. Mempelajari daur hidup Activity
Di task ini, kita akan mempelajari daur hidup activity dengan menggunakan Log. Logging merupakan
proses memunculkan catatan/pesan pendek pada Logcat ketika aplikasi berjalan. Hal ini sudah pernah
kita lakukan beberapa kali pada modul sebelumnya dengan menggunakan keyword Log.d. Langkah
pertama yang kita lakukan yaitu menambahkan Log pada method onCreate:

class MainActivity : AppCompatActivity() {

override fun onCreate(savedInstanceState: Bundle?) {

super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)

Log.i("MainActivity", "onCreate dijalankan")

}
}
Pada kode di atas, kita menambahkan Log.i. Dengan kata lain, log yang ditambahkan bukan lagi untuk
kepentingan debug (Log.d) tapi menampilkan informasi (Log.i). Jalankan project, dan perhatikan pada
bagian Logcat akan muncul tulisan “onCreate dijalankan”. Pastikan pada bagian type memilih “Info”,
dan pada bagian filter menuliskan tag yang sesuai, yaitu “MainActivity” (sesuai parameter pertama
pada kode Log.i). Maka akan terlihat tampilan Logcat seperti berikut ini:

Informasi ini muncul ketika method onCreate dipanggil, sedangkan pemanggilan dari method ini
berkaitan dengan daur hidup Activity yang diperlihatkan seperti berikut.

Dengan memperhatikan gambar di atas, dapat kita pahami bahwa tulisan “onCreate dijalankan” pada
log muncul karena method onCreate dieksekusi saat project di-run. Daur hidup ini terdiri dari stage
initialized → created → started → resumed → started → created → destroyed. Setiap staging ini
diwakili oleh method-nya masing-masing mulai dari onCreate hingga onDestroyed.
Secara default, saat project Android Studio pertama kali dibentuk, hanya method onCreate yang
muncul, sedangkan method lainnya tidak tertulis pada MainActivity.kt. Method-method lifecycle ini
dapat kita tambahkan dengan cara melakukan penulisan method override. Berikutnya, kita akan
membuat method onStart pada MainActivity.kt, dan menuliskan log “onStart Called” dan memastikan
tulisan tersebut muncul pada Logcat.

Caranya, tekan Ctrl+O pada keyboard, cari method onStart() dan klik Enter. Setelah method onStart
terbentuk, tambahkan kode log dengan tulisan “onStart Called”. Lakukan hal yang sama untuk empat
method lifecycle lainnya. Kode akhir yang terbentuk pada MainActivity.kt setelah semua beres
ditunjukkan pada kode di bawah ini.

class MainActivity : AppCompatActivity() {

override fun onCreate(savedInstanceState: Bundle?) {

super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)

Log.i("MainActivity", "onCreate dijalankan")

}

override fun onStart() {

super.onStart()
Log.i("MainActivity", "onStart dijalankan")

override fun onResume() {

super.onResume()
Log.i("MainActivity", "onResume dijalankan")

override fun onPause() {

Log.i("MainActivity", "onPause dijalankan")
super.onPause()
}

override fun onStop() {

Log.i("MainActivity", "onStop dijalankan")
super.onStop()
}

override fun onDestroy() {

Log.i("MainActivity", "onDestroy dijalankan")
super.onDestroy()
}
}
Setelah memastikan kode benar, jalankan kembali project, dan cek bagian Logcat. Akan terlihat tiga
method lifecycle dipanggil secara berurutan sesuai diagram Activity Lifecycle di halaman sebelumnya.
Mengapa tiga method lifecycle lainnya tidak muncul?

Ya, benar.. Tiga method lifecycle lainnya baru akan muncul setelah kita menekan tombol Back dan
keluar dari aplikasi. Berikut screenshot Logcat-nya:

Sekarang kita akan melakukan percobaan lain. Jalankan kembali ke aplikasi, maka akan terlihat tiga
method lifecycle awal. Apa yang terjadi ketika pengguna keluar dari aplikasi dengan cara menekan
tombol Home? Method lifecycle apa yang tidak dipanggil? Ada yang tahu kenapa bisa begitu? Hehe..

Masih menyambung percobaan sebelumnya, sekarang kita lihat apa yang terjadi ketika pengguna
masuk ke aplikasi melalui menu Recent Apps. Coba cek Logcat, method lifecycle apa yang tidak
dipanggil? Adakah yang tahu kenapa bisa begitu?
Sebagai bantuan, kamu dapat membuat tabel pengamatan seperti contoh di bawah ini:

Aksi Catatan Simpulan

Pertama kali onCreate → onStart → onResume App berjalan pada stage
dijalankan “Resumed”

Pertama kali … …
dijalankan dan
ditutup secara
normal

Pertama kali … …
dijalankan & ditutup
dengan menekan
home button

Aplikasi dijalankan … …
dari Recent App &
ditutup dengan
menekan tombol
Back

Pertama kali … …
dijalankan & dirotasi

<tuliskan … …
kemungkinan atau
skenario lain jika
ada>

Menarik bukan..? Setelah selesai mengisi tabel di atas, silahkan lakukan commit sesuai judul task ini.

3.2. Mempelajari daur hidup Fragment

Setelah mengamati daur hidup Activity, sekarang kita akan bereksperimen untuk mempelajari daur
hidup Fragment. Metode eksperimennya tetap sama dimana kita akan melakukan override method-
method lifecycle yang ada di Fragment. Perhatikan diagram Fragment lifecycle berikut.
Cobalah untuk melakukan override method-method lifecycle yang ada di Fragment secara mandiri.
Bisakah kamu..? Gunakan cara yang sama dengan task 3.1. Sebagai pembanding, berikut adalah hasil
Logcat ketika aplikasi dijalankan pertama kali. Sudah samakah hasilnya?

Jika sudah sama, cobalah keluar dari aplikasi. Apakah method-method lifecycle lainnya muncul?
Lakukan beberapa percobaan sebagaimana yang telah kita lakukan di task 3.1, lalu catat hasilnya di
tabel pengamatan. Bandingkan juga method lifecycle Fragment dengan Activity, siapa yang akan
dipanggil terlebih dahulu? Setelah selesai meng-explore daur hidup Fragment dan Activity, silahkan
lakukan commit dengan commit message sesuai dengan judul task ini.

3.3. Menggunakan Timer pada Lifecycle

Pada task kali ini, kita akan menggunakan timer sebagai proses yang berjalan di background. Di dunia
nyata, background process ini dapat berupa apa saja, mulai dari menjalankan audio, mendeteksi GPS,
mengunduh file dari internet, dan sebagainya. Kita perlu memahami behaviour-nya untuk dapat
menerapkan kontrol yang baik terhadap background process tersebut.
Langkah awal pada task ini adalah membuat timer pada aplikasi Galeri Hewan. Klik kanan pada
package utama, lalu pilih New → Package. Masukkan util lalu tekan Enter.

Pada package baru di atas, klik kanan lalu pilih New → Kotlin Class/File, lalu masukkan nama MyTimer.

Di kelas ini kita akan membuat dua buah method, yaitu startTimer dan stopTimer. Sesuai namanya,
startTimer akan memulai timer, kemudian memunculkan waktu yang berjalan pada log setiap detik.
Adapun method stopTimer akan menghentikan timer yang sedang berjalan tersebut. Kode akhir kelas
diperlihatkan sebagai berikut.

class MyTimer {

private var secondsCount = 0

private var handler = Handler(Looper.getMainLooper())

private lateinit var runnable: Runnable

fun startTimer() {
runnable = Runnable {
secondsCount++
Log.i("Timer", "Detik ke: $secondsCount")
handler.postDelayed(runnable, 1000)
}
handler.postDelayed(runnable, 1000)
}

fun stopTimer() {
handler.removeCallbacks(runnable)
}
}
Gunakan method dari class MyTimer pada MainActivity.kt dengan menuliskan objeknya sebagai
property class, dan memanggil konstruktornya pada method onCreate.

class MainActivity : AppCompatActivity() {

private lateinit var myTimer: MyTimer

override fun onCreate(savedInstanceState: Bundle?) {

super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)

myTimer = MyTimer()
Log.i("MainActivity", "onCreate dipanggil.")
}
...
}

Berikutnya, kita harus memperkirakan di mana tepatnya pemanggilan startTimer dan stopTimer
diberikan. Bayangkan timer adalah animasi/audio/sensor yang berjalan pada sebuah aplikasi. Animasi
ini sebaiknya diputar ketika aplikasi sedang dalam kondisi on screen (terlihat oleh pengguna) dan
dihentikan ketika aplikasi dalam kondisi off screen (tidak terlihat oleh pengguna). Sebagai percobaan
awal, kita akan mencoba melakukan pemanggilan seperti ini.

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

myTimer = MyTimer()
myTimer.startTimer()
Log.i("MainActivity", "onCreate dipanggil.")
}

...
override fun onDestroy() {
Log.i("MainActivity", "onDestroy dipanggil.")
myTimer.stopTimer()
super.onDestroy()
}

Sekarang jalankan aplikasi dan periksa bagian Logcat.

Dapat kita lihat di Logcat, timer akan berjalan ketika aplikasi dijalankan. Ketika kita tekan tombol Back,
aplikasi akan keluar, dan timer juga berhenti. Test case #1 sukses.

Test case #2, bagaimana jika pengguna keluar dengan menekan tombol Home? Untuk mengujinya,
jalankan kembali aplikasi. Kita akan melihat timer berjalan di Logcat. Sekarang tekan tombol Home.
Aplikasi telah tertutup dan masuk ke Recent Apps. Namun perhatikan Logcat nya.. Ternyata timer kita
masih tetap berjalan. Test case #2 gagal. Kode harus diperbaiki.

Sesuai percobaan di task 3.1, kita tahu bahwa ketika pengguna menekan tombol Home, method
onDestroy tidak akan dijalankan. Method lifecycle yang dipanggil terakhir adalah onStop. Oleh karena
itu, kita dapat menaruh kode pemanggilan stopTimer pada method onStop. Pindahkan kode sehingga
menjadi seperti ini, jalankan kembali aplikasi, lalu cek Logcat.

...
override fun onStop() {
Log.i("MainActivity", "onStop dipanggil.")
myTimer.stopTimer()
super.onStop()
}

override fun onDestroy() {

Log.i("MainActivity", "onDestroy dipanggil.")
myTimer.stopTimer()
super.onDestroy()
}

Sekarang kita bisa lihat bahwa ketika aplikasi dijalankan, timer akan berjalan. Ketika kita menekan
tombol Home, timer akan berhenti. Apakah aplikasi kita sudah benar? Untuk menjawabnya, coba
perhatikan apa yang terjadi ketika pengguna masuk ke aplikasi lagi melalui menu Recent Apps. Timer
kita ternyata tidak berjalan kembali seperti seharusnya
Hal ini dikarenakan startTimer dipanggil di onCreate, sedangkan ketika pengguna masuk kembali ke
aplikasi melalui Recent Apps, method lifecycle tersebut tidak dipanggil. Sebagai solusi dari masalah
ini, pindahkan kode startTimer pada method onStart seperti ini.

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

myTimer = MyTimer()
myTimer.startTimer()
Log.i("MainActivity", "onCreate dipanggil.")
}

override fun onStart() {

super.onStart()
myTimer.startTimer()
Log.i("MainActivity", "onStart dipanggil.")
}

Run project, dan cek di bagian Log, akan terlihat timer yang berjalan. Tekan tombol Home, maka timer
akan berhenti. Masuk lagi ke aplikasi melalui Recent Apps, maka timer akan berjalan kembali. Jadi
aplikasi kita sudah benar sekarang. Silahkan lakukan commit dengan commit message berupa judul
dari task 3.3 ini, kemudian push ke repository praktikum.

4. Summary
Pada modul kali ini kita telah mengetahui lifecycle atau daur hidup dari Activity dan Fragment. Kita
juga sudah mempraktekkan penempatan background proses (timer) yang salah akan menyebabkan
proses tersebut tetap berjalan walaupun aplikasi sudah tidak digunakan lagi. Ini tentunya akan
membebani smartphone pengguna sehingga kurang baik. Oleh sebab itu, sebagai developer, kita
harus memahami lifecycle, sehingga aplikasi yang kita kembangkan akan berjalan seperti yang
diharapkan oleh pengguna kita, apapun kondisinya