modul piranti bergerak d3 elins
DESCRIPTION
D3 UGMTRANSCRIPT
MODUL PRAKTIKUM PIRANTI BERGERAK
(MOBILE DEVICE)
D3 ELEKTRONIKA DAN INSTRUMENTASI
SEKOLAH VOKASI
UNIVERSITAS GADJAH MADA
2015
DAFTAR ISI
BAB 1 Pengenalan Android .............................................................................................................. 10
1.1. Aplikasi menyediakan beberapa entry point ........................................................................ 10
1.2. Aplikasi beradaptasi dengan perangkat yang berbeda ......................................................... 10
1.3. Fundamental aplikasi ............................................................................................................ 10
1.4. Komponen aplikasi ................................................................................................................ 11
BAB 2 INSTALASI ANDROID STUDIO ................................................................................................ 15
2.1. System Requirements ........................................................................................................... 15
2.1.1. Windows ....................................................................................................................... 15
2.1.2. Mac OS X ....................................................................................................................... 15
2.1.3. Linux .............................................................................................................................. 15
2.2. Install Java ............................................................................................................................. 16
2.3. Set JAVA_HOME anda ........................................................................................................... 18
BAB 3 MEMBUAT APLIKASI PERTAMA KALI ..................................................................................... 24
3.1. Membuat Aplikasi Hello World ............................................................................................. 24
3.2. Menjalankan Aplikasi ............................................................................................................ 33
3.2.1. Menjalankan pada Device ............................................................................................. 33
Set up device ............................................................................................................................. 33
Menjalankan aplikasi dari Android Studio ................................................................................ 36
OEM USB Drivers ....................................................................................................................... 37
Install USB Driver .................................................................................................................. 38
Windows 7 ........................................................................................................................ 38
Windows Vista .................................................................................................................. 38
OEM Drivers .......................................................................................................................... 40
3.2.2. Menjalankan pada Emulator ......................................................................................... 41
Membuat AVD ........................................................................................................................... 41
Menjalankan aplikasi dari Android Studio ................................................................................ 43
BAB 4 USER INTERFACE 1 ................................................................................................................ 46
4.1. User Interface ....................................................................................................................... 46
4.1.1. User Interface Layout .................................................................................................... 46
4.1.2. User Interface Components .......................................................................................... 47
4.1.3. Layouts .......................................................................................................................... 47
Menulis XML ............................................................................................................................. 48
Memuat resource XML ............................................................................................................. 49
Attributes .................................................................................................................................. 49
ID ............................................................................................................................................... 49
Layout Parameters .................................................................................................................... 51
4.1. Percobaan 1 Layout, TextView, EditText dan Button ........................................................... 51
4.1.2. Membuat Linear Layout ................................................................................................ 54
4.1.3. Menambahkan TextField .............................................................................................. 56
4.1.4. Menambah Button ........................................................................................................ 58
4.2. Tugas ..................................................................................................................................... 63
BAB 5 USER INTERFACE 2 ................................................................................................................ 64
5.1. Input Controls ....................................................................................................................... 64
5.1.1. Common Controls ......................................................................................................... 65
5.1.2. Buttons .......................................................................................................................... 66
Respond ke Click Events ............................................................................................................ 66
Menggunakan OnClickListener ................................................................................................. 67
Styling Button ............................................................................................................................ 68
Custom background .................................................................................................................. 68
5.1.3. Text Fields ..................................................................................................................... 69
Menentukan Jenis Keyboard ..................................................................................................... 70
Menentukan Tindakan Keyboard .............................................................................................. 72
Merespon action button events ............................................................................................... 72
Setting custom action button label ........................................................................................... 73
5.2. Percobaan 1 ImageView ....................................................................................................... 74
5.3. Percobaan 2 Hitung Luas Lingkaran ...................................................................................... 80
5.4. Percobaan 3 Menambahkan Radio Button ........................................................................... 85
5.5. Tugas ..................................................................................................................................... 89
BAB 6 USER INTERFACE 3 ................................................................................................................ 90
6.1. Input Control ......................................................................................................................... 90
6.1.1. Checkboxes ................................................................................................................... 90
Merespon Click Events .............................................................................................................. 90
6.1.2. Toggle Buttons .............................................................................................................. 91
Merespon Button yang ditekan ................................................................................................ 92
6.1.3. Spinners ......................................................................................................................... 92
Merespon User Selection .......................................................................................................... 94
6.1.4. Pickers ........................................................................................................................... 94
6.2. Percobaan 1 Date Picker Time Picker ................................................................................... 95
Untuk Program Date Picker ...................................................................................................... 98
Untuk program Time Picker .................................................................................................... 100
6.3. Percobaan 2 Spinner ........................................................................................................... 102
6.4. Tugas ................................................................................................................................... 106
BAB 7 KOMPONEN APLIKASI ......................................................................................................... 109
7.1. Intents dan Intent Filters .................................................................................................... 109
7.1.1. Untuk memulai suatu Activity ..................................................................................... 109
7.1.2. Untuk memulai Service ............................................................................................... 109
7.1.3. Untuk memberikan Broadcast .................................................................................... 109
7.2. Tipe Intent ........................................................................................................................... 109
7.3. Membangun Intent ............................................................................................................. 111
7.3.1. Component name ....................................................................................................... 111
7.3.2. Action .......................................................................................................................... 111
ACTION_VIEW ........................................................................................................................ 112
ACTION_SEND ........................................................................................................................ 112
7.3.3. Data ............................................................................................................................. 112
7.3.4. Category ...................................................................................................................... 113
CATEGORY_BROWSABLE ........................................................................................................ 113
CATEGORY_LAUNCHER ........................................................................................................... 113
7.3.5. Extras ........................................................................................................................... 113
7.3.6. Flags ............................................................................................................................ 114
7.4. Contoh explicit intent ......................................................................................................... 114
7.5. Contoh implicit intent ......................................................................................................... 114
7.6. Forcing an app chooser ....................................................................................................... 115
7.7. Menerima Implicit Intent .................................................................................................... 116
7.7.1. Restricting access to components............................................................................... 118
7.7.2. Contoh Filters .............................................................................................................. 118
7.8. Menggunakan Pending Intent ............................................................................................. 119
7.9. Intent Resolution ................................................................................................................ 120
7.9.1. Action test ................................................................................................................... 120
7.9.2. Category test ............................................................................................................... 120
7.9.3. Data test ...................................................................................................................... 121
7.9.4. Intent matching ........................................................................................................... 123
7.10. Percobaan 1 Explicit Intent Untuk menampilkan layout baru. ....................................... 123
7.11. Percobaan 2 Implicit Intent untuk Aplikasi Telp dan SMS .............................................. 133
7.12. Percobaan 3 Implicit Intent dengan Intent.createChooser(). ......................................... 139
7.13. Tugas ............................................................................................................................... 144
DAFTAR GAMBAR
Gambar 2.1 Mengecek versi java .......................................................................................................... 16
Gambar 2.2 Halaman Penginstalan JDK ................................................................................................ 17
Gambar 2.3 Mengecek Tipe System ..................................................................................................... 17
Gambar 2.4 Mendownload sesuai dengan type system ....................................................................... 18
Gambar 2.5 Properties PC ..................................................................................................................... 18
Gambar 2.6 System ............................................................................................................................... 19
Gambar 2.7 Memilih Advance System Setting ...................................................................................... 19
Gambar 2.8 Tampilan System Properties ............................................................................................. 20
Gambar 2.9 Environment Variables ...................................................................................................... 21
Gambar 2.10 Menambah System Variables ......................................................................................... 21
Gambar 2.11 Hasil Menambah Environment Variables........................................................................ 22
Gambar 2.12 Membuat JAVA_HOME ................................................................................................... 22
Gambar 2.13 SDK Manager ................................................................................................................... 23
Gambar 2.14 Install SDK ........................................................................................................................ 23
Gambar 3.1 Membuat Aplikasi Baru ..................................................................................................... 24
Gambar 3.2 Membuat Project Baru ...................................................................................................... 25
Gambar 3.3 Pilih Minimum SDK ............................................................................................................ 25
Gambar 3.4 List Dari minimum SDK ...................................................................................................... 26
Gambar 3.5 Pilih Blank Activity ............................................................................................................. 26
Gambar 3.6 Mengisi Nama Activity , Layout, title dan Menu Resource Name .................................... 27
Gambar 3.7 Tampilan Awal dari Aplikasi Pertama................................................................................ 27
Gambar 3.8 Tampilan List Folder dari Aplikasi...................................................................................... 28
Gambar 3.9 Tampilan Activity_main.xml secara Desain ....................................................................... 29
Gambar 3.10 Tampilan Activity_main.xml secara Text ........................................................................ 29
Gambar 3.11 Tampilan MainActivity.java ............................................................................................. 30
Gambar 3.12 Tampilan AndroidManifest.xml ...................................................................................... 31
Gambar 3.13 Tampilan Build.gradle ..................................................................................................... 32
Gambar 3.14 Folder res ........................................................................................................................ 32
Gambar 3.15 Menyambung perangkat ................................................................................................. 34
Gambar 3.16 Build Number .................................................................................................................. 35
Gambar 3.17 Developer Option ............................................................................................................ 35
Gambar 3.18 USB Debugging ................................................................................................................ 36
Gambar 3.19 Pilih Run .......................................................................................................................... 36
Gambar 3.20 Memilih Device ............................................................................................................... 37
Gambar 3.21 Hasil Akhir Aplikasi Hello World ...................................................................................... 37
Gambar 3.22 AVD .................................................................................................................................. 41
Gambar 3.23 Pilih Hardware ................................................................................................................. 42
Gambar 3.24 Pilih Image System .......................................................................................................... 42
Gambar 3.25 Konfigurasi AVD............................................................................................................... 43
Gambar 3.26 Hasil Jadi AVD .................................................................................................................. 43
Gambar 3.27 Hasil Jadi Aplikasi Helloworld menggunakan AVD .......................................................... 45
Gambar 4.1 Ilustrasi bagaimana objek ViewGroup membentuk cabang di layout dan mengandung
View object lainnya. .............................................................................................................................. 46
Gambar 4.2 Layout XML ........................................................................................................................ 47
Gambar 4.3 Layout XML 2 ..................................................................................................................... 49
Gambar 4.4 Method OnCreate ............................................................................................................. 49
Gambar 4.5 Penulisan ID ....................................................................................................................... 50
Gambar 4.6 Menambah paket namespace android ............................................................................. 50
Gambar 4.7 file layout .......................................................................................................................... 50
Gambar 4.8 Menampilkan layout ......................................................................................................... 50
Gambar 4.9 Visualisasi tampilan hirarki dengan parameter layout yang terkait dengan setiap
tampilan ................................................................................................................................................ 51
Gambar 4.10 Project UI1 ....................................................................................................................... 52
Gambar 4.11 Pilih Minimum SDK sesuai ............................................................................................... 52
Gambar 4.12 Pilih Blank Activity ........................................................................................................... 53
Gambar 4.13 Beri nama Activity ........................................................................................................... 53
Gambar 4.14 Hasil tampilan pembuatan project ................................................................................. 54
Gambar 4.15 Buka Activity_main.xml ................................................................................................... 54
Gambar 4.16 Plih pada Text Mode ....................................................................................................... 55
Gambar 4.17 Tampilan activity_main.xml text mode ........................................................................... 55
Gambar 4.18 Mengubah RelativeLayout menjadi LinearLayout .......................................................... 56
Gambar 4.19 Tambahkan atribut orientation ....................................................................................... 56
Gambar 4.20 Menambah EditText ........................................................................................................ 57
Gambar 4.21 Membuka Strings.xml ..................................................................................................... 57
Gambar 4.22 Membuat string............................................................................................................... 58
Gambar 4.23 Menambah atribut Hint pada EditText ........................................................................... 58
Gambar 4.24 Menambah Button .......................................................................................................... 59
Gambar 4.25 Menambah atribut onClick ............................................................................................. 59
Gambar 4.26 Menambah TextView 6 ................................................................................................... 60
Gambar 4.27 Kode program Layout Terakhir ....................................................................................... 60
Gambar 4.28 Tampilan Layout .............................................................................................................. 61
Gambar 4.29 Menambah Library .......................................................................................................... 61
Gambar 4.30 Menambah Object .......................................................................................................... 61
Gambar 4.31 Menentukan Variable nama sebagai EditText Berdasar ID............................................. 61
Gambar 4.32 Method SendMessage .................................................................................................... 61
Gambar 4.33 Fie main_activity.java ...................................................................................................... 62
Gambar 4.34 Hasil Akhir dijalankan ...................................................................................................... 63
Gambar 5.1 Input Control ..................................................................................................................... 64
Gambar 5.2 Contoh layout .................................................................................................................... 64
Gambar 5.3 Macam-macam Button ..................................................................................................... 66
Gambar 5.4 Button Text ........................................................................................................................ 66
Gambar 5.5 Image Button ..................................................................................................................... 66
Gambar 5.6 Button dengan text dan Gambar ...................................................................................... 66
Gambar 5.7 Layout Button .................................................................................................................... 67
Gambar 5.8 Method SendMessage ...................................................................................................... 67
Gambar 5.9 Method SerOnClickListener .............................................................................................. 67
Gambar 5.10 Button_custom XML ....................................................................................................... 69
Gambar 5.11 Button Background ......................................................................................................... 69
Gambar 5.12 EditText ........................................................................................................................... 70
Gambar 5.13 EditText email ................................................................................................................. 70
Gambar 5.14 default text input type .................................................................................................... 71
Gambar 5.15 textEmailAddress input type ........................................................................................... 71
Gambar 5.16 phone input type. ............................................................................................................ 71
Gambar 5.17 Contoh EditText............................................................................................................... 72
Gambar 5.18 Tindakan Keyboard ......................................................................................................... 72
Gambar 5.19 EditText ActionSend ........................................................................................................ 72
Gambar 5.20 OnEditorActionListener ................................................................................................... 73
Gambar 5.21 Custom action Button label ............................................................................................ 73
Gambar 5.22 custom action label dengan android:imeActionLabel .................................................... 73
Gambar 5.23 Buat project image aplication ......................................................................................... 74
Gambar 5.24 Menghapus textView ...................................................................................................... 74
Gambar 5.25 Copy gambar ................................................................................................................... 75
Gambar 5.26 Paste Gambar .................................................................................................................. 75
Gambar 5.27 Menempatkan gambar ke direktori pada project ........................................................... 76
Gambar 5.28 Terlihat gambar pada folder drawable ........................................................................... 76
Gambar 5.29 menempatkan ImageView .............................................................................................. 77
Gambar 5.30 Layout ImageView ........................................................................................................... 77
Gambar 5.31 Src pada properties ......................................................................................................... 78
Gambar 5.32 Memilih gambar yang akan ditampilkan imageView ...................................................... 78
Gambar 5.33 Tampilan ImageView ....................................................................................................... 79
Gambar 5.34 Hasil Aplikasi ImageView ................................................................................................. 79
Gambar 5.35 Project Hitung Luas Lingkaran ......................................................................................... 80
Gambar 5.36 Layout Program Luas Lingkaran ...................................................................................... 81
Gambar 5.37 Strings.xml pada Pogram Luas Lingkaran ........................................................................ 81
Gambar 5.38 Mengubah String pada TextView .................................................................................... 82
Gambar 5.39 Mengubah String pada Button ........................................................................................ 82
Gambar 5.40 Mengubah String pada TextView2 .................................................................................. 82
Gambar 5.41 Hasil Akhir tampilan ........................................................................................................ 83
Gambar 5.42 Library pada program Menghitung Luas Lingkaran ........................................................ 83
Gambar 5.43 Menambahkan implements OnClickListener .................................................................. 83
Gambar 5.44 Menambahkan Object eJari, eLuas, dan LuasLingkaran ................................................. 84
Gambar 5.45 Memasukkan Id pada Object .......................................................................................... 84
Gambar 5.46 Menambahkan setOnClickListener ................................................................................. 84
Gambar 5.47 Menambahkan Fungsi onClick ........................................................................................ 84
Gambar 5.48 Hasil Program Menghitung Luas Lingkaran ..................................................................... 85
Gambar 5.49 Mengubah Strings.xml .................................................................................................... 85
Gambar 5.50 Layout Hitung Luas dan Keliling Lingkaran ...................................................................... 86
Gambar 5.51 Layout program ............................................................................................................... 88
Gambar 5.52 Menambah object rLuas dan rKeliling ............................................................................ 88
Gambar 5.53 Menentukan Id ................................................................................................................ 88
Gambar 5.54 menghitung Luas dan Keliling pada fungsi onClick ......................................................... 88
Gambar 5.55 Hasil Tampilan program .................................................................................................. 89
Gambar 6.1 Contoh CheckBox .............................................................................................................. 90
Gambar 6.2 Layout ada checkbox ......................................................................................................... 90
Gambar 6.3 Isi onCheckboxClicked ....................................................................................................... 91
Gambar 6.4 Toggle buttons .................................................................................................................. 91
Gambar 6.5 Switches (in Android 4.0+) ................................................................................................ 92
Gambar 6.6 Memanggil OnCheckedChangeListener ............................................................................ 92
Gambar 6.7 Contoh Spinner ................................................................................................................. 92
Gambar 6.8 Spinner pada layout .......................................................................................................... 93
Gambar 6.9 Spinner Adapter ................................................................................................................ 93
Gambar 6.10 Memanggil Spinner ......................................................................................................... 93
Gambar 6.11 Class SpinnerActivity ....................................................................................................... 94
Gambar 6.12 Memanggil SetOnItemSelectedListener ......................................................................... 94
Gambar 6.13 Pickers ............................................................................................................................. 95
Gambar 6.14 Membuat Project Date Picker Time Picker ..................................................................... 96
Gambar 6.15 Tampilan awal ................................................................................................................. 96
Gambar 6.16 Ubah tampilan Program .................................................................................................. 97
Gambar 6.17 Layout DatePickerTimePicker ......................................................................................... 98
Gambar 6.18 Tambah Library ............................................................................................................... 98
Gambar 6.19 Menambahkan implements OnClickListener .................................................................. 98
Gambar 6.20 Menambahkan UI Reference .......................................................................................... 99
Gambar 6.21 Method OnCreate ........................................................................................................... 99
Gambar 6.22 Method OnClick .............................................................................................................. 99
Gambar 6.23 Hasil Program DatePicker.............................................................................................. 100
Gambar 6.24 Tambahan Library untuk Time Picker ........................................................................... 100
Gambar 6.25 UI Reference Time Picker .............................................................................................. 100
Gambar 6.26 Menambah method addListenerOnButton .................................................................. 101
Gambar 6.27 Menambah Method berikut ini ..................................................................................... 102
Gambar 6.28 Hasil Program Time Pickering ....................................................................................... 102
Gambar 7.1 Ilustrasi bagaimana implicit Intent disampaikan melalui sistem untuk memulai activity
lain: [1] Activity A menciptakan Intent dengan deskripsi tindakan dan lolos ke startActivity (). [2]
Sistem Android mencari semua aplikasi untuk intent filter yang cocok dengan intent. Ketika
kecocokan ditemukan, [3] sistem mulai aktivitas pencocokan (Kegiatan B) dengan menerapkan
metode OnCreate() dan menyampaikannya ke Intent. ...................................................................... 110
Gambar 7.2 Intent chooser ................................................................................................................. 116
Gambar 7.3 Tampilan Contoh Intent .................................................................................................. 124
Gambar 7.4 Method onCreate pada program share Text dan Gambar ............................................. 142
Android menyediakan kerangka aplikasi yang kaya yang memungkinkan Anda untuk
membangun aplikasi yang inovatif dan game untuk perangkat mobile di lingkungan bahasa Java.
Jika Anda baru untuk pengembangan Android, penting bahwa Anda memahami konsep dasar
berikut tentang kerangka aplikasi Android:
Aplikasi Android dibangun sebagai kombinasi dari komponen yang berbeda yang dapat
dipanggil secara individual. Misalnya, kegiatan individu menyediakan satu layar untuk antarmuka
pengguna, dan layanan independen melakukan pekerjaan di latar belakang.
Dari salah satu component Anda dapat mulai menggunakan component lain menggunakan
intent. Anda bahkan dapat mulai Component dalam aplikasi yang berbeda, seperti activity di aplikasi
peta untuk menunjukkan alamat. Model ini memberikan beberapa entry point untuk aplikasi tunggal
dan memungkinkan aplikasi apapun untuk berperilaku sebagai penggunaan "default" untuk sebuah
tindakan yang aplikasi lain dapat dipanggil.
Android menyediakan kerangka kerja aplikasi adaptif yang memungkinkan Anda untuk
menyediakan sumber daya yang unik untuk konfigurasi perangkat yang berbeda. Sebagai contoh,
Anda dapat membuat berbagai file layout XML untuk ukuran layar yang berbeda dan sistem
menentukan tata letak untuk menerapkan berdasarkan ukuran layar perangkat saat ini.
Anda dapat meng-query ketersediaan fitur perangkat di runtime jika ada fitur aplikasi
memerlukan perangkat keras tertentu seperti kamera. Jika perlu, Anda juga dapat mendeklarasikan
fitur aplikasi Anda membutuhkan begitu aplikasi pasar seperti Google Play Store tidak memungkinkan
instalasi pada perangkat yang tidak mendukung fitur itu.
Aplikasi Android ditulis dalam bahasa pemrograman Java. Alat SDK Android mengkompilasi
Kode Anda bersama dengan data dan file ke resource sebuah APK: paket Android, yang merupakan
file arsip dengan akhiran .apk. Satu file APK berisi semua isi dari sebuah aplikasi Android dan file yang
digunakan untuk menginstal aplikasi.
Setelah diinstal pada perangkat, setiap aplikasi Android tinggal di sandbox keamanan sendiri:
1. Sistem operasi Android adalah multi-user sistem Linux di mana setiap aplikasi adalah pengguna
yang berbeda.
2. Secara default, sistem memberikan tiap app pengguna Linux ID unik (ID hanya digunakan oleh
sistem dan tidak diketahui ke app). Sistem ini menetapkan hak akses untuk semua file dalam
sebuah aplikasi sehingga hanya user ID ditugaskan untuk aplikasi yang dapat mengaksesnya.
3. Setiap proses memiliki mesin virtual sendiri (VM), sehingga kode sebuah aplikasi yang berjalan di
isolasi dari aplikasi lain.
4. Secara default, setiap aplikasi berjalan dalam proses Linux sendiri. Android mulai proses ketika
salah satu komponen app harus dieksekusi, kemudian menutup proses ketika itu tidak lagi
diperlukan atau ketika sistem harus memulihkan memori untuk aplikasi lain.
Dengan cara ini, sistem Android mengimplementasikan prinsip paling istimewa. Artinya,
setiap aplikasi, secara default, memiliki akses hanya untuk komponen yang membutuhkan untuk
melakukan tugasnya dan tidak lebih. Ini menciptakan lingkungan yang sangat aman di mana sebuah
aplikasi tidak dapat mengakses bagian dari sistem yang tidak diberikan izin.
Namun, ada cara untuk sebuah aplikasi untuk berbagi data dengan aplikasi lain dan untuk
sebuah aplikasi untuk layanan sistem akses:
1. Ini mungkin untuk mengatur dua aplikasi untuk berbagi sama Linux ID pengguna, dalam hal ini
mereka dapat mengakses file masing-masing. Untuk menghemat sumber daya sistem, aplikasi
dengan user ID yang sama juga dapat mengatur untuk menjalankan dalam proses Linux yang
sama dan berbagi VM yang sama (aplikasi juga harus ditandatangani dengan sertifikat yang
sama).
2. Sebuah aplikasi dapat meminta izin untuk mengakses data perangkat seperti kontak pengguna,
pesan SMS, penyimpanan mountable (SD card), kamera, Bluetooth, dan banyak lagi. Semua izin
aplikasi harus diberikan oleh pengguna pada waktu menginstal.
Komponen aplikasi adalah blok bangunan penting dari sebuah aplikasi Android. Masing-
masing komponen adalah titik yang berbeda melalui mana sistem dapat memasukkan aplikasi Anda.
Tidak semua komponen entry point yang sebenarnya bagi pengguna dan beberapa bergantung satu
sama lain, namun masing-masing ada sebagai entitas sendiri dan memainkan peran-masing spesifik
satu adalah sebuah blok bangunan yang unik yang membantu menentukan perilaku aplikasi Anda
secara keseluruhan.
Ada empat jenis komponen aplikasi. Setiap jenis memiliki tujuan yang berbeda dan memiliki
lifecycle yang berbeda yang mendefinisikan bagaimana komponen dibuat dan dihancurkan.
Berikut adalah empat jenis komponen aplikasi:
1. Activities
Sebuah activity mewakili satu layar dengan user interface. Sebagai contoh, sebuah aplikasi
email mungkin memiliki satu activity yang menunjukkan daftar email baru, activity lain untuk menulis
email, dan activity lain untuk membaca email. Meskipun activity bekerja sama untuk membentuk
pengalaman pengguna yang kohesif dalam aplikasi email, masing-masing adalah independen dari yang
lain. Dengan demikian, aplikasi yang berbeda dapat mulai salah satu dari activity ini (jika aplikasi email
memungkinkan). Sebagai contoh, sebuah aplikasi kamera dapat memulai activity di app email yang
menyusun surat baru, agar pengguna untuk berbagi gambar. Activity diimplementasikan sebagai
subclass Activity.
2. Services
Service adalah komponen yang berjalan di latar belakang untuk melakukan operasi lama
berjalan atau melakukan pekerjaan untuk proses jarak jauh. Layanan A tidak menyediakan antarmuka
pengguna. Sebagai contoh, sebuah layanan mungkin memainkan musik di latar belakang saat
pengguna berada dalam aplikasi yang berbeda, atau mungkin mengambil data melalui jaringan tanpa
menghalangi interaksi pengguna dengan aktivitas. Komponen lain, seperti kegiatan, dapat memulai
layanan dan biarkan berjalan atau mengikat itu dalam rangka untuk berinteraksi dengan itu.
Sebuah layanan diimplementasikan sebagai subclass Layanan dan Anda dapat mempelajari
lebih lanjut tentang hal itu di buku Jasa pengembang.
3. Content providers
Content providers membuat kumpulan aplikasi data secara spesifik sehingga bisa digunakan
oleh aplikasi lain. Anda dapat menyimpan data dalam sistem file, database SQLite, di web, atau lokasi
penyimpanan persisten lainnya dimana aplikasi Anda dapat mengakses. Melalui Content provider,
aplikasi lain dapat melakukan permintaan atau bahkan memodifikasi data (jika penyedia konten
memungkinkan). Misalnya, sistem Android menyediakan penyedia konten yang mengelola informasi
kontak pengguna. Dengan demikian, setiap aplikasi dengan izin yang tepat dapat meminta bagian dari
Content provider (seperti ContactsContract.Data) untuk membaca dan menulis informasi tentang
orang tertentu.
Content provider juga berguna untuk membaca dan menulis data yang bersifat pribadi untuk
aplikasi Anda dan tidak dibagi. Sebagai contoh, aplikasi Note Pad sampel menggunakan penyedia
konten untuk menyimpan catatan.
Sebuah penyedia konten diimplementasikan sebagai subclass dari ContentProvider dan harus
menerapkan satu set standar API yang memungkinkan aplikasi lain untuk melakukan transaksi. Untuk
informasi lebih lanjut, lihat Content Provider panduan pengembang.
4. Broadcast receivers
Sebuah broadcast receiver adalah komponen yang merespon system-wide broadcast
announcements. Banyak broadcasts berasal dari sistem. contoh, broadcast mengumumkan bahwa
layar telah dimatikan, baterai rendah, atau gambar ditangkap. Aplikasi juga dapat memulai broadcast
, misalnya, untuk membiarkan aplikasi lain tahu bahwa beberapa data telah diunduh ke perangkat dan
tersedia bagi mereka untuk digunakan. Meskipun broadcast receivers tidak menampilkan antarmuka
pengguna, mereka dapat membuat pemberitahuan status bar untuk mengingatkan pengguna ketika
broadcast terjadi. Lebih umum, meskipun, broadcast receiver hanya "gerbang" untuk komponen lain
dan dimaksudkan untuk melakukan pekerjaan dengan jumlah yang sangat minim. Misalnya, mungkin
memulai layanan untuk melakukan beberapa pekerjaan berdasarkan acara.
Sebuah penerima siaran diimplementasikan sebagai subclass dari BroadcastReceiver dan
setiap siaran disampaikan sebagai objek Intent. Untuk informasi lebih lanjut, lihat kelas
BroadcastReceiver.
Aspek unik dari desain sistem Android adalah bahwa aplikasi apapun dapat memulai
komponen aplikasi lain. Sebagai contoh, jika Anda ingin pengguna untuk menangkap foto dengan
kamera, mungkin ada aplikasi lain yang melakukan itu dan aplikasi Anda dapat menggunakannya,
bukannya mengembangkan suatu kegiatan untuk menangkap foto diri Anda. Anda tidak perlu untuk
memasukkan atau bahkan link ke kode dari aplikasi kamera. Sebaliknya, Anda bisa mulai activity pada
app kamera yang menangkap foto. Ketika selesai, foto tersebut bahkan kembali ke aplikasi Anda
sehingga Anda dapat menggunakannya. Untuk pengguna, tampaknya seolah-olah kamera sebenarnya
merupakan bagian dari aplikasi Anda.
Ketika sistem mulai component, hal ini akan memulai process untuk aplikasi tersebut (jika
tidak sudah berjalan) dan menjalankan Class yang dibutuhkan untuk component. Misalnya, jika
aplikasi Anda memulai aktivitas app kamera untuk menangkap foto, activity yang berjalan dalam
proses yang dimiliki aplikasi kamera, bukan proses aplikasi Anda. Oleh karena itu, tidak seperti aplikasi
pada kebanyakan sistem lain, aplikasi Android tidak memiliki satu titik masuk (tidak ada main () fungsi,
misalnya).
Karena sistem menjalankan setiap aplikasi dalam proses yang terpisah dengan hak akses file
yang membatasi akses ke aplikasi lain, aplikasi Anda tidak dapat langsung mengaktifkan komponen
dari aplikasi lain. Sistem Android, namun, bisa. Jadi, untuk mengaktifkan komponen di aplikasi lain,
Anda harus menyampaikan pesan ke sistem yang menentukan intent Anda untuk memulai komponen
tertentu. Sistem kemudian mengaktifkan komponen.
Instruksi ini digunakan untuk yang pertama kali menggunakan android studio.
NB: Jika anda memiliki Android studio 1.0 kebawah maka disarankan anda meng-uninstall Android
Studio dari komputer anda.
Sebelum menginstall anda harus mengecek apakah komputer anda telah mencapai spek minimum.
Microsoft® Windows® 8/7/Vista/2003 (32 or 64-bit)
2 GB RAM minimum, 4 GB RAM recommended
400 MB hard disk space
At least 1 GB for Android SDK, emulator system images, and caches
1280 x 800 minimum screen resolution
Java Development Kit (JDK) 7
Optional for accelerated emulator: Intel® processor with support for Intel® VT-x, Intel® EM64T
(Intel® 64), and Execute Disable (XD) Bit functionality
Mac® OS X® 10.8.5 or higher, up to 10.9 (Mavericks)
2 GB RAM minimum, 4 GB RAM recommended
400 MB hard disk space
At least 1 GB for Android SDK, emulator system images, and caches
1280 x 800 minimum screen resolution
Java Runtime Environment (JRE) 6
Java Development Kit (JDK) 7
Optional for accelerated emulator: Intel® processor with support for Intel® VT-x, Intel® EM64T
(Intel® 64), and Execute Disable (XD) Bit functionality
On Mac OS, run Android Studio with Java Runtime Environment (JRE) 6 for optimized font rendering.
You can then configure your project to use Java Development Kit (JDK) 6 or JDK 7.
GNOME or KDE desktop
GNU C Library (glibc) 2.15 or later
2 GB RAM minimum, 4 GB RAM recommended
400 MB hard disk space
At least 1 GB for Android SDK, emulator system images, and caches
1280 x 800 minimum screen resolution
Oracle® Java Development Kit (JDK) 7
Tested on Ubuntu® 14.04, Trusty Tahr (64-bit distribution capable of running 32-bit applications).
Langkah yang perlu diambil untuk instalasi adalah:
1. Install Java
2. Set JAVA_HOME
3. Install Android Studio
4. Check for updates
5. Install System Images and Tools in SDK Manager
OPTIONAL - Making your emulator run faster with Genymotion
1. Pertama, cek apakah anda telah memiliki Java Developer Kit (JDK) versi 6 keatas. Caranya adalah
dengan membuka terminal, kemudian ketikkan “java -version”.
Gambar 2.1 Mengecek versi java
Diatas ini merupakan contoh dari hasil command “Java -version”. Hasil diatas menunjukkan
bahwa java yang telah digunakan adalah versi 8. Pembacaan versi dilakukan setelah angka “1”.
Jika JDK tidak tersedia atau lebih rendah dari versi 6, maka lanjutkan dengan nomor 2.
2. Masuk ke halaman website penginstalan JDK.
http://www.oracle.com/technetwork/java/javase/downloads/index.html
Gambar 2.2 Halaman Penginstalan JDK
3. Klik pada Download Java Platform (JDK)
4. Pilihlah JDK yang sesuai dengan Sistem operasi anda. Accept License agreement. Kemudian
download.
Gambar 2.3 Mengecek Tipe System
64 bit OS
Gambar 2.4 Mendownload sesuai dengan type system
5. Instal JDK yang telah di download.
1. Pilih klik kanan pada “This PC”/ Computer properties.
Gambar 2.5 Properties PC
2. Maka akan muncul system
Pilih 64 bit, karena
menggunakan SO 64
bit
Gambar 2.6 System
3. Pilihlah Advanced System Setting.
Gambar 2.7 Memilih Advance System Setting
4. Pilihlah pada tab Advanced, Environment Variables
Pilihlah Advanced System
Setting
Gambar 2.8 Tampilan System Properties
5. Klik New pada system Variable. Masukkan JAVA_HOME pada variable name box dan path dari
java instalasi pada Variable value box.
Pilihlah pada tab
Advanced
Klik pada Environment
Variables
Gambar 2.9 Environment Variables
Gambar 2.10 Menambah System Variables
Gambar 2.11 Hasil Menambah Environment Variables
Gambar 2.12 Membuat JAVA_HOME
6. Install Android studio yang telah di download dengan cara menjalankan file *.exe.
7. Setelah selesai penginstalan Maka langkah selanjutnya adalah menginstal SDK tools yang
diperlukan. Caranya adalah pilih Configure SDK Manager.
Gambar 2.13 SDK Manager
8. Pilhlah SDK yang diperlukan dan Klik tombol Install.
9. Pada Window selanjutnya akan muncul halaman persetujuan. Anda harus mengeklik setiap
lisence agreement. Kemudian klik install.
Gambar 2.14 Install SDK
10. Setelah selesai penginstalan, Android Studio siap Digunakan.
Langkah-langkah yang harus di lakukan adalah:
1. Jalankan Aplikasi Android Studio.
Gambar 3.1 Membuat Aplikasi Baru
2. Klik pada Start a new Android Studio Project.
3. Isikan nama aplikasi dan Company domain anda.
Gambar 3.2 Membuat Project Baru
Application Name adalah nama aplikasi yang muncul untuk pengguna. Untuk proyek ini,
menggunakan "Aplikasi Pertama_."
Company domain menyediakan kualifikasi yang akan ditambahkan ke nama paket; Android
Studio akan mengingat kualifikasi ini untuk setiap proyek baru Anda buat
Package name adalah nama yang memenuhi syarat untuk proyek (mengikuti aturan yang
sama dengan yang untuk penamaan paket dalam bahasa pemrograman Java). Nama paket
Anda harus unik di semua paket yang terinstal di sistem Android. Anda dapat mengedit nilai
ini secara independen dari nama aplikasi atau Company domain .
Project location adalah direktori pada sistem Anda yang memegang file proyek.
4. Pilih Target Android Device yang dapat menggunakan aplikasi yang akan anda buat. Kemudian
klik next.
Gambar 3.3 Pilih Minimum SDK
Gambar 3.4 List Dari minimum SDK
5. Pilihlah Blank Activity.
Gambar 3.5 Pilih Blank Activity
6. Mengisi Nama Activity , Layout, title dan Menu Resource Name. Klik Finish.
Gambar 3.6 Mengisi Nama Activity , Layout, title dan Menu Resource Name
7. Tampilan akan menjadi seperti berikut ini.
Gambar 3.7 Tampilan Awal dari Aplikasi Pertama
Proyek Android Anda sekarang menjadi dasar "Hello World" aplikasi yang berisi beberapa file
default. Luangkan waktu sejenak untuk meninjau hal paling penting dari ini:
Gambar 3.8 Tampilan List Folder dari Aplikasi
app/res/layout/activity_main.xml
Ini adalah file XML layout untuk activity yang Anda tambahkan saat membuat proyek dengan
Android Studio. Setelah alur kerja Proyek Baru, Android Studio menyajikan file ini dengan kedua
tampilan teks dan preview dari UI layar. File berisi beberapa pengaturan default dan elemen
TextView yang menampilkan pesan, " Hello world!"
Gambar 3.9 Tampilan Activity_main.xml secara Desain
Gambar 3.10 Tampilan Activity_main.xml secara Text
Pilih Desain
atau text
app/java/com.example.tyas.aplikasipertama/MainActivity.java
Sebuah tab untuk file ini muncul di Android Studio ketika workflow Proyek Baru selesai. Bila
Anda memilih file yang Anda lihat definisi kelas untuk activity yang Anda buat. Ketika Anda
membangun dan menjalankan aplikasi, yang Activity class dimulai kegiatan dan memuat file
layout yang mengatakan "Hello World!"
Gambar 3.11 Tampilan MainActivity.java
manifest/AndroidManifest.xml
File manifest menggambarkan karakteristik mendasar dari aplikasi dan mendefinisikan masing-
masing komponennya.
Gambar 3.12 Tampilan AndroidManifest.xml
app/build.gradle
Android Studio menggunakan Gradle untuk mengkompilasi dan membangun aplikasi
Anda. Ada file build.gradle untuk setiap modul proyek Anda, serta file
build.gradle untuk keseluruhan proyek. Biasanya, Anda hanya tertarik dalam file
build.gradle untuk modul, dalam hal ini aplikasi atau modul aplikasi. Di sinilah aplikasi
yang Anda bangun dependensinya ditetapkan, termasuk pengaturan defaultConfig :
compiledSdkVersion adalah versi platform untuk mengkompilasi aplikasi Anda. Secara
default, ini diatur ke versi terbaru Android yang tersedia di SDK Anda. (Harus Android 4.1
atau lebih besar, jika Anda tidak memiliki versi seperti yang tersedia, Anda harus
menginstal salah satu menggunakan SDK Manager.) Anda masih dapat membangun
aplikasi untuk mendukung versi lama, tapi pengaturan ini ke versi terbaru memungkinkan
Anda untuk mengaktifkan fitur baru dan mengoptimalkan aplikasi Anda untuk user
experience yang luar biasa pada perangkat terbaru
applicationId adalah nama paket yang memenuhi syarat untuk aplikasi Anda yang
Anda tentukan selama workflow Proyek Baru.
minSdkVersion adalah versi Minimum SDK yang Anda tentukan selama workflow Proyek
Baru. Ini adalah versi awal dari SDK Android yang didukung aplikasi Anda.
targetSdkVersion menunjukkan versi tertinggi Android yang Anda telah uji. Ketika versi
baru dari Android tersedia, Anda harus menguji aplikasi Anda pada versi baru dan
memperbarui nilai ini untuk mencocokkan API Level terbaru dan dengan demikian
memanfaatkan fitur platform baru.
Gambar 3.13 Tampilan Build.gradle
Sebagai catatan, Folder /res memiliki subdirectori yang terdiri dari resources for untuk aplikasi
anda:
Gambar 3.14 Folder res
drawable<density>/ atau mipmap
Direktori untuk objek gambar (seperti bitmap) yang dirancang untuk berbagai kualitas, seperti
media-density (mdpi) dan high-density (hdpi) layar. Direktori ditarik lainnya mengandung aset
dirancang untuk kepadatan layar lainnya. Di sini Anda akan menemukan ic_launcher.png yang
muncul saat Anda menjalankan aplikasi default.
layout/
Direktori untuk file yang mendefinisikan user interface aplikasi Anda seperti activity_main.xml,
dibahas di atas, yang menggambarkan tata letak dasar untuk kelas MainActivity.
menu/
Direktori untuk file yang mendefinisikan item menu aplikasi Anda.
values/
Direktori untuk file XML lain yang berisi kumpulan resource, seperti string dan definisi warna. File
strings.xml mendefinisikan "Halo dunia!" yang tampil ketika Anda menjalankan aplikasi default.
Bagaimana Anda menjalankan aplikasi Anda tergantung pada dua hal: apakah Anda memiliki
perangkat nyata yang menjalankan Android dan apakah Anda menggunakan Android Studio.
Langkah ini menunjukkan kepada Anda bagaimana menginstal dan menjalankan aplikasi Anda pada
perangkat nyata dan pada emulator Android.
Untuk Menjalankan pada device (Handphone atau SBC) ada beberapa langkah yang harus di jalankan
Set up device 1. Menyambungkan perangkat Anda ke mesin development (Komputer) dengan kabel USB. Jika
Anda sedang mengembangkan pada Windows, Anda mungkin perlu menginstal driver USB yang
sesuai untuk perangkat Anda. Untuk bantuan menginstal driver, lihat OEM Driver USB dokumen
Gambar 3.15 Menyambung perangkat
2. Aktifkan USB debugging pada perangkat Anda. Pada kebanyakan perangkat yang menjalankan
Android 3.2 atau yang lebih tua, Anda dapat menemukan pilihan Settings > Applications >
Development. Pada Android 4.0 dan lebih baru, itu di Settings > Developer options.
Catatan: Pada Android 4.2 dan lebih baru, Developer options tersembunyi secara default.
Untuk membuatnya tersedia, pergi ke Settings > About phone dan tekan Build number
tujuh kali. Kembali ke layar sebelumnya untuk menemukan Developer options.
Gambar 3.16 Build Number
Gambar 3.17 Developer Option
SETTINGAbout
DeviceBuild
number
SETTINGDeveloper
Option
Gambar 3.18 USB Debugging
Menjalankan aplikasi dari Android Studio 1. Pilih salah satu file proyek Anda dan klik Run dari toolbar.
Gambar 3.19 Pilih Run
2. Dalam Window Choose Device yang muncul, pilih radio button
Choose a running device, pilih perangkat Anda, dan klik OK.
SETTINGDeveloper
Option
Klik RUN
Gambar 3.20 Memilih Device
3. Maka di layar HP akan muncul halaman seperti berikut ini.
Gambar 3.21 Hasil Akhir Aplikasi Hello World
OEM USB Drivers Jika Anda sedang mengembangkan pada Windows dan ingin menghubungkan Android-powered
device untuk menguji aplikasi Anda, maka Anda perlu menginstal driver USB yang sesuai. Dokumen
ini menyediakan link ke situs web untuk beberapa original equipment manufacturers (OEM), di
mana Anda dapat men-download driver USB yang sesuai untuk perangkat Anda. Namun, daftar ini
tidak lengkap untuk semua Android-powered devices tersedia.
Jika Anda sedang mengembangkan pada Mac OS X atau Linux, maka Anda mungkin tidak perlu
menginstal driver USB.
Install USB Driver
1. menemukan driver yang sesuai untuk perangkat Anda dari tabel driver
OEM di bawah.
2. Setelah mengunduh driver USB Anda, ikuti petunjuk di bawah ini untuk
menginstal atau meng-upgrade driver, berdasarkan versi Windows dan
apakah Anda menginstal untuk pertama kalinya atau upgrade driver
yang ada.
Windows 7
Untuk menginstal driver USB Android pada Windows 7 untuk pertama kalinya:
1. Hubungkan perangkat Android Anda ke port USB komputer Anda
2. Klik kanan pada Computer dari desktop atau Windows Explorer, dan pilih Manage
3. Pilih Devices di sebelah kiri
4. Cari dan memperluas perangkat lain di panel kanan
5. Klik kanan nama perangkat (seperti Nexus S) dan pilih Update Driver Software. Ini akan
meluncurkan Hardware Update Wizard.
6. Pilih Browse my Computer untuk driver software dan klik Next
7. Klik Browse dan cari folder driver USB. (Google USB Driver terletak di
sdk>\extras\google\usb_driver\)
8. Klik Next untuk menginstal driver.
Atau, untuk upgrade driver USB Android yang ada pada Windows 7 dengan driver baru:
1. Hubungkan perangkat Anda Android ke port USB komputer Anda
2. Klik kanan pada Computer dari desktop atau Windows Explorer, dan pilih Manage
3. Pilih Device Manager di sebelah kiri dari Computer Management window
4. Cari dan memperluas Android Phone di panel kanan.
5. Klik kanan pada Android Composite ADB Interface dan pilih Update Driver. Ini akan meluncurkan
Hardware Update Wizard.
6. Pilih Install from a list or specific location dan klik Next
7. Pilih Search for the best driver in these locations; un-check Search removable media;
dan check Include this location in the search
8. Klik Browse dan cari folder driver USB. (Google USB Driver terletak di
sdk>\extras\google\usb_driver\)
9. Klik Next untuk menginstal driver
Windows Vista
To install the Android USB driver on Windows Vista for the first time:
1. Connect your Android-powered device to your computer's USB port. Windows will detect the
device and launch the Found New Hardware wizard.
2. Select Locate and install driver software.
3. Select Don't search online.
4. Select I don't have the disk. Show me other options.
5. Select Browse my computer for driver software.
6. Click Browse and locate the USB driver folder. (The Google USB Driver is located
in<sdk>\extras\google\usb_driver\.) As long as you specified the exact location of the
installation package, you may leave Include subfolders checked or unchecked—it doesn't
matter.
7. Click Next. Vista may prompt you to confirm the privilege elevation required for driver
installation. Confirm it.
8. When Vista asks if you'd like to install the Google ADB Interface device, click Install to install the
driver.
Or, to upgrade an existing Android USB driver on Windows Vista with the new driver:
1. Connect your Android-powered device to your computer's USB port.
2. Right-click on Computer from your desktop or Windows Explorer, and select Manage.
3. Select Device Manager in the left pane.
4. Locate and expand ADB Interface in the right pane.
5. Right-click on Android Composite ADB Interface, and select Update Driver Software.
6. When Vista starts updating the driver, a prompt will ask how you want to search for the driver
software. Select Browse my computer for driver software.
7. Click Browse and locate the USB driver folder. (The Google USB Driver is located
in<sdk>\extras\google\usb_driver\.) As long as you specified the exact location of the
installation package, you may leave Include subfolders checked or unchecked—it doesn't
matter.
8. Click Next. Vista might prompt you to confirm the privilege elevation required for driver
installation. Confirm it.
9. When Vista asks if you'd like to install the Google ADB Interface device, click Install to upgrade
the driver.
OEM Drivers
Tabel 3.1 Alamat OEM Driver
OEM Driver URL
Acer http://www.acer.com/worldwide/support/mobile.html
ALCATEL ONE TOUCH http://www.alcatelonetouch.com/global-en/support/faq/usbdriver.html
Asus http://support.asus.com/download/
Dell http://support.dell.com/support/downloads/index.aspx?c=us&cs=19&l=en&s=dhs&~ck=anavml
Foxconn http://drivers.cmcs.com.tw/
Fujitsu http://www.fmworld.net/product/phone/sp/android/develop/
Garmin-Asus https://www.garminasus.com/en_US/support/pcsync/
Hisense http://app.hismarttv.com/dss/resourcecontent.do?method=viewResourceDetail&resourceId=16&type=5
HTC http://www.htc.com Click on the support tab to select your products/device. Different regions will have different links.
Huawei http://www.huaweidevice.com/worldwide/downloadCenter.do?method=index
Intel http://www.intel.com/software/android
KT Tech http://www.kttech.co.kr/cscenter/download05.asp for EV-S100 (Take)
Kyocera http://www.kyocera-wireless.com/support/phone_drivers.htm
Lenovo http://developer.lenovomm.com/developer/download.jsp
LGE http://www.lg.com/us/mobile-phones/mobile-support/mobile-lg-mobile-phone-support.jsp
Motorola http://developer.motorola.com/docstools/USB_Drivers/
MTK http://online.mediatek.com/Public%20Documents/MTK_Android_USB_Driver.zip
Oppo http://www.oppo.com/index.php?q=software/view&sw_id=631
Pantech http://www.isky.co.kr/cs/software/software.sky?fromUrl=index
Pegatron http://www.pegatroncorp.com/download/New_Duke_PC_Driver_0705.zip (ZIP download)
Samsung http://www.samsung.com/us/support/downloads
Sharp http://k-tai.sharp.co.jp/support/
SK Telesys http://www.sk-w.com/service/wDownload/wDownload.jsp
Sony Mobile Communications
http://developer.sonymobile.com/downloads/drivers/
Teleepoch http://www.teleepoch.com/android.html
Toshiba http://support.toshiba.com/sscontent?docId=4001814
Yulong Coolpad http://www.yulong.com/product/product/product/downloadList.html#downListUL
Xiaomi http://www.xiaomi.com/c/driver/index.html
ZTE http://support.zte.com.cn/support/news/NewsDetail.aspx?newsId=1000442
Untuk menjalankan aplikasi Anda pada emulator Anda harus terlebih dahulu membuat Virtual
Device Android (AVD). Sebuah AVD adalah konfigurasi perangkat untuk emulator Android yang
memungkinkan Anda untuk model perangkat tertentu.
Membuat AVD 1. Jalankan Android Virtual Device Manager:
2. Pada Android Studio, Pilih Tools > Android > AVD Manager, atau klik AVD Manager
icon pada toolbar.
Gambar 3.22 AVD
3. Pada layar utama AVD Manager (gambar 1), klik Create Virtual Device
4. Pada jendela Pilih Hardware, pilih konfigurasi perangkat, seperti Nexus 6, kemudian klik Next.
Gambar 3.23 Pilih Hardware
5. Pilih versi sistem yang diinginkan untuk AVD dan klik Next.
Gambar 3.24 Pilih Image System
6. Memverifikasi pengaturan konfigurasi, lalu klik Finish.
Gambar 3.25 Konfigurasi AVD
Gambar 3.26 Hasil Jadi AVD
Menjalankan aplikasi dari Android Studio 1. Di Android Studio, pilih proyek Anda dan klik Run dari toolbar.
2. Pada Choose Device window, klik Launch emulator radio button
3. Dari Android virtual device menu, pilih emulator yang anda buat, and
click OK.
NB: Jika Emulator tidak terlihat, You can use this Method for moving any window that
is off the screen in a windows environment.
First Select the window either by Alt-Tab or Click clicking it
Press Alt & Space keys together
Press "M" or select it with the mouse Use your arrow keys to move the Window
Press Enter to exit
4. Hasilnya adalah Sebagai berikut
Pilih Launch emulator
serta pilih AVD yang
anda buat
Gambar 3.27 Hasil Jadi Aplikasi Helloworld menggunakan AVD
Dalam pelajaran ini, Anda membuat tata letak / layout di XML yang mencakup bidang teks dan
tombol.
Antarmuka pengguna grafis (graphical user interface) untuk sebuah aplikasi Android
dibangun menggunakan hirarki View dan ViewGroup object. View objek biasanya widget UI seperti
tombol atau textfield.
Android menyediakan kosakata XML yang sesuai dengan subclass dari View dan ViewGroup
sehingga Anda dapat menentukan UI dalam XML menggunakan hirarki elemen UI.
Layouts adalah subclass of the ViewGroup.
User interface untuk setiap komponen dari aplikasi Anda didefinisikan menggunakan hirarki
View dan ViewGroup object, seperti yang ditunjukkan pada Gambar 4.1 Setiap kelompok pandangan
merupakan sebuah wadah yang menyelenggarakan terlihat pemandangan anak, sementara
pandangan anak mungkin kontrol input atau widget lain yang menarik beberapa bagian dari UI. Pohon
hirarki ini dapat sesederhana atau serumit yang Anda butuhkan untuk menjadi (tapi kesederhanaan
yang terbaik untuk kinerja).
Gambar 4.1 Ilustrasi bagaimana objek ViewGroup membentuk cabang di layout dan mengandung View object lainnya.
Untuk menyatakan layout Anda, Anda dapat memulai View objects dalam kode dan mulai
membangun tree, tetapi yang paling mudah dan paling efektif untuk menentukan layout Anda dengan
file XML. XML menawarkan human-readable structure untuk layout, mirip dengan HTML.
Nama elemen XML untuk tampilan adalah masing-masing untuk kelas Android yang
diwakilinya. Jadi <TextView> elemen menciptakan widget TextView di UI, dan <LinearLayout> elemen
menciptakan view group LinearLayout.
Misalnya, tata letak vertikal sederhana dengan tampilan teks dan tombol terlihat seperti ini:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical" >
<TextView android:id="@+id/text"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="I am a TextView" />
<Button android:id="@+id/button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="I am a Button" />
</LinearLayout>
Gambar 4.2 Layout XML
Ketika Anda memuat layout resource di app, Android menginisialisasi setiap node dari layout
menjadi objek runtime yang dapat digunakan untuk menentukan additional behaviors, query the
object state, atau memodifikasi layout.
Anda tidak harus membangun semua UI Anda menggunakan View dan ViewGroup object.
Android menyediakan beberapa komponen aplikasi yang menawarkan layout UI standar yang hanya
perlu Anda definisikan konten nya. Komponen UI ini contohnya adalah Action Bar, Dialogs, dan Status
Notifications.
Layout didefinisikan sebagai struktur visual untuk user interface, seperti UI untuk activity atau
widget aplikasi. Anda dapat mendeklarasikan sebuah layout dalam dua cara:
1. Mendeklarasikan elemen UI dalam XML. Android menyediakan XML dengan kosakata sederhana
yang sesuai dengan View kelas dan subclass, seperti untuk widget dan layout.
2. Mengatur unsur tata letak pada saat runtime. Aplikasi Anda dapat membuat View dan
ViewGroup object (dan memanipulasi propertiesnya) secara program.
Framework Android memberi Anda fleksibilitas untuk menggunakan salah satu atau kedua
metode ini untuk menyatakan dan mengelola UI dari aplikasi Anda. Misalnya, Anda bisa menyatakan
layout standar aplikasi Anda dalam XML, termasuk unsur-unsur layar yang akan muncul di dalamnya
dan sifat mereka. Anda kemudian dapat menambahkan kode dalam aplikasi Anda yang akan
mengubah keadaan obyek layar, termasuk yang dinyatakan dalam XML, pada saat dijalankan.
Keuntungan untuk menyatakan UI Anda dalam XML adalah bahwa hal itu memungkinkan
Anda untuk lebih memisahkan penyajian aplikasi Anda dari kode yang mengontrol perilakunya.
Deskripsi UI Anda adalah eksternal untuk kode aplikasi Anda, yang berarti bahwa Anda dapat
mengubah atau beradaptasi tanpa harus memodifikasi kode sumber Anda dan mengkompilasi ulang.
Sebagai contoh, Anda dapat membuat layout XML untuk orientasi yang berbeda layar, ukuran layar
perangkat yang berbeda, dan bahasa yang berbeda. Selain itu, menyatakan layout di XML
membuatnya lebih mudah untuk memvisualisasikan struktur UI Anda, sehingga lebih mudah untuk
masalah debug.
Secara umum, vocabulary XML untuk menyatakan elemen UI erat mengikuti struktur dan
penamaan class dan method, di mana nama elemen sesuai dengan nama class dan atribut nama
sesuai dengan method. Bahkan, korespondensi sering langsung bisa menebak apa atribut XML yang
sesuai dengan metode class, atau menebak apa class sesuai dengan elemen XML yang diberikan.
Namun, perlu diketahui bahwa tidak semua kosakata identik. Dalam beberapa kasus, ada perbedaan
penamaan sedikit. Misalnya, unsur EditText memiliki atribut text yang sesuai dengan
EditText.setText()
Menulis XML Menggunakan Android vocabulary XML, Anda dapat dengan cepat merancang layout UI dan
elemen layar yang dikandungnya, dengan cara yang sama Anda membuat halaman web di HTML.
Setiap file layout harus berisi tepat satu root element, yang harus Lihat atau objek ViewGroup.
Setelah Anda mendefinisikan root element, Anda dapat menambahkan objek layout tambahan atau
widget sebagai elemen anak untuk secara bertahap membangun hirarki View yang mendefinisikan
layout Anda. Sebagai contoh, di sini adalah layout XML yang menggunakan LinearLayout vertikal untuk
menampilkan TextView dan Button:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical" >
<TextView android:id="@+id/text"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Hello, I am a TextView" />
<Button android:id="@+id/button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Hello, I am a Button" />
</LinearLayout
Gambar 4.3 Layout XML 2
Setelah Anda menyatakan layout Anda dalam XML, simpan file dengan ekstensi .xml, di res /
layout / direktori proyek Android Anda, sehingga akan terkompilasi.
Memuat resource XML Ketika Anda mengkompilasi aplikasi Anda, setiap file layout XML dikompilasi ke dalam
resource View. Anda harus memuat resource layout dari kode aplikasi Anda pada Activity.onCreate().
Dengan memanggil setContentView (), lewat referensi untuk resource layout Anda dalam bentuk:
R.layout.layout_file_name. Misalnya, jika layout XML Anda disimpan sebagai main_layout.xml, Anda
akan memuatnya untuk activity Anda seperti:
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main_layout);
}
Gambar 4.4 Method OnCreate
The OnCreate ()callback method pada Activity Anda dipanggil oleh framework Android saat
Activity Anda diluncurkan.
Attributes Setiap View dan objek ViewGroup mendukung berbagai atribut XML mereka sendiri.
Beberapa atribut yang spesifik untuk object View (misalnya, TextView mendukung atribut
textSize), tetapi sifat-sifat ini juga diwarisi oleh object View yang dapat extend kelas. Beberapa
umum untuk semua object View, karena mereka mewarisi dari root class View (seperti atribut id).
Dan, atribut lain dianggap " layout parameters," yang merupakan atribut yang menggambarkan
orientasi layout tertentu dari objek View, seperti yang didefinisikan oleh parent ViewGroup object.
ID Setiap object View mungkin memiliki ID integer yang terkait dengan itu, untuk secara unik
mengidentifikasi View dalam root. Ketika aplikasi dikompilasi, ID ini dirujuk sebagai integer, tapi ID
yang biasanya ditugaskan di tata letak file XML sebagai string, dalam atribut id. Ini adalah atribut XML
yang umum untuk semua objek View (didefinisikan oleh class View) dan Anda akan menggunakannya
sangat sering. Sintaks untuk ID, dalam tag XML adalah:
android:id="@+id/my_button"
Gambar 4.5 Penulisan ID
Di-simbol (@) pada awal string menunjukkan bahwa parser XML harus mengurai dan
memperluas sisa ID string dan mengidentifikasinya sebagai sumber ID. Plus-simbol (+) berarti bahwa
ini adalah nama sumber daya baru yang harus dibuat dan ditambahkan ke sumber daya (dalam file
R.java). Ada sejumlah sumber daya ID lainnya yang ditawarkan oleh kerangka Android. Ketika referensi
ID sumber daya Android, Anda tidak perlu ditambah-simbol, tetapi harus menambahkan paket
namespace android, seperti:
android:id="@android:id/empty"
Gambar 4.6 Menambah paket namespace android
Dalam rangka menciptakan view, pola umum adalah:
1. Menentukan view/ widget di file layout dan menetapkan ID unik:
<Button android:id="@+id/my_button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/my_button_text"/>
Gambar 4.7 file layout
2. Kemudian membuat sebuah instance dari objek view dan mengambil dari layout (biasanya di
OnCreate () metode):
Button myButton = (Button) findViewById(R.id.my_button);
Gambar 4.8 Menampilkan layout
Mendefinisikan ID untuk objek view penting saat membuat RelativeLayout. Dalam tata letak
relatif, siblings view dapat menentukan layout relatif mereka terhadap siblings view lain, yang
direferensikan oleh ID unik.
ID tidak perlu unik di seluruh tree, tetapi harus unik dalam bagian dari tree yang Anda cari
(yang sering mungkin seluruh tree, jadi yang terbaik untuk menjadi benar-benar unik bila
memungkinkan).
Layout Parameters Atribut tata letak XML bernama layout_something menentukan parameter tata letak untuk
View yang sesuai untuk ViewGroup di mana ia berada.
Setiap kelas ViewGroup mengimplementasikan nested class yang meng- extends
ViewGroup.LayoutParams. Subclass ini berisi jenis properti yang menentukan ukuran dan posisi untuk
setiap tampilan anak, yang sesuai untuk kelompok pandangan. Seperti yang Anda lihat pada Gambar
4.9, parent view group mendefinisikan parameter layout untuk setiap child view (termasuk child view
group).
Gambar 4.9 Visualisasi tampilan hirarki dengan parameter layout yang terkait dengan setiap tampilan
Langkah langkah yang harus diambil adalah:
1. Buat Project baru dengan nama UI1
Gambar 4.10 Project UI1
2. Pilih Minimum SDK yang sesuai
Gambar 4.11 Pilih Minimum SDK sesuai
3. Pilih Blank Activity
Gambar 4.12 Pilih Blank Activity
4. Beri nama Activity
Gambar 4.13 Beri nama Activity
5. Maka Hasilnya adalah seperti berikut
Gambar 4.14 Hasil tampilan pembuatan project
1. Masih dalam satu project. Pada folder res/layout, buka activity_main.xml.
Gambar 4.15 Buka Activity_main.xml
2. Klik Pada text pada halaman activity_main.xml.
Gambar 4.16 Plih pada Text Mode
3. Maka akan menjadi seperti ini
Gambar 4.17 Tampilan activity_main.xml text mode
4. Ubahlah RelativeLayout menjadi LinearLayout.
Klik pada Text Mode
Gambar 4.18 Mengubah RelativeLayout menjadi LinearLayout
5. Tambahkan android:orientation atribut dan set menjadi “vertical”.
Gambar 4.19 Tambahkan atribut orientation
1. Masih pada project yang sama, tambahkan EditText pada main_activity.xml. Tambahkan atribut
android:layout_width="match_parent" dan android:layout_height="wrap_content".
Diubah LinearLayout
Diubah LinearLayout
Tambah atribut orientasi
Gambar 4.20 Menambah EditText
2. Buka strings.xml resource pada folder res/values.
Gambar 4.21 Membuka Strings.xml
3. Tambahkan beberapa baris string dengan nama “edit_message” dengan nilai “Masukkan pesan”
dan baris dengan nama “button_send” dengan nilai “Mengirim”. Dan mengganti isi helloword
dengan” Nama:”
Gambar 4.22 Membuat string
4. Buka lagi file activity_main.xml pada folder res/layout. Tambahkan atribut hint yaitu dengan
menuliskan android:hint="@string/edit_message" pada EditText.
Gambar 4.23 Menambah atribut Hint pada EditText
1. Pada Project yang sama, tambahkan Button pada Layout. Beri text dengan
android:text="@string/button_send".
Gambar 4.24 Menambah Button
2. Agar Button merespon, tambahkan android:onClick="sendMessage" pada atribut button.
Gambar 4.25 Menambah atribut onClick
3. Tambahkan TextView di bawah button unuk menampilkan hasil isian EditText.
<TextView
android:id="@+id/textView6"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerVertical="true"
android:text="" />
Gambar 4.26 Menambah TextView 6
4. Maka Layout akan menjadi seperti berikut ini:
Gambar 4.27 Kode program Layout Terakhir
5. Hasil Layout akan menjadi seperti berikut ini
Gambar 4.28 Tampilan Layout
6. Buka main_activity.java. Tambahkan Library
import android.view.View; import android.widget.EditText; import android.widget.TextView; import android.graphics.Color;
Gambar 4.29 Menambah Library
7. Pada Class tambahkan perintah berikut
EditText nama; TextView tampilnama;
Gambar 4.30 Menambah Object
8. Pada method onCreate, tambahkan perintah berikut ini
nama = (EditText)findViewById(R.id.editText);
Gambar 4.31 Menentukan Variable nama sebagai EditText Berdasar ID
9. Buka main_activity.java. tambahkan Method sendMessage
public void sendMessage(View view) { tampilnama = (TextView)findViewById(R.id.textView6); tampilnama.setTextColor(Color.BLUE);
tampilnama.setText(nama.getText()); }
Gambar 4.32 Method SendMessage
10. Maka Hasil main_activity.java. akan menjadi seperti berikut ini
package com.example.tyas.ui1; import android.support.v7.app.AppCompatActivity; import android.os.Bundle;
import android.view.Menu; import android.view.MenuItem; import android.view.View; import android.widget.EditText; import android.widget.TextView; import android.graphics.Color; public class MainActivity extends AppCompatActivity { EditText nama; TextView tampilnama; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); nama = (EditText)findViewById(R.id.editText); } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.menu_main, menu); return true; } public void sendMessage(View view) { tampilnama = (TextView)findViewById(R.id.textView6); tampilnama.setTextColor(Color.BLUE); tampilnama.setText(nama.getText()); } @Override public boolean onOptionsItemSelected(MenuItem item) { // Handle action bar item clicks here. The action bar will // automatically handle clicks on the Home/Up button, so long // as you specify a parent activity in AndroidManifest.xml. int id = item.getItemId(); //noinspection SimplifiableIfStatement if (id == R.id.action_settings) { return true; } return super.onOptionsItemSelected(item); } }
Gambar 4.33 Fie main_activity.java
11. Hasilnya akan menjadi seperti berikut ini
Gambar 4.34 Hasil Akhir dijalankan
Buatlah biodata anda yang terdiri dari nama, nim, alamat, Agama dan hobi anda yang di
tuliskan masing-masing ke EditText. Dan kemudian tampilkan dalam TextView. Silahkan ubah warna
tulisan nama = biru, nim = hijau, alamat = merah, Agama = hitam, dan hobi dengan coklat.
Input controls adalah komponen interaktif user interface aplikasi Anda. Android menyediakan
berbagai macam kontrol yang dapat digunakan dalam UI Anda, seperti tombol, bidang teks, mencari
bar, checkbox, tombol zoom, tombol toggle, dan banyak lagi.
Gambar 5.1 Input Control
Menambahkan kontrol input untuk UI Anda adalah yang sederhana seperti menambahkan
elemen XML untuk layout XML Anda. Sebagai contoh, di sini adalah tata letak dengan field teks dan
tombol:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="horizontal">
<EditText android:id="@+id/edit_message"
android:layout_weight="1"
android:layout_width="0dp"
android:layout_height="wrap_content"
android:hint="@string/edit_message" />
<Button android:id="@+id/button_send"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/button_send"
android:onClick="sendMessage" />
</LinearLayout>
Gambar 5.2 Contoh layout
Setiap input control mendukung satu set input events sehingga Anda dapat menangani events
seperti ketika pengguna memasukkan teks atau menyentuh tombol.
Berikut adalah daftar dari beberapa kontrol umum yang dapat Anda gunakan dalam aplikasi
Anda. Catatan: Android menyediakan beberapa kontrol lebih dari yang tercantum di sini. Isi paket
android.widget untuk menemukan lebih banyak. Jika aplikasi Anda membutuhkan jenis tertentu input
control, Anda dapat membangun komponen kustom Anda sendiri.
Tabel 5.1 Daftar Input Control
Control
Type
Description Related Classes
Button A push-button that can be pressed, or
clicked, by the user to perform an action.
Button
Text field An editable text field. You can use
theAutoCompleteTextView widget to
create a text entry widget that provides
auto-complete suggestions
EditText,AutoCompleteTextView
Checkbox An on/off switch that can be toggled by
the user. You should use checkboxes
when presenting users with a group of
selectable options that are not mutually
exclusive.
CheckBox
Radio
button
Similar to checkboxes, except that only
one option can be selected in the group.
RadioGroup
RadioButton
Toggle
button
An on/off button with a light indicator. ToggleButton
Spinner A drop-down list that allows users to
select one value from a set.
Spinner
Pickers A dialog for users to select a single value
for a set by using up/down buttons or via
a swipe gesture. Use aDatePickercode>
widget to enter the values for the date
(month, day, year) or
a TimePicker widget to enter the values
for a time (hour, minute, AM/PM), which
will be formatted automatically for the
user's locale.
DatePicker,TimePicker
Tombol terdiri dari teks atau ikon (atau teks dan ikon) yang berkomunikasi tindakan apa yang
terjadi ketika pengguna menyentuh itu.
Gambar 5.3 Macam-macam Button
Tergantung pada apakah Anda ingin tombol dengan teks, ikon, atau keduanya, Anda dapat
membuat tombol dalam tata letak Anda dalam tiga cara:
1. Dengan teks, menggunakan kelas Button:
Gambar 5.4 Button Text
2. Dengan ikon, menggunakan kelas ImageButton:
Gambar 5.5 Image Button
3. Dengan teks dan ikon, menggunakan kelas Button dengan android: drawableLeft atribut:
Gambar 5.6 Button dengan text dan Gambar
Respond ke Click Events Ketika pengguna mengklik tombol, objek button menerima sebuah on-click event.
Untuk menentukan click event handler untuk button, tambahkan atribut android: onClick ke
< Button > elemen dalam layout XML Anda. Nilai untuk atribut ini harus menjadi nama metode yang
ingin Anda panggil dalam menanggapi click event.
Sebagai contoh, di sini adalah layout dengan button menggunakan android: onClick:
Gambar 5.7 Layout Button
Dalam Activity yang menggunakan layout ini, metode berikut menangani event klik:
Gambar 5.8 Method SendMessage
Metode Anda menyatakan di android: onClick atribut harus memiliki signature persis seperti
yang ditunjukkan di atas. Secara khusus, metode harus:
Berbentuk publik
Return Void
Mendefinisikan View sebagai satu-satunya parameter (ini akan menjadi View yang diklik)
Menggunakan OnClickListener Anda juga dapat mendeklarasikan click event handler secara pemrograman bukan di layout
XML. Hal ini mungkin diperlukan jika Anda instantiate Tombol pada saat runtime atau Anda perlu
menyatakan perilaku klik di subclass Fragment.
Untuk menyatakan event handler secara pemrograman, membuat objek View.OnClickListener
dan menetapkan ke button dengan memanggil setOnClickListener (View.OnClickListener). Sebagai
contoh:
Gambar 5.9 Method SerOnClickListener
Styling Button Tampilan Button Anda (gambar background dan font) dapat bervariasi dari satu perangkat ke
perangkat lainnya, karena perangkat oleh produsen yang berbeda sering memiliki styles default yang
berbeda untuk input controls.
Anda dapat mengontrol persis bagaimana bergaya menggunakan tema yang Anda pakai untuk
seluruh aplikasi Anda. Misalnya, untuk memastikan bahwa semua perangkat yang menjalankan
Android 4.0 dan lebih tinggi penggunaan tema Holo di app, menyatakan android:theme =
"@android:style/ Theme.Holo" dalam manifes elemen <application> Anda. Juga membaca posting
blog, Holo Mana untuk informasi tentang menggunakan tema Holo sementara mendukung perangkat
yang lebih tua.
Untuk menyesuaikan tombol individu dengan latar belakang yang berbeda, tentukan android:
background atribut dengan drawable atau color resource. Atau, Anda dapat menerapkan gaya untuk
tombol, yang bekerja dalam cara yang mirip dengan gaya HTML mendefinisikan beberapa style
properti seperti background, font, size, dan lain-lain.
Custom background Jika Anda ingin benar-benar mendefinisikan kembali penampilan tombol Anda, Anda dapat
menentukan custom background. Alih-alih menyediakan bitmap sederhana atau warna,
bagaimanapun, background Anda harus menjadi state list resource yang dapat berubah penampilan
tergantung pada keadaan tombol.
Anda dapat menentukan state list dalam file XML yang mendefinisikan tiga gambar atau warna
yang berbeda untuk menggunakan untuk keadaan tombol yang berbeda.
Untuk membuat state list ditarik untuk tombol latar belakang Anda:
Buat tiga bitmap untuk background tombol yang mewakili default, ditekan, dan
terfokus tombol negara. Untuk memastikan bahwa gambar Anda sesuai dengan
tombol dari berbagai ukuran, menciptakan bitmap sebagai Nine-patch bitmaps.
Tempatkan bitmap ke direktori res/drawable/ proyek Anda. Pastikan setiap bitmap
bernama benar untuk mencerminkan keadaan tombol yang mereka masing-masing
mewakili, seperti button_default.9.png, button_pressed.9.png, dan
button_focused.9.png.
Buat file XML baru di res/drawable/ direktori / (nama itu sesuatu seperti
button_custom.xml). Masukkan XML berikut:
Gambar 5.10 Button_custom XML
This defines a single drawable resource, which will change its image based on the current state
of the button.
1. The first <item> defines the bitmap to use when the button is pressed (activated).
2. The second <item> defines the bitmap to use when the button is focused (when the button is
highlighted using the trackball or directional pad).
3. The third <item> defines the bitmap to use when the button is in the default state (it's neither
pressed nor focused).
Ini mendefinisikan single drawable resource, yang akan mengubah citranya berdasarkan
keadaan saat tombol.
Pertama <item> mendefinisikan bitmap untuk digunakan saat tombol ditekan
(diaktifkan).
Kedua <item> mendefinisikan bitmap untuk digunakan saat tombol difokuskan
(ketika tombol disorot menggunakan trackball atau directional pad).
The <item> ketiga mendefinisikan bitmap untuk digunakan saat tombol dalam
keadaan default (itu tidak ditekan atau fokus).
4. Kemudian hanya menerapkan file XML sebagai button background:
Gambar 5.11 Button Background
Sebuah text field memungkinkan pengguna untuk mengetik teks ke aplikasi Anda. Hal ini dapat
berupa garis tunggal atau multi-line. Menyentuh text field menempatkan kursor dan secara otomatis
menampilkan keyboard. Selain mengetik, text field memungkinkan untuk berbagai kegiatan lain,
seperti pemilihan teks (cut, copy, paste) dan data look-up melalui auto-completion.
Anda dapat menambahkan text field untuk Anda layout dengan objek EditText. Anda biasanya
harus melakukannya dalam layout XML Anda dengan <EditText>
Gambar 5.12 EditText
Menentukan Jenis Keyboard Text fields dapat memiliki input types yang berbeda, seperti nomor, tanggal, sandi, atau
alamat email. Jenis menentukan apa jenis karakter yang diizinkan di dalam lapangan, dan mungkin
akan meminta virtual keyboard untuk mengoptimalkan layout untuk karakter yang sering digunakan.
Anda dapat menentukan jenis keyboard yang Anda inginkan untuk objek EditText Anda
dengan android:inputType. Sebagai contoh, jika Anda ingin pengguna untuk memasukkan alamat
email, Anda harus menggunakan jenis masukan textEmailAddress :
Gambar 5.13 EditText email
Ada beberapa jenis input yang berbeda tersedia untuk situasi yang berbeda. Berikut adalah
beberapa nilai lebih umum untuk android: inputType:
"text"
Normal text keyboard.
"textEmailAddress"
Normal text keyboard with the @ character.
"textUri"
Normal text keyboard with the / character.
"number"
Basic number keypad.
"phone"
Phone-style keypad.
Gambar 5.14 default text input type
Gambar 5.15 textEmailAddress input type
Gambar 5.16 phone input type.
Sebagai contoh, di sini adalah bagaimana Anda dapat mengumpulkan alamat pos,
memanfaatkan setiap kata, dan menonaktifkan saran teks:
Gambar 5.17 Contoh EditText
Menentukan Tindakan Keyboard Selain mengubah jenis input keyboard, Android memungkinkan Anda untuk menentukan tindakan
yang harus dibuat ketika pengguna telah selesai masukan text. Tindakan menentukan tombol yang
muncul di tempat carriage return key dan tindakan yang akan dilakukan, seperti " Search " atau
"Send."
Gambar 5.18 Tindakan Keyboard
Anda dapat menentukan tindakan dengan menetapkan android: imeOptions atribut. Sebagai contoh,
berikut adalah cara Anda dapat menentukan tindakan Kirim:
Gambar 5.19 EditText ActionSend
Jika Anda tidak secara eksplisit menentukan input action maka sistem mencoba untuk
menentukan apakah ada android:focusable. Jika ada bidang focusable yang ditemukan berikut ini,
sistem menerapkan "actionNext" tindakan ke EditText saat ini sehingga pengguna dapat memilih Next
untuk pindah ke kolom berikutnya. Jika tidak ada bidang focusable berikutnya, sistem menerapkan
"actionDone" tindakan. Anda dapat mengganti ini dengan menetapkan atribut android: imeOptions
untuk setiap nilai lain seperti "actionSend" atau "actionSearch" atau menekan perilaku default dengan
menggunakan "actionNone" action.
Merespon action button events Jika Anda telah ditentukan keyboard action untuk metode input menggunakan atribut
android:imeOptions (seperti "actionSend"), Anda dapat mendengarkan specific action event
menggunakan TextView.OnEditorActionListener. Antarmuka TextView.OnEditorActionListener
menyediakan metode callback disebut onEditorAction() yang menunjukkan jenis tindakan dipanggil
dengan ID tindakan seperti IME_ACTION_SEND atau IME_ACTION_SEARCH.
Sebagai contoh, di sini adalah bagaimana Anda dapat mendengarkan ketika pengguna
mengklik tombol Send pada keyboard:
Gambar 5.20 OnEditorActionListener
Setting custom action button label Jika keyboard terlalu besar untuk cukup ruang berbagi dengan aplikasi yang mendasari
(seperti ketika perangkat handset dalam orientasi landscape) maka fullscreen ("mode ekstrak") dipicu.
Dalam mode ini, tombol aksi berlabel ditampilkan di sebelah input. Anda dapat menyesuaikan teks
tombol ini dengan menetapkan android: atribut imeActionLabel:
Gambar 5.21 Custom action Button label
Gambar 5.22 custom action label dengan android:imeActionLabel
Langkah yang diperlukan adalah:
1. Buat project baru dengan nama image aplication
Gambar 5.23 Buat project image aplication
2. Hapus textview helloworld dengan cara klik kanan pada textview helloworld kemudian pilih
delete. Hasil akan menjadi seperti gambar di bawah ini
Gambar 5.24 Menghapus textView
3. Masukkan image dengan format png ke dalam project dengan mengcopy image hello.png
Gambar 5.25 Copy gambar
Gambar 5.26 Paste Gambar
4. Maka akan muncul gambar berikut ini. Pada gambar terlihat Menempatkan gambar ke direktori
pada project. Kemudian Klik tombol ok
Gambar 5.27 Menempatkan gambar ke direktori pada project
5. Maka hello.png akan muncul di folder drawable
Gambar 5.28 Terlihat gambar pada folder drawable
6. Drag ImageView ke tengah tampilan dari layar android. Maka akan muncul tampilan seperti
gambar di bawah ini
Gambar 5.29 menempatkan ImageView
7. Ubah tinggi dan lebar image View menjadi match parent. Maka layout menjadi seperti berikut ini
Gambar 5.30 Layout ImageView
8. Pada properties ImageView, klik tombol “...”pada “src”
Gambar 5.31 Src pada properties
9. Pada window Resource pilih gambar yang tadi telah di masukkan ke folder drawable yaitu
hello.png. Kemudian klik OK.
NB: nama gambar tidak boleh menggunakan spasi.
Gambar 5.32 Memilih gambar yang akan ditampilkan imageView
10. Maka hasil akan menjadi seperti berikut ini.
Gambar 5.33 Tampilan ImageView
11. Jalankan program. Maka hasilnya akan menjadi seperti berikut ini.
Gambar 5.34 Hasil Aplikasi ImageView
Langkah yang harus di ambil adalah:
1. Buat project baru dengan nama Hitung luas Lingkaran Maka akan muncul tampilan seperti
berikut ini.
Gambar 5.35 Project Hitung Luas Lingkaran
2. Drag 2 EditText, 1 button dan ditambah 1 TextView pada layout. Buat tampilan menjadi seperti
berikut
Gambar 5.36 Layout Program Luas Lingkaran
3. Buka Strings.xml pada folder values. Tambahkan string dengan nama “luas”, “hitung” dan
“jarijari”. String luas diisi dengan kalimat “Luas Lingkaran :” . String hitung diisi dengan kalimat
“Hitung!”. Sedangkan String jarijari diisi dengan nama “Jari-jari:”.
Gambar 5.37 Strings.xml pada Pogram Luas Lingkaran
4. Kembali ke layout activity_main.xml. pada textview “@string/hello_world” diubah menjadi
“@string/jarijari”
Gambar 5.38 Mengubah String pada TextView
5. Pada Button, android:text diisi dengan “@string/hitung”
Gambar 5.39 Mengubah String pada Button
6. pada textview terakhir, textview diubah menjadi “@string/luas”
Gambar 5.40 Mengubah String pada TextView2
7. Maka tampilan akan menjadi seperti berikut ini
Gambar 5.41 Hasil Akhir tampilan
8. Buka MainActivity.java. Tambahkan library :
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
Gambar 5.42 Library pada program Menghitung Luas Lingkaran
9. Tambahkan “implements OnClickListener” pada class MainActivity.
Gambar 5.43 Menambahkan implements OnClickListener
10. Tambahkan Edittext eJari, eLuas, dan Button LuasSegitiga.
Gambar 5.44 Menambahkan Object eJari, eLuas, dan LuasLingkaran
11. Tambahkan eJari = (EditText)findViewById(R.id.editText);
12. Tambahkan eLuas = (EditText)findViewById(R.id.editText2);
13. Tambahkan LuasLingkaran = (Button)findViewById(R.id.button);
Gambar 5.45 Memasukkan Id pada Object
14. Tambahkan LuasLingkaran.setOnClickListener(this);
Gambar 5.46 Menambahkan setOnClickListener
15. Tambahkan Fungsi onClick. Tuliskan Fungsi tersebut seperti gambar di bawah ini.
Gambar 5.47 Menambahkan Fungsi onClick
16. Jalankan program. Maka hasilnya akan menjadi seperti berikut ini.
Gambar 5.48 Hasil Program Menghitung Luas Lingkaran
Masih menggunakan project percobaan 2. Hal yang harus dilakukan adalah:
1. Ubah String.xml menjadi seperti berikut ini.
Gambar 5.49 Mengubah Strings.xml
2. Drag RadioGroup ke Layout serta RadioButton. Ubah tampilan menjadi seperti berikut ini.
Gambar 5.50 Layout Hitung Luas dan Keliling Lingkaran
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
android:paddingBottom="@dimen/activity_vertical_margin"
tools:context=".MainActivity">
<TextView android:text="@string/jarijari" android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/textView" />
<EditText
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/editText"
android:layout_below="@+id/textView"
android:layout_alignParentLeft="true"
android:layout_alignParentStart="true"
android:layout_alignParentRight="true"
android:layout_alignParentEnd="true" />
<RadioGroup
android:id="@+id/radio"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_below="@+id/editText"
android:layout_alignParentLeft="true"
android:layout_alignParentStart="true">
<RadioButton
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Luas"
android:id="@+id/radioButton" />
<RadioButton
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Keliling"
android:id="@+id/radioButton2" />
</RadioGroup>
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/hitung"
android:id="@+id/button"
android:layout_below="@+id/radio"
android:layout_alignParentLeft="true"
android:layout_alignParentStart="true" />
<EditText
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/editText2"
android:layout_below="@+id/textView2"
android:layout_alignParentLeft="true"
android:layout_alignParentStart="true"
android:layout_alignRight="@+id/editText"
android:layout_alignEnd="@+id/editText" />
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/luas"
android:id="@+id/textView2"
android:layout_below="@+id/button"
android:layout_alignParentLeft="true"
android:layout_alignParentStart="true" />
</RelativeLayout>
Gambar 5.51 Layout program
3. Tambahkan object Radiobutton rLuas dan rKeliling.
Gambar 5.52 Menambah object rLuas dan rKeliling
4. Tambahkan rLuas = (RadioButton)findViewById(R.id.radioButton); dan rKeliling =
(RadioButton)findViewById(R.id.radioButton2);
Gambar 5.53 Menentukan Id
5. Ubahlah Fungsi onClick menjadi seperti berikut ini
Gambar 5.54 menghitung Luas dan Keliling pada fungsi onClick
6. Jalankan Program dan lihat hasilnya.
Gambar 5.55 Hasil Tampilan program
1. Buatlah Biodata dengan memasukkan nama, nim, serta Foto Anda
2. Buatlah Program untuk menghitung luas serta keliling segitiga dan luas dan keliling Persegi
panjang
3. Buat Program untuk menghitung RTotal secara serial dan paralel.
Checkbox memungkinkan pengguna untuk memilih satu atau lebih pilihan dari set. Biasanya,
Anda harus menyajikan setiap pilihan kotak centang di daftar vertikal.
Gambar 6.1 Contoh CheckBox
Untuk membuat checkbox option, membuat CheckBox dalam layout Anda. Karena satu set
checkbox memungkinkan pengguna untuk memilih beberapa item, masing-masing checkbox dikelola
secara terpisah dan Anda harus men register click listener tiap masing-masing.
Merespon Click Events Ketika pengguna memilih checkbox, objek checkbox menerima sebuah on-click event. Untuk
menentukan event handler klik checkbox, tambahkan android: onClick atribut ke <CheckBox> elemen
dalam layout XML Anda. Nilai untuk atribut ini harus menjadi nama metode yang ingin Anda panggil
dalam menanggapi click event.
Sebagai contoh, berikut adalah beberapa objek CheckBox dalam daftar:
Gambar 6.2 Layout ada checkbox
Dalam Activity yang Menjalankan layout ini, metode berikut menangani click event untuk kedua
checkboxes:
Gambar 6.3 Isi onCheckboxClicked
Metode yang Anda nyatakan di android:onClick atribut harus memiliki signature persis seperti
yang ditunjukkan di atas. Secara khusus, metode harus:
publik
Return void
Mendefinisikan View sebagai satu-satunya parameter (ini akan menjadi View yang diklik)
Sebuah toggle button memungkinkan pengguna untuk mengubah pengaturan antara dua
keadaan. Anda dapat menambahkan toggle button dasar untuk layout Anda dengan objek
ToggleButton. Android 4.0 (API tingkat 14) memperkenalkan jenis lain dari tombol toggle disebut
switch yang menyediakan slider control, yang dapat Anda tambahkan dengan objek Switch.
Jika Anda perlu mengubah keadaan tombol ini sendiri, Anda dapat menggunakan
CompoundButton.setChecked () atau CompoundButton.toggle () metode.
Gambar 6.4 Toggle buttons
Gambar 6.5 Switches (in Android 4.0+)
Merespon Button yang ditekan Untuk mendeteksi ketika pengguna mengaktifkan tombol atau switch, membuat objek
CompoundButton.OnCheckedChangeListener dan menetapkan ke tombol dengan memanggil
setOnCheckedChangeListener (). Sebagai contoh:
Gambar 6.6 Memanggil OnCheckedChangeListener
Spinner menyediakan cara cepat untuk memilih salah satu nilai dari satu set. Dalam keadaan
default, Spinner menunjukkan nilai yang sedang dipilih. Sentuh spinner menampilkan menu dropdown
dengan semua nilai-nilai lain yang tersedia, dari mana pengguna dapat memilih nilai yang baru.
Gambar 6.7 Contoh Spinner
Anda dapat menambahkan spinner pada layout Anda dengan objek Spinner. Anda biasanya
harus melakukannya dalam layout XML Anda dengan <Spinner> elemen. Sebagai contoh:
Gambar 6.8 Spinner pada layout
Untuk mengisi spinner dengan daftar pilihan, maka Anda perlu menentukan SpinnerAdapter
di Activity atau Fragment source code.
Gambar 6.9 Spinner Adapter
Dengan array seperti ini, Anda dapat menggunakan kode berikut dalam Activity atau Fragmen
untuk menyediakan spinner dengan array menggunakan sebuah instance dari ArrayAdapter:
Gambar 6.10 Memanggil Spinner
Metode createFromResource() memungkinkan Anda untuk membuat ArrayAdapter dari array
string. Argumen ketiga untuk metode ini adalah layout resource yang mendefinisikan bagaimana
pilihan yang dipilih muncul dalam kontrol spinner. Layout simple_spinner_item disediakan oleh
platform dan layout default yang harus digunakan kecuali Anda ingin menentukan layout Anda sendiri
untuk penampilan spinner.
Maka Anda harus memanggil setDropDownViewResource (int) untuk menentukan layout
adaptor harus digunakan untuk menampilkan daftar pilihan spinner (simple_spinner_dropdown_item
adalah layout standar lain yang ditetapkan oleh platform).
Panggil setAdapter () untuk menjalankan adaptor untuk Spinner Anda.
Merespon User Selection Ketika pengguna memilih item dari drop-down, objek Spinner menerima sebuah on-item-
selected event.
Untuk menentukan selection event handler untuk spinner, implementasikan antarmuka
AdapterView.OnItemSelectedListener dan metode onItemSelected() callback yang sesuai. Sebagai
contoh, di sini adalah implementasi antarmuka dalam Activity:
Gambar 6.11 Class SpinnerActivity
The AdapterView.OnItemSelectedListener membutuhkan onItemSelected () dan metode
onNothingSelected() callback. Kemudian Anda perlu menentukan pelaksanaan interface dengan
memanggil setOnItemSelectedListener():
Gambar 6.12 Memanggil SetOnItemSelectedListener
Android menyediakan kontrol bagi pengguna untuk memilih waktu atau memilih tanggal
sebagai siap digunakan dialog. Setiap pemilih memberikan kontrol untuk memilih setiap bagian dari
waktu (jam, menit, AM / PM) atau tanggal (bulan, hari, tahun). Menggunakan pickers membantu
memastikan bahwa pengguna Anda dapat memilih waktu atau tanggal yang valid, diformat dengan
benar, dan disesuaikan dengan user's locale.
Gambar 6.13 Pickers
Kami menyarankan Anda menggunakan DialogFragment menjadi host setiap kali atau pemilih
tanggal. The DialogFragment mengelola siklus hidup dialog untuk Anda dan memungkinkan Anda
untuk menampilkan pickers dalam konfigurasi layout yang berbeda, misalnya di dalam dialog dasar
pada handset atau sebagai bagian tertanam dari layout di layar besar.
Meskipun DialogFragment pertama kali ditambahkan ke platform di Android 3.0 (API level 11),
jika aplikasi Anda mendukung versi Android yang lebih tua dari 3,0-bahkan serendah Android 1.6 Anda
dapat menggunakan kelas DialogFragment yang tersedia di support library untuk kompatibilitas .
Membuat Waktu Picker
Langkah yang harus diambil adalah:
1. Buat project baru dengan nama Date Picker Time Picker
Gambar 6.14 Membuat Project Date Picker Time Picker
2. Maka akan muncul tampilan seperti berikut ini
Gambar 6.15 Tampilan awal
3. Ubah Tampilan menjadi seperti berikut ini
Gambar 6.16 Ubah tampilan Program
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
android:paddingBottom="@dimen/activity_vertical_margin"
tools:context=".MainActivity">
<ScrollView
android:layout_width="match_parent"
android:layout_height="match_parent"
android:id="@+id/scrollView"
android:layout_alignParentBottom="true"
android:layout_centerHorizontal="true" >
<LinearLayout
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical" >
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Date Picker Pada EditText"
android:id="@+id/textView" />
<EditText
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:id="@+id/editText" />
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Hasil"
android:id="@+id/textView2" />
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Time Picker dengan tombol"
android:id="@+id/textView3"
android:layout_marginTop="40dp"/>
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Ambil Waktu"
android:id="@+id/button" />
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Hasil Waktu:"
android:id="@+id/textView4" />
</LinearLayout>
</ScrollView>
</RelativeLayout>
Gambar 6.17 Layout DatePickerTimePicker
Untuk Program Date Picker 4. Tambahkan Library berikut ini
//------library untuk date picker------
import android.app.Activity;
import android.app.DatePickerDialog;
import android.app.DatePickerDialog.OnDateSetListener;
import android.text.InputType;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.DatePicker;
import android.widget.EditText;
import android.widget.TextView;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Locale;
//-------------------------------------
Gambar 6.18 Tambah Library
5. Tambahkan implements OnClickListener pada Class MainActivity
Gambar 6.19 Menambahkan implements OnClickListener
6. Tambahkan UI reference yaitu EditText, TextView, DatePickerDialog, serta SimpleDateFormat.
Gambar 6.20 Menambahkan UI Reference
7. Buat Method onCreate Menjadi seperti berikut ini.
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
dateFormatter = new SimpleDateFormat("dd-MM-yyyy", Locale.US);
textDate = (TextView) findViewById(R.id.textView2);
fromDateEtxt = (EditText) findViewById(R.id.editText);
fromDateEtxt.setInputType(InputType.TYPE_NULL);
fromDateEtxt.setOnClickListener(this);
Calendar newCalendar = Calendar.getInstance();
fromDatePickerDialog = new DatePickerDialog(this, new OnDateSetListener() {
public void onDateSet(DatePicker view, int year, int monthOfYear, int
dayOfMonth) {
Calendar newDate = Calendar.getInstance();
newDate.set(year, monthOfYear, dayOfMonth);
fromDateEtxt.setText(dateFormatter.format(newDate.getTime()));
textDate.setText("Tahun : " + new StringBuilder().append(year) +
"\nBulan :" + new StringBuilder().append(monthOfYear) +
"\nTanggal :" + new StringBuilder().append(dayOfMonth));
}
},newCalendar.get(Calendar.YEAR), newCalendar.get(Calendar.MONTH),
newCalendar.get(Calendar.DAY_OF_MONTH));
}
Gambar 6.21 Method OnCreate
8. Tambahkan Method onClick
Gambar 6.22 Method OnClick
9. Jalankan Program. Maka hasilnya akan menjadi seperti berikut ini
Gambar 6.23 Hasil Program DatePicker
Untuk program Time Picker Pada Project yang sama:
10. Tampahkan Library
//--------library untuk time picker-----------
import android.widget.TimePicker;
import android.app.Dialog;
import android.app.TimePickerDialog;
import android.widget.Button;
Gambar 6.24 Tambahan Library untuk Time Picker
11. Tambahkan UI Reference untuk Time Picker
Gambar 6.25 UI Reference Time Picker
12. Panggil Method addListenerOnButton()
13. Tambahkan Method addListenerOnButton.
Gambar 6.26 Menambah method addListenerOnButton
14. Tambahkan Method Berikut ini
@Override
protected Dialog onCreateDialog(int id) {
switch (id) {
case TIME_DIALOG_ID:
// set time picker as current time
return new TimePickerDialog(this,
timePickerListener, hour, minute,false);
}
return null;
}
private TimePickerDialog.OnTimeSetListener timePickerListener =
new TimePickerDialog.OnTimeSetListener() {
public void onTimeSet(TimePicker view, int selectedHour,
int selectedMinute) {
hour = selectedHour;
minute = selectedMinute;
// set current time into textview
tvDisplayTime.setText(new StringBuilder().append(pad(hour))
.append(":").append(pad(minute)));
}
};
private static String pad(int c) {
if (c >= 10)
return String.valueOf(c);
else
return "0" + String.valueOf(c);
}
Gambar 6.27 Menambah Method berikut ini
15. Jalankan Program. Maka hasilnya akan menjadi seperti berikut ini.
Gambar 6.28 Hasil Program Time Pickering
Membuat Program Spinner. Langkah yang harus di ambil adalah:
1. Buat project baru dengan nama Luas dan keliling bagun.
NB. Project Harus diatas SDK 15.
2. Buat Tampilan menjadi seperti berikut ini
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
android:paddingBottom="@dimen/activity_vertical_margin"
tools:context=".MainActivity">
<ScrollView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/scrollView"
android:layout_centerHorizontal="true" >
<LinearLayout
android:orientation="vertical"
android:layout_width="match_parent"
android:layout_height="match_parent">
<TextView android:text="@string/hello_world"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/textView" />
<Spinner
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/spinner"
android:layout_below="@+id/textView"
android:layout_alignParentLeft="true"
android:layout_alignParentStart="true" />
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Berikut adalah Bangun Persegi"
android:id="@+id/textView2"
android:visibility="gone"
android:layout_alignParentLeft="true"
android:layout_alignParentStart="true"/>
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Berikut adalah Lingkaran"
android:visibility="gone"
android:id="@+id/textView3"
android:layout_alignParentLeft="true"
android:layout_alignParentStart="true"/>
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Berikut adalah Segitiga"
android:visibility="gone"
android:id="@+id/textView4"
android:layout_alignParentLeft="true"
android:layout_alignParentStart="true"/>
</LinearLayout>
</ScrollView>
</RelativeLayout>
Buat Strings.xml menjadi seperti berikut ini!
<resources>
<string name="app_name">Luas Dan Keliling Bangun</string>
<string name="hello_world">Pilihlah Bangun yang akan dihitung!</string>
<string name="action_settings">Settings</string>
</resources>
Buka MainActivity.java
//------------------library tambahan------------------
import android.view.View;
import android.widget.AdapterView;
import android.widget.TextView;
import android.widget.Spinner;
import android.view.View.OnClickListener;
import android.widget.ArrayAdapter;
import android.widget.Toast;
import java.util.ArrayList;
import java.util.List;
Tambahkan Object TextView dan Spinner
Method OnCreate Menjadi seperti berikut ini
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
setSupportActionBar(toolbar);
FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.fab);
fab.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Snackbar.make(view, "Replace with your own action",
Snackbar.LENGTH_LONG)
.setAction("Action", null).show();
}
});
tLingkaran = (TextView)findViewById(R.id.textView3);
tPersegi = (TextView)findViewById(R.id.textView2);
tSegitiga = (TextView)findViewById(R.id.textView4);
spinner1 = (Spinner)findViewById(R.id.spinner);
List<String> list = new ArrayList<String>();
list.add("Persegi");
list.add("Lingkaran");
list.add("Segitiga");
ArrayAdapter<String> dataAdapter = new ArrayAdapter<String>
(this, android.R.layout.simple_spinner_item,list);
dataAdapter.setDropDownViewResource
(android.R.layout.simple_spinner_dropdown_item);
spinner1.setAdapter(dataAdapter);
// membuat method untuk merespon spinner ketika di tekan---
listenerUntukSpinner();
}
private void listenerUntukSpinner() {
spinner1.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
@Override
public void onItemSelected(AdapterView<?> parent, View view, int
position, long id) {
if(parent.getItemAtPosition(position).toString()=="Lingkaran"){
tLingkaran.setVisibility(View.VISIBLE);
tPersegi.setVisibility(View.GONE);
tSegitiga.setVisibility(View. GONE);
} else if (parent.getItemAtPosition(position).toString()=="Persegi"){
tLingkaran.setVisibility(View.GONE);
tPersegi.setVisibility(View.VISIBLE);
tSegitiga.setVisibility(View.GONE);
} else if(parent.getItemAtPosition(position).toString()=="Segitiga")
{
tLingkaran.setVisibility(View.GONE);
tPersegi.setVisibility(View.GONE);
tSegitiga.setVisibility(View.VISIBLE);
}
}
@Override
public void onNothingSelected(AdapterView<?> parent) {
}
});
}
Jalankan Program! Apakah yang terjadi?
1. Buatlah Program untuk memilih menghitung Luas atau Keliling (atau dua-duanya) dari salah satu
dari 3 Bangun (Lingkaran, persegi atau segitiga).
NB: Menggunakan Spinner, CheckBox, TextView, EditText.
Android application framework memungkinkan Anda membuat aplikasi yang kaya dan inovatif
menggunakan seperangkat komponen dapat digunakan kembali. Bagian ini menjelaskan bagaimana
Anda dapat membangun components yang menentukan blok bangunan dari aplikasi Anda dan
bagaimana untuk menghubungkan mereka bersama-sama menggunakan intent.
Intent adalah messaging object yang dapat digunakan untuk meminta tindakan dari
komponen aplikasi lain. Meskipun intents memfasilitasi komunikasi antara komponen dalam
beberapa cara, ada tiga penggunaan-kasus yang mendasar:
Sebuah activity mewakili satu layar dalam sebuah aplikasi. Anda dapat memulai new instance
dari sebuah activity dengan melewati sebuah Intent untuk startActivity(). Intent yang menggambarkan
activity untuk memulai dan membawa data yang diperlukan.
Jika Anda ingin menerima hasil dari activity ketika selesai, sebut startActivityForResult().
Activity Anda menerima hasilnya sebagai objek Intent terpisah di onActivityResult () callback aktivitas
Anda.
Service adalah component yang melakukan operasi di latar belakang tanpa user interface.
Anda dapat memulai service untuk melakukan operasi satu kali (seperti download file) dengan
melewatkan Intent untuk startService(). Intent yang mendeskripsikan service untuk memulai dan
membawa data yang diperlukan.
Jika service ini dirancang dengan interface client-server, Anda dapat mengikat ke service dari
component lain dengan melewati sebuah Intent untuk bindService().
broadcast adalah sebuah pesan yang dapat diterima oleh aplikasi apapun. Sistem ini
memberikan berbagai broadcast untuk system events, seperti ketika sistem boot up atau mulai
pengisian perangkat (Charging). Anda dapat memberikan broadcast untuk aplikasi lain dengan
melewati sebuah Intent untuk sendBroadcast(), sendOrderedBroadcast(), atau sendStickyBroadcast().
Ada dua jenis intent:
Explicit intent menentukan komponen untuk memulai dengan nama (nama kelas
sepenuhnya memenuhi syarat). Anda biasanya akan menggunakan explicit intent
untuk memulai sebuah komponen dalam aplikasi Anda sendiri, karena Anda tahu
nama kelas dari activity atau Service Anda ingin memulai. Misalnya, memulai activity
baru dalam menanggapi tindakan pengguna atau memulai Service untuk men-
download file di latar belakang.
Implicit Intent tidak menyebutkan komponen tertentu, melainkan menyatakan
melakukan tindakan umum, yang memungkinkan komponen dari aplikasi lain untuk
ditanganinya. Sebagai contoh, jika Anda ingin menunjukkan lokasi pengguna pada
peta, Anda dapat menggunakan Implicit Intent meminta aplikasi lain yang lebih
mampu menunjukkan lokasi tertentu pada peta.
Bila Anda membuat implicit intent, sistem Android menemukan komponen yang tepat untuk
memulai dengan membandingkan isi dari intent untuk intent filters dideklarasikan pada file manifest
dari aplikasi lain pada perangkat. Jika intent cocok dengan intent filter, sistem memulai komponen
tersebut dan mengirimkannya ke objek Intent. Jika beberapa intent filters kompatibel, sistem
menampilkan dialog sehingga pengguna dapat memilih aplikasi mana untuk digunakan.
Intent filter adalah ekspresi pada file manifest sebuah aplikasi yang menentukan jenis intents
yang komponen ingin menerima. Misalnya, dengan menyatakan intent filter untuk suatu activity, Anda
memungkinkan untuk aplikasi lain untuk langsung memulai activity Anda dengan jenis tertentu dari
intent. Demikian juga, jika Anda tidak menyatakan apapun intent filters untuk suatu kegiatan, maka
dapat dimulai hanya dengan explicit intent.
Gambar 7.1 Ilustrasi bagaimana implicit Intent disampaikan melalui sistem untuk memulai activity lain: [1] Activity A menciptakan Intent dengan deskripsi tindakan dan lolos ke startActivity (). [2] Sistem Android mencari semua aplikasi untuk
intent filter yang cocok dengan intent. Ketika kecocokan ditemukan, [3] sistem mulai aktivitas pencocokan (Kegiatan B) dengan menerapkan metode OnCreate() dan menyampaikannya ke Intent.
Perhatian: Untuk memastikan aplikasi Anda aman, selalu menggunakan eksplisit intent ketika
memulai layanan dan tidak menyatakan intent filter untuk service Anda. Menggunakan implisit intent
untuk memulai layanan adalah bahaya keamanan karena Anda tidak bisa memastikan apa service akan
menanggapi intent, dan pengguna tidak dapat melihat layanan dimulai. Dimulai dengan Android 5.0
(tingkat API 21), sistem throws exception jika Anda memanggil bindService() dengan implicit intent.
Sebuah objek Intent membawa informasi bahwa sistem Android menggunakan untuk
menentukan komponen untuk memulai (seperti nama yang tepat komponen atau kategori komponen
yang harus menerima maksud), ditambah informasi bahwa komponen penerima menggunakan dalam
rangka untuk benar melakukan tindakan (seperti tindakan untuk mengambil dan data untuk bertindak
atas).
Informasi utama yang terkandung dalam sebuah Intent adalah sebagai berikut:
Component name adalah opsional, tetapi itu adalah bagian yang penting dari informasi yang
membuat intent explicit, yang berarti bahwa intent harus disampaikan hanya untuk komponen
aplikasi didefinisikan oleh nama komponen. Tanpa nama komponen, intent adalah implisit dan sistem
memutuskan mana komponen harus menerima intent berdasarkan informasi intent lainnya (seperti
tindakan, data, dan kategori-dijelaskan di bawah). Jadi jika Anda perlu untuk memulai komponen
tertentu dalam aplikasi Anda, Anda harus menentukan nama komponen.
Catatan: Ketika memulai Service, Anda harus selalu menentukan nama komponen. Jika tidak,
Anda tidak bisa memastikan apa service akan menanggapi intent, dan pengguna tidak dapat melihat
service dimulai.
Bidang Intent adalah objek ComponentName, yang dapat Anda tentukan menggunakan nama
kelas yang memenuhi syarat dari komponen sasaran, termasuk nama paket aplikasi. Misalnya,
com.example.ExampleActivity. Anda dapat mengatur nama komponen dengan setComponent (),
setClass (), setClassName (), atau dengan Intent constructor.
Sebuah string yang menentukan tindakan umum untuk melakukan (seperti melihat atau
memilih).
Dalam kasus broadcast intent, ini adalah action yang berlangsung dan sedang dilaporkan.
action sangat menentukan bagaimana sisa intent adalah terstruktur-terutama apa yang terkandung
dalam data dan ekstra.
Anda dapat menentukan tindakan Anda sendiri untuk digunakan oleh maksud dalam aplikasi
Anda (atau untuk digunakan oleh aplikasi lain untuk memohon komponen dalam aplikasi Anda), tetapi
Anda biasanya harus menggunakan konstanta tindakan didefinisikan oleh kelas Intent atau kelas
kerangka lainnya. Berikut adalah beberapa tindakan umum untuk memulai kegiatan:
ACTION_VIEW Gunakan action ini di intent dengan startActivity () ketika Anda memiliki beberapa informasi
bahwa suatu activity dapat menunjukkan kepada pengguna, seperti foto untuk melihat dalam aplikasi
galeri, atau alamat untuk melihat dalam aplikasi peta.
ACTION_SEND Juga dikenal sebagai "share" intent, Anda harus menggunakan intent ini dengan startActivity()
ketika Anda memiliki beberapa data bahwa pengguna dapat berbagi melalui aplikasi lain, seperti
aplikasi email atau aplikasi berbagi sosial.
Anda dapat menentukan tindakan untuk maksud dengan setAction () atau dengan konstruktor
Intent.
Jika Anda menentukan tindakan Anda sendiri, pastikan untuk menyertakan nama paket
aplikasi Anda sebagai awalan. Sebagai contoh:
static final String ACTION_TIMETRAVEL = "com.example.action.TIMETRAVEL";
URI (Uri Object) yang merujuk data yang akan bertindak dan / atau jenis MIME dari data. Jenis
data yang diberikan umumnya ditentukan oleh aksi maksud itu. Sebagai contoh, jika tindakan tersebut
ACTION_EDIT, data harus berisi URI dari dokumen untuk mengedit.
Saat membuat intent, penting sering untuk menentukan jenis data (tipe MIME nya) di samping
nya URI. Sebagai contoh, activity yang mampu menampilkan gambar mungkin tidak akan dapat
memutar file audio, meskipun format URI bisa menjadi serupa. Jadi menentukan jenis MIME data
Anda membantu sistem Android menemukan komponen terbaik untuk menerima intent Anda.
Namun, jenis MIME kadang-kadang dapat disimpulkan dari URI-terutama ketika data adalah konten:
URI, yang menunjukkan data terletak pada perangkat dan dikendalikan oleh ContentProvider, yang
membuat data tipe MIME terlihat ke sistem.
Untuk mengatur hanya data URI, sebut setData (). Untuk mengatur jenis MIME, sebut
setType(). Jika perlu, Anda dapat mengatur baik secara eksplisit dengan setDataAndType ().
Sebuah string yang berisi informasi tambahan tentang jenis komponen yang harus menangani
intent. Sejumlah deskripsi kategori dapat ditempatkan dalam intent, tapi kebanyakan intent tidak
memerlukan kategori. Berikut adalah beberapa kategori umum:
CATEGORY_BROWSABLE Target activity memungkinkan dirinya untuk memulai dengan web browser untuk
menampilkan data direferensikan oleh-link seperti gambar atau pesan e-mail.
CATEGORY_LAUNCHER Activity ini merupakan activity awal dari tugas dan tercantum dalam sistem aplikasi launcher.
Anda dapat menentukan kategori dengan addCategory ().
Properti ini tercantum di atas (nama komponen, tindakan, data, dan kategori) mewakili
karakteristik mendefinisikan intent. Dengan membaca sifat ini, sistem Android mampu mengatasi yang
app komponen mana yang harus dimulai.
Namun, intent dapat membawa informasi tambahan yang tidak mempengaruhi bagaimana
memutuskan untuk komponen aplikasi. Maksud juga dapat menyediakan:
Key-value pairs yang membawa informasi tambahan yang diperlukan untuk mencapai
tindakan yang diminta. Sama seperti beberapa tindakan menggunakan jenis data URI tertentu,
beberapa tindakan juga menggunakan tambahan tertentu.
Anda dapat menambahkan data tambahan dengan berbagai metode putExtra(), masing-
masing menerima dua parameter: key name dan nilai. Anda juga dapat membuat objek Bundle dengan
semua data tambahan, kemudian masukkan Bundle di Intent dengan putExtras ().
Misalnya, saat membuat maksud untuk mengirim email dengan ACTION_SEND, Anda dapat
menentukan "untuk" penerima dengan key EXTRA_EMAIL, dan menentukan "subjek" dengan key
EXTRA_SUBJECT.
Intent class menentukan banyak EXTRA_ * konstanta untuk tipe data standar. Jika Anda perlu
menyatakan kunci tambahan Anda sendiri (untuk maksud bahwa aplikasi Anda menerima), pastikan
untuk menyertakan app's package name Anda sebagai awalan. Sebagai contoh:
static final String EXTRA_GIGAWATTS = "com.example.EXTRA_GIGAWATTS";
Flags didefinisikan dalam class Intent yang berfungsi sebagai metadata untuk intent. Flags
dapat memerintahkan sistem Android bagaimana untuk memulai suatu activity (misalnya, yang tugas
activity ini harus dimiliki) dan bagaimana memperlakukannya setelah itu diluncurkan (misalnya,
apakah itu termasuk dalam daftar activity baru-baru ini).
Explicit intent adalah salah satu yang Anda gunakan untuk meluncurkan komponen aplikasi
tertentu, seperti activity tertentu atau service di app. Untuk membuat explicit intent, tentukan nama
komponen untuk Intent object -semua intent properties adalah opsional.
Sebagai contoh, jika Anda membangun service di app, bernama DownloadService, dirancang
untuk men-download file dari web, Anda dapat memulainya dengan kode berikut:
// Executed in an Activity, so 'this' is the Context
// The fileUrl is a string URL, such as "http://www.example.com/image.png"
Intent downloadIntent = new Intent(this, DownloadService.class);
downloadIntent.setData(Uri.parse(fileUrl));
startService(downloadIntent);
Intent (Context, Kelas) konstruktor memasok Context aplikasi dan komponen objek Class.
Dengan demikian, intent explicitly memulai class DownloadService di app.
implicit intent menentukan tindakan yang dapat memanggil aplikasi apapun pada perangkat
dapat melakukan tindakan. Menggunakan implicit intent berguna ketika aplikasi Anda tidak dapat
melakukan tindakan, tetapi aplikasi lain mungkin bisa dan Anda ingin pengguna untuk memilih mana
aplikasi untuk menggunakan.
Misalnya, jika Anda memiliki konten yang ingin pengguna untuk berbagi dengan orang lain,
membuat intent dengan tindakan ACTION_SEND dan menambahkan extras yang menentukan konten
untuk berbagi. Ketika Anda memanggil startActivity() dengan intent, pengguna dapat memilih sebuah
aplikasi yang akan digunakan untuk berbagi konten.
Perhatian: Ada kemungkinan bahwa pengguna tidak akan memiliki aplikasi yang menangani
implicit intent yang Anda kirim ke startActivity(). Jika itu terjadi, panggilan akan gagal dan aplikasi Anda
akan crash. Untuk memverifikasi bahwa suatu kegiatan akan menerima intent, sebut resolveActivity()
pada objek Intent Anda. Jika hasilnya adalah non-null, maka setidaknya ada satu aplikasi yang dapat
menangani intent dan itu aman untuk memanggil startActivity(). Jika hasilnya adalah nol, Anda tidak
harus menggunakan intent dan, jika mungkin, Anda harus menonaktifkan fitur yang mengeluarkan
intent.
// Create the text message with a string
Intent sendIntent = new Intent();
sendIntent.setAction(Intent.ACTION_SEND);
sendIntent.putExtra(Intent.EXTRA_TEXT, textMessage);
sendIntent.setType("text/plain");
// Verify that the intent will resolve to an activity
if (sendIntent.resolveActivity(getPackageManager()) != null) {
startActivity(sendIntent);
}
Catatan: Dalam kasus ini, sebuah URI tidak digunakan, tetapi tipe data intent itu dinyatakan
untuk menentukan konten yang dibawa oleh ekstra.
Ketika startActivity() disebut, sistem memeriksa semua aplikasi yang diinstal untuk
menentukan mana yang dapat menangani jenis intent (maksud dengan aksi ACTION_SEND dan yang
membawa "text / plain" data). Jika hanya ada satu aplikasi yang bisa mengatasinya, aplikasi yang
terbuka segera dan diberikan maksud. Jika beberapa kegiatan menerima maksud, sistem
menampilkan dialog sehingga pengguna dapat memilih mana aplikasi untuk menggunakan
Bila ada lebih dari satu aplikasi yang merespon implicit intent Anda, pengguna dapat memilih
aplikasi untuk menggunakan dan membuat aplikasi bahwa pilihan default untuk tindakan. Ini bagus
ketika melakukan suatu tindakan yang pengguna mungkin ingin menggunakan aplikasi yang sama dari
sekarang, seperti ketika membuka halaman web (pengguna biasanya lebih memilih hanya satu web
browser).
Namun, jika beberapa aplikasi dapat menanggapi maksud dan pengguna mungkin ingin
menggunakan aplikasi yang berbeda setiap kali, Anda harus secara eksplisit menunjukkan dialog
pemilih. Dialog pemilih meminta user untuk memilih aplikasi mana yang akan digunakan untuk aksi
setiap kali (pengguna tidak dapat memilih aplikasi default untuk tindakan). Misalnya, ketika aplikasi
Anda melakukan "berbagi" dengan tindakan ACTION_SEND, pengguna mungkin ingin berbagi dengan
menggunakan aplikasi yang berbeda tergantung pada situasi mereka saat ini, sehingga Anda harus
selalu menggunakan dialog pemilih, seperti yang ditunjukkan pada Gambar 7.2.
Gambar 7.2 Intent chooser
Untuk menunjukkan pemilih, membuat Intent menggunakan createChooser () dan
menyebarkannya ke startActivity (). Sebagai contoh:
Intent sendIntent = new Intent(Intent.ACTION_SEND);
...
// Always use string resources for UI text.
// This says something like "Share this photo with"
String title = getResources().getString(R.string.chooser_title);
// Create intent to show the chooser dialog
Intent chooser = Intent.createChooser(sendIntent, title);
// Verify the original intent will resolve to at least one activity
if (sendIntent.resolveActivity(getPackageManager()) != null) {
startActivity(chooser);
}
Untuk mengumumkan implisit intent aplikasi mana yang dapat menerima, menyatakan satu
atau lebih intent filters untuk masing-masing komponen aplikasi Anda dengan <intent-filter> elemen
dalam file manifest Anda. Setiap niat penyaring menentukan jenis maksud itu hanya menerima
sesuatu didasarkan pada intent action, data, dan category. Sistem ini akan memberikan implisit intent
untuk komponen aplikasi Anda hanya jika intent dapat melewati salah satu intent filters Anda.
Note: explicit intent selalu dikirim ke target, terlepas dari intent filters apapun yang dinyatakan
komponen
Komponen aplikasi harus menyatakan filter terpisah untuk setiap pekerjaan yang unik yang
dapat dilakukan. Sebagai contoh, salah satu activity dalam sebuah aplikasi galeri gambar mungkin
memiliki dua filter: satu filter untuk melihat gambar, dan filter lain untuk mengedit gambar. Ketika
activity dimulai, itu memeriksa Intent dan memutuskan bagaimana berperilaku berdasarkan informasi
di Intent (seperti untuk menampilkan kontrol redaksi atau tidak).
Setiap intent filter didefinisikan oleh elemen <intent-filter> dalam file manifest app, berulang
di komponen aplikasi yang sesuai (seperti <activity> elemen). Di dalam <intent-filter>, Anda dapat
menentukan jenis maksud untuk menerima menggunakan satu atau lebih dari tiga unsur ini:
<action>
Menyatakan intent action diterima, dalam name atribut. Nilai harus nilai string literal dari
suatu tindakan, bukan class constant.
<data>
Declares the type of data accepted, using one or more attributes that specify various aspects
of the data URI (scheme, host, port, path, etc.) and MIME type.
Menyatakan jenis data yang diterima, menggunakan satu atau lebih atribut yang menentukan
berbagai aspek data URI (skema, host, port, jalan, dll) dan jenis MIME.
<category>
Declares the intent category accepted, in the name attribute. The value must be the literal
string value of an action, not the class constant.
Note: In order to receive implicit intents, you must
include the CATEGORY_DEFAULT category in the intent filter. The
methods startActivity() and startActivityForResult() treat all intents as if they
declared the CATEGORY_DEFAULT category. If you do not declare this category in your
intent filter, no implicit intents will resolve to your activity.
For example, here's an activity declaration with an intent filter to receive
an ACTION_SEND intent when the data type is text:
<activity android:name="ShareActivity">
<intent-filter>
<action android:name="android.intent.action.SEND"/>
<category android:name="android.intent.category.DEFAULT"/>
<data android:mimeType="text/plain"/>
</intent-filter>
</activity>
It's okay to create a filter that includes more than one instance of <action>, <data>,
or <category>. If you do, you simply need to be certain that the component can handle any and all
combinations of those filter elements.
When you want to handle multiple kinds of intents, but only in specific combinations of action,
data, and category type, then you need to create multiple intent filters.
An implicit intent is tested against a filter by comparing the intent to each of the three
elements. To be delivered to the component, the intent must pass all three tests. If it fails to match
even one of them, the Android system won't deliver the intent to the component. However, because
a component may have multiple intent filters, an intent that does not pass through one of a
component's filters might make it through on another filter. More information about how the system
resolves intents is provided in the section below about Intent Resolution.
Using an intent filter is not a secure way to prevent other apps from starting your components.
Although intent filters restrict a component to respond to only certain kinds of implicit intents,
another app can potentially start your app component by using an explicit intent if the developer
determines your component names. If it's important that only your own app is able to start one of
your components, set the exportedattribute to "false" for that component.
Caution: To avoid inadvertently running a different app'sService, always use an explicit
intent to start your own service and do not declare intent filters for your service.
Note: For all activities, you must declare your intent filters in the manifest file. However,
filters for broadcast receivers can be registered dynamically by
calling registerReceiver(). You can then unregister the receiver
with unregisterReceiver(). Doing so allows your app to listen for specific broadcasts
during only a specified period of time while your app is running.
To better understand some of the intent filter behaviors, look at the following snippet from
the manifest file of a social-sharing app.
<activity android:name="MainActivity">
<!-- This activity is the main entry, should appear in app launcher -->
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<activity android:name="ShareActivity">
<!-- This activity handles "SEND" actions with text data -->
<intent-filter>
<action android:name="android.intent.action.SEND"/>
<category android:name="android.intent.category.DEFAULT"/>
<data android:mimeType="text/plain"/>
</intent-filter>
<!-- This activity also handles "SEND" and "SEND_MULTIPLE" with media data -
->
<intent-filter>
<action android:name="android.intent.action.SEND"/>
<action android:name="android.intent.action.SEND_MULTIPLE"/>
<category android:name="android.intent.category.DEFAULT"/>
<data android:mimeType="application/vnd.google.panorama360+jpg"/>
<data android:mimeType="image/*"/>
<data android:mimeType="video/*"/>
</intent-filter>
</activity>
The first activity, MainActivity, is the app's main entry point—the activity that opens when the
user initially launches the app with the launcher icon:
The ACTION_MAIN action indicates this is the main entry point and does not expect any intent
data.
The CATEGORY_LAUNCHER category indicates that this activity's icon should be placed in the
system's app launcher. If the <activity> element does not specify an icon with icon, then
the system uses the icon from the <application> element.
These two must be paired together in order for the activity to appear in the app launcher.
The second activity, ShareActivity, is intended to facilitate sharing text and media content.
Although users might enter this activity by navigating to it from MainActivity, they can also
enter ShareActivity directly from another app that issues an implicit intent matching one of the
two intent filters.
Note: The MIME type, application/vnd.google.panorama360+jpg, is a special data type that
specifies panoramic photos, which you can handle with the Google panorama APIs.
When the system receives an implicit intent to start an activity, it searches for the best activity
for the intent by comparing the intent to intent filters based on three aspects:
The intent action
The intent data (both URI and data type)
The intent category
The following sections describe how intents are matched to the appropriate component(s) in
terms of how the intent filter is declared in an app's manifest file.
To specify accepted intent actions, an intent filter can declare zero or
more <action> elements. For example:
<intent-filter>
<action android:name="android.intent.action.EDIT" />
<action android:name="android.intent.action.VIEW" />
...
</intent-filter>
To get through this filter, the action specified in the Intent must match one of the actions
listed in the filter.
If the filter does not list any actions, there is nothing for an intent to match, so all intents fail
the test. However, if an Intent does not specify an action, it will pass the test (as long as the filter
contains at least one action).
To specify accepted intent categories, an intent filter can declare zero or
more <category> elements. For example:
<intent-filter>
<category android:name="android.intent.category.DEFAULT" />
<category android:name="android.intent.category.BROWSABLE" />
...
</intent-filter>
For an intent to pass the category test, every category in the Intent must match a category in
the filter. The reverse is not necessary—the intent filter may declare more categories than are
specified in the Intent and theIntent will still pass. Therefore, an intent with no categories
should always pass this test, regardless of what categories are declared in the filter.
Note: Android automatically applies the the CATEGORY_DEFAULT category to all implicit intents
passed tostartActivity() and startActivityForResult(). So if you want your activity to
receive implicit intents, it must include a category for "android.intent.category.DEFAULT" in
its intent filters (as shown in the previous <intent-filter> example.
To specify accepted intent data, an intent filter can declare zero or more <data> elements. For
example:
<intent-filter>
<data android:mimeType="video/mpeg" android:scheme="http" ... />
<data android:mimeType="audio/mpeg" android:scheme="http" ... />
...
</intent-filter>
Each <data> element can specify a URI structure and a data type (MIME media type). There are
separate attributes — scheme, host, port, and path — for each part of the URI:
<scheme>://<host>:<port>/<path>
For example:
content://com.example.project:200/folder/subfolder/etc
In this URI, the scheme is content, the host is com.example.project, the port is 200, and the
path isfolder/subfolder/etc.
Each of these attributes is optional in a <data> element, but there are linear dependencies:
If a scheme is not specified, the host is ignored.
If a host is not specified, the port is ignored.
If both the scheme and host are not specified, the path is ignored.
When the URI in an intent is compared to a URI specification in a filter, it's compared only to the
parts of the URI included in the filter. For example:
If a filter specifies only a scheme, all URIs with that scheme match the filter.
If a filter specifies a scheme and an authority but no path, all URIs with the same scheme and
authority pass the filter, regardless of their paths.
If a filter specifies a scheme, an authority, and a path, only URIs with the same scheme,
authority, and path pass the filter.
Note: A path specification can contain a wildcard asterisk (*) to require only a partial match of the
path name.
The data test compares both the URI and the MIME type in the intent to a URI and MIME type
specified in the filter. The rules are as follows:
a. An intent that contains neither a URI nor a MIME type passes the test only if the filter does not
specify any URIs or MIME types.
b. An intent that contains a URI but no MIME type (neither explicit nor inferable from the URI)
passes the test only if its URI matches the filter's URI format and the filter likewise does not
specify a MIME type.
c. An intent that contains a MIME type but not a URI passes the test only if the filter lists the
same MIME type and does not specify a URI format.
d. An intent that contains both a URI and a MIME type (either explicit or inferable from the URI)
passes the MIME type part of the test only if that type matches a type listed in the filter. It
passes the URI part of the test either if its URI matches a URI in the filter or if it has
a content: or file: URI and the filter does not specify a URI. In other words, a component is
presumed to support content: and file: data if its filter lists only a MIME type.
This last rule, rule (d), reflects the expectation that components are able to get local data from a
file or content provider. Therefore, their filters can list just a data type and do not need to
explicitly name the content: andfile: schemes. This is a typical case. A <data> element like
the following, for example, tells Android that the component can get image data from a content
provider and display it:
<intent-filter>
<data android:mimeType="image/*" />
...
</intent-filter>
Because most available data is dispensed by content providers, filters that specify a data type
but not a URI are perhaps the most common.
Another common configuration is filters with a scheme and a data type. For example,
a <data> element like the following tells Android that the component can retrieve video data from
the network in order to perform the action:
<intent-filter>
<data android:scheme="http" android:type="video/*" />
...
</intent-filter>
Intents are matched against intent filters not only to discover a target component to activate,
but also to discover something about the set of components on the device. For example, the Home
app populates the app launcher by finding all the activities with intent filters that specify
the ACTION_MAIN action and CATEGORY_LAUNCHERcategory.
Your application can use intent matching in a similar way. The PackageManager has a set
of query...()methods that return all components that can accept a particular intent, and a similar
series of resolve...()methods that determine the best component to respond to an intent. For
example, queryIntentActivities()returns a list of all activities that can perform the intent passed
as an argument, and queryIntentServices()returns a similar list of services. Neither method
activates the components; they just list the ones that can respond. There's a similar
method, queryBroadcastReceivers(), for broadcast receivers.
Langkah yang harus diambil adalah:
1. Buat project baru dengan nama ContohIntent.
2. Pada program terdapat 2 layout. Layout pertama object yang dibutuhkan adalah textView,
EditText, serta button yang masing masing berjumlah 1. Tatalah Layout pertama seperti di
bawah ini.
Gambar 7.3 Tampilan Contoh Intent
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
xmlns:app="http://schemas.android.com/apk/res-auto"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
android:paddingBottom="@dimen/activity_vertical_margin"
app:layout_behavior="@string/appbar_scrolling_view_behavior"
tools:showIn="@layout/activity_main" tools:context=".MainActivity">
<TextView
android:id="@+id/textView1"
android:text="Hello World!"
android:layout_width="wrap_content"
android:layout_height="wrap_content" />
<EditText
android:id="@+id/editText1"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:ems="10"
android:layout_below="@id/textView1">
<requestFocus />
</EditText>
<Button
android:id="@+id/button1"
android:layout_below="@id/editText1"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:text="Menuju Layout ke 2" />
</RelativeLayout>
3. Buat Layout ke dua dengan cara klik kanan pada folder layoutnew Layout resource file
Maka akan muncul tampilan New Resource File. Isilah Filename dengan tampilan2. Kemudian klik ok
4. Maka akan muncul file baru tampilan2.xml pada folder layout
5. Buat tampilan menjadi seperti berikut ini.
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical" android:layout_width="match_parent"
android:layout_height="match_parent">
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:textAppearance="?android:attr/textAppearanceLarge"
android:text="Large Text"
android:id="@+id/textView"
android:layout_gravity="center_horizontal" />
</LinearLayout>
6. Buat activity baru dengan cara klik kanan pada package New Activity Blank Activity.
7. Maka akan muncul window New Android Activity. Masukkan nama Activity yang baru. Kemudian
klik tombol Finish.
8. Pada activity_main2.xml, buat tampilan seperti berikut ini.
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
xmlns:app="http://schemas.android.com/apk/res-auto"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
android:paddingBottom="@dimen/activity_vertical_margin"
app:layout_behavior="@string/appbar_scrolling_view_behavior"
tools:showIn="@layout/activity_main2"
tools:context="com.example.tyas.contohintent.Main2Activity">
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:textAppearance="?android:attr/textAppearanceLarge"
android:text="Large Text"
android:id="@+id/textView2"
android:layout_alignParentTop="true"
android:layout_centerHorizontal="true"
android:layout_marginTop="61dp" />
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Klik Sekali lagi"
android:id="@+id/button"
android:layout_below="@+id/textView2"
android:layout_centerHorizontal="true"
android:layout_marginTop="69dp"
android:onClick="cobaLagi"/>
<EditText
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/editText"
android:layout_below="@+id/textView2"
android:layout_alignParentRight="true"
android:layout_alignParentEnd="true"
android:layout_alignParentLeft="true"
android:layout_alignParentStart="true" />
</RelativeLayout>
9. Bukalah MainActivity.java. Tambahkan library seperti berikut ini
//---- library tambahan
import android.widget.EditText;
import android.widget.Button;
10. Tambahkan object seperti berikut ini
EditText eNama;
Button bProses;
String nama;
11. Pada method Oncreate tambahkan seperti berikut ini
// -----------tambahan-----
eNama = (EditText)findViewById(R.id.editText1);
bProses = (Button)findViewById(R.id.button1);
bProses.setOnClickListener(new ButtonClickHandler());
12. Tambahkan inner class ButtonClickHandler dalam class MainActivity.
private class ButtonClickHandler implements View.OnClickListener {
@Override
public void onClick(View v) {
if(eNama != null && eNama.getText().length() != 0){
nama = eNama.getText().toString();
} else {
nama = "Guest";
}
Intent intObj = new Intent(MainActivity.this,Main2Activity.class);
intObj.putExtra("USERNAME",nama);
startActivity(intObj);
}
}
13. Kode secara keseluruhan akan menjadi seperti berikut ini
package com.example.tyas.contohintent;
import android.content.Intent;
import android.os.Bundle;
//---- ini tidak di pakai-----
import android.support.design.widget.FloatingActionButton;
import android.support.design.widget.Snackbar;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.Toolbar;
//---- sampai sini tidak di pakai-----
import android.view.View;
import android.view.Menu;
import android.view.MenuItem;
//---- library tambahan
import android.widget.EditText;
import android.widget.Button;
public class MainActivity extends AppCompatActivity {
EditText eNama;
Button bProses;
String nama;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// -----------Kode yang hanya digunakan dalam floating button, hanya digunakan
//----------pada Android studio 1.4.0 keatas-----
// -----------Tidak usah digunakan-----
Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
setSupportActionBar(toolbar);
FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.fab);
fab.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Snackbar.make(view, "Replace with your own action",
Snackbar.LENGTH_LONG)
.setAction("Action", null).show();
}
});
// -----------Sampai sini tidak digunakan-----
// -----------tambahan untuk intent-----
eNama = (EditText)findViewById(R.id.editText1);
bProses = (Button)findViewById(R.id.button1);
bProses.setOnClickListener(new ButtonClickHandler());
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.menu_main, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
// Handle action bar item clicks here. The action bar will
// automatically handle clicks on the Home/Up button, so long
// as you specify a parent activity in AndroidManifest.xml.
int id = item.getItemId();
//noinspection SimplifiableIfStatement
if (id == R.id.action_settings) {
return true;
}
return super.onOptionsItemSelected(item);
}
private class ButtonClickHandler implements View.OnClickListener {
@Override
public void onClick(View v) {
if(eNama != null && eNama.getText().length() != 0){
nama = eNama.getText().toString();
} else {
nama = "Guest";
}
Intent intObj = new Intent(MainActivity.this,Main2Activity.class);
intObj.putExtra("USERNAME",nama);
startActivity(intObj);
}
}
}
14. Bukalah Activity2Main.java. Tambahkan Library sebagai berikut
//library tambahan-------
import android.widget.TextView;
import android.widget.EditText;
15. Tambahkan object sebagai berikut.
TextView greetMsg;
TextView textCobaLagi;
EditText namaAkhir;
String namaLagi;
String unama;
16. Masukkan dalam method OnCreate()
// mulai tambahan buat intent ----
greetMsg = (TextView) findViewById(R.id.textView2);
namaAkhir = (EditText) findViewById(R.id.editText);
Intent intenama = getIntent();
unama = (String) intenama.getSerializableExtra("USERNAME");
greetMsg.setText("Selamat Datang "+unama + "\nMasukkan nama Akhir anda!");
17. Buat Method baru yaitu cobaLagi. Method ni digunakan untuk memproses aktivitas juka kita
mengisi edittext dan menekan pada tombol di main_Activity2.xml. Tampilan yang digunakan
adalah tampilan2.xml
public void cobaLagi(View view){
setContentView(R.layout.tampilan2);
textCobaLagi = (TextView) findViewById(R.id.textView);
namaLagi = unama +" " +String.valueOf(namaAkhir.getText());
textCobaLagi.setText("Selamat Uji Coba ke 2 kali, \n" +namaLagi);
}
Jalankan program. Maka hasilnya akan menjadi seperti berikut ini.
Langkah yang harus diambil adalah:
1. Buat project baru dengan nama ImplicitIntent
2. Buat tampilan menjadi seperti berikut ini
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
xmlns:app="http://schemas.android.com/apk/res-auto"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
android:paddingBottom="@dimen/activity_vertical_margin"
app:layout_behavior="@string/appbar_scrolling_view_behavior"
tools:showIn="@layout/activity_main" tools:context=".MainActivity">
<TextView
android:id="@+id/textView1"
android:text="Aplikasi Intent SMS dan Telp"
android:layout_width="wrap_content"
android:layout_height="wrap_content" />
<LinearLayout
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:orientation="vertical"
android:layout_below="@+id/textView1">
<Button
android:id="@+id/read"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text=" View Contacts "/>
<EditText
android:id="@+id/phone"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:hint="Masukkan No Telp"/>
<EditText
android:id="@+id/pesan"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:hint="Masukkan Pesan"
android:inputType="textMultiLine"
android:height="150dp" />
<Button
android:id="@+id/call"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text=" call " />
<Button
android:id="@+id/sms"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Send SMS" />
</LinearLayout>
</RelativeLayout>
3. Buka AndroidManifest.xml. Tambahkan user-permission sebagai berikut.
<uses-permission android:name=“android.permission.READ_CONTACTS”/>
<uses-permission android:name=“android.permission.CALL_PHONE”/>
<uses-permission android:name=“android.permission.SEND_SMS”/>
Maka tampilan User permission akan menjadi seperti berikut ini.
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.tyas.implicitintenttelpdansms" >
<uses-permission android:name="android.permission.READ_CONTACTS"/>
<uses-permission android:name="android.permission.CALL_PHONE"/>
<uses-permission android:name="android.permission.SEND_SMS"/>
<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:supportsRtl="true"
android:theme="@style/AppTheme" >
<activity
android:name=".MainActivity"
android:label="@string/app_name"
android:theme="@style/AppTheme.NoActionBar" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>
4. Tambahkan library sebagai berikut ini:
// tambahan library
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.provider.ContactsContract;
import android.content.Intent;
import android.net.Uri;
import android.widget.Toast;
import android.telephony.SmsManager;
import android.util.Log;
5. Tambahkan objek sebagai berikut ini
Button read, call, msg;
EditText phone,pesan;
6. Untuk memanggil Contact, dapat menuliskan berikut ini pada method onCreate.
read = (Button) findViewById(R.id.read);
read.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
Intent read1 = new Intent();
read1.setAction(android.content.Intent.ACTION_VIEW);
read1.setData(ContactsContract.Contacts.CONTENT_URI);
startActivity(read1);
}
});
7. Untuk memanggil telepon, anda dapat menggunakan intent sebagai berikut ini:
phone = (EditText) findViewById(R.id.phone);
call = (Button) findViewById(R.id.call);
call.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
String toDial = "tel: " + phone.getText().toString();
startActivity(new Intent (Intent.ACTION_DIAL,Uri.parse(toDial)));
}
});
8. Untuk Memanggil sms, anda dapat menuliskan perintah sebagai berikut dengan memanggil
method sendSMSMessage
msg=(Button)findViewById(R.id.sms);
pesan = (EditText) findViewById(R.id.pesan);
msg.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
// TODO Auto-generated method stub
if (phone.length()>0 && pesan.length()>0){
sendSMSMessage(phone.getText().toString(),
pesan.getText().toString());
} else {
Toast.makeText(getBaseContext(), "Silahkan masukkan nomor
telepon dan pesan", Toast.LENGTH_SHORT).show();
}
//sendSMSMessage();
}
});
9. Untuk mengirim sms, buatlah method sendSMSMessage.
protected void sendSMSMessage(String phone, String pesan) {
Log.i("Send SMS", "");
String SENT = "SMS_SENT";
String DELIVERED = "SMS_DELIVERED";
PendingIntent sentPI = PendingIntent.getBroadcast(this, 0, new Intent(SENT),
0);
PendingIntent deliveredPI = PendingIntent.getActivity(this, 0, new
Intent(DELIVERED), 0);
registerReceiver(new BroadcastReceiver(){
public void onReceiver(Context arg0, Intent arg1){
switch (getResultCode()){
case Activity.RESULT_OK:
Toast.makeText(getBaseContext(), "SMS sent",
Toast.LENGTH_SHORT).show();
break;
case SmsManager.RESULT_ERROR_GENERIC_FAILURE:
Toast.makeText(getBaseContext(), "Generic failure",
Toast.LENGTH_SHORT).show();
break;
case SmsManager.RESULT_ERROR_NO_SERVICE:
Toast.makeText(getBaseContext(), "No Services",
Toast.LENGTH_SHORT).show();
break;
case SmsManager.RESULT_ERROR_NULL_PDU:
Toast.makeText(getBaseContext(), "Null PDU",
Toast.LENGTH_SHORT).show();
break;
case SmsManager.RESULT_ERROR_RADIO_OFF:
Toast.makeText(getBaseContext(), "Radio Off",
Toast.LENGTH_SHORT).show();
break;
}
}
@Override
public void onReceive(Context context, Intent intent) {
// TODO Auto-generated method stub
}
}, new IntentFilter(SENT));
registerReceiver(new BroadcastReceiver(){
public void onReceive(Context arg0, Intent arg1){
switch (getResultCode()){
case Activity.RESULT_OK:
Toast.makeText(getBaseContext(), "SMS Delivered",
Toast.LENGTH_SHORT).show();
break;
case Activity.RESULT_CANCELED:
Toast.makeText(getBaseContext(), "SMS not Delivered",
Toast.LENGTH_SHORT).show();
break;
}
}
}, new IntentFilter(DELIVERED));
SmsManager sms = SmsManager.getDefault();
sms.sendTextMessage(phone, null, pesan, sentPI, deliveredPI);
}
10. Maka hasilnya akan menjadi berikut ini
Langkah yang harus di ambil adalah:
1. Buatlah Sebuah project dengan nama “Share Text dan Gambar”
2. Buat tampilan menjadi seperti berikut ini
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
xmlns:app="http://schemas.android.com/apk/res-auto"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
android:paddingBottom="@dimen/activity_vertical_margin"
app:layout_behavior="@string/appbar_scrolling_view_behavior"
tools:showIn="@layout/activity_main" tools:context=".MainActivity">
<TextView
android:text="Ini Intent buat Implicit intent dengan Chooser"
android:id="@+id/textView"
android:layout_width="wrap_content"
android:layout_height="wrap_content" />
<Button
android:id="@+id/buttonShareTextUrl"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_below="@+id/textView"
android:text="Share Text or URL" />
<Button
android:id="@+id/buttonShareImage"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_below="@+id/buttonShareTextUrl"
android:text="Share Image" />
<ImageView
android:layout_width="match_parent"
android:layout_height="match_parent"
android:id="@+id/imageView"
android:layout_below="@+id/buttonShareImage"
android:layout_alignParentRight="true"
android:layout_alignParentEnd="true" />
</RelativeLayout>
3. Tambahkan library menjadi seperti berikut ini
import android.content.Intent;
import android.graphics.Bitmap;
import android.net.Uri;
import android.os.Bundle;
import android.provider.MediaStore;
import android.support.design.widget.FloatingActionButton;
import android.support.design.widget.Snackbar;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.Toolbar;
import android.view.View;
import android.view.Menu;
import android.view.MenuItem;
import android.widget.ImageView;
import java.io.IOException;
4. Tambah variable private int PICK_IMAGE_REQUEST = 1;
5. Tambahkan pada method oncreate kode program seperti berikut ini
View.OnClickListener handler = new View.OnClickListener() {
public void onClick(View v) {
switch (v.getId()) {
case R.id.buttonShareTextUrl:
shareTextUrl();
break;
case R.id.buttonShareImage:
shareImage();
break;
}
}
private void shareTextUrl() {
Intent share = new Intent(android.content.Intent.ACTION_SEND);
share.setType("text/plain");
share.addFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET);
// Add data to the intent, the receiving app will decide
// what to do with it.
share.putExtra(Intent.EXTRA_SUBJECT, "Website UGM");
share.putExtra(Intent.EXTRA_TEXT, "http://www.ugm.ac.id");
startActivity(Intent.createChooser(share, "Share link!"));
}
private void shareImage() {
// Ambil gambar dari galery
Intent photoPicker = new Intent(Intent.ACTION_GET_CONTENT);
photoPicker.setType("image/*");
startActivityForResult(Intent.createChooser(photoPicker, "Select
Picture"), PICK_IMAGE_REQUEST);
}
};
// button kita
findViewById(R.id.buttonShareTextUrl).setOnClickListener(handler);
findViewById(R.id.buttonShareImage).setOnClickListener(handler);
6. Tambahkan method onActivityResult seperti pada Gambar 7.4
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
if (requestCode == PICK_IMAGE_REQUEST && resultCode == RESULT_OK && data !=
null && data.getData() != null) {
Uri uri = data.getData();
try {
Bitmap bitmap =
MediaStore.Images.Media.getBitmap(getContentResolver(), uri);
// Log.d(TAG, String.valueOf(bitmap));
ImageView imageView = (ImageView) findViewById(R.id.imageView);
imageView.setImageBitmap(bitmap);
shareData(uri);
} catch (IOException e) {
e.printStackTrace();
}
}
}
Gambar 7.4 Method onCreate pada program share Text dan Gambar
7. Buat method baru dengan nama shareData().
public void shareData(Uri uri){
Intent share = new Intent(Intent.ACTION_SEND);
share.setType("image/*");
share.putExtra(Intent.EXTRA_STREAM, uri);
startActivity(Intent.createChooser(share, "Share Image!"));
}
8. Jalankan Program.
Buatlah Sebuah Program untuk membuat List contact sendiri kemudian dari List tersebut
dapat digunakan untuk telp dan sms.
Langkah yang harus di ambil adalah:
1. Buatlah sebuah Project Baru dengan nama Intent Filter Aja
Buat User Interface Activity_Main.xml menjadi seperti berikut ini
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
xmlns:app="http://schemas.android.com/apk/res-auto"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
android:paddingBottom="@dimen/activity_vertical_margin"
app:layout_behavior="@string/appbar_scrolling_view_behavior"
tools:showIn="@layout/activity_main"
tools:context=".MainActivity">
<TextView
android:id="@+id/TextView1"
android:text="Pilih Akan menampilkan Waktu atau tanggal"
android:layout_width="wrap_content"
android:layout_height="wrap_content" />
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/btnTime"
android:text="Show time"
android:layout_below="@id/TextView1">
</Button>
<Button
android:layout_below="@id/btnTime"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/btnDate"
android:text="Show date">
</Button>
</RelativeLayout>
Bukalah MainActivity.java. Tambahkan Library tambahannya menjadi seperti berikut ini
// library tambahan
//import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.content.Intent;
Tambahkan implements OnClickListener pada Class MainActivity.
Tambahkan kode berikut ini di dalam method onCreate
Button btnTime = (Button) findViewById(R.id.btnTime);
Button btnDate = (Button) findViewById(R.id.btnDate);
btnTime.setOnClickListener(this);
btnDate.setOnClickListener(this);
Buatlah Method OnClick . Tuliskan kode berikut ini
@Override
public void onClick(View v) {
Intent intent;
switch(v.getId()) {
case R.id.btnTime:
intent = new Intent("showtime");
startActivity(intent);
break;
case R.id.btnDate:
intent = new Intent("showdate");
startActivity(intent);
break;
}
}
Buatlah Activity baru dengan cara klik kanan pada package NewActivityBlank Activity.
Berilah nama activity Tersebut dengan nama ActivityTime. Kemudian klik Finish.
Buatlah tampilan activity_activity_time.xml menjadi seperti berikut ini.
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
xmlns:app="http://schemas.android.com/apk/res-auto"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
android:paddingBottom="@dimen/activity_vertical_margin"
app:layout_behavior="@string/appbar_scrolling_view_behavior"
tools:showIn="@layout/activity_activity_time"
tools:context="com.example.tyas.intentfilteraja.ActivityTime">
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/tvTime"
android:text="TextView"
android:layout_gravity="center_horizontal"
android:layout_marginTop="20dp"
android:textSize="30sp">
</TextView>
</RelativeLayout>
Bukalah ActivityTime.java. Tambahkan Library seperti pada berikut ini
// tambahan library---
import java.sql.Date;
import java.text.SimpleDateFormat;
import android.widget.TextView;
Tambahkan Kode berikut ini pada Method onCreate
SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
String time = sdf.format(new Date(System.currentTimeMillis()));
TextView tvTime = (TextView) findViewById(R.id.tvTime);
tvTime.setText(time);
Buatlah Activity baru dengan cara klik kanan pada package NewActivityBlank Activity.
Beri nama Activity dengan ActivityDate
Buatlah tampilan activity_date.xml menjadi seperti berikut ini
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
xmlns:app="http://schemas.android.com/apk/res-auto"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
android:paddingBottom="@dimen/activity_vertical_margin"
app:layout_behavior="@string/appbar_scrolling_view_behavior"
tools:showIn="@layout/activity_activity_date"
tools:context="com.example.tyas.intentfilteraja.ActivityDate">
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/tvDate"
android:text="TextView"
android:layout_gravity="center_horizontal"
android:layout_marginTop="20dp"
android:textSize="30sp">
</TextView>
</RelativeLayout>
Bukalah ActivityDate.java. Tambahkan library seperti berikut ini
// tambah library
import android.widget.TextView;
import java.sql.Date;
import java.text.SimpleDateFormat;
Pada Method onCreate, tambahkan perintah seperti berikut ini
SimpleDateFormat sdf = new SimpleDateFormat("dd.MM.yyyy");
String date = sdf.format(new Date(System.currentTimeMillis()));
TextView tvDate = (TextView) findViewById(R.id.tvDate);
tvDate.setText(date);
Tambahkan 1 activity namun dengan layout activity_date.xml. Caranya adalah dengan klik kanan
pada package di dalam folder javaNewJava Class.
Beri nama Class dengan ActivityDateEx.
Maka hasilnya akan menjadi seperti berikut ini.
Buatlah Class ActivityDateEx tersebut menjadi seperti berikut ini!
package com.example.tyas.intentfilteraja;
import android.os.Bundle;
import android.support.design.widget.FloatingActionButton;
import android.support.design.widget.Snackbar;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.Toolbar;
import android.view.View;
// tambah library
import android.widget.TextView;
import java.sql.Date;
import java.text.SimpleDateFormat;
/**
* Created by tyas on 10/13/2015.
*/
public class ActivityDateEx extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_activity_date);
Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
setSupportActionBar(toolbar);
FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.fab);
fab.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Snackbar.make(view, "Replace with your own action",
Snackbar.LENGTH_LONG)
.setAction("Action", null).show();
}
});
SimpleDateFormat sdf = new SimpleDateFormat("EEE, MMM d, yyyy");
String date = sdf.format(new Date(System.currentTimeMillis()));
TextView tvDate = (TextView) findViewById(R.id.tvDate);
tvDate.setText(date);
}
}
NB: yang berbeda dari ActivityDate.java adalah Format Tanggalnya.
Bukalah AndroidManifest.xml yang terletak di folder manifest. Pada File terlihat Ada 3 Activity. Kita
akan membuat 1 Activity lagi untuk ActivityDateEx. Maka hasilnya akan menjadi seperti berikut
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.tyas.intentfilteraja" >
<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:supportsRtl="true"
android:theme="@style/AppTheme" >
<activity
android:name=".MainActivity"
android:label="@string/app_name"
android:theme="@style/AppTheme.NoActionBar" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<activity
android:name=".ActivityTime"
android:label="@string/title_activity_activity_time"
android:theme="@style/AppTheme.NoActionBar" >
</activity>
<activity
android:name=".ActivityDate"
android:label="Date Basic"
android:theme="@style/AppTheme.NoActionBar" >
</activity>
<activity
android:name=".ActivityDateEx"
android:label="Date Extended"
android:theme="@style/AppTheme.NoActionBar" >
</activity>
</application>
</manifest>
Untuk menjalankan activity, diperlukan intent-filter. Maka Tambahkan intent filter di dalam activity
Maka hasilnya akan menjadi seperti berikut ini
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.tyas.intentfilteraja" >
<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:supportsRtl="true"
android:theme="@style/AppTheme" >
<activity
android:name=".MainActivity"
android:label="@string/app_name"
android:theme="@style/AppTheme.NoActionBar" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<activity
android:name=".ActivityTime"
android:label="@string/title_activity_activity_time"
android:theme="@style/AppTheme.NoActionBar" >
<intent-filter>
<action android:name="showtime"></action>
<category
android:name="android.intent.category.DEFAULT"></category>
</intent-filter>
</activity>
<activity
android:name=".ActivityDate"
android:label="Date Basic"
android:theme="@style/AppTheme.NoActionBar" >
<intent-filter>
<action android:name="showdate"></action>
<category
android:name="android.intent.category.DEFAULT"></category>
</intent-filter>
</activity>
<activity
android:name=".ActivityDateEx"
android:label="Date Extended"
android:theme="@style/AppTheme.NoActionBar" >
<intent-filter>
<action android:name="showdate"></action>
<category
android:name="android.intent.category.DEFAULT"></category>
</intent-filter>
</activity>
</application>
</manifest>
Jalankan Program. Maka hasilnya akan menjadi seperti berikut ini:
Aplikasi ini akan berhubungan dengan aplikasi pada percobaan 1 Langkah yang harus diambil
adalah:
1. Buatlah Aplikasi baru dengan nama InfoTimeDate.
2. Buatlah Tampilan MainActivity.xml menjadi seperti berikut ini
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
xmlns:app="http://schemas.android.com/apk/res-auto"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
android:paddingBottom="@dimen/activity_vertical_margin"
app:layout_behavior="@string/appbar_scrolling_view_behavior"
tools:showIn="@layout/activity_main" tools:context=".MainActivity">
<TextView
android:id="@+id/TextView1"
android:text="Ini adalah aplikasi info\nPilih Akan menampilkan Waktu atau
tanggal"
android:layout_width="wrap_content"
android:layout_height="wrap_content" />
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_below="@id/TextView1"
android:id="@+id/btnTime"
android:text="Show time">
</Button>
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/btnDate"
android:layout_below="@id/btnTime"
android:text="Show date">
</Button>
</RelativeLayout>
3. Bukalah MainActivity.java. Tambahkan library seperti berikut ini
// tambahan library
import android.view.View.OnClickListener;
import android.widget.Button;
import android.content.Intent;
4. Tambahkan implements OnClickListener pada class MainActivity.
5. Tambahkan pada method onCreate kode berikut ini
Button btnTime = (Button) findViewById(R.id.btnTime);
Button btnDate = (Button) findViewById(R.id.btnDate);
btnTime.setOnClickListener(this);
btnDate.setOnClickListener(this);
6. Tambahkhan method onClick untuk menjalankan intent ketika button di klik
@Override
public void onClick(View v) {
Intent intent;
switch(v.getId()) {
case R.id.btnTime:
intent = new Intent("showtime");
startActivity(intent);
break;
case R.id.btnDate:
intent = new Intent("showdate");
startActivity(intent);
break;
}
}
7. Buat Activity Baru yaitu info.
8. Buatlah tampilan activity_info.xml menjadi seperti berikut ini
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
xmlns:app="http://schemas.android.com/apk/res-auto"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
android:paddingBottom="@dimen/activity_vertical_margin"
app:layout_behavior="@string/appbar_scrolling_view_behavior"
tools:showIn="@layout/activity_info"
tools:context="com.example.tyas.infotimedate.info">
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/tvInfo"
android:text="TextView"
android:layout_gravity="center_horizontal"
android:layout_marginTop="20dp"
android:textSize="30sp">
</TextView>
</RelativeLayout>
9. Buka info.java. Tambahkan library sebagai berikut ini.
//Library tambahan..
import java.sql.Date;
import java.text.SimpleDateFormat;
import android.widget.TextView;
10. Tambahkan pada method onCreate sebagai berikut ini
Intent intent = getIntent();
// читаем из него action
String action = intent.getAction();
String format = "", textInfo = "";
if (action.equals("showtime")) {
format = "HH:mm:ss";
textInfo = "Time: ";
}
else if (action.equals("showdate")) {
format = "dd.MM.yyyy";
textInfo = "Date: ";
}
SimpleDateFormat sdf = new SimpleDateFormat(format);
String datetime = sdf.format(new Date(System.currentTimeMillis()));
TextView tvDate = (TextView) findViewById(R.id.tvInfo);
tvDate.setText(textInfo + datetime);
11. Bukalah AndroidManifest.xml pada folder manifest. Pada Activity info, tambahkan intent-filter.
<intent-filter>
<action android:name="showtime"></action>
<action android:name="showdate"></action>
<category android:name="android.intent.category.DEFAULT"></category>
</intent-filter>
12. Maka hasil dari AndroidManifest.xml akan menjadi seperti berikut ini.
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.tyas.infotimedate" >
<application
android:allowBackup="true"
android:icon="@mipmap/ic_launcher"
android:label="@string/app_name"
android:supportsRtl="true"
android:theme="@style/AppTheme" >
<activity
android:name=".MainActivity"
android:label="@string/app_name"
android:theme="@style/AppTheme.NoActionBar" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<activity
android:name=".info"
android:label="@string/title_activity_info"
android:theme="@style/AppTheme.NoActionBar" >
<intent-filter>
<action android:name="showtime"></action>
<action android:name="showdate"></action>
<category
android:name="android.intent.category.DEFAULT"></category>
</intent-filter>
</activity>
</application>
</manifest>
13. Jalankan program. Apakah hasilnya???
Activity adalah komponen aplikasi yang menyediakan tampilan dimana user dapat
berinteraksi untuk melakukan sesuatu, seperti telepon, mengambil gambar, mengirim email, atau
melihat map. Setiap activity diberikan sebuah window dimana digambarkan user interface. Windows
biasanya memenuhi layar, tetapi dapat lebih kecil dari layar dan mengambang (float) diatas window
lainnya.
Sebuah aplikasi biasanya terdiri dari satu atau lebih activity yang memiliki hubungan satu
sama lain. Biasanya satu activity pada aplikasi di spesifikasikan sebagai “main” activity, dimana
ditampilkan kepada user ketika menjalankan aplikasi pada waktu pertama kali. Setiap activity, dapat
menjalankan activity lainnya dalam rangka menjalankan aksi yang berbeda. Setiap kali activity baru
dijalankan, activity sebelumnya akan dihentikan (stopped), tetapi mempertahankan activity pada
stack (stack back). Ketika activity baru berjalan, activity tersebut didorong ke back stack dan
mendapatkan fokus user. Back stack berlaku mekanisme “first in first out”. Jadi ketika user selesai
dengan activity yang sekarang dan menekan tombol kembali, activity yang baru akan keluar dari stack
(dan dihancurkan) dan activity sebelumnya akan di-resume.
Ketika suatu activity dihentikan karena activity baru dimulai, akan diberitahu tentang
perubahan ini melalui activity's lifecycle callback methods. Ada beberapa metode callback yang suatu
activity dapat terima, karena perubahan keadaan-apakah sistem tersebut menciptakan activity,
menghentikan activity, melanjutkan, atau merusaknya-dan setiap callback memberikan Anda
kesempatan untuk melakukan pekerjaan tertentu yang sesuai perubahan keadaan. Misalnya, ketika
berhenti, activity Anda harus melepaskan objects besar, seperti network atau database connections.
Ketika activity resume, Anda dapat mengakses kembali resources yang diperlukan dan melanjutkan
tindakan yang tertunda. Transisi keadaan ini semua bagian dari activity lifecycle.
Untuk membuat suatu activity, Anda harus membuat subclass Activity (atau subclass yang
telah ada). Dalam subclass Anda, Anda perlu menerapkan metode callback bahwa system calls ketika
transisi activity antara berbagai keadaan lifecycle, seperti ketika activity sedang dibuat, berhenti,
kembali, atau hancur. Dua metode callback yang paling penting adalah:
onCreate()
Anda harus menerapkan metode ini. system calls ini saat membuat activity Anda. Dalam
implementasi Anda, Anda harus menginisialisasi komponen penting dari activity Anda. Yang paling
penting, ini adalah di mana Anda harus memanggil setContentView () untuk menentukan tata letak
untuk user interface activity.
onPause()
metode system calls ini sebagai indikasi pertama bahwa pengguna meninggalkan activity Anda
(meskipun tidak selalu berarti activity sedang dihancurkan). Ini biasanya di mana Anda harus
melakukan perubahan yang harus bertahan di luar sesi pengguna saat ini (karena pengguna mungkin
tidak akan kembali).
Anda dapat memulai activity lain dengan memanggil startActivity (), lewat itu Intent yang
menggambarkan activity yang Anda ingin mulai. Tujuannya menentukan baik activity yang tepat yang
Anda ingin memulai atau menggambarkan jenis tindakan Anda ingin lakukan (dan sistem memilih
activity yang tepat untuk Anda, yang bahkan bisa dari aplikasi yang berbeda). Maksud juga dapat
membawa sejumlah kecil data yang akan digunakan oleh kegiatan yang dimulai.
Ketika bekerja dalam aplikasi Anda sendiri, Anda akan sering perlu untuk hanya memulai
activity diketahui. Anda dapat melakukannya dengan menciptakan intent yang secara eksplisit
mendefinisikan activity Anda ingin memulai, menggunakan nama kelas. Sebagai contoh, berikut
adalah cara satu kegiatan dimulai kegiatan bernama SignInActivity lain:
Intent intent = new Intent(this, SignInActivity.class);
startActivity(intent);
Namun, aplikasi Anda juga mungkin ingin melakukan beberapa tindakan, seperti mengirim
email, pesan teks, atau memperbarui status, menggunakan data dari activity Anda. Dalam hal ini,
aplikasi Anda mungkin tidak memiliki activity sendiri untuk melakukan tindakan tersebut, sehingga
Anda malah dapat memanfaatkan activity yang disediakan oleh aplikasi lain pada perangkat, yang
dapat melakukan tindakan untuk Anda. Di sinilah intent yang benar-benar berharga-Anda dapat
membuat intent yang menggambarkan tindakan Anda ingin melakukan dan sistem meluncurkan
activity yang sesuai dari aplikasi lain. Jika ada beberapa activity yang dapat menangani intent, maka
pengguna dapat memilih mana yang akan digunakan. Sebagai contoh, jika Anda ingin mengizinkan
pengguna untuk mengirim pesan email, Anda dapat membuat intent berikut:
Intent intent = new Intent(Intent.ACTION_SEND);
intent.putExtra(Intent.EXTRA_EMAIL, recipientArray);
startActivity(intent);
Kadang-kadang, Anda mungkin ingin menerima hasil dari activity yang Anda mulai. Dalam hal
ini, memulai activity dengan memanggil startActivityForResult () (bukan startActivity ()). Untuk
kemudian menerima hasil dari activity berikutnya, menerapkan metode callback onActivityResult ().
Ketika activity selanjutnya dilakukan, ia mengembalikan hasilnya dalam Intent untuk onActivityResult
Anda () metode.
Misalnya, mungkin Anda ingin pengguna untuk memilih salah satu dari kontak mereka,
sehingga activity Anda dapat melakukan sesuatu dengan informasi kontak yang. Berikut adalah
bagaimana Anda dapat membuat intent seperti dan menangani hasilnya:
private void pickContact() {
// Create an intent to "pick" a contact, as defined by the content provider URI
Intent intent = new Intent(Intent.ACTION_PICK, Contacts.CONTENT_URI);
startActivityForResult(intent, PICK_CONTACT_REQUEST);
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
// If the request went well (OK) and the request was PICK_CONTACT_REQUEST
if (resultCode == Activity.RESULT_OK && requestCode == PICK_CONTACT_REQUEST) {
// Perform a query to the contact's content provider for the contact's name
Cursor cursor = getContentResolver().query(data.getData(),
new String[] {Contacts.DISPLAY_NAME}, null, null, null);
if (cursor.moveToFirst()) { // True if the cursor is not empty
int columnIndex = cursor.getColumnIndex(Contacts.DISPLAY_NAME);
String name = cursor.getString(columnIndex);
// Do something with the selected contact's name...
}
}
}
Contoh ini menunjukkan logika dasar yang harus anda gunakan onActivityResult () metode
Anda untuk menangani hasil activity. Cek kondisi pertama apakah permintaan itu berhasil-jika itu,
maka resultCode akan RESULT_OK-dan apakah permintaan yang hasil ini merespons dikenal-dalam
hal ini, yang requestCode sesuai dengan parameter kedua dikirim dengan startActivityForResult ().
Dari sana, kode menangani hasil activity dengan query data yang dikembalikan dalam Intent
(parameter data).
Apa yang terjadi adalah, ContentResolver melakukan query terhadap content provider, yang
mengembalikan kursor yang memungkinkan data bertanya untuk dibaca.
Anda bisa menutup activity dengan memanggil metode finish (). Anda juga dapat mematikan
activity terpisah yang sebelumnya Anda mulai dengan memanggil finishActivity ().
Mengelola lifecycle activity Anda dengan menerapkan metode callback sangat penting untuk
mengembangkan aplikasi yang kuat dan fleksibel. lifecycle dari suatu activity secara langsung
dipengaruhi oleh hubungannya dengan activity lain, tugas dan back stack.
Suatu activity terdapat 3 keadaan:
Resumed Activity ini di latar depan layar dan memiliki fokus pengguna. (keadaan ini juga kadang-kadang
disebut sebagai "running".)
Paused Activity lain adalah di latar depan dan memiliki fokus, tetapi yang satu ini masih terlihat.
Artinya, activity lain terlihat di atas satu activity ini dan activity yang transparan sebagian atau tidak
menutupi seluruh layar. paused activity benar-benar hidup (objek activity masih dipertahankan dalam
memori, ia mempertahankan semua informasi keadaan dan anggota, dan tetap melekat pada window
manager), tetapi dapat dibunuh oleh sistem dalam situasi memori yang sangat rendah.
Stopped activity ini benar-benar tertutup oleh activity lain (activity sekarang di "latar belakang").
stopped activity juga masih hidup (objek activity masih dipertahankan dalam memori, ia
mempertahankan semua informasi keadaan dan anggota, namun tidak melekat pada window
manager). Namun, itu tidak lagi terlihat oleh pengguna dan dapat dibunuh oleh sistem ketika memori
yang dibutuhkan di tempat lain.
Jika suatu activity dijeda atau dihentikan, sistem dapat menghapusnya dari memori baik
dengan meminta untuk menyelesaikannya (memanggil metode finish ()), atau hanya membunuh
proses nya. Ketika activity dibuka lagi (setelah selesai atau dibunuh), maka harus diciptakan
seluruhnya.
Ketika suatu activity transisi ke dalam dan keluar dari keadaan yang berbeda yang dijelaskan
di atas, itu diberitahukan melalui berbagai metode callback. Semua metode callback adalah kait yang
dapat Anda mengesampingkan untuk melakukan pekerjaan yang tepat ketika keadaan activity Anda
berubah. kerangka Activity berikut meliputi setiap metode siklus hidup yang mendasar:
public class ExampleActivity extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// The activity is being created.
}
@Override
protected void onStart() {
super.onStart();
// The activity is about to become visible.
}
@Override
protected void onResume() {
super.onResume();
// The activity has become visible (it is now "resumed").
}
@Override
protected void onPause() {
super.onPause();
// Another activity is taking focus (this activity is about to be
"paused").
}
@Override
protected void onStop() {
super.onStop();
// The activity is no longer visible (it is now "stopped")
}
@Override
protected void onDestroy() {
super.onDestroy();
// The activity is about to be destroyed.
}
}
Catatan: Penerapan Anda pada metode lifecycle ini harus selalu memanggil superclass
implementation sebelum melakukan pekerjaan apapun, seperti yang ditunjukkan pada contoh di atas.
Secara bersama-sama, metode ini menentukan seluruh siklus hidup dari suatu activity.
Dengan menerapkan metode ini, Anda dapat memantau tiga loop bersarang dalam activity lifecycle:
entire lifetime dari suatu activity yang terjadi antara panggilan untuk OnCreate () dan
panggilan untuk onDestroy (). activity Anda harus melakukan pengaturan state "global" (seperti
mendefinisikan user interface) di OnCreate (), dan melepaskan semua resource yang tersisa di
onDestroy (). Sebagai contoh, jika activity Anda memiliki thread berjalan di background untuk men-
download data dari jaringan, mungkin membuat thread di OnCreate () dan kemudian menghentikan
thread di onDestroy ().
visible lifetime dari suatu activity yang terjadi antara panggilan untuk OnStart () dan
panggilan untuk OnStop(). Selama ini, pengguna dapat melihat activity di layar dan berinteraksi
dengan itu. Misalnya, OnStop() dipanggil saat activity baru dimulai dan yang satu ini tidak lagi terlihat.
Antara dua metode ini, Anda dapat mempertahankan resource yang diperlukan untuk menunjukkan
activity untuk pengguna. Sebagai contoh, Anda dapat mendaftarkan BroadcastReceiver di OnStart()
untuk memantau perubahan yang berdampak UI Anda, dan unregister di OnStop() ketika pengguna
tidak dapat lagi melihat apa yang Anda menampilkan. Sistem dapat memanggil OnStart() dan OnStop()
beberapa kali selama seumur hidup dari activity, seperti activity bergantian antara menjadi terlihat
dan tersembunyi kepada pengguna.
foreground lifetime dari suatu actvity yang terjadi antara panggilan untuk onResume() dan
panggilan untuk onPause(). Selama ini, activity ini di depan semua activity lain di layar dan memiliki
user input focus. Suatu activity yang sering dapat transisi masuk dan keluar dari contoh latar-misal,
onPause () dipanggil saat perangkat sleep atau ketika dialog muncul. Karena keadaan ini dapat transisi
sering, kode dalam dua metode ini harus cukup ringan untuk menghindari transisi lambat yang
membuat pengguna menunggu.
Gambar 9.1 menggambarkan loop ini dan jalur activity mungkin memakan waktu antara
keadaan. Persegi panjang mewakili metode callback Anda dapat menerapkan untuk melakukan
operasi ketika activity transisi antara keadaan.
Gambar 9.1 activity lifecycle
Table 1. A summary of the activity lifecycle's callback methods.
Method Description Killable
after?
Next
onCreate() Called when the activity is
first created. This is where
you should do all of your
normal static set up —
No onStart()
Method Description Killable
after?
Next
create views, bind data to
lists, and so on. This
method is passed a Bundle
object containing the
activity's previous state, if
that state was captured
(see Saving Activity State,
later).
Always followed
by onStart().
onRestart() Called after the activity has
been stopped, just prior to it
being started again.
Always followed
by onStart()
No onStart()
onStart() Called just before the
activity becomes visible to
the user.
Followed by onResume() if
the activity comes to the
foreground, or onStop() if it
becomes hidden.
No onResume()
or
onStop()
onResume() Called just before the
activity starts interacting
with the user. At this point
the activity is at the top of
the activity stack, with user
input going to it.
Always followed
by onPause().
No onPause()
Method Description Killable
after?
Next
onPause() Called when the system is
about to start resuming
another activity. This
method is typically used to
commit unsaved changes
to persistent data, stop
animations and other things
that may be consuming
CPU, and so on. It should
do whatever it does very
quickly, because the next
activity will not be resumed
until it returns.
Followed either
by onResume() if the activity
returns back to the front, or
by onStop() if it becomes
invisible to the user.
Yes onResume()
or
onStop()
onStop() Called when the activity is
no longer visible to the
user. This may happen
because it is being
destroyed, or because
another activity (either an
existing one or a new one)
has been resumed and is
covering it.
Followed either
by onRestart() if the
activity is coming back to
interact with the user, or
byonDestroy() if this
activity is going away.
Yes onRestart()
or
onDestroy()
Method Description Killable
after?
Next
onDestroy() Called before the activity is
destroyed. This is the final
call that the activity will
receive. It could be called
either because the activity
is finishing (someone
called finish() on it), or
because the system is
temporarily destroying this
instance of the activity to
save space. You can
distinguish between these
two scenarios with
the isFinishing() method.
Yes nothing
Langkah yang harus di ambil adalah:
1. Buatlah project dengan nama Activity satu
2. Bukalah MainActivity.java. Tambahkan library sebagai berikut ini
//library tambahan
import android.widget.Toast;
3. Pada Merhod onCreate tambahkan kode berikut ini
Toast.makeText(getApplicationContext(), "Creating CodeLearn",
Toast.LENGTH_SHORT).show();
4. Tambahkan Beberapa method dalam Class Main Activity berikut ini
@Override
protected void onStart() {
Toast.makeText(getApplicationContext(), "Starting CodeLearn",
Toast.LENGTH_SHORT).show();
super.onStart();
}
@Override
protected void onResume() {
Toast.makeText(getApplicationContext(), "Resuming CodeLearn",
Toast.LENGTH_SHORT).show();
super.onResume();
}
@Override
protected void onPause() {
Toast.makeText(getApplicationContext(), "Pausing CodeLearn",
Toast.LENGTH_SHORT).show();
super.onPause();
}
@Override
protected void onStop() {
Toast.makeText(getApplicationContext(), "Stopping CodeLearn",
Toast.LENGTH_SHORT).show();
super.onStop();
}
@Override
protected void onRestart() {
Toast.makeText(getApplicationContext(), "Restarting CodeLearn",
Toast.LENGTH_SHORT).show();
super.onRestart();
}
@Override
protected void onDestroy() {
// TODO Auto-generated method stub
Toast.makeText(getApplicationContext(), "Destroying CodeLearn",
Toast.LENGTH_SHORT).show();
super.onDestroy();
}
5. Maka kode secara lengkap akan menjadi seperti berikut ini
package com.example.tyas.activitysatu;
import android.os.Bundle;
import android.support.design.widget.FloatingActionButton;
import android.support.design.widget.Snackbar;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.Toolbar;
import android.view.View;
import android.view.Menu;
import android.view.MenuItem;
//library tambahan
import android.widget.Toast;
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
setSupportActionBar(toolbar);
FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.fab);
fab.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
Snackbar.make(view, "Replace with your own action",
Snackbar.LENGTH_LONG)
.setAction("Action", null).show();
}
});
Toast.makeText(getApplicationContext(), "Creating CodeLearn",
Toast.LENGTH_SHORT).show();
}
@Override
protected void onStart() {
Toast.makeText(getApplicationContext(), "Starting CodeLearn",
Toast.LENGTH_SHORT).show();
super.onStart();
}
@Override
protected void onResume() {
Toast.makeText(getApplicationContext(), "Resuming CodeLearn",
Toast.LENGTH_SHORT).show();
super.onResume();
}
@Override
protected void onPause() {
Toast.makeText(getApplicationContext(), "Pausing CodeLearn",
Toast.LENGTH_SHORT).show();
super.onPause();
}
@Override
protected void onStop() {
Toast.makeText(getApplicationContext(), "Stopping CodeLearn",
Toast.LENGTH_SHORT).show();
super.onStop();
}
@Override
protected void onRestart() {
Toast.makeText(getApplicationContext(), "Restarting CodeLearn",
Toast.LENGTH_SHORT).show();
super.onRestart();
}
@Override
protected void onDestroy() {
// TODO Auto-generated method stub
Toast.makeText(getApplicationContext(), "Destroying CodeLearn",
Toast.LENGTH_SHORT).show();
super.onDestroy();
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.menu_main, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
// Handle action bar item clicks here. The action bar will
// automatically handle clicks on the Home/Up button, so long
// as you specify a parent activity in AndroidManifest.xml.
int id = item.getItemId();
//noinspection SimplifiableIfStatement
if (id == R.id.action_settings) {
return true;
}
return super.onOptionsItemSelected(item);
}
}
Jalankan Program. Apakah yang terjadi?
Langkah yang harus diambil adalah:
1. Buatlah project dengan nama Activity Dua
2. Buatlah Tampilan menjadi seperti berikut ini
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
xmlns:app="http://schemas.android.com/apk/res-auto"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
android:paddingBottom="@dimen/activity_vertical_margin"
app:layout_behavior="@string/appbar_scrolling_view_behavior"
tools:showIn="@layout/activity_main" tools:context=".MainActivity">
<TextView android:text="Ini adalah Activity 1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/textView" />
<Button
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Ke Activity 2"
android:id="@+id/button"
android:layout_below="@+id/textView"
android:layout_alignParentLeft="true"
android:layout_alignParentStart="true" />
</RelativeLayout>
3. Bukalah MainActivity.java. Tambah Library sebagai berikut ini
// tambah library
import android.view.View.OnClickListener;
import android.widget.Button;
import android.content.Intent;
import android.widget.Toast;
4. Tambahkan implements OnClickListener pada Class MainActivity
5. Tambahkan inisialisasi berikut ini
final String TAG = "States";
Button btnActTwo;
6. Pada Method onCreate, tambahkan kode berikut ini
Toast.makeText(getApplicationContext(), "Creating CodeLearn",
Toast.LENGTH_SHORT).show();
btnActTwo = (Button) findViewById(R.id.button);
btnActTwo.setOnClickListener(this);
7. Tambahkan method berikut ini pada class Main Activity
@Override
protected void onStart() {
Toast.makeText(getApplicationContext(), "Starting CodeLearn",
Toast.LENGTH_SHORT).show();
super.onStart();
}
@Override
protected void onResume() {
Toast.makeText(getApplicationContext(), "Resuming CodeLearn",
Toast.LENGTH_SHORT).show();
super.onResume();
}
@Override
protected void onPause() {
Toast.makeText(getApplicationContext(), "Pausing CodeLearn",
Toast.LENGTH_SHORT).show();
super.onPause();
}
@Override
protected void onStop() {
Toast.makeText(getApplicationContext(), "Stopping CodeLearn",
Toast.LENGTH_SHORT).show();
super.onStop();
}
@Override
protected void onRestart() {
Toast.makeText(getApplicationContext(), "Restarting CodeLearn",
Toast.LENGTH_SHORT).show();
super.onRestart();
}
@Override
protected void onDestroy() {
// TODO Auto-generated method stub
Toast.makeText(getApplicationContext(), "Destroying CodeLearn",
Toast.LENGTH_SHORT).show();
super.onDestroy();
}
8. Buatlah Method onClick, dan isikan kode berikut ini.
@Override
public void onClick(View v) {
Intent intent = new Intent(this, ActivityDua.class);
startActivity(intent);
}
9. Buatlah activity baru dengan nama ActivityDua
10. Buatlah tampilan activity_dua.xml menjadi seperti berikut ini
11. Bukalah ActivityDua.java. Tambahkan library sebagai berikut ini
import android.widget.Toast;
12. Pada Method onCreate tambahkan kode berikut ini
Toast.makeText(getApplicationContext(), "Creating CodeLearn 2",
Toast.LENGTH_SHORT).show();
13. Tambahkan Method berikut ini pada class ActivityDua
@Override
protected void onStart() {
Toast.makeText(getApplicationContext(), "Starting CodeLearn 2",
Toast.LENGTH_SHORT).show();
super.onStart();
}
@Override
protected void onResume() {
Toast.makeText(getApplicationContext(), "Resuming CodeLearn 2",
Toast.LENGTH_SHORT).show();
super.onResume();
}
@Override
protected void onPause() {
Toast.makeText(getApplicationContext(), "Pausing CodeLearn 2",
Toast.LENGTH_SHORT).show();
super.onPause();
}
@Override
protected void onStop() {
Toast.makeText(getApplicationContext(), "Stopping CodeLearn 2",
Toast.LENGTH_SHORT).show();
super.onStop();
}
@Override
protected void onRestart() {
Toast.makeText(getApplicationContext(), "Restarting CodeLearn 2",
Toast.LENGTH_SHORT).show();
super.onRestart();
}
@Override
protected void onDestroy() {
// TODO Auto-generated method stub
Toast.makeText(getApplicationContext(), "Destroying CodeLearn 2",
Toast.LENGTH_SHORT).show();
super.onDestroy();
}
14. Jalankan Aplikasi. Apakah hasilnya?
DAFTAR PUSTAKA
https://www.youtube.com/watch?v=E4gIgKaQuMw&list=PL2IBFdPQHBzZxe3yg_kEe1F_SzTG
DpaQ1&index=15
https://androiddesk.wordpress.com/tag/implicit-intent-using-an-example/
http://www.concretepage.com/android/android-implicit-intent-example-open-url-in-
browser-make-phone-call
https://www.codeofaninja.com/2013/02/android-share-intent-example.html
http://examples.javacodegeeks.com/android/core/content/intent/android-intents-and-intent-
filters-example/
http://startandroid.ru/en/lessons/complete-list/237-lesson-26-intent-filter-practice.html
http://www.sanfoundry.com/java-android-program-demonstrate-intent-filter/
http://startandroid.ru/en/lessons/complete-list/238-lesson-27-reading-action-from-intent.html