Dasar pemrograman android

138 Pages·2014·3 MB·Indonesian

BAB III
DASAR PEMROGRAMAN ANDROID

3.1 Latar Belakang
Perkembangan aplikasi Android saat ini berkembang dengan pesat. Bermacam-macam
aplikasi Android gratis ataupun bayar dapat kita install di handphone (smartphone) berbasis
sistem operasi Android. Banyaknya kebutuhan aplikasi-aplikasi berbasis Android di masa
sekarang dan masa yang akan datang membuka peluang yang sangat menjanjikan bagi siapa saja
yang mau untuk menjadi pembuat atau pengembang aplikasi Android. Namun kebanyakan dari
pemilik smartphone saat ini hanya sebagai pengguna aplikasinya saja. Sudah saatnya sekarang
ini kita Putra Putri Bangsa Indonesia membuat atau mengembangkan aplikasi Android dan
menunjuk ke pada dunia bahwa kita mampu bersaing secara global, salah satunya dengan
membuat atau mengembangkan aplikasi Android, atau minimal aplikasinya bisa digunakan
sendiri. Oleh karena itu, tutorial ini dibuat untuk khusunya bagi siapa saja yang ingin menjadi
pembuat atau pengembang aplikasi Android dan umumnya bagi yang ingin menambah wawasan
tentang Android.
Untuk memulai pemrograman Android, pengetahuan dan pemahaman akan dasar dari
pemrograman Android tersebut sangatlah penting. Pemahaman yang dimaksud seperti
memahami mekanisme kerja komponen dalam sistem operasi Android dan bagaimana
menggunakan komponen secara efektif dalam membuat aplikasi Android tersebut. Tanpa
pengetahuan dan pemahaman tersebut kita ibarat kapal yang berlayar tanpa membawa peta.
Pada Tutorial ini akan membahas tentang struktur, mekanisme dan contoh program dari
setiap komponen yang ada di pemrograman Android. Materi yang akan dibahasa diantaranya
pengenalan dasar widget view (Text Control, Button, Check Box, Radio Button,Lis t View, Grid
View,Spinner, Date and Time), Layout, Adapter, Menu, Dialog, dan Animasi.

3.2 Tujuan
Setelah mempelajari tutorial ini, pembaca diharapkan dapat:
a. Memahami dasar pemrograman Android.
b. Mengetahui dan memahami komponen yang ada pada aplikasi Android.
Dasar Pemrograman Android Page 61
c. Mengetahui dan memahami mekanisme kerja komponen dalam sistem operasi Android.
d. Memahami dan dapat menggunakan Widget View, Layout, Adapter, Menu, Dialog dan
Animasi.
e. Dapat menggunakan komponen secara efektif dalam membuat aplikasi di Android.
f. Dapat membuat program sederhana dengan memanfaatkan komponen yang ada pada aplikasi
Android.

3.3 Dasar Pemrograman Android
Aplikasi Android ditulis dengan menggunakan bahasa pemrograman Java. Kode Java
dikompilasi beserta dengan data dan file sumber yang dibutuhkan oleh aplikasi yang
digabungkan oleh tool aapt ke dalam paket Android, dan hasilnya berupa file archive berekstensi
.apk. File inilah yang di distribusikan atau diunduh pengguna dan menginstalnya ke dalam
perangkat mobile. Semua kode yang ada di dalam sebuah file berekstensi .apk dianggap sebagai
sebuah aplikasi. Dalam banyak hal, setiap aplikasi Android hidup di dalam dunianya sendiri:
a. Secara default, setiap aplikasi berjalan pada proses Linuxnya masing-masing. Android
memulai prosesnya ketika kode yang ada di dalam aplikasi akan dieksekusi, dan akan
mengakhirinya ketika proses itu tidak lagi diperlukan(system resources akan digunakan oleh
aplikasi lain).
b. Setiap proses mempunyai virtual machine(VM) masing-masing, sehingga kode aplikasi akan
dipisahkan dari aplikasi yang lainnya.
c. Secara default, setiap aplikasi diberikan sebuah user ID Linux yang unik. Aturan
penggunaan telah ditentukan sedemikian rupa sehingga hanya pengguna yang berhak saja
yang dapat mengakses dan menggunakan aplikasi tersebut walaupun ada beberapa cara
untuk mengekspor sebuah aplikasi ke dalam aplikasi lainnya.

User ID yang sama juga dapat digunakan oleh dua buah aplikasi sehingga aplikasi tersebut
dapat melihat file yang ada di kelolah oleh kedua aplikasi tersebut. User ID dapat mengatur dua
aplikasi, sehingga kedua aplikasi tersebut dapat saling berbagi file dan virtual machine untuk
menghemat system resources.

Dasar Pemrograman Android Page 62
3.4 Komponen Aplikasi
Fitur utama dari Android adalah sebuah aplikasi dapat menggunakan elemen dari aplikasi
lainnya (apabila diizinkan). Contohnya, jika aplikasi ditugaskan untuk menampilkan daftar
gambar yang dapat bergulir, maka aplikasi yang lain dapat menggunakannya untuk menampilkan
di dalam aplikasi tersebut. Fungsi yang sama dapat dipanggil di dalam dua aplikasi tanpa harus
membuatnya lagi. Aplikasi Android tidak mempunyai single entry point di dalamnya (contohnya,
tidak ada fungsi main()). Namun, Android mempunyai komponen penting yang dapat di
instantiate dan dijalankan oleh sistem apabila dibutuhkan. Ada empat macam komponen, yaitu:

a. Activities
Sebuah activity menyajikan sebuah user interface visual yang berfokus pada kegiatan dari
user. Sebuah aplikasi dapat terdiri dari satu atau beberapa activity. Ragam dan banyaknya
activity tersebut tergantung pada aplikasi dan perancangannya. Umumnya, sebuah activity
ditugaskan sebagai activity pertama yang akan tampil ketika aplikasi dijalankan, kemudian
dilanjutkan oleh activity berikutnya.
Contohnya, sebuah aplikasi dapat menyajikan daftar menu item atau menampilkan gambar
beserta keterangan yang dipilih oleh user. Sebuah aplikasi pengiriman teks bisa mempunyai
sebuah activity yang menampilkan daftar kontak untuk mengirim pesan, activity kedua
adalah menulis pesan ke kontak yang telah dipilih, dan activity yang lain adalah
menampilkan pesan lama atau mengubah pengaturan pesan. Walaupun activity tersebut
bekerja bersama pada sebuah user interface, namun setiap activity tidak saling bergantung
satu sama lain. Setiap activity diimplementasikan sebagai turunan (subclass) dari class
utama.

b. Services.
Servis adalah sebuah komponen aplikasi yang dapat melakukan operasi panjang yang
berjalan di background dan tidak menyediakan sebuah tampilan. Komponen aplikasi yang
lain dapat memulai sebuah servis dan terus berjalan di background meskipun pengguna
berpindah ke aplikasi lain. Sebagai tambahan, sebuah komponen dapat mengikat ke sebuah
services dan bahkan melakukan komunikasi antar proses (interprocess communication/IPC).
Sebagai contoh, sebuah services dapata menangani traksaksi jaringan, memutar musik,
Dasar Pemrograman Android Page 63
melakukan file I/O, atau berinteraksi dengan sebuah content provider semuanya berjalan di
background.
Pada dasarnya sebuah services memiliki dua bentuk :
a. Started
Sebuah services “started” ketika sebuah komponen aplikasi (misalnya activity)
memulainya dengan memanggil startService(). Sekali dimulai, sebuah services
dapat berjalan di background tanpa batas, bahkan jika komponen yang telah berjalan di
hancurkan. Biasanya, sebuah services yang telah berjalan akan melakukan operasi
tunggal dan tidak mengembalihan sebuah hasil ke pemanggil. Sebagai contoh,
mengunduh atau mengunggah sebuah file melalui jaringan. Ketika operasi berjalan,
services harus berhenti dengan sendirinya.
b. Bound
Sebuah services “bound” ketika sebuah komponen aplikasi mengikat kepadanya dengan
memanggil bindService(). Sebuah bound services menawarkan sebuah antarmuka
klien-server yang memungkinkan komponen untuk berinteraksi dengan services,
mengirimkan permintaan, memperoleh hasil dan bahkan melakukan seluruh proses
dengan interprocess communication(IPC). Sebuah bound services hanya berjalan selama
komponen aplikasi lain terikat kepadanya. Banyak komponen dapat terikat kepada
services sekali, tetapi ketika seluruhnya melepaskan ikatan, services akan dihancurkan.
Sebuah services dapat melakukan keduanya, services dapat dimulai dan juga
memungkinkan mengikat, dengan mengimplementasikan sepasang method callback:
onStartCommand() untuk memungkin komponen memulai services dan onBind()
untuk memungkinkan mengikatnya.
Terlepas dari apakah aplikasi dijalankan, terikat, atau keduanya, komponen aplikasi dapat
menggunakan services ini (bahkan dari aplikasi terpisah), dengan cara yang sama setiap
komponen dapat menggunakan suatu activity dengan memulainya menggunakan sebuah
Intent. Services dapat dideklarasikan sebagai private di file manifest, dan membatasi
akses dari aplikasi lain. Bagian ini akan dibahas lebih pada sesi “Mendeklarasikan
Services di Manifest”

Dasar Pemrograman Android Page 64
The Basic
Sebuah services dapat dibuat dengan membuat sebuah subclass dari Service. Pada
pengimplementasian, dibutuhkan beberapa method callback yang menangani aspek kunci dari
siklus hidup services dan menyediakan sebuah mekanisme untuk komponen mengikat ke
services ini, jika sesuai. Method callback yang paling penting untuk di override adalah :

a. onStartCommand()
Sistem akan memanggil method ini ketika komponen lain seperti sebuah activity,
meminta service untuk dimulai dengan memannggil startService(). Sekali method
ini dieksekusi, services akan dimulai dan dapat berjalan di background tanpa batas. Jika
ini diterapkan, maka services harus di hentikan ketika tugasnya telah selesai dengan
memanggil stopSelf() atau stopService().
b. onBind()
Sistem memanggil method ini ketika komponen lain ingin mengikat dengan services
(misalnya melakukan RPC), dengan memanggil bindService(). Pada saat Anda
menerapkan method ini, Anda harus menyediakan sebuah antarmuka yang digunakan
klien untuk berkomunikasi dengan services, dengan mengembalikan Ibinder. Anda
harus selalu menerapkan method ini, tapi jika Anda tidak mengizinkan binding, makan
Anda harus mengembalikan null.
c. onCreate()
Sistem memanggil method ini ketika services pertama kali dibuat, untuk melakukan satu
kali prosedur setup (sebelum memanggil onStartCommand() atau onBind() yang lain).
Jika services telah berjalan, method ini tidak akan dipanggil.
d. onDestroy()
Sistem memanggil method ini ketika services tidak lagi digunakan dan akan dihancurkan.
Services Anda harus menerapkan ini untuk membersihkan berbagai resouces seperti
threads, registered listener, receivers, dan lain-lain. Method ini merupakan panggilan
terakhir yang diterima oleh services.

Jika sebuah komponen di mulai dengan memanggil startService() (yang merupakan hasil
pemanggilan onStartCommand()), kemudian services akan tetap berjalan hingga berhenti
Dasar Pemrograman Android Page 65
dengan sendirinya dengan stopSelf() atau komponen lain menghentikannya dengan
memanggil stopService().
Jika sebuah komponen memanggil bindService() untuk menciptakan services (dan
onStartCommand() tidak dipanggil), services akan berjalan hanya selama komponen terikat
kepadanya. Sekali layanan tidak terikat dengan semua klien, sistem akan menghancurkannya.
Sistem Android akan force-stop sebuah services hanya jika memory rendah dan harus
memulihkan sumber daya sistem untuk activity yang menjadi fokus pengguna. Jika services
terikat dengan sebuah activity yang menjadi fokus pengguna, services tersebut memiliki
kemungkinan kecil untuk di kill dan jika services di deklarasikan untuk berjalan di depan latar,
maka services tersevut hampir tidak akan di kill.

Declaring a Service in Manifest
Seperti halnya activity, semua services yang digunakan pada aplikasi harus dideklarasian di
file manifest. Untuk mendeklarasikan services, tambahkan elemen <service> sebagai anak dari
elemen <application>. Dapat dilihat contoh koding di bawah ini.
<manifest ... >
...
<application ... >
<service android:name=".ExampleService" />
...
</application>
</manifest>

Ada atribut lain yang dapat Anda masukkan ke dalam elemen <service> untuk menentukan
properti, seperti permissions untuk memulai services dan menentukan proses yang harus di
jalankan oleh services.
Atribut android:name merupakan atribut yang dibutuhkan, atribut ini menentukan nama
dari services. Ketika Anda mempublish aplikasi, Anda tidak diperkenankan untuk mengubah
nama ini, karena jika diubah akan menyebabkan merusak beberapa fungsi yang digunakan oleh
intents yang mengacu kepada services tersebut. Sama seperti activity, sebuah services dapat
mendefinisikan intent filters yang mengizinkan componen lain untuk meminta services
menggunakan implicit intents. Dengan mendeklarasikan intent filter, komponen dari berbagai
aplikasi yang terinstal di handset pengguna dapat menjalankan services Anda jika services
Dasar Pemrograman Android Page 66
tersebut mendeklarasikan sebuah intent filter yang sesuai dengan intent dari aplikasi lain yang
dilewatkan ke startService().
Creating a Started Service
Sebuah started services merupakan salah satu komponen starts dengan memanggil
startService(), menghasilkan sebuah panggilan ke method onStartCommand(). Ketika
sebuah services di jalankan, services tersebut memiliki siklus hidup yang independen dan dapat
berjalan di belakang layar tanpa batas, bahkan jika komponen yang berjalan mulai hancur.
Dengan demikian, services harus berhenti sendiri ketika tugasnya dilakukan dengan memanggil
stopSelf(), atau komponen lain dapat menghentikannya dengan memanggil stopServices().
Sebuah komponen aplikasi seperti sebuah activity dapat memullai services dengan memanggil
startService() dan melewatkan sebuah Intent yang menentukan services dan termasuk data
yang digunakan oleh services. Services menerima Intent ini dalam method onStartComand().
Misalnya, suatu kegiatan perlu menyimpan data ke database online. Activity dapat
menjalankan sebuah services pendamping dan mengirimkan data yang akan disimpan dengan
melewatkan intent() untuk startService(). Services menerima intent di
onStartCommand(), menghubungkan ke internet dan melakukan transaksi database. Setelah
transaksi dilakukan, services berhenti sendiri dan akan dihancurkan.
Ada dua class yang dapat di extends untuk membuat sebuah services.
a. Services
Merupakan class daras untuk semua services. Ketika mengextends class ini, penting
utnuk membuat thread baru sebagai tempat kerja services, karena services ini
menggunakan thread utama dari aplikasi yang dibuat, secara default dapat memperlambat
kinerja dari setiap aktivitas aplikasi yang berjalan.
b. IntentServices
Merupakan subclass dari Services yang menggunakan thread untuk menangani semua
permintaan awal satu per satu. Merupakan pilihan terbaik jika services yang ditangani
tidak memerlukan beberapa request secara bersamaan. Yang harus dilakukan adalah
mengimplementasikan onHandleIntent(), yang menerima intent untuk setiap request
sehingga dapat melakukan background work.
Dasar Pemrograman Android Page 67
Sesi berikut menjelaskan bagaimana menimplementasikan services menggunakan salah satu dari
class tersebut.

Extending the IntentService Class
Karena sebagian started services tidak perlu menangani berbagai permintaan secara
simulatan (yang dapat menjadi sebuah skenario multi-threading yang berbahaya), sebaiknya
mengimplement services menggunakan class IntentService.
IntentServices melakukan hal-hal berikut:
a. Membuat sebuah worker thread yang mengeksekusi seluruh intent yang dikirimkan ke
onStartComand() terpisah dari thread utama aplikasi.
b. Membuat sebuah work queue yang melewatkan sebuah intent pada suatu waktu ke
penerapan onHandleIntent(), sehingga Anda tidak perlu mengkhawatirkan multi-
threading.
c. Menghentikan services setelah semua request ditangani, sehingga tidak perlu memanggil
stopSelf().
d. Menyediakan implementasi standar dari onBind() yang mengembalikan null.
e. Menyediakan asebuah implementasi standar dari onStartCommand() yang mengirimkan
intent ke antrian kerja dan kemudian ke implementasi onHandleIntent().
Yang dibutuhkan adalah mengimplementasikan onHandleIntent() untuk melakukan pekerjaan
yang disediakan oleh klien.
Contoh:
public class HelloIntentService extends IntentService {

/**
* A constructor is required, and must call the super
IntentService(String)
* constructor with a name for the worker thread.
*/
public HelloIntentService() {
super("HelloIntentService");
}

/**
* The IntentService calls this method from the default worker thread
with
* the intent that started the service. When this method returns,
IntentService
Dasar Pemrograman Android Page 68
* stops the service, as appropriate.
*/
@Override
protected void onHandleIntent(Intent intent) {
// Normally we would do some work here, like download a file.
// For our sample, we just sleep for 5 seconds.
long endTime = System.currentTimeMillis() + 5*1000;
while (System.currentTimeMillis() < endTime) {
synchronized (this) {
try {
wait(endTime - System.currentTimeMillis());
} catch (Exception e) {
}
}
}
}
}

Jika akan meng override method callback, seperti onCreate(), onStartCommand() atau
onDestroy(), pastikan untuk memanggil implementasi super, sehingga IntentServices dapat
menangani worker thread. Sebagai contoh, onStartCommand() harus mengembalikan
implementasi standar (bagaimana intent mengirim ke onHandleIntent()) :
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
Toast.makeText(this, "service starting", Toast.LENGTH_SHORT).show();
return super.onStartCommand(intent,flags,startId);
}
Selain onHandleIntent(), method yang tidak dibutuhkan untuk memanggil super class
adalah onBind() (tapi dibutuhkan jika services mengizinkan binding).

Extending the Service Class
Penggunaan IntentService membuat implementasi sebuah started service sangat sederhana.
Jika services melakukan multi-threading (daripada memproses start request melalui sebuah
antrian kerja), dapat dilakukan dengan meng extenda class Service untuk menangani setiap
intent. Sebagai perbandingan, contoh kode berikut adalah sebuah implementasi dari kelas Service
yang melakukan pekerjaan yang sama dengan contoh diatas yang menggunakan IntentServices.
Untuk setiap start request, menggunakan sebuah worker thread untuk melakukan pekerjaan dan
hanya memproses satu request pada satu waktu.
Dasar Pemrograman Android Page 69
public class HelloService extends Service {
private Looper mServiceLooper;
private ServiceHandler mServiceHandler;

// Handler that receives messages from the thread
private final class ServiceHandler extends Handler {
public ServiceHandler(Looper looper) {
super(looper);
}
@Override
public void handleMessage(Message msg) {
// Normally we would do some work here, like download a file.
// For our sample, we just sleep for 5 seconds.
long endTime = System.currentTimeMillis() + 5*1000;
while (System.currentTimeMillis() < endTime) {
synchronized (this) {
try {
wait(endTime - System.currentTimeMillis());
} catch (Exception e) {
}
}
}
// Stop the service using the startId, so that we don't stop
// the service in the middle of handling another job
stopSelf(msg.arg1);
}
}

@Override
public void onCreate() {
// Start up the thread running the service. Note that we create a
// separate thread because the service normally runs in the process's
// main thread, which we don't want to block. We also make it
// background priority so CPU-intensive work will not disrupt our UI.
HandlerThread thread = new HandlerThread("ServiceStartArguments",
Process.THREAD_PRIORITY_BACKGROUND);
thread.start();

// Get the HandlerThread's Looper and use it for our Handler
mServiceLooper = thread.getLooper();
mServiceHandler = new ServiceHandler(mServiceLooper);
}

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
Toast.makeText(this, "service starting",
Toast.LENGTH_SHORT).show();

// For each start request, send a message to start a job and
Dasar Pemrograman Android Page 70