Tujuan Instruksional:
Mengetahui komponen-komponen aplikasi
Memahami siklus hidup activity
Arsitektur aplikasi Android berbeda dengan arsitektur aplikasi desktop. Arsitektur aplikasi
Android didasarkan atas komponen-komponen yang saling berhubungan satu dengan yang lain
menggunakan Intent. Intent dideskripsikan pada manifest dalam paket aplikasi.
Komponen-Komponen Aplikasi
Aplikasi Android merupakan gabungan komponen-komponen (seperti Activity, service, content
provider, dan broadcast receiver) yang dijalankan pada Linux dan dikelola oleh Android.
Komponen-komponen tersebut saling berbagi resource, yang meliputi database, preferensi
(preference), sistem file, dan proses Linux.
Catatan :
Semua komponen tidak selalu harus ada dalam sebuah aplikasi. Sebagai contoh, sebuah aplikasi mungkin
terdiri dari Activity-activity saja, sementara aplikasi lain hanya terdiri dari Activity dan service.
Arsitektur Android yang berbasis komponen memungkinkan sebuah aplikasi menggunakan
ulang komponen-komponen dari aplikasi lain yang mengizinkan penggunaan ulang komponen-
komponennya. Penggunaan ulang komponen akan mengurangi keseluruhan jejak memori yang
sangat penting untuk perangkat dengan memori terbatas. Misalkan, kita membuat aplikasi
menggambar yang mengizinkan user untuk memilih warna dari palette. Maka aplikasi
menggambar dapat memanggil komponen pemilih warna dari aplikasi lain yang sesuai dan
menggizinkan komponen ini untuk digunakan ulang. Aplikasi menggambar tidak memuat
komponen pemilih warna atau bahkan link ke aplikasi lain, melainkan hanya men-startup
komponen pemilih warna aplikasi lain pada saat diperlukan saja.
Android memulai suatu proses ketika suatu komponen dari suatu aplikasi benar-benar diperlukan
(seperti komponen pemilih warna), dan menginstansiasi objek Java untuk komponen tersebut.
Hal ini yang menjadi alasan mengapa aplikasi Android tidak memiliki single-entry-point (tanpa
fungsi main() seperti pada C). Aplikasi Android hanya menggunakan komponen-komponen yang
telah diinstansiasi dan menjalankannya pada saat diperlukan saja.
Activity
Activity merupakan komponen dari suatu aplikasi yang menyediakan user interface sehingga
user dapat berinteraksi dengan aplikasi.
Misalnya, aplikasi Contact Android memiliki activity yang menyediakan user interface untuk
memasukkan contact baru, aplikasi Phone memiliki activity yang menyediakan user interface
untuk dialing nomor telepon, atau aplikasi Calculator yang memiliki activity yang menyediakan
user interface untuk melakukan perhitungan-perhitungan dasar.
Gambar 1. Activity utama aplikasi Calculator
Gambar 1. di atas menunjukkan Activity utama (Main activity) dari aplikasi Calculator Android
yang memungkinkan user untuk melakukan perhitungan-perhitungan dasar[1]
.
Sebuah aplikasi dapat mempunyai lebih dari sebuah activity. Sebagai contoh, selain activity
untuk melakukan perhitungan dasar, Calculator juga memuat activity "advance panel" yang
memungkinkan user untuk melakukan perhitungan akar kuadrat, mengerjakan trigonometri, dan
melakukan operasi-operasi matematika lanjut lainnya.
Dalam program, Activity dideskripsikan oleh subclass dari class android.app.Activity, yang
merupakan subclass tidak langsung dari class abstrak android.content.Context. Subclass-subclass
Activity meng-override beberapa method Activity (yang dikenal dengan "lifecycle callback
method" seperti method onCreate(), onStart(), dan lain-lain) yang dipanggil oleh Android selama
Activity masih aktif (hidup).
Sebagai contoh, misal pada listring program berikut, class SimpleActivity meng-extend Activity
dan juga meng-override method void onCreate(Bundle savedInstanceState) dan method void
onDestroy().
------------------------------------------------------------------------------------------------------
package gie.triana;
import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
public class AktivitasActivity extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState); // always call superclass method first
setContentView(R.layout.main);
Log.d(tag, "pada event method onCreate(");
}
@Override
protected void onDestroy() {
// TODO Auto-generated method stub
super.onDestroy(); // always call superclass method first
}
}
------------------------------------------------------------------------------------------------------------
Overriding method onCreate(Bundle) dan method onDestroy() pada listing program di atas,
masing-masing selalu meng-invoke superclassnya terlebih dahulu, ini merupakan pola yang
harus selalu diikuti pada saat kita meng-override "lifecycle callback method" yang lain seperti
method-method void onStart(), void onRestart(), void onResume(), void onPause(), dan void
onStop().
Method onCreate(Bundle) dipanggil ketika suatu Activity pertama kali dibuat. Method
ini digunakan untuk membuat user interface dari Activity, membuat background thread,
dan melakukan inisialisasi global lainnya. Method onCreate() akan melewatkan obyek
dari kelas android.os.Bundle yang berisi keadaan (state) Activity sebelumya jika state
tersebut telah di-capture. Android akan selalu memanggil method onStart() setelah
pemanggilan method onCreate(Bundle).
Method onStart() dipanggil sebelum suatu Activity menjadi visible (terlihat oleh user).
Android memanggil method onResume() setelah pemanggilan onStart() ketika Activity
menuju ke latar depan (foreground), dan memanggil method onStop() setelah onStart()
pada saat Activity tersembunyi (tidak terlihat oleh user).
Method onRestart(), dipanggil setelah suatu Activity dalam keadaan berhenti (stop),
beberapa saat sebelum Activity dimulai lagi. Android akan selalu memanggil onStart()
setelah pemanggilan onRestart().
Method onResume() dipanggil sebelum suatu Activity berinteraksi dengan user. Pada
titik ini, Activity memperoleh focus dan input user diarahkan ke Activity. Android akan
selalu memanggil method onPause() setelah pemanggilan onResume(), namun hanya
ketika Activity harus berhenti sementara waktu (pause).
ketika Activity harus berhenti sementara waktu (pause).
Method onPause() dipanggil ketika Android mulai menjalankan Activity lain. Method
ini digunakan untuk menahan perubahan yang tidak disimpan, menghentikan animasi
yang mungkin mengganggu siklus prosesor, dan sebagainya. Method onPause() akan
melakukan tugasnya dengan cepat, karena Activity selanjutnya tidak akan mulai
dijalankan sampai tugasnya selesai. Android memanggil onResume() setelah
pemanggilan method onPause() ketika suatu Activity mulai berinteraksi dengan user,
dan memanggil onStop() pada saat Activity menjadi invisible (tidak terlihat oleh user).
Method onStop() dipanggil ketika suatu Activity sudah tidak terlihat lagi oleh user. Hal
ini terjadi karena suatu Activity sudah tidak aktif lagi (dimusnahkan) atau disebabkan
Activity lain (baik yang telah ada atau yang baru) telah dijalankan dan menutupi Activity
sebelumnya. Android memanggil onRestart() setelah pemanggilan onStop() ketika suatu
Activity kembali berinteraksi dengan user, dan memanggil method onDestroy() pada
saat suatu Activity menghilang.
Method onDestroy() dipanggil sebelum suatu Activity dimusnahkan. Kalaupun memori
memadat, Android hanya akan menghentikan proses dari suatu Activity. Method
onDestroy() tidak akan pernah dipanggil. Jika onDestroy() dipanggil, maka akan menjadi
panggilan terakhir yang diterima Activity.
Ketujuh method di atas mendefinisikan siklus hidup Activity (Activity lifecycle) yang dapat
digambarkan seperti pada Gambar 2 berikut[1]
Gambar 2. Siklus hidup Activity (Activity lifecycle).
Untuk memahami siklus hidup Activity, lakukan percobaan berikut:
1. Menggunakan eclipse, buatlah sebuah project Android baru dan beri nama seperti pada
Gambar 3. dibawah berikut :
2. Ubah file ActivitiesActivity.java, sehingga isi file terlihat seperti berikut :
------------------------------------------------------------------------------------------------------------
package gie.triana;
import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
public class AktivitasActivity extends Activity {
String tag = "Event";
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
Log.d(tag, "pada event method onCreate(");
}
@Override
protected void onDestroy() {
// TODO Auto-generated method stub
super.onDestroy();
Log.d(tag, "pada event method onDestroy()");
}
@Override
protected void onPause() {
// TODO Auto-generated method stub
super.onPause();
Log.d(tag, "pada event method onPause()");
}
@Override
protected void onRestart() {
// TODO Auto-generated method stub
super.onRestart();
Log.d(tag, "pada event method onRestart()");
}
@Override
protected void onResume() {
// TODO Auto-generated method stub
super.onResume();
Log.d(tag, "pada event method onResume()");
}
@Override
protected void onStart() {
// TODO Auto-generated method stub
super.onStart();
Log.d(tag, "pada event method onStrat()");
}
@Override
protected void onStop() {
// TODO Auto-generated method stub
super.onStop();
Log.d(tag, "pada event method onStop()");
}
}
------------------------------------------------------------------------------------------------------------
Catatan : Penjelasan mengenai Log.d() dapat dilihat di :
http://developer.android.com//reference/android/util/Log.htm
3. Buka file AndroidManifest.xml. Pilih tab Application. Ubah nilai Debuggable ke nilai true
(lihat Gambar 4) dan save file.
Gambar 4.
4. Tekan F11 untuk men-debug aplikasi pada emulator Android
5. Ketika Activity pertama kali di-load, pada jendela LogCat akan terlihat catatan / Log seperti
berikut (lihat pada Gambar 5) :
10-09 23:34:16.951: DEBUG/Kejadian(544): pada event method onCreate()
10-09 23:34:16.951: DEBUG/Kejadian(544): pada event method onStart()
10-09 23:34:16.961: DEBUG/Kejadian(544): pada event method onResume()
Membuka jendela LogCat:
Pilih menu Window > Open perspective > Debug. Maksimumkan jendela LogCat hingga
seperti Gambar 5 berikut :
Gambar 5.
6. Pilih tombol Back pada emulator Android, Amati bahwa Log yang tercetak adalah:
10-09 23:42:02.672: DEBUG/Kejadian(544): pada event method onPause()
10-09 23:42:07.151: DEBUG/Kejadian(544): pada event method onStop()
10-09 23:42:07.151: DEBUG/Kejadian(544): pada event method onDestroy()
7. Klik dan tekan tombol Home hingga beberapa saat, klik icon Activities dan Amati bahwa
Log yang tercetak adalah :
10-09 23:44:02.252: DEBUG/Kejadian(544): pada event method onCreate()
10-09 23:44:02.252: DEBUG/Kejadian(544): pada event method onStart()
10-09 23:44:02.262: DEBUG/Kejadian(544): pada event method onResume()
8. Tekan tombol Phone pada emulator Android terlihat bahwa Activity didesak ke area
background. Amati output jendela LogCat:
10-09 23:45:27.362: DEBUG/Kejadian(544): pada event method onPause()
10-09 23:45:42.591: DEBUG/Kejadian(544): pada event method onStop()
9. Perhatikan bahwa event onDestroy tidak dipanggil, menunjukkan bahwa Activity masih
berjalan dalam memori. Keluarlah dari dialer phone dengan menekan tombol Back. Activity
sekarang terlihat lagi. Amati output pada jendela LogCat :
10-09 23:50:35.752: DEBUG/Kejadian(544): pada event method onRestart()
10-09 23:50:35.752: DEBUG/Kejadian(544): pada event method onStart()
10-09 23:50:35.762: DEBUG/Kejadian(544): pada event method onResume()
Event onRestart() sekarang dinyalakan, diikuti oleh event onStart() dan onResume().
Seperti yang kita lihat pada percobaan ini, Activity akan dihentikan (destroyed) pada saat kita
menekan tombol Back.
Pada saat sebuah activity mulai dijalankan, event onStart() dan onResume() selalu dipanggil,
tidak terkecuali apakah activity tersebut merupakan activity yang di-restore dari background atau
activity yang baru dibuat.
Service
Service merupakan komponen aplikasi yang beroperasi di area belakang layar (background)
untuk periode waktu yang tidak terbatas dan tidak memiliki user interface. Seperti dengan
activity, service berjalan dalam thread utama proses; dan pasti akan melahirkan thread lain untuk
menjalankan suatu operasi yang memerlukan banyak waktu. Service diklasifikasikan sebagai
local atau remote service:
Local service: berjalan pada proses yang sama sebagai penopang aplikasi. Service seperti
ini membuat aplikasi mudah untuk melaksanakan tugas-tugas di balik layar.
Remote service: berjalan pada proses yang terpisah. Service seperti ini memungkinkan
kita untuk melakukan komunikasi antar proses.
Catatan:
Service bukan merupakan suatu proses yang terpisah, walaupun service dapat dispesifikasikan ke dalam
proses yang terpisah. Service juga bukan thread. Service memungkinkan suatu aplikasi memberitahu
Android mengenai sesuatu yang ingin dilakukan di area background (bahkan pada saat pengguna tidak
secara langsung berinteraksi dengan aplikasi), dan memungkinkan aplikasi meng-expose
fungsionalitasnya untuk aplikasi lain.
Bayangkan service yang menjalankan musik sebagai respon atas pilihan user melalui activity.
Pengguna memilih lagu untuk dimainkan melalui activity ini, dan service segera bekerja sebagai
respon atas pilihan pengguna. Selanjutnya service memainkan musik pada thread lain untuk
mencegah munculnya dialog box Application Not Responding.
Broadcast Receiver
Broadcast Receiver adalah komponen yang menerima dan memberikan reaksi terhadap
broadcast. Kebanyakan broadcast bermula dari dalam kode sistem. Contohnya, sebuah
pemberitahuan dibuat untuk mengindikasikan bahwa timezone telah berubah atau batere telah
melemah.
Applikasi juga dapat memulakan broadcast. Contohnya sebuah aplikasi mungkin menghendaki
aplikasi-aplikasi lain untuk mengetahui bahwa data telah selesai diunduh dari jaringan ke dalam
perangkat dan sekarang telah tersedia untuk digunakan.
Content Provider
Content provider merupakan komponen yang memungkinkan data dari suatu aplikasi tersedia
bagi aplikasi lainnya. Data dapat tersimpan dalam sistem file Android, dalam database SQLite,
atau dalam bentuk lain yang dapat difahami sehingga memungkinkan aplikasi untuk saling
berbagi data dengan aplikasi lainnya.
Content provider melakukan pengaksesan raw data secara langsung karena content provider
men-decouple kode komponen dari format raw data. Pen-decouple-an ini dimaksudkan untuk
mencegah kerusakan kode ketika format data berubah.
Sumber: Kuliah Mobile Programing U.Tresna
3:04 PM
Unknown
